#![allow(dead_code, private_interfaces)]
use serde::{Deserialize, Serialize};
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AboutDto {
#[serde(rename = "buildBranch")]
pub build_branch: Option<String>,
#[serde(rename = "buildRevision")]
pub build_revision: Option<String>,
#[serde(rename = "buildTag")]
pub build_tag: Option<String>,
#[serde(rename = "buildTimestamp")]
pub build_timestamp: Option<String>,
#[serde(rename = "contentViewerUrl")]
pub content_viewer_url: Option<String>,
pub timezone: Option<String>,
pub title: Option<String>,
pub uri: Option<String>,
pub version: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub(crate) struct AboutEntity {
pub about: Option<AboutDto>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AccessPolicyDto {
pub action: Option<String>,
#[serde(rename = "componentReference")]
pub component_reference: Option<ComponentReferenceEntity>,
pub configurable: Option<bool>,
pub id: Option<String>,
#[serde(rename = "parentGroupId")]
pub parent_group_id: Option<String>,
pub position: Option<PositionDto>,
pub resource: Option<String>,
#[serde(rename = "userGroups")]
pub user_groups: Option<Vec<TenantEntity>>,
pub users: Option<Vec<TenantEntity>>,
#[serde(rename = "versionedComponentId")]
pub versioned_component_id: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AccessPolicyEntity {
pub bulletins: Option<Vec<BulletinEntity>>,
pub component: Option<AccessPolicyDto>,
#[serde(rename = "disconnectedNodeAcknowledged")]
pub disconnected_node_acknowledged: Option<bool>,
pub generated: Option<String>,
pub id: Option<String>,
pub permissions: Option<PermissionsDto>,
pub position: Option<PositionDto>,
pub revision: Option<RevisionDto>,
pub uri: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AccessPolicySummaryDto {
pub action: Option<String>,
#[serde(rename = "componentReference")]
pub component_reference: Option<ComponentReferenceEntity>,
pub configurable: Option<bool>,
pub id: Option<String>,
#[serde(rename = "parentGroupId")]
pub parent_group_id: Option<String>,
pub position: Option<PositionDto>,
pub resource: Option<String>,
#[serde(rename = "versionedComponentId")]
pub versioned_component_id: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AccessPolicySummaryEntity {
pub bulletins: Option<Vec<BulletinEntity>>,
pub component: Option<AccessPolicySummaryDto>,
#[serde(rename = "disconnectedNodeAcknowledged")]
pub disconnected_node_acknowledged: Option<bool>,
pub id: Option<String>,
pub permissions: Option<PermissionsDto>,
pub position: Option<PositionDto>,
pub revision: Option<RevisionDto>,
pub uri: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ActionDetailsDto {}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ActionDto {
#[serde(rename = "actionDetails")]
pub action_details: Option<ActionDetailsDto>,
#[serde(rename = "componentDetails")]
pub component_details: Option<ComponentDetailsDto>,
pub id: Option<i32>,
pub operation: Option<String>,
#[serde(rename = "sourceId")]
pub source_id: Option<String>,
#[serde(rename = "sourceName")]
pub source_name: Option<String>,
#[serde(rename = "sourceType")]
pub source_type: Option<String>,
pub timestamp: Option<String>,
#[serde(rename = "userIdentity")]
pub user_identity: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ActionEntity {
pub action: Option<ActionDto>,
#[serde(rename = "canRead")]
pub can_read: Option<bool>,
pub id: Option<i32>,
#[serde(rename = "sourceId")]
pub source_id: Option<String>,
pub timestamp: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ActivateControllerServicesEntity {
pub components: Option<std::collections::HashMap<String, Option<RevisionDto>>>,
#[serde(rename = "disconnectedNodeAcknowledged")]
pub disconnected_node_acknowledged: Option<bool>,
pub id: Option<String>,
pub state: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AdditionalDetailsEntity {
#[serde(rename = "additionalDetails")]
pub additional_details: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AffectedComponentDto {
#[serde(rename = "activeThreadCount")]
pub active_thread_count: Option<i32>,
pub id: Option<String>,
pub name: Option<String>,
#[serde(rename = "processGroupId")]
pub process_group_id: Option<String>,
#[serde(rename = "referenceType")]
pub reference_type: Option<String>,
pub state: Option<String>,
#[serde(rename = "validationErrors")]
pub validation_errors: Option<Vec<String>>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AffectedComponentEntity {
pub bulletins: Option<Vec<BulletinEntity>>,
pub component: Option<AffectedComponentDto>,
#[serde(rename = "disconnectedNodeAcknowledged")]
pub disconnected_node_acknowledged: Option<bool>,
pub id: Option<String>,
pub permissions: Option<PermissionsDto>,
pub position: Option<PositionDto>,
#[serde(rename = "processGroup")]
pub process_group: Option<ProcessGroupNameDto>,
#[serde(rename = "referenceType")]
pub reference_type: Option<String>,
pub revision: Option<RevisionDto>,
pub uri: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AllowableValueDto {
pub description: Option<String>,
#[serde(rename = "displayName")]
pub display_name: Option<String>,
pub value: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AllowableValueEntity {
#[serde(rename = "allowableValue")]
pub allowable_value: Option<AllowableValueDto>,
#[serde(rename = "canRead")]
pub can_read: Option<bool>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AssetDto {
pub digest: Option<String>,
pub id: Option<String>,
#[serde(rename = "missingContent")]
pub missing_content: Option<bool>,
pub name: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub(crate) struct AssetEntity {
pub asset: Option<AssetDto>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AssetReferenceDto {
pub id: Option<String>,
pub name: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AssetsEntity {
pub assets: Option<Vec<AssetEntity>>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct Attribute {
pub description: Option<String>,
pub name: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AttributeDto {
pub name: Option<String>,
#[serde(rename = "previousValue")]
pub previous_value: Option<String>,
pub value: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AuthenticationConfigurationDto {
#[serde(rename = "externalLoginRequired")]
pub external_login_required: Option<bool>,
#[serde(rename = "loginSupported")]
pub login_supported: Option<bool>,
#[serde(rename = "loginUri")]
pub login_uri: Option<String>,
#[serde(rename = "logoutUri")]
pub logout_uri: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub(crate) struct AuthenticationConfigurationEntity {
pub authentication_configuration: Option<AuthenticationConfigurationDto>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct BannerDto {
#[serde(rename = "footerText")]
pub footer_text: Option<String>,
#[serde(rename = "headerText")]
pub header_text: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub(crate) struct BannerEntity {
pub banners: Option<BannerDto>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct BatchSettingsDto {
pub count: Option<i32>,
pub duration: Option<String>,
pub size: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct BatchSize {
pub count: Option<i32>,
pub duration: Option<String>,
pub size: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct BuildInfo {
pub compiler: Option<String>,
#[serde(rename = "compilerFlags")]
pub compiler_flags: Option<String>,
pub revision: Option<String>,
#[serde(rename = "targetArch")]
pub target_arch: Option<String>,
pub timestamp: Option<i64>,
pub version: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct BulletinBoardDto {
pub bulletins: Option<Vec<BulletinEntity>>,
pub generated: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub(crate) struct BulletinBoardEntity {
pub bulletin_board: Option<BulletinBoardDto>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct BulletinBoardPatternParameter {
pub pattern: Option<serde_json::Value>,
#[serde(rename = "rawPattern")]
pub raw_pattern: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct BulletinDto {
pub category: Option<String>,
#[serde(rename = "groupId")]
pub group_id: Option<String>,
pub id: Option<i64>,
pub level: Option<String>,
pub message: Option<String>,
#[serde(rename = "nodeAddress")]
pub node_address: Option<String>,
#[serde(rename = "sourceId")]
pub source_id: Option<String>,
#[serde(rename = "sourceName")]
pub source_name: Option<String>,
#[serde(rename = "sourceType")]
pub source_type: Option<String>,
#[serde(rename = "stackTrace")]
pub stack_trace: Option<String>,
pub timestamp: Option<String>,
#[serde(rename = "timestampIso")]
pub timestamp_iso: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct BulletinEntity {
pub bulletin: Option<BulletinDto>,
#[serde(rename = "canRead")]
pub can_read: Option<bool>,
#[serde(rename = "groupId")]
pub group_id: Option<String>,
pub id: Option<i64>,
#[serde(rename = "nodeAddress")]
pub node_address: Option<String>,
#[serde(rename = "sourceId")]
pub source_id: Option<String>,
pub timestamp: Option<String>,
#[serde(rename = "timestampIso")]
pub timestamp_iso: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct Bundle {
pub artifact: Option<String>,
pub group: Option<String>,
pub version: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct BundleDto {
pub artifact: Option<String>,
pub group: Option<String>,
pub version: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ClearBulletinsForGroupRequestEntity {
pub components: Option<Vec<String>>,
#[serde(rename = "fromTimestamp")]
pub from_timestamp: Option<String>,
pub id: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ClearBulletinsForGroupResultsEntity {
#[serde(rename = "bulletinsCleared")]
pub bulletins_cleared: Option<i32>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ClearBulletinsRequestEntity {
#[serde(rename = "fromTimestamp")]
pub from_timestamp: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ClearBulletinsResultEntity {
pub bulletins: Option<Vec<BulletinEntity>>,
#[serde(rename = "bulletinsCleared")]
pub bulletins_cleared: Option<i32>,
#[serde(rename = "componentId")]
pub component_id: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ClientIdParameter {
#[serde(rename = "clientId")]
pub client_id: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ClusterDto {
pub generated: Option<String>,
pub nodes: Option<Vec<NodeDto>>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub(crate) struct ClusterEntity {
pub cluster: Option<ClusterDto>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ClusterSearchResultsEntity {
#[serde(rename = "nodeResults")]
pub node_results: Option<Vec<NodeSearchResultDto>>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ClusterSummaryDto {
pub clustered: Option<bool>,
#[serde(rename = "connectedNodeCount")]
pub connected_node_count: Option<i32>,
#[serde(rename = "connectedNodes")]
pub connected_nodes: Option<String>,
#[serde(rename = "connectedToCluster")]
pub connected_to_cluster: Option<bool>,
#[serde(rename = "totalNodeCount")]
pub total_node_count: Option<i32>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub(crate) struct ClusterSummaryEntity {
pub cluster_summary: Option<ClusterSummaryDto>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ComponentDetailsDto {}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ComponentDifferenceDto {
#[serde(rename = "componentId")]
pub component_id: Option<String>,
#[serde(rename = "componentName")]
pub component_name: Option<String>,
#[serde(rename = "componentType")]
pub component_type: Option<String>,
pub differences: Option<Vec<DifferenceDto>>,
#[serde(rename = "processGroupId")]
pub process_group_id: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ComponentHistoryDto {
#[serde(rename = "componentId")]
pub component_id: Option<String>,
#[serde(rename = "propertyHistory")]
pub property_history: Option<std::collections::HashMap<String, Option<PropertyHistoryDto>>>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub(crate) struct ComponentHistoryEntity {
pub component_history: Option<ComponentHistoryDto>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ComponentManifest {
pub apis: Option<Vec<DefinedType>>,
#[serde(rename = "controllerServices")]
pub controller_services: Option<Vec<ControllerServiceDefinition>>,
#[serde(rename = "flowAnalysisRules")]
pub flow_analysis_rules: Option<Vec<FlowAnalysisRuleDefinition>>,
#[serde(rename = "flowRegistryClients")]
pub flow_registry_clients: Option<Vec<FlowRegistryClientDefinition>>,
#[serde(rename = "parameterProviders")]
pub parameter_providers: Option<Vec<ParameterProviderDefinition>>,
pub processors: Option<Vec<ProcessorDefinition>>,
#[serde(rename = "reportingTasks")]
pub reporting_tasks: Option<Vec<ReportingTaskDefinition>>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ComponentReferenceDto {
pub id: Option<String>,
pub name: Option<String>,
#[serde(rename = "parentGroupId")]
pub parent_group_id: Option<String>,
pub position: Option<PositionDto>,
#[serde(rename = "versionedComponentId")]
pub versioned_component_id: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ComponentReferenceEntity {
pub bulletins: Option<Vec<BulletinEntity>>,
pub component: Option<ComponentReferenceDto>,
#[serde(rename = "disconnectedNodeAcknowledged")]
pub disconnected_node_acknowledged: Option<bool>,
pub id: Option<String>,
#[serde(rename = "parentGroupId")]
pub parent_group_id: Option<String>,
pub permissions: Option<PermissionsDto>,
pub position: Option<PositionDto>,
pub revision: Option<RevisionDto>,
pub uri: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ComponentRestrictionPermissionDto {
pub permissions: Option<PermissionsDto>,
#[serde(rename = "requiredPermission")]
pub required_permission: Option<RequiredPermissionDto>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ComponentSearchResultDto {
#[serde(rename = "groupId")]
pub group_id: Option<String>,
pub id: Option<String>,
pub matches: Option<Vec<String>>,
pub name: Option<String>,
#[serde(rename = "parentGroup")]
pub parent_group: Option<SearchResultGroupDto>,
#[serde(rename = "versionedGroup")]
pub versioned_group: Option<SearchResultGroupDto>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ComponentStateDto {
#[serde(rename = "clusterState")]
pub cluster_state: Option<StateMapDto>,
#[serde(rename = "componentId")]
pub component_id: Option<String>,
#[serde(rename = "dropStateKeySupported")]
pub drop_state_key_supported: Option<bool>,
#[serde(rename = "localState")]
pub local_state: Option<StateMapDto>,
#[serde(rename = "stateDescription")]
pub state_description: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub(crate) struct ComponentStateEntity {
pub component_state: Option<ComponentStateDto>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ComponentValidationResultDto {
#[serde(rename = "activeThreadCount")]
pub active_thread_count: Option<i32>,
#[serde(rename = "currentlyValid")]
pub currently_valid: Option<bool>,
pub id: Option<String>,
pub name: Option<String>,
#[serde(rename = "processGroupId")]
pub process_group_id: Option<String>,
#[serde(rename = "referenceType")]
pub reference_type: Option<String>,
#[serde(rename = "resultantValidationErrors")]
pub resultant_validation_errors: Option<Vec<String>>,
#[serde(rename = "resultsValid")]
pub results_valid: Option<bool>,
pub state: Option<String>,
#[serde(rename = "validationErrors")]
pub validation_errors: Option<Vec<String>>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ComponentValidationResultEntity {
pub bulletins: Option<Vec<BulletinEntity>>,
pub component: Option<ComponentValidationResultDto>,
#[serde(rename = "disconnectedNodeAcknowledged")]
pub disconnected_node_acknowledged: Option<bool>,
pub id: Option<String>,
pub permissions: Option<PermissionsDto>,
pub position: Option<PositionDto>,
pub revision: Option<RevisionDto>,
pub uri: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ComponentValidationResultsEntity {
#[serde(rename = "validationResults")]
pub validation_results: Option<Vec<ComponentValidationResultEntity>>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ConfigVerificationResultDto {
pub explanation: Option<String>,
pub outcome: Option<String>,
#[serde(rename = "verificationStepName")]
pub verification_step_name: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ConfigurationAnalysisDto {
#[serde(rename = "componentId")]
pub component_id: Option<String>,
pub properties: Option<std::collections::HashMap<String, Option<String>>>,
#[serde(rename = "referencedAttributes")]
pub referenced_attributes: Option<std::collections::HashMap<String, Option<String>>>,
#[serde(rename = "supportsVerification")]
pub supports_verification: Option<bool>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub(crate) struct ConfigurationAnalysisEntity {
pub configuration_analysis: Option<ConfigurationAnalysisDto>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ConnectableComponent {
pub comments: Option<String>,
#[serde(rename = "groupId")]
pub group_id: Option<String>,
pub id: Option<String>,
#[serde(rename = "instanceIdentifier")]
pub instance_identifier: Option<String>,
pub name: Option<String>,
pub r#type: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ConnectableDto {
pub comments: Option<String>,
pub exists: Option<bool>,
#[serde(rename = "groupId")]
pub group_id: Option<String>,
pub id: Option<String>,
pub name: Option<String>,
pub running: Option<bool>,
pub transmitting: Option<bool>,
pub r#type: Option<String>,
#[serde(rename = "versionedComponentId")]
pub versioned_component_id: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ConnectionDto {
#[serde(rename = "availableRelationships")]
pub available_relationships: Option<Vec<String>>,
#[serde(rename = "backPressureDataSizeThreshold")]
pub back_pressure_data_size_threshold: Option<String>,
#[serde(rename = "backPressureObjectThreshold")]
pub back_pressure_object_threshold: Option<i64>,
pub bends: Option<Vec<PositionDto>>,
pub destination: Option<ConnectableDto>,
#[serde(rename = "flowFileExpiration")]
pub flow_file_expiration: Option<String>,
#[serde(rename = "getzIndex")]
pub getz_index: Option<i64>,
pub id: Option<String>,
#[serde(rename = "labelIndex")]
pub label_index: Option<i32>,
#[serde(rename = "loadBalanceCompression")]
pub load_balance_compression: Option<String>,
#[serde(rename = "loadBalancePartitionAttribute")]
pub load_balance_partition_attribute: Option<String>,
#[serde(rename = "loadBalanceStatus")]
pub load_balance_status: Option<String>,
#[serde(rename = "loadBalanceStrategy")]
pub load_balance_strategy: Option<String>,
pub name: Option<String>,
#[serde(rename = "parentGroupId")]
pub parent_group_id: Option<String>,
pub position: Option<PositionDto>,
pub prioritizers: Option<Vec<String>>,
#[serde(rename = "retriedRelationships")]
pub retried_relationships: Option<Vec<String>>,
#[serde(rename = "selectedRelationships")]
pub selected_relationships: Option<Vec<String>>,
pub source: Option<ConnectableDto>,
#[serde(rename = "versionedComponentId")]
pub versioned_component_id: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ConnectionEntity {
pub bends: Option<Vec<PositionDto>>,
pub bulletins: Option<Vec<BulletinEntity>>,
pub component: Option<ConnectionDto>,
#[serde(rename = "destinationGroupId")]
pub destination_group_id: Option<String>,
#[serde(rename = "destinationId")]
pub destination_id: Option<String>,
#[serde(rename = "destinationType")]
pub destination_type: Option<String>,
#[serde(rename = "disconnectedNodeAcknowledged")]
pub disconnected_node_acknowledged: Option<bool>,
#[serde(rename = "getzIndex")]
pub getz_index: Option<i64>,
pub id: Option<String>,
#[serde(rename = "labelIndex")]
pub label_index: Option<i32>,
pub permissions: Option<PermissionsDto>,
pub position: Option<PositionDto>,
pub revision: Option<RevisionDto>,
#[serde(rename = "sourceGroupId")]
pub source_group_id: Option<String>,
#[serde(rename = "sourceId")]
pub source_id: Option<String>,
#[serde(rename = "sourceType")]
pub source_type: Option<String>,
pub status: Option<ConnectionStatusDto>,
pub uri: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ConnectionStatisticsDto {
#[serde(rename = "aggregateSnapshot")]
pub aggregate_snapshot: Option<ConnectionStatisticsSnapshotDto>,
pub id: Option<String>,
#[serde(rename = "nodeSnapshots")]
pub node_snapshots: Option<Vec<NodeConnectionStatisticsSnapshotDto>>,
#[serde(rename = "statsLastRefreshed")]
pub stats_last_refreshed: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ConnectionStatisticsEntity {
#[serde(rename = "canRead")]
pub can_read: Option<bool>,
#[serde(rename = "connectionStatistics")]
pub connection_statistics: Option<ConnectionStatisticsDto>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ConnectionStatisticsSnapshotDto {
pub id: Option<String>,
#[serde(rename = "predictedBytesAtNextInterval")]
pub predicted_bytes_at_next_interval: Option<i64>,
#[serde(rename = "predictedCountAtNextInterval")]
pub predicted_count_at_next_interval: Option<i32>,
#[serde(rename = "predictedMillisUntilBytesBackpressure")]
pub predicted_millis_until_bytes_backpressure: Option<i64>,
#[serde(rename = "predictedMillisUntilCountBackpressure")]
pub predicted_millis_until_count_backpressure: Option<i64>,
#[serde(rename = "predictedPercentBytes")]
pub predicted_percent_bytes: Option<i32>,
#[serde(rename = "predictedPercentCount")]
pub predicted_percent_count: Option<i32>,
#[serde(rename = "predictionIntervalMillis")]
pub prediction_interval_millis: Option<i64>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ConnectionStatusDto {
#[serde(rename = "aggregateSnapshot")]
pub aggregate_snapshot: Option<ConnectionStatusSnapshotDto>,
#[serde(rename = "destinationId")]
pub destination_id: Option<String>,
#[serde(rename = "destinationName")]
pub destination_name: Option<String>,
#[serde(rename = "groupId")]
pub group_id: Option<String>,
pub id: Option<String>,
pub name: Option<String>,
#[serde(rename = "nodeSnapshots")]
pub node_snapshots: Option<Vec<NodeConnectionStatusSnapshotDto>>,
#[serde(rename = "sourceId")]
pub source_id: Option<String>,
#[serde(rename = "sourceName")]
pub source_name: Option<String>,
#[serde(rename = "statsLastRefreshed")]
pub stats_last_refreshed: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ConnectionStatusEntity {
#[serde(rename = "canRead")]
pub can_read: Option<bool>,
#[serde(rename = "connectionStatus")]
pub connection_status: Option<ConnectionStatusDto>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ConnectionStatusPredictionsSnapshotDto {
#[serde(rename = "predictedBytesAtNextInterval")]
pub predicted_bytes_at_next_interval: Option<i64>,
#[serde(rename = "predictedCountAtNextInterval")]
pub predicted_count_at_next_interval: Option<i32>,
#[serde(rename = "predictedMillisUntilBytesBackpressure")]
pub predicted_millis_until_bytes_backpressure: Option<i64>,
#[serde(rename = "predictedMillisUntilCountBackpressure")]
pub predicted_millis_until_count_backpressure: Option<i64>,
#[serde(rename = "predictedPercentBytes")]
pub predicted_percent_bytes: Option<i32>,
#[serde(rename = "predictedPercentCount")]
pub predicted_percent_count: Option<i32>,
#[serde(rename = "predictionIntervalSeconds")]
pub prediction_interval_seconds: Option<i32>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ConnectionStatusSnapshotDto {
#[serde(rename = "bytesIn")]
pub bytes_in: Option<i64>,
#[serde(rename = "bytesOut")]
pub bytes_out: Option<i64>,
#[serde(rename = "bytesQueued")]
pub bytes_queued: Option<i64>,
#[serde(rename = "destinationId")]
pub destination_id: Option<String>,
#[serde(rename = "destinationName")]
pub destination_name: Option<String>,
#[serde(rename = "flowFileAvailability")]
pub flow_file_availability: Option<String>,
#[serde(rename = "flowFilesIn")]
pub flow_files_in: Option<i32>,
#[serde(rename = "flowFilesOut")]
pub flow_files_out: Option<i32>,
#[serde(rename = "flowFilesQueued")]
pub flow_files_queued: Option<i32>,
#[serde(rename = "groupId")]
pub group_id: Option<String>,
pub id: Option<String>,
pub input: Option<String>,
#[serde(rename = "loadBalanceStatus")]
pub load_balance_status: Option<String>,
pub name: Option<String>,
pub output: Option<String>,
#[serde(rename = "percentUseBytes")]
pub percent_use_bytes: Option<i32>,
#[serde(rename = "percentUseCount")]
pub percent_use_count: Option<i32>,
pub predictions: Option<ConnectionStatusPredictionsSnapshotDto>,
pub queued: Option<String>,
#[serde(rename = "queuedCount")]
pub queued_count: Option<String>,
#[serde(rename = "queuedSize")]
pub queued_size: Option<String>,
#[serde(rename = "sourceId")]
pub source_id: Option<String>,
#[serde(rename = "sourceName")]
pub source_name: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ConnectionStatusSnapshotEntity {
#[serde(rename = "canRead")]
pub can_read: Option<bool>,
#[serde(rename = "connectionStatusSnapshot")]
pub connection_status_snapshot: Option<ConnectionStatusSnapshotDto>,
pub id: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ConnectionsEntity {
pub connections: Option<Vec<ConnectionEntity>>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ContentViewerDto {
#[serde(rename = "displayName")]
pub display_name: Option<String>,
#[serde(rename = "supportedMimeTypes")]
pub supported_mime_types: Option<Vec<SupportedMimeTypesDto>>,
pub uri: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ContentViewerEntity {
#[serde(rename = "contentViewers")]
pub content_viewers: Option<Vec<ContentViewerDto>>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ControllerBulletinsEntity {
pub bulletins: Option<Vec<BulletinEntity>>,
#[serde(rename = "controllerServiceBulletins")]
pub controller_service_bulletins: Option<Vec<BulletinEntity>>,
#[serde(rename = "flowAnalysisRuleBulletins")]
pub flow_analysis_rule_bulletins: Option<Vec<BulletinEntity>>,
#[serde(rename = "flowRegistryClientBulletins")]
pub flow_registry_client_bulletins: Option<Vec<BulletinEntity>>,
#[serde(rename = "parameterProviderBulletins")]
pub parameter_provider_bulletins: Option<Vec<BulletinEntity>>,
#[serde(rename = "reportingTaskBulletins")]
pub reporting_task_bulletins: Option<Vec<BulletinEntity>>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ControllerConfigurationDto {
#[serde(rename = "maxTimerDrivenThreadCount")]
pub max_timer_driven_thread_count: Option<i32>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ControllerConfigurationEntity {
pub component: Option<ControllerConfigurationDto>,
#[serde(rename = "disconnectedNodeAcknowledged")]
pub disconnected_node_acknowledged: Option<bool>,
pub permissions: Option<PermissionsDto>,
pub revision: Option<RevisionDto>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ControllerDto {
#[serde(rename = "activeRemotePortCount")]
pub active_remote_port_count: Option<i32>,
pub comments: Option<String>,
#[serde(rename = "disabledCount")]
pub disabled_count: Option<i32>,
pub id: Option<String>,
#[serde(rename = "inactiveRemotePortCount")]
pub inactive_remote_port_count: Option<i32>,
#[serde(rename = "inputPortCount")]
pub input_port_count: Option<i32>,
#[serde(rename = "inputPorts")]
pub input_ports: Option<Vec<PortDto>>,
#[serde(rename = "instanceId")]
pub instance_id: Option<String>,
#[serde(rename = "invalidCount")]
pub invalid_count: Option<i32>,
pub name: Option<String>,
#[serde(rename = "outputPortCount")]
pub output_port_count: Option<i32>,
#[serde(rename = "outputPorts")]
pub output_ports: Option<Vec<PortDto>>,
#[serde(rename = "remoteSiteHttpListeningPort")]
pub remote_site_http_listening_port: Option<i32>,
#[serde(rename = "remoteSiteListeningPort")]
pub remote_site_listening_port: Option<i32>,
#[serde(rename = "runningCount")]
pub running_count: Option<i32>,
#[serde(rename = "siteToSiteSecure")]
pub site_to_site_secure: Option<bool>,
#[serde(rename = "stoppedCount")]
pub stopped_count: Option<i32>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub(crate) struct ControllerEntity {
pub controller: Option<ControllerDto>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ControllerServiceAPI {
pub bundle: Option<Bundle>,
pub r#type: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ControllerServiceApiDto {
pub bundle: Option<BundleDto>,
pub r#type: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ControllerServiceDefinition {
#[serde(rename = "additionalDetails")]
pub additional_details: Option<bool>,
pub artifact: Option<String>,
#[serde(rename = "buildInfo")]
pub build_info: Option<BuildInfo>,
pub deprecated: Option<bool>,
#[serde(rename = "deprecationAlternatives")]
pub deprecation_alternatives: Option<Vec<String>>,
#[serde(rename = "deprecationReason")]
pub deprecation_reason: Option<String>,
#[serde(rename = "dynamicProperties")]
pub dynamic_properties: Option<Vec<DynamicProperty>>,
#[serde(rename = "explicitRestrictions")]
pub explicit_restrictions: Option<Vec<Restriction>>,
pub group: Option<String>,
#[serde(rename = "propertyDescriptors")]
pub property_descriptors: Option<std::collections::HashMap<String, Option<PropertyDescriptor>>>,
#[serde(rename = "providedApiImplementations")]
pub provided_api_implementations: Option<Vec<DefinedType>>,
pub restricted: Option<bool>,
#[serde(rename = "restrictedExplanation")]
pub restricted_explanation: Option<String>,
#[serde(rename = "seeAlso")]
pub see_also: Option<Vec<String>>,
pub stateful: Option<Stateful>,
#[serde(rename = "supportsDynamicProperties")]
pub supports_dynamic_properties: Option<bool>,
#[serde(rename = "supportsSensitiveDynamicProperties")]
pub supports_sensitive_dynamic_properties: Option<bool>,
#[serde(rename = "systemResourceConsiderations")]
pub system_resource_considerations: Option<Vec<SystemResourceConsideration>>,
pub tags: Option<Vec<String>>,
pub r#type: Option<String>,
#[serde(rename = "typeDescription")]
pub type_description: Option<String>,
pub version: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ControllerServiceDto {
#[serde(rename = "annotationData")]
pub annotation_data: Option<String>,
#[serde(rename = "bulletinLevel")]
pub bulletin_level: Option<String>,
pub bundle: Option<BundleDto>,
pub comments: Option<String>,
#[serde(rename = "controllerServiceApis")]
pub controller_service_apis: Option<Vec<ControllerServiceApiDto>>,
#[serde(rename = "customUiUrl")]
pub custom_ui_url: Option<String>,
pub deprecated: Option<bool>,
pub descriptors: Option<std::collections::HashMap<String, Option<PropertyDescriptorDto>>>,
#[serde(rename = "extensionMissing")]
pub extension_missing: Option<bool>,
pub id: Option<String>,
#[serde(rename = "multipleVersionsAvailable")]
pub multiple_versions_available: Option<bool>,
pub name: Option<String>,
#[serde(rename = "parentGroupId")]
pub parent_group_id: Option<String>,
#[serde(rename = "persistsState")]
pub persists_state: Option<bool>,
pub position: Option<PositionDto>,
pub properties: Option<std::collections::HashMap<String, Option<String>>>,
#[serde(rename = "referencingComponents")]
pub referencing_components: Option<Vec<ControllerServiceReferencingComponentEntity>>,
pub restricted: Option<bool>,
#[serde(rename = "sensitiveDynamicPropertyNames")]
pub sensitive_dynamic_property_names: Option<Vec<String>>,
pub state: Option<String>,
#[serde(rename = "supportsSensitiveDynamicProperties")]
pub supports_sensitive_dynamic_properties: Option<bool>,
pub r#type: Option<String>,
#[serde(rename = "validationErrors")]
pub validation_errors: Option<Vec<String>>,
#[serde(rename = "validationStatus")]
pub validation_status: Option<String>,
#[serde(rename = "versionedComponentId")]
pub versioned_component_id: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ControllerServiceEntity {
pub bulletins: Option<Vec<BulletinEntity>>,
pub component: Option<ControllerServiceDto>,
#[serde(rename = "disconnectedNodeAcknowledged")]
pub disconnected_node_acknowledged: Option<bool>,
pub id: Option<String>,
#[serde(rename = "operatePermissions")]
pub operate_permissions: Option<PermissionsDto>,
#[serde(rename = "parentGroupId")]
pub parent_group_id: Option<String>,
pub permissions: Option<PermissionsDto>,
pub position: Option<PositionDto>,
pub revision: Option<RevisionDto>,
pub status: Option<ControllerServiceStatusDto>,
pub uri: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ControllerServiceReferencingComponentDto {
#[serde(rename = "activeThreadCount")]
pub active_thread_count: Option<i32>,
pub descriptors: Option<std::collections::HashMap<String, Option<PropertyDescriptorDto>>>,
#[serde(rename = "groupId")]
pub group_id: Option<String>,
pub id: Option<String>,
pub name: Option<String>,
pub properties: Option<std::collections::HashMap<String, Option<String>>>,
#[serde(rename = "referenceCycle")]
pub reference_cycle: Option<bool>,
#[serde(rename = "referenceType")]
pub reference_type: Option<String>,
#[serde(rename = "referencingComponents")]
pub referencing_components: Option<Vec<ControllerServiceReferencingComponentEntity>>,
pub state: Option<String>,
pub r#type: Option<String>,
#[serde(rename = "validationErrors")]
pub validation_errors: Option<Vec<String>>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ControllerServiceReferencingComponentEntity {
pub bulletins: Option<Vec<BulletinEntity>>,
pub component: Option<ControllerServiceReferencingComponentDto>,
#[serde(rename = "disconnectedNodeAcknowledged")]
pub disconnected_node_acknowledged: Option<bool>,
pub id: Option<String>,
#[serde(rename = "operatePermissions")]
pub operate_permissions: Option<PermissionsDto>,
pub permissions: Option<PermissionsDto>,
pub position: Option<PositionDto>,
pub revision: Option<RevisionDto>,
pub uri: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ControllerServiceReferencingComponentsEntity {
#[serde(rename = "controllerServiceReferencingComponents")]
pub controller_service_referencing_components:
Option<Vec<ControllerServiceReferencingComponentEntity>>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ControllerServiceRunStatusEntity {
#[serde(rename = "disconnectedNodeAcknowledged")]
pub disconnected_node_acknowledged: Option<bool>,
pub revision: Option<RevisionDto>,
pub state: Option<String>,
#[serde(rename = "uiOnly")]
pub ui_only: Option<bool>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ControllerServiceStatusDto {
#[serde(rename = "activeThreadCount")]
pub active_thread_count: Option<i32>,
#[serde(rename = "runStatus")]
pub run_status: Option<String>,
#[serde(rename = "validationStatus")]
pub validation_status: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ControllerServiceTypesEntity {
#[serde(rename = "controllerServiceTypes")]
pub controller_service_types: Option<Vec<DocumentedTypeDto>>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ControllerServicesEntity {
#[serde(rename = "controllerServices")]
pub controller_services: Option<Vec<ControllerServiceEntity>>,
#[serde(rename = "currentTime")]
pub current_time: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ControllerStatusDto {
#[serde(rename = "activeRemotePortCount")]
pub active_remote_port_count: Option<i32>,
#[serde(rename = "activeThreadCount")]
pub active_thread_count: Option<i32>,
#[serde(rename = "bytesQueued")]
pub bytes_queued: Option<i64>,
#[serde(rename = "disabledCount")]
pub disabled_count: Option<i32>,
#[serde(rename = "flowFilesQueued")]
pub flow_files_queued: Option<i32>,
#[serde(rename = "inactiveRemotePortCount")]
pub inactive_remote_port_count: Option<i32>,
#[serde(rename = "invalidCount")]
pub invalid_count: Option<i32>,
#[serde(rename = "locallyModifiedAndStaleCount")]
pub locally_modified_and_stale_count: Option<i32>,
#[serde(rename = "locallyModifiedCount")]
pub locally_modified_count: Option<i32>,
pub queued: Option<String>,
#[serde(rename = "runningCount")]
pub running_count: Option<i32>,
#[serde(rename = "staleCount")]
pub stale_count: Option<i32>,
#[serde(rename = "stoppedCount")]
pub stopped_count: Option<i32>,
#[serde(rename = "syncFailureCount")]
pub sync_failure_count: Option<i32>,
#[serde(rename = "terminatedThreadCount")]
pub terminated_thread_count: Option<i32>,
#[serde(rename = "upToDateCount")]
pub up_to_date_count: Option<i32>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub(crate) struct ControllerStatusEntity {
pub controller_status: Option<ControllerStatusDto>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct CopyRequestEntity {
pub connections: Option<Vec<String>>,
pub funnels: Option<Vec<String>>,
#[serde(rename = "inputPorts")]
pub input_ports: Option<Vec<String>>,
pub labels: Option<Vec<String>>,
#[serde(rename = "outputPorts")]
pub output_ports: Option<Vec<String>>,
#[serde(rename = "processGroups")]
pub process_groups: Option<Vec<String>>,
pub processors: Option<Vec<String>>,
#[serde(rename = "remoteProcessGroups")]
pub remote_process_groups: Option<Vec<String>>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct CopyResponseEntity {
pub connections: Option<Vec<VersionedConnection>>,
#[serde(rename = "externalControllerServiceReferences")]
pub external_controller_service_references:
Option<std::collections::HashMap<String, Option<ExternalControllerServiceReference>>>,
pub funnels: Option<Vec<VersionedFunnel>>,
pub id: Option<String>,
#[serde(rename = "inputPorts")]
pub input_ports: Option<Vec<VersionedPort>>,
pub labels: Option<Vec<VersionedLabel>>,
#[serde(rename = "outputPorts")]
pub output_ports: Option<Vec<VersionedPort>>,
#[serde(rename = "parameterContexts")]
pub parameter_contexts:
Option<std::collections::HashMap<String, Option<VersionedParameterContext>>>,
#[serde(rename = "parameterProviders")]
pub parameter_providers:
Option<std::collections::HashMap<String, Option<ParameterProviderReference>>>,
#[serde(rename = "processGroups")]
pub process_groups: Option<Vec<VersionedProcessGroup>>,
pub processors: Option<Vec<VersionedProcessor>>,
#[serde(rename = "remoteProcessGroups")]
pub remote_process_groups: Option<Vec<VersionedRemoteProcessGroup>>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct CopySnippetRequestEntity {
#[serde(rename = "disconnectedNodeAcknowledged")]
pub disconnected_node_acknowledged: Option<bool>,
#[serde(rename = "originX")]
pub origin_x: Option<f64>,
#[serde(rename = "originY")]
pub origin_y: Option<f64>,
#[serde(rename = "snippetId")]
pub snippet_id: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct CounterDto {
pub context: Option<String>,
pub id: Option<String>,
pub name: Option<String>,
pub value: Option<String>,
#[serde(rename = "valueCount")]
pub value_count: Option<i64>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub(crate) struct CounterEntity {
pub counter: Option<CounterDto>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct CountersDto {
#[serde(rename = "aggregateSnapshot")]
pub aggregate_snapshot: Option<CountersSnapshotDto>,
#[serde(rename = "nodeSnapshots")]
pub node_snapshots: Option<Vec<NodeCountersSnapshotDto>>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub(crate) struct CountersEntity {
pub counters: Option<CountersDto>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct CountersSnapshotDto {
pub counters: Option<Vec<CounterDto>>,
pub generated: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct CreateActiveRequestEntity {
#[serde(rename = "disconnectedNodeAcknowledged")]
pub disconnected_node_acknowledged: Option<bool>,
#[serde(rename = "processGroupId")]
pub process_group_id: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct CurrentUserEntity {
pub anonymous: Option<bool>,
#[serde(rename = "canVersionFlows")]
pub can_version_flows: Option<bool>,
#[serde(rename = "componentRestrictionPermissions")]
pub component_restriction_permissions: Option<Vec<ComponentRestrictionPermissionDto>>,
#[serde(rename = "controllerPermissions")]
pub controller_permissions: Option<PermissionsDto>,
#[serde(rename = "countersPermissions")]
pub counters_permissions: Option<PermissionsDto>,
pub identity: Option<String>,
#[serde(rename = "logoutSupported")]
pub logout_supported: Option<bool>,
#[serde(rename = "parameterContextPermissions")]
pub parameter_context_permissions: Option<PermissionsDto>,
#[serde(rename = "policiesPermissions")]
pub policies_permissions: Option<PermissionsDto>,
#[serde(rename = "provenancePermissions")]
pub provenance_permissions: Option<PermissionsDto>,
#[serde(rename = "restrictedComponentsPermissions")]
pub restricted_components_permissions: Option<PermissionsDto>,
#[serde(rename = "systemPermissions")]
pub system_permissions: Option<PermissionsDto>,
#[serde(rename = "tenantsPermissions")]
pub tenants_permissions: Option<PermissionsDto>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct DateTimeParameter {
#[serde(rename = "dateTime")]
pub date_time: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct DefinedType {
pub artifact: Option<String>,
pub group: Option<String>,
pub r#type: Option<String>,
#[serde(rename = "typeDescription")]
pub type_description: Option<String>,
pub version: Option<String>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub enum DiagnosticLevel {
#[serde(rename = "BASIC")]
Basic,
#[serde(rename = "VERBOSE")]
Verbose,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct DifferenceDto {
pub difference: Option<String>,
#[serde(rename = "differenceType")]
pub difference_type: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct DimensionsDto {
pub height: Option<f64>,
pub width: Option<f64>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct DocumentedTypeDto {
pub bundle: Option<BundleDto>,
#[serde(rename = "controllerServiceApis")]
pub controller_service_apis: Option<Vec<ControllerServiceApiDto>>,
#[serde(rename = "deprecationReason")]
pub deprecation_reason: Option<String>,
pub description: Option<String>,
#[serde(rename = "explicitRestrictions")]
pub explicit_restrictions: Option<Vec<ExplicitRestrictionDto>>,
pub restricted: Option<bool>,
pub tags: Option<Vec<String>>,
pub r#type: Option<String>,
#[serde(rename = "usageRestriction")]
pub usage_restriction: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct DropRequestDto {
pub current: Option<String>,
#[serde(rename = "currentCount")]
pub current_count: Option<i32>,
#[serde(rename = "currentSize")]
pub current_size: Option<i64>,
pub dropped: Option<String>,
#[serde(rename = "droppedCount")]
pub dropped_count: Option<i32>,
#[serde(rename = "droppedSize")]
pub dropped_size: Option<i64>,
#[serde(rename = "failureReason")]
pub failure_reason: Option<String>,
pub finished: Option<bool>,
pub id: Option<String>,
#[serde(rename = "lastUpdated")]
pub last_updated: Option<String>,
pub original: Option<String>,
#[serde(rename = "originalCount")]
pub original_count: Option<i32>,
#[serde(rename = "originalSize")]
pub original_size: Option<i64>,
#[serde(rename = "percentCompleted")]
pub percent_completed: Option<i32>,
pub state: Option<String>,
#[serde(rename = "submissionTime")]
pub submission_time: Option<String>,
pub uri: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub(crate) struct DropRequestEntity {
pub drop_request: Option<DropRequestDto>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct DynamicProperty {
pub description: Option<String>,
#[serde(rename = "expressionLanguageScope")]
pub expression_language_scope: Option<String>,
pub name: Option<String>,
pub value: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct DynamicRelationship {
pub description: Option<String>,
pub name: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ExplicitRestrictionDto {
pub explanation: Option<String>,
#[serde(rename = "requiredPermission")]
pub required_permission: Option<RequiredPermissionDto>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ExternalControllerServiceReference {
pub identifier: Option<String>,
pub name: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct FlowAnalysisResultEntity {
#[serde(rename = "flowAnalysisPending")]
pub flow_analysis_pending: Option<bool>,
#[serde(rename = "ruleViolations")]
pub rule_violations: Option<Vec<FlowAnalysisRuleViolationDto>>,
pub rules: Option<Vec<FlowAnalysisRuleDto>>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct FlowAnalysisRuleDefinition {
#[serde(rename = "additionalDetails")]
pub additional_details: Option<bool>,
pub artifact: Option<String>,
#[serde(rename = "buildInfo")]
pub build_info: Option<BuildInfo>,
pub deprecated: Option<bool>,
#[serde(rename = "deprecationAlternatives")]
pub deprecation_alternatives: Option<Vec<String>>,
#[serde(rename = "deprecationReason")]
pub deprecation_reason: Option<String>,
#[serde(rename = "dynamicProperties")]
pub dynamic_properties: Option<Vec<DynamicProperty>>,
#[serde(rename = "explicitRestrictions")]
pub explicit_restrictions: Option<Vec<Restriction>>,
pub group: Option<String>,
#[serde(rename = "propertyDescriptors")]
pub property_descriptors: Option<std::collections::HashMap<String, Option<PropertyDescriptor>>>,
#[serde(rename = "providedApiImplementations")]
pub provided_api_implementations: Option<Vec<DefinedType>>,
pub restricted: Option<bool>,
#[serde(rename = "restrictedExplanation")]
pub restricted_explanation: Option<String>,
#[serde(rename = "seeAlso")]
pub see_also: Option<Vec<String>>,
pub stateful: Option<Stateful>,
#[serde(rename = "supportsDynamicProperties")]
pub supports_dynamic_properties: Option<bool>,
#[serde(rename = "supportsSensitiveDynamicProperties")]
pub supports_sensitive_dynamic_properties: Option<bool>,
#[serde(rename = "systemResourceConsiderations")]
pub system_resource_considerations: Option<Vec<SystemResourceConsideration>>,
pub tags: Option<Vec<String>>,
pub r#type: Option<String>,
#[serde(rename = "typeDescription")]
pub type_description: Option<String>,
pub version: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct FlowAnalysisRuleDto {
pub bundle: Option<BundleDto>,
pub comments: Option<String>,
pub deprecated: Option<bool>,
pub descriptors: Option<std::collections::HashMap<String, Option<PropertyDescriptorDto>>>,
#[serde(rename = "enforcementPolicy")]
pub enforcement_policy: Option<String>,
#[serde(rename = "extensionMissing")]
pub extension_missing: Option<bool>,
pub id: Option<String>,
#[serde(rename = "multipleVersionsAvailable")]
pub multiple_versions_available: Option<bool>,
pub name: Option<String>,
#[serde(rename = "parentGroupId")]
pub parent_group_id: Option<String>,
#[serde(rename = "persistsState")]
pub persists_state: Option<bool>,
pub position: Option<PositionDto>,
pub properties: Option<std::collections::HashMap<String, Option<String>>>,
pub restricted: Option<bool>,
#[serde(rename = "sensitiveDynamicPropertyNames")]
pub sensitive_dynamic_property_names: Option<Vec<String>>,
pub state: Option<String>,
#[serde(rename = "supportsSensitiveDynamicProperties")]
pub supports_sensitive_dynamic_properties: Option<bool>,
pub r#type: Option<String>,
#[serde(rename = "validationErrors")]
pub validation_errors: Option<Vec<String>>,
#[serde(rename = "validationStatus")]
pub validation_status: Option<String>,
#[serde(rename = "versionedComponentId")]
pub versioned_component_id: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct FlowAnalysisRuleEntity {
pub bulletins: Option<Vec<BulletinEntity>>,
pub component: Option<FlowAnalysisRuleDto>,
#[serde(rename = "disconnectedNodeAcknowledged")]
pub disconnected_node_acknowledged: Option<bool>,
pub id: Option<String>,
#[serde(rename = "operatePermissions")]
pub operate_permissions: Option<PermissionsDto>,
pub permissions: Option<PermissionsDto>,
pub position: Option<PositionDto>,
pub revision: Option<RevisionDto>,
pub status: Option<FlowAnalysisRuleStatusDto>,
pub uri: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct FlowAnalysisRuleRunStatusEntity {
#[serde(rename = "disconnectedNodeAcknowledged")]
pub disconnected_node_acknowledged: Option<bool>,
pub revision: Option<RevisionDto>,
pub state: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct FlowAnalysisRuleStatusDto {
#[serde(rename = "activeThreadCount")]
pub active_thread_count: Option<i32>,
#[serde(rename = "runStatus")]
pub run_status: Option<String>,
#[serde(rename = "validationStatus")]
pub validation_status: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct FlowAnalysisRuleTypesEntity {
#[serde(rename = "flowAnalysisRuleTypes")]
pub flow_analysis_rule_types: Option<Vec<DocumentedTypeDto>>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct FlowAnalysisRuleViolationDto {
pub enabled: Option<bool>,
#[serde(rename = "enforcementPolicy")]
pub enforcement_policy: Option<String>,
#[serde(rename = "groupId")]
pub group_id: Option<String>,
#[serde(rename = "issueId")]
pub issue_id: Option<String>,
#[serde(rename = "ruleId")]
pub rule_id: Option<String>,
pub scope: Option<String>,
#[serde(rename = "subjectComponentType")]
pub subject_component_type: Option<String>,
#[serde(rename = "subjectDisplayName")]
pub subject_display_name: Option<String>,
#[serde(rename = "subjectId")]
pub subject_id: Option<String>,
#[serde(rename = "subjectPermissionDto")]
pub subject_permission_dto: Option<PermissionsDto>,
#[serde(rename = "violationMessage")]
pub violation_message: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct FlowAnalysisRulesEntity {
#[serde(rename = "currentTime")]
pub current_time: Option<String>,
#[serde(rename = "flowAnalysisRules")]
pub flow_analysis_rules: Option<Vec<FlowAnalysisRuleEntity>>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct FlowBreadcrumbDto {
pub id: Option<String>,
pub name: Option<String>,
#[serde(rename = "versionControlInformation")]
pub version_control_information: Option<VersionControlInformationDto>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct FlowBreadcrumbEntity {
pub breadcrumb: Option<FlowBreadcrumbDto>,
pub id: Option<String>,
#[serde(rename = "parentBreadcrumb")]
pub parent_breadcrumb: Option<Box<FlowBreadcrumbEntity>>,
pub permissions: Option<PermissionsDto>,
#[serde(rename = "versionedFlowState")]
pub versioned_flow_state: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct FlowComparisonEntity {
#[serde(rename = "componentDifferences")]
pub component_differences: Option<Vec<ComponentDifferenceDto>>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct FlowConfigurationDto {
#[serde(rename = "currentTime")]
pub current_time: Option<String>,
#[serde(rename = "defaultBackPressureDataSizeThreshold")]
pub default_back_pressure_data_size_threshold: Option<String>,
#[serde(rename = "defaultBackPressureObjectThreshold")]
pub default_back_pressure_object_threshold: Option<i64>,
#[serde(rename = "supportsConfigurableAuthorizer")]
pub supports_configurable_authorizer: Option<bool>,
#[serde(rename = "supportsConfigurableUsersAndGroups")]
pub supports_configurable_users_and_groups: Option<bool>,
#[serde(rename = "supportsManagedAuthorizer")]
pub supports_managed_authorizer: Option<bool>,
#[serde(rename = "timeOffset")]
pub time_offset: Option<i32>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub(crate) struct FlowConfigurationEntity {
pub flow_configuration: Option<FlowConfigurationDto>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct FlowDto {
pub connections: Option<Vec<ConnectionEntity>>,
pub funnels: Option<Vec<FunnelEntity>>,
#[serde(rename = "inputPorts")]
pub input_ports: Option<Vec<PortEntity>>,
pub labels: Option<Vec<LabelEntity>>,
#[serde(rename = "outputPorts")]
pub output_ports: Option<Vec<PortEntity>>,
#[serde(rename = "processGroups")]
pub process_groups: Option<Vec<ProcessGroupEntity>>,
pub processors: Option<Vec<ProcessorEntity>>,
#[serde(rename = "remoteProcessGroups")]
pub remote_process_groups: Option<Vec<RemoteProcessGroupEntity>>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub(crate) struct FlowEntity {
pub flow: Option<FlowDto>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct FlowFileDto {
pub attributes: Option<std::collections::HashMap<String, Option<String>>>,
#[serde(rename = "clusterNodeAddress")]
pub cluster_node_address: Option<String>,
#[serde(rename = "clusterNodeId")]
pub cluster_node_id: Option<String>,
#[serde(rename = "contentClaimContainer")]
pub content_claim_container: Option<String>,
#[serde(rename = "contentClaimFileSize")]
pub content_claim_file_size: Option<String>,
#[serde(rename = "contentClaimFileSizeBytes")]
pub content_claim_file_size_bytes: Option<i64>,
#[serde(rename = "contentClaimIdentifier")]
pub content_claim_identifier: Option<String>,
#[serde(rename = "contentClaimOffset")]
pub content_claim_offset: Option<i64>,
#[serde(rename = "contentClaimSection")]
pub content_claim_section: Option<String>,
pub filename: Option<String>,
#[serde(rename = "lineageDuration")]
pub lineage_duration: Option<i64>,
#[serde(rename = "mimeType")]
pub mime_type: Option<String>,
pub penalized: Option<bool>,
#[serde(rename = "penaltyExpiresIn")]
pub penalty_expires_in: Option<i64>,
pub position: Option<i32>,
#[serde(rename = "queuedDuration")]
pub queued_duration: Option<i64>,
pub size: Option<i64>,
pub uri: Option<String>,
pub uuid: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub(crate) struct FlowFileEntity {
pub flow_file: Option<FlowFileDto>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct FlowFileSummaryDto {
#[serde(rename = "clusterNodeAddress")]
pub cluster_node_address: Option<String>,
#[serde(rename = "clusterNodeId")]
pub cluster_node_id: Option<String>,
pub filename: Option<String>,
#[serde(rename = "lineageDuration")]
pub lineage_duration: Option<i64>,
#[serde(rename = "mimeType")]
pub mime_type: Option<String>,
pub penalized: Option<bool>,
#[serde(rename = "penaltyExpiresIn")]
pub penalty_expires_in: Option<i64>,
pub position: Option<i32>,
#[serde(rename = "queuedDuration")]
pub queued_duration: Option<i64>,
pub size: Option<i64>,
pub uri: Option<String>,
pub uuid: Option<String>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub enum FlowMetricsReportingStrategy {
#[serde(rename = "ALL_COMPONENTS")]
AllComponents,
#[serde(rename = "ALL_PROCESS_GROUPS")]
AllProcessGroups,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct FlowRegistryBranchDto {
pub name: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub(crate) struct FlowRegistryBranchEntity {
pub branch: Option<FlowRegistryBranchDto>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct FlowRegistryBranchesEntity {
pub branches: Option<Vec<FlowRegistryBranchEntity>>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct FlowRegistryBucket {
#[serde(rename = "createdTimestamp")]
pub created_timestamp: Option<i64>,
pub description: Option<String>,
pub identifier: Option<String>,
pub name: Option<String>,
pub permissions: Option<FlowRegistryPermissions>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct FlowRegistryBucketDto {
pub created: Option<i64>,
pub description: Option<String>,
pub id: Option<String>,
pub name: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct FlowRegistryBucketEntity {
pub bucket: Option<FlowRegistryBucketDto>,
pub id: Option<String>,
pub permissions: Option<PermissionsDto>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct FlowRegistryBucketsEntity {
pub buckets: Option<Vec<FlowRegistryBucketEntity>>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct FlowRegistryClientDefinition {
#[serde(rename = "additionalDetails")]
pub additional_details: Option<bool>,
pub artifact: Option<String>,
#[serde(rename = "buildInfo")]
pub build_info: Option<BuildInfo>,
pub deprecated: Option<bool>,
#[serde(rename = "deprecationAlternatives")]
pub deprecation_alternatives: Option<Vec<String>>,
#[serde(rename = "deprecationReason")]
pub deprecation_reason: Option<String>,
#[serde(rename = "dynamicProperties")]
pub dynamic_properties: Option<Vec<DynamicProperty>>,
#[serde(rename = "explicitRestrictions")]
pub explicit_restrictions: Option<Vec<Restriction>>,
pub group: Option<String>,
#[serde(rename = "propertyDescriptors")]
pub property_descriptors: Option<std::collections::HashMap<String, Option<PropertyDescriptor>>>,
#[serde(rename = "providedApiImplementations")]
pub provided_api_implementations: Option<Vec<DefinedType>>,
pub restricted: Option<bool>,
#[serde(rename = "restrictedExplanation")]
pub restricted_explanation: Option<String>,
#[serde(rename = "seeAlso")]
pub see_also: Option<Vec<String>>,
pub stateful: Option<Stateful>,
#[serde(rename = "supportsDynamicProperties")]
pub supports_dynamic_properties: Option<bool>,
#[serde(rename = "supportsSensitiveDynamicProperties")]
pub supports_sensitive_dynamic_properties: Option<bool>,
#[serde(rename = "systemResourceConsiderations")]
pub system_resource_considerations: Option<Vec<SystemResourceConsideration>>,
pub tags: Option<Vec<String>>,
pub r#type: Option<String>,
#[serde(rename = "typeDescription")]
pub type_description: Option<String>,
pub version: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct FlowRegistryClientDto {
#[serde(rename = "annotationData")]
pub annotation_data: Option<String>,
pub bundle: Option<BundleDto>,
pub deprecated: Option<bool>,
pub description: Option<String>,
pub descriptors: Option<std::collections::HashMap<String, Option<PropertyDescriptorDto>>>,
#[serde(rename = "extensionMissing")]
pub extension_missing: Option<bool>,
pub id: Option<String>,
#[serde(rename = "multipleVersionsAvailable")]
pub multiple_versions_available: Option<bool>,
pub name: Option<String>,
pub properties: Option<std::collections::HashMap<String, Option<String>>>,
pub restricted: Option<bool>,
#[serde(rename = "sensitiveDynamicPropertyNames")]
pub sensitive_dynamic_property_names: Option<Vec<String>>,
#[serde(rename = "supportsBranching")]
pub supports_branching: Option<bool>,
#[serde(rename = "supportsSensitiveDynamicProperties")]
pub supports_sensitive_dynamic_properties: Option<bool>,
pub r#type: Option<String>,
#[serde(rename = "validationErrors")]
pub validation_errors: Option<Vec<String>>,
#[serde(rename = "validationStatus")]
pub validation_status: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct FlowRegistryClientEntity {
pub bulletins: Option<Vec<BulletinEntity>>,
pub component: Option<FlowRegistryClientDto>,
#[serde(rename = "disconnectedNodeAcknowledged")]
pub disconnected_node_acknowledged: Option<bool>,
pub id: Option<String>,
#[serde(rename = "operatePermissions")]
pub operate_permissions: Option<PermissionsDto>,
pub permissions: Option<PermissionsDto>,
pub position: Option<PositionDto>,
pub revision: Option<RevisionDto>,
pub uri: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct FlowRegistryClientTypesEntity {
#[serde(rename = "flowRegistryClientTypes")]
pub flow_registry_client_types: Option<Vec<DocumentedTypeDto>>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct FlowRegistryClientsEntity {
#[serde(rename = "currentTime")]
pub current_time: Option<String>,
pub registries: Option<Vec<FlowRegistryClientEntity>>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct FlowRegistryPermissions {
#[serde(rename = "canDelete")]
pub can_delete: Option<bool>,
#[serde(rename = "canRead")]
pub can_read: Option<bool>,
#[serde(rename = "canWrite")]
pub can_write: Option<bool>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct FlowSnippetDto {
pub connections: Option<Vec<ConnectionDto>>,
#[serde(rename = "controllerServices")]
pub controller_services: Option<Vec<ControllerServiceDto>>,
pub funnels: Option<Vec<FunnelDto>>,
#[serde(rename = "inputPorts")]
pub input_ports: Option<Vec<PortDto>>,
pub labels: Option<Vec<LabelDto>>,
#[serde(rename = "outputPorts")]
pub output_ports: Option<Vec<PortDto>>,
#[serde(rename = "processGroups")]
pub process_groups: Option<Vec<ProcessGroupDto>>,
pub processors: Option<Vec<ProcessorDto>>,
#[serde(rename = "remoteProcessGroups")]
pub remote_process_groups: Option<Vec<RemoteProcessGroupDto>>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct FunnelDto {
pub id: Option<String>,
#[serde(rename = "parentGroupId")]
pub parent_group_id: Option<String>,
pub position: Option<PositionDto>,
#[serde(rename = "versionedComponentId")]
pub versioned_component_id: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct FunnelEntity {
pub bulletins: Option<Vec<BulletinEntity>>,
pub component: Option<FunnelDto>,
#[serde(rename = "disconnectedNodeAcknowledged")]
pub disconnected_node_acknowledged: Option<bool>,
pub id: Option<String>,
pub permissions: Option<PermissionsDto>,
pub position: Option<PositionDto>,
pub revision: Option<RevisionDto>,
pub uri: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct FunnelsEntity {
pub funnels: Option<Vec<FunnelEntity>>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct GarbageCollectionDto {
#[serde(rename = "collectionCount")]
pub collection_count: Option<i64>,
#[serde(rename = "collectionMillis")]
pub collection_millis: Option<i64>,
#[serde(rename = "collectionTime")]
pub collection_time: Option<String>,
pub name: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct HistoryDto {
pub actions: Option<Vec<ActionEntity>>,
#[serde(rename = "lastRefreshed")]
pub last_refreshed: Option<String>,
pub total: Option<i32>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub(crate) struct HistoryEntity {
pub history: Option<HistoryDto>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub enum IncludedRegistries {
#[serde(rename = "BULLETIN")]
Bulletin,
#[serde(rename = "CLUSTER")]
Cluster,
#[serde(rename = "CONNECTION")]
Connection,
#[serde(rename = "JVM")]
Jvm,
#[serde(rename = "NIFI")]
Nifi,
#[serde(rename = "VERSION_INFO")]
VersionInfo,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct InputPortsEntity {
#[serde(rename = "inputPorts")]
pub input_ports: Option<Vec<PortEntity>>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct IntegerParameter {
pub integer: Option<i32>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct JmxMetricsResultDto {
#[serde(rename = "attributeName")]
pub attribute_name: Option<String>,
#[serde(rename = "attributeValue")]
pub attribute_value: Option<serde_json::Value>,
#[serde(rename = "beanName")]
pub bean_name: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct JmxMetricsResultsEntity {
#[serde(rename = "jmxMetricsResults")]
pub jmx_metrics_results: Option<Vec<JmxMetricsResultDto>>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct LabelDto {
#[serde(rename = "getzIndex")]
pub getz_index: Option<i64>,
pub height: Option<f64>,
pub id: Option<String>,
pub label: Option<String>,
#[serde(rename = "parentGroupId")]
pub parent_group_id: Option<String>,
pub position: Option<PositionDto>,
pub style: Option<std::collections::HashMap<String, Option<String>>>,
#[serde(rename = "versionedComponentId")]
pub versioned_component_id: Option<String>,
pub width: Option<f64>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct LabelEntity {
pub bulletins: Option<Vec<BulletinEntity>>,
pub component: Option<LabelDto>,
pub dimensions: Option<DimensionsDto>,
#[serde(rename = "disconnectedNodeAcknowledged")]
pub disconnected_node_acknowledged: Option<bool>,
#[serde(rename = "getzIndex")]
pub getz_index: Option<i64>,
pub id: Option<String>,
pub permissions: Option<PermissionsDto>,
pub position: Option<PositionDto>,
pub revision: Option<RevisionDto>,
pub uri: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct LabelsEntity {
pub labels: Option<Vec<LabelEntity>>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct LatestProvenanceEventsDto {
#[serde(rename = "componentId")]
pub component_id: Option<String>,
#[serde(rename = "provenanceEvents")]
pub provenance_events: Option<Vec<ProvenanceEventDto>>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub(crate) struct LatestProvenanceEventsEntity {
pub latest_provenance_events: Option<LatestProvenanceEventsDto>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct LineageDto {
pub expiration: Option<String>,
pub finished: Option<bool>,
pub id: Option<String>,
#[serde(rename = "percentCompleted")]
pub percent_completed: Option<i32>,
pub request: Option<LineageRequestDto>,
pub results: Option<LineageResultsDto>,
#[serde(rename = "submissionTime")]
pub submission_time: Option<String>,
pub uri: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub(crate) struct LineageEntity {
pub lineage: Option<LineageDto>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct LineageRequestDto {
#[serde(rename = "clusterNodeId")]
pub cluster_node_id: Option<String>,
#[serde(rename = "eventId")]
pub event_id: Option<i64>,
#[serde(rename = "lineageRequestType")]
pub lineage_request_type: Option<String>,
pub uuid: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct LineageResultsDto {
pub errors: Option<Vec<String>>,
pub links: Option<Vec<ProvenanceLinkDto>>,
pub nodes: Option<Vec<ProvenanceNodeDto>>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ListenPortDto {
#[serde(rename = "applicationProtocols")]
pub application_protocols: Option<Vec<String>>,
#[serde(rename = "componentClass")]
pub component_class: Option<String>,
#[serde(rename = "componentId")]
pub component_id: Option<String>,
#[serde(rename = "componentName")]
pub component_name: Option<String>,
#[serde(rename = "componentType")]
pub component_type: Option<String>,
#[serde(rename = "parentGroupId")]
pub parent_group_id: Option<String>,
#[serde(rename = "parentGroupName")]
pub parent_group_name: Option<String>,
#[serde(rename = "portName")]
pub port_name: Option<String>,
#[serde(rename = "portNumber")]
pub port_number: Option<i32>,
#[serde(rename = "transportProtocol")]
pub transport_protocol: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ListenPortsEntity {
#[serde(rename = "listenPorts")]
pub listen_ports: Option<Vec<ListenPortDto>>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ListingRequestDto {
#[serde(rename = "destinationRunning")]
pub destination_running: Option<bool>,
#[serde(rename = "failureReason")]
pub failure_reason: Option<String>,
pub finished: Option<bool>,
#[serde(rename = "flowFileSummaries")]
pub flow_file_summaries: Option<Vec<FlowFileSummaryDto>>,
pub id: Option<String>,
#[serde(rename = "lastUpdated")]
pub last_updated: Option<String>,
#[serde(rename = "maxResults")]
pub max_results: Option<i32>,
#[serde(rename = "percentCompleted")]
pub percent_completed: Option<i32>,
#[serde(rename = "queueSize")]
pub queue_size: Option<QueueSizeDto>,
#[serde(rename = "sourceRunning")]
pub source_running: Option<bool>,
pub state: Option<String>,
#[serde(rename = "submissionTime")]
pub submission_time: Option<String>,
pub uri: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub(crate) struct ListingRequestEntity {
pub listing_request: Option<ListingRequestDto>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct LongParameter {
pub long: Option<i64>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct MultiProcessorUseCase {
pub configurations: Option<Vec<ProcessorConfiguration>>,
pub description: Option<String>,
pub keywords: Option<Vec<String>>,
pub notes: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct NarCoordinateDto {
pub artifact: Option<String>,
pub group: Option<String>,
pub version: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct NarDetailsEntity {
#[serde(rename = "controllerServiceTypes")]
pub controller_service_types: Option<Vec<DocumentedTypeDto>>,
#[serde(rename = "dependentCoordinates")]
pub dependent_coordinates: Option<Vec<NarCoordinateDto>>,
#[serde(rename = "flowAnalysisRuleTypes")]
pub flow_analysis_rule_types: Option<Vec<DocumentedTypeDto>>,
#[serde(rename = "flowRegistryClientTypes")]
pub flow_registry_client_types: Option<Vec<DocumentedTypeDto>>,
#[serde(rename = "narSummary")]
pub nar_summary: Option<NarSummaryDto>,
#[serde(rename = "parameterProviderTypes")]
pub parameter_provider_types: Option<Vec<DocumentedTypeDto>>,
#[serde(rename = "processorTypes")]
pub processor_types: Option<Vec<DocumentedTypeDto>>,
#[serde(rename = "reportingTaskTypes")]
pub reporting_task_types: Option<Vec<DocumentedTypeDto>>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct NarSummariesEntity {
#[serde(rename = "currentTime")]
pub current_time: Option<String>,
#[serde(rename = "narSummaries")]
pub nar_summaries: Option<Vec<NarSummaryEntity>>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct NarSummaryDto {
#[serde(rename = "buildTime")]
pub build_time: Option<String>,
pub coordinate: Option<NarCoordinateDto>,
#[serde(rename = "createdBy")]
pub created_by: Option<String>,
#[serde(rename = "dependencyCoordinate")]
pub dependency_coordinate: Option<NarCoordinateDto>,
pub digest: Option<String>,
#[serde(rename = "extensionCount")]
pub extension_count: Option<i32>,
#[serde(rename = "failureMessage")]
pub failure_message: Option<String>,
pub identifier: Option<String>,
#[serde(rename = "installComplete")]
pub install_complete: Option<bool>,
#[serde(rename = "sourceIdentifier")]
pub source_identifier: Option<String>,
#[serde(rename = "sourceType")]
pub source_type: Option<String>,
pub state: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub(crate) struct NarSummaryEntity {
pub nar_summary: Option<NarSummaryDto>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct NodeConnectionStatisticsSnapshotDto {
pub address: Option<String>,
#[serde(rename = "apiPort")]
pub api_port: Option<i32>,
#[serde(rename = "nodeId")]
pub node_id: Option<String>,
#[serde(rename = "statisticsSnapshot")]
pub statistics_snapshot: Option<ConnectionStatisticsSnapshotDto>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct NodeConnectionStatusSnapshotDto {
pub address: Option<String>,
#[serde(rename = "apiPort")]
pub api_port: Option<i32>,
#[serde(rename = "nodeId")]
pub node_id: Option<String>,
#[serde(rename = "statusSnapshot")]
pub status_snapshot: Option<ConnectionStatusSnapshotDto>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct NodeCountersSnapshotDto {
pub address: Option<String>,
#[serde(rename = "apiPort")]
pub api_port: Option<i32>,
#[serde(rename = "nodeId")]
pub node_id: Option<String>,
pub snapshot: Option<CountersSnapshotDto>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct NodeDto {
#[serde(rename = "activeThreadCount")]
pub active_thread_count: Option<i32>,
pub address: Option<String>,
#[serde(rename = "apiPort")]
pub api_port: Option<i32>,
#[serde(rename = "bytesQueued")]
pub bytes_queued: Option<i64>,
#[serde(rename = "connectionRequested")]
pub connection_requested: Option<String>,
pub events: Option<Vec<NodeEventDto>>,
#[serde(rename = "flowFileBytes")]
pub flow_file_bytes: Option<i64>,
#[serde(rename = "flowFilesQueued")]
pub flow_files_queued: Option<i32>,
pub heartbeat: Option<String>,
#[serde(rename = "nodeId")]
pub node_id: Option<String>,
#[serde(rename = "nodeStartTime")]
pub node_start_time: Option<String>,
pub queued: Option<String>,
pub roles: Option<Vec<String>>,
pub status: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub(crate) struct NodeEntity {
pub node: Option<NodeDto>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct NodeEventDto {
pub category: Option<String>,
pub message: Option<String>,
pub timestamp: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct NodePortStatusSnapshotDto {
pub address: Option<String>,
#[serde(rename = "apiPort")]
pub api_port: Option<i32>,
#[serde(rename = "nodeId")]
pub node_id: Option<String>,
#[serde(rename = "statusSnapshot")]
pub status_snapshot: Option<PortStatusSnapshotDto>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct NodeProcessGroupStatusSnapshotDto {
pub address: Option<String>,
#[serde(rename = "apiPort")]
pub api_port: Option<i32>,
#[serde(rename = "nodeId")]
pub node_id: Option<String>,
#[serde(rename = "statusSnapshot")]
pub status_snapshot: Option<ProcessGroupStatusSnapshotDto>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct NodeProcessorStatusSnapshotDto {
pub address: Option<String>,
#[serde(rename = "apiPort")]
pub api_port: Option<i32>,
#[serde(rename = "nodeId")]
pub node_id: Option<String>,
#[serde(rename = "statusSnapshot")]
pub status_snapshot: Option<ProcessorStatusSnapshotDto>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct NodeRemoteProcessGroupStatusSnapshotDto {
pub address: Option<String>,
#[serde(rename = "apiPort")]
pub api_port: Option<i32>,
#[serde(rename = "nodeId")]
pub node_id: Option<String>,
#[serde(rename = "statusSnapshot")]
pub status_snapshot: Option<RemoteProcessGroupStatusSnapshotDto>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct NodeReplayLastEventSnapshotDto {
pub address: Option<String>,
#[serde(rename = "apiPort")]
pub api_port: Option<i32>,
#[serde(rename = "nodeId")]
pub node_id: Option<String>,
pub snapshot: Option<ReplayLastEventSnapshotDto>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct NodeSearchResultDto {
pub address: Option<String>,
pub id: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct NodeStatusSnapshotsDto {
pub address: Option<String>,
#[serde(rename = "apiPort")]
pub api_port: Option<i32>,
#[serde(rename = "nodeId")]
pub node_id: Option<String>,
#[serde(rename = "statusSnapshots")]
pub status_snapshots: Option<Vec<StatusSnapshotDto>>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct NodeSystemDiagnosticsSnapshotDto {
pub address: Option<String>,
#[serde(rename = "apiPort")]
pub api_port: Option<i32>,
#[serde(rename = "nodeId")]
pub node_id: Option<String>,
pub snapshot: Option<SystemDiagnosticsSnapshotDto>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct OutputPortsEntity {
#[serde(rename = "outputPorts")]
pub output_ports: Option<Vec<PortEntity>>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ParameterContextDto {
#[serde(rename = "boundProcessGroups")]
pub bound_process_groups: Option<Vec<ProcessGroupEntity>>,
pub description: Option<String>,
pub id: Option<String>,
#[serde(rename = "inheritedParameterContexts")]
pub inherited_parameter_contexts: Option<Vec<ParameterContextReferenceEntity>>,
pub name: Option<String>,
#[serde(rename = "parameterProviderConfiguration")]
pub parameter_provider_configuration: Option<ParameterProviderConfigurationEntity>,
pub parameters: Option<Vec<ParameterEntity>>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ParameterContextEntity {
pub bulletins: Option<Vec<BulletinEntity>>,
pub component: Option<ParameterContextDto>,
#[serde(rename = "disconnectedNodeAcknowledged")]
pub disconnected_node_acknowledged: Option<bool>,
pub id: Option<String>,
pub permissions: Option<PermissionsDto>,
pub position: Option<PositionDto>,
pub revision: Option<RevisionDto>,
pub uri: Option<String>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub enum ParameterContextHandlingStrategy {
#[serde(rename = "KEEP_EXISTING")]
KeepExisting,
#[serde(rename = "REPLACE")]
Replace,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ParameterContextReferenceDto {
pub id: Option<String>,
pub name: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ParameterContextReferenceEntity {
pub component: Option<ParameterContextReferenceDto>,
pub id: Option<String>,
pub permissions: Option<PermissionsDto>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ParameterContextUpdateEntity {
#[serde(rename = "parameterContext")]
pub parameter_context: Option<ParameterContextDto>,
#[serde(rename = "parameterContextRevision")]
pub parameter_context_revision: Option<RevisionDto>,
#[serde(rename = "referencingComponents")]
pub referencing_components: Option<Vec<AffectedComponentEntity>>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ParameterContextUpdateRequestDto {
pub complete: Option<bool>,
#[serde(rename = "failureReason")]
pub failure_reason: Option<String>,
#[serde(rename = "lastUpdated")]
pub last_updated: Option<String>,
#[serde(rename = "parameterContext")]
pub parameter_context: Option<ParameterContextDto>,
#[serde(rename = "percentCompleted")]
pub percent_completed: Option<i32>,
#[serde(rename = "referencingComponents")]
pub referencing_components: Option<Vec<AffectedComponentEntity>>,
#[serde(rename = "requestId")]
pub request_id: Option<String>,
pub state: Option<String>,
#[serde(rename = "submissionTime")]
pub submission_time: Option<String>,
#[serde(rename = "updateSteps")]
pub update_steps: Option<Vec<ParameterContextUpdateStepDto>>,
pub uri: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ParameterContextUpdateRequestEntity {
#[serde(rename = "parameterContextRevision")]
pub parameter_context_revision: Option<RevisionDto>,
pub request: Option<ParameterContextUpdateRequestDto>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ParameterContextUpdateStepDto {
pub complete: Option<bool>,
pub description: Option<String>,
#[serde(rename = "failureReason")]
pub failure_reason: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ParameterContextValidationRequestDto {
pub complete: Option<bool>,
#[serde(rename = "componentValidationResults")]
pub component_validation_results: Option<ComponentValidationResultsEntity>,
#[serde(rename = "failureReason")]
pub failure_reason: Option<String>,
#[serde(rename = "lastUpdated")]
pub last_updated: Option<String>,
#[serde(rename = "parameterContext")]
pub parameter_context: Option<ParameterContextDto>,
#[serde(rename = "percentCompleted")]
pub percent_completed: Option<i32>,
#[serde(rename = "requestId")]
pub request_id: Option<String>,
pub state: Option<String>,
#[serde(rename = "submissionTime")]
pub submission_time: Option<String>,
#[serde(rename = "updateSteps")]
pub update_steps: Option<Vec<ParameterContextValidationStepDto>>,
pub uri: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ParameterContextValidationRequestEntity {
#[serde(rename = "disconnectedNodeAcknowledged")]
pub disconnected_node_acknowledged: Option<bool>,
pub request: Option<ParameterContextValidationRequestDto>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ParameterContextValidationStepDto {
pub complete: Option<bool>,
pub description: Option<String>,
#[serde(rename = "failureReason")]
pub failure_reason: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ParameterContextsEntity {
#[serde(rename = "currentTime")]
pub current_time: Option<String>,
#[serde(rename = "parameterContexts")]
pub parameter_contexts: Option<Vec<ParameterContextEntity>>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ParameterDto {
pub description: Option<String>,
pub inherited: Option<bool>,
pub name: Option<String>,
#[serde(rename = "parameterContext")]
pub parameter_context: Option<ParameterContextReferenceEntity>,
pub provided: Option<bool>,
#[serde(rename = "referencedAssets")]
pub referenced_assets: Option<Vec<AssetReferenceDto>>,
#[serde(rename = "referencingComponents")]
pub referencing_components: Option<Vec<AffectedComponentEntity>>,
pub sensitive: Option<bool>,
pub value: Option<String>,
#[serde(rename = "valueRemoved")]
pub value_removed: Option<bool>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ParameterEntity {
#[serde(rename = "canWrite")]
pub can_write: Option<bool>,
pub parameter: Option<ParameterDto>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ParameterGroupConfigurationEntity {
#[serde(rename = "groupName")]
pub group_name: Option<String>,
#[serde(rename = "parameterContextName")]
pub parameter_context_name: Option<String>,
#[serde(rename = "parameterSensitivities")]
pub parameter_sensitivities: Option<std::collections::HashMap<String, Option<String>>>,
pub synchronized: Option<bool>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ParameterProviderApplyParametersRequestDto {
pub complete: Option<bool>,
#[serde(rename = "failureReason")]
pub failure_reason: Option<String>,
#[serde(rename = "lastUpdated")]
pub last_updated: Option<String>,
#[serde(rename = "parameterContextUpdates")]
pub parameter_context_updates: Option<Vec<ParameterContextUpdateEntity>>,
#[serde(rename = "parameterProvider")]
pub parameter_provider: Option<ParameterProviderDto>,
#[serde(rename = "percentCompleted")]
pub percent_completed: Option<i32>,
#[serde(rename = "referencingComponents")]
pub referencing_components: Option<Vec<AffectedComponentEntity>>,
#[serde(rename = "requestId")]
pub request_id: Option<String>,
pub state: Option<String>,
#[serde(rename = "submissionTime")]
pub submission_time: Option<String>,
#[serde(rename = "updateSteps")]
pub update_steps: Option<Vec<ParameterProviderApplyParametersUpdateStepDto>>,
pub uri: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub(crate) struct ParameterProviderApplyParametersRequestEntity {
pub request: Option<ParameterProviderApplyParametersRequestDto>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ParameterProviderApplyParametersUpdateStepDto {
pub complete: Option<bool>,
pub description: Option<String>,
#[serde(rename = "failureReason")]
pub failure_reason: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ParameterProviderConfigurationDto {
#[serde(rename = "parameterGroupName")]
pub parameter_group_name: Option<String>,
#[serde(rename = "parameterProviderId")]
pub parameter_provider_id: Option<String>,
#[serde(rename = "parameterProviderName")]
pub parameter_provider_name: Option<String>,
pub synchronized: Option<bool>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ParameterProviderConfigurationEntity {
pub component: Option<ParameterProviderConfigurationDto>,
pub id: Option<String>,
pub permissions: Option<PermissionsDto>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ParameterProviderDefinition {
#[serde(rename = "additionalDetails")]
pub additional_details: Option<bool>,
pub artifact: Option<String>,
#[serde(rename = "buildInfo")]
pub build_info: Option<BuildInfo>,
pub deprecated: Option<bool>,
#[serde(rename = "deprecationAlternatives")]
pub deprecation_alternatives: Option<Vec<String>>,
#[serde(rename = "deprecationReason")]
pub deprecation_reason: Option<String>,
#[serde(rename = "dynamicProperties")]
pub dynamic_properties: Option<Vec<DynamicProperty>>,
#[serde(rename = "explicitRestrictions")]
pub explicit_restrictions: Option<Vec<Restriction>>,
pub group: Option<String>,
#[serde(rename = "propertyDescriptors")]
pub property_descriptors: Option<std::collections::HashMap<String, Option<PropertyDescriptor>>>,
#[serde(rename = "providedApiImplementations")]
pub provided_api_implementations: Option<Vec<DefinedType>>,
pub restricted: Option<bool>,
#[serde(rename = "restrictedExplanation")]
pub restricted_explanation: Option<String>,
#[serde(rename = "seeAlso")]
pub see_also: Option<Vec<String>>,
pub stateful: Option<Stateful>,
#[serde(rename = "supportsDynamicProperties")]
pub supports_dynamic_properties: Option<bool>,
#[serde(rename = "supportsSensitiveDynamicProperties")]
pub supports_sensitive_dynamic_properties: Option<bool>,
#[serde(rename = "systemResourceConsiderations")]
pub system_resource_considerations: Option<Vec<SystemResourceConsideration>>,
pub tags: Option<Vec<String>>,
pub r#type: Option<String>,
#[serde(rename = "typeDescription")]
pub type_description: Option<String>,
pub version: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ParameterProviderDto {
#[serde(rename = "affectedComponents")]
pub affected_components: Option<Vec<AffectedComponentEntity>>,
#[serde(rename = "annotationData")]
pub annotation_data: Option<String>,
pub bundle: Option<BundleDto>,
pub comments: Option<String>,
#[serde(rename = "customUiUrl")]
pub custom_ui_url: Option<String>,
pub deprecated: Option<bool>,
pub descriptors: Option<std::collections::HashMap<String, Option<PropertyDescriptorDto>>>,
#[serde(rename = "extensionMissing")]
pub extension_missing: Option<bool>,
pub id: Option<String>,
#[serde(rename = "multipleVersionsAvailable")]
pub multiple_versions_available: Option<bool>,
pub name: Option<String>,
#[serde(rename = "parameterGroupConfigurations")]
pub parameter_group_configurations: Option<Vec<ParameterGroupConfigurationEntity>>,
#[serde(rename = "parameterStatus")]
pub parameter_status: Option<Vec<ParameterStatusDto>>,
#[serde(rename = "parentGroupId")]
pub parent_group_id: Option<String>,
#[serde(rename = "persistsState")]
pub persists_state: Option<bool>,
pub position: Option<PositionDto>,
pub properties: Option<std::collections::HashMap<String, Option<String>>>,
#[serde(rename = "referencingParameterContexts")]
pub referencing_parameter_contexts: Option<Vec<ParameterProviderReferencingComponentEntity>>,
pub restricted: Option<bool>,
pub r#type: Option<String>,
#[serde(rename = "validationErrors")]
pub validation_errors: Option<Vec<String>>,
#[serde(rename = "validationStatus")]
pub validation_status: Option<String>,
#[serde(rename = "versionedComponentId")]
pub versioned_component_id: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ParameterProviderEntity {
pub bulletins: Option<Vec<BulletinEntity>>,
pub component: Option<ParameterProviderDto>,
#[serde(rename = "disconnectedNodeAcknowledged")]
pub disconnected_node_acknowledged: Option<bool>,
pub id: Option<String>,
pub permissions: Option<PermissionsDto>,
pub position: Option<PositionDto>,
pub revision: Option<RevisionDto>,
pub uri: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ParameterProviderParameterApplicationEntity {
#[serde(rename = "disconnectedNodeAcknowledged")]
pub disconnected_node_acknowledged: Option<bool>,
pub id: Option<String>,
#[serde(rename = "parameterGroupConfigurations")]
pub parameter_group_configurations: Option<Vec<ParameterGroupConfigurationEntity>>,
pub revision: Option<RevisionDto>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ParameterProviderParameterFetchEntity {
#[serde(rename = "disconnectedNodeAcknowledged")]
pub disconnected_node_acknowledged: Option<bool>,
pub id: Option<String>,
pub revision: Option<RevisionDto>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ParameterProviderReference {
pub bundle: Option<Bundle>,
pub identifier: Option<String>,
pub name: Option<String>,
pub r#type: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ParameterProviderReferencingComponentDto {
pub id: Option<String>,
pub name: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ParameterProviderReferencingComponentEntity {
pub bulletins: Option<Vec<BulletinEntity>>,
pub component: Option<ParameterProviderReferencingComponentDto>,
#[serde(rename = "disconnectedNodeAcknowledged")]
pub disconnected_node_acknowledged: Option<bool>,
pub id: Option<String>,
pub permissions: Option<PermissionsDto>,
pub position: Option<PositionDto>,
pub revision: Option<RevisionDto>,
pub uri: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ParameterProviderReferencingComponentsEntity {
#[serde(rename = "parameterProviderReferencingComponents")]
pub parameter_provider_referencing_components:
Option<Vec<ParameterProviderReferencingComponentEntity>>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ParameterProviderTypesEntity {
#[serde(rename = "parameterProviderTypes")]
pub parameter_provider_types: Option<Vec<DocumentedTypeDto>>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ParameterProvidersEntity {
#[serde(rename = "currentTime")]
pub current_time: Option<String>,
#[serde(rename = "parameterProviders")]
pub parameter_providers: Option<Vec<ParameterProviderEntity>>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ParameterStatusDto {
pub parameter: Option<ParameterEntity>,
pub status: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PasteRequestEntity {
#[serde(rename = "copyResponse")]
pub copy_response: Option<CopyResponseEntity>,
#[serde(rename = "disconnectedNodeAcknowledged")]
pub disconnected_node_acknowledged: Option<bool>,
pub revision: Option<RevisionDto>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PasteResponseEntity {
pub flow: Option<FlowDto>,
pub revision: Option<RevisionDto>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PeerDto {
#[serde(rename = "flowFileCount")]
pub flow_file_count: Option<i32>,
pub hostname: Option<String>,
pub port: Option<i32>,
pub secure: Option<bool>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PeersEntity {
pub peers: Option<Vec<PeerDto>>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PermissionsDto {
#[serde(rename = "canRead")]
pub can_read: Option<bool>,
#[serde(rename = "canWrite")]
pub can_write: Option<bool>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PortDto {
#[serde(rename = "allowRemoteAccess")]
pub allow_remote_access: Option<bool>,
pub comments: Option<String>,
#[serde(rename = "concurrentlySchedulableTaskCount")]
pub concurrently_schedulable_task_count: Option<i32>,
pub id: Option<String>,
pub name: Option<String>,
#[serde(rename = "parentGroupId")]
pub parent_group_id: Option<String>,
#[serde(rename = "portFunction")]
pub port_function: Option<String>,
pub position: Option<PositionDto>,
pub state: Option<String>,
pub transmitting: Option<bool>,
pub r#type: Option<String>,
#[serde(rename = "validationErrors")]
pub validation_errors: Option<Vec<String>>,
#[serde(rename = "versionedComponentId")]
pub versioned_component_id: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PortEntity {
#[serde(rename = "allowRemoteAccess")]
pub allow_remote_access: Option<bool>,
pub bulletins: Option<Vec<BulletinEntity>>,
pub component: Option<PortDto>,
#[serde(rename = "disconnectedNodeAcknowledged")]
pub disconnected_node_acknowledged: Option<bool>,
pub id: Option<String>,
#[serde(rename = "operatePermissions")]
pub operate_permissions: Option<PermissionsDto>,
pub permissions: Option<PermissionsDto>,
#[serde(rename = "portType")]
pub port_type: Option<String>,
pub position: Option<PositionDto>,
pub revision: Option<RevisionDto>,
pub status: Option<PortStatusDto>,
pub uri: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PortRunStatusEntity {
#[serde(rename = "disconnectedNodeAcknowledged")]
pub disconnected_node_acknowledged: Option<bool>,
pub revision: Option<RevisionDto>,
pub state: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PortStatusDto {
#[serde(rename = "aggregateSnapshot")]
pub aggregate_snapshot: Option<PortStatusSnapshotDto>,
#[serde(rename = "groupId")]
pub group_id: Option<String>,
pub id: Option<String>,
pub name: Option<String>,
#[serde(rename = "nodeSnapshots")]
pub node_snapshots: Option<Vec<NodePortStatusSnapshotDto>>,
#[serde(rename = "runStatus")]
pub run_status: Option<String>,
#[serde(rename = "statsLastRefreshed")]
pub stats_last_refreshed: Option<String>,
pub transmitting: Option<bool>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PortStatusEntity {
#[serde(rename = "canRead")]
pub can_read: Option<bool>,
#[serde(rename = "portStatus")]
pub port_status: Option<PortStatusDto>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PortStatusSnapshotDto {
#[serde(rename = "activeThreadCount")]
pub active_thread_count: Option<i32>,
#[serde(rename = "bytesIn")]
pub bytes_in: Option<i64>,
#[serde(rename = "bytesOut")]
pub bytes_out: Option<i64>,
#[serde(rename = "flowFilesIn")]
pub flow_files_in: Option<i32>,
#[serde(rename = "flowFilesOut")]
pub flow_files_out: Option<i32>,
#[serde(rename = "groupId")]
pub group_id: Option<String>,
pub id: Option<String>,
pub input: Option<String>,
pub name: Option<String>,
pub output: Option<String>,
#[serde(rename = "runStatus")]
pub run_status: Option<String>,
pub transmitting: Option<bool>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PortStatusSnapshotEntity {
#[serde(rename = "canRead")]
pub can_read: Option<bool>,
pub id: Option<String>,
#[serde(rename = "portStatusSnapshot")]
pub port_status_snapshot: Option<PortStatusSnapshotDto>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct Position {
pub x: Option<f64>,
pub y: Option<f64>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PositionDto {
pub x: Option<f64>,
pub y: Option<f64>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PreviousValueDto {
#[serde(rename = "previousValue")]
pub previous_value: Option<String>,
pub timestamp: Option<String>,
#[serde(rename = "userIdentity")]
pub user_identity: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PrioritizerTypesEntity {
#[serde(rename = "prioritizerTypes")]
pub prioritizer_types: Option<Vec<DocumentedTypeDto>>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ProcessGroupDto {
#[serde(rename = "activeRemotePortCount")]
pub active_remote_port_count: Option<i32>,
pub comments: Option<String>,
pub contents: Option<FlowSnippetDto>,
#[serde(rename = "defaultBackPressureDataSizeThreshold")]
pub default_back_pressure_data_size_threshold: Option<String>,
#[serde(rename = "defaultBackPressureObjectThreshold")]
pub default_back_pressure_object_threshold: Option<i64>,
#[serde(rename = "defaultFlowFileExpiration")]
pub default_flow_file_expiration: Option<String>,
#[serde(rename = "disabledCount")]
pub disabled_count: Option<i32>,
#[serde(rename = "executionEngine")]
pub execution_engine: Option<String>,
#[serde(rename = "flowfileConcurrency")]
pub flowfile_concurrency: Option<String>,
#[serde(rename = "flowfileOutboundPolicy")]
pub flowfile_outbound_policy: Option<String>,
pub id: Option<String>,
#[serde(rename = "inactiveRemotePortCount")]
pub inactive_remote_port_count: Option<i32>,
#[serde(rename = "inputPortCount")]
pub input_port_count: Option<i32>,
#[serde(rename = "invalidCount")]
pub invalid_count: Option<i32>,
#[serde(rename = "localInputPortCount")]
pub local_input_port_count: Option<i32>,
#[serde(rename = "localOutputPortCount")]
pub local_output_port_count: Option<i32>,
#[serde(rename = "locallyModifiedAndStaleCount")]
pub locally_modified_and_stale_count: Option<i32>,
#[serde(rename = "locallyModifiedCount")]
pub locally_modified_count: Option<i32>,
#[serde(rename = "logFileSuffix")]
pub log_file_suffix: Option<String>,
#[serde(rename = "maxConcurrentTasks")]
pub max_concurrent_tasks: Option<i32>,
pub name: Option<String>,
#[serde(rename = "outputPortCount")]
pub output_port_count: Option<i32>,
#[serde(rename = "parameterContext")]
pub parameter_context: Option<ParameterContextReferenceEntity>,
#[serde(rename = "parentGroupId")]
pub parent_group_id: Option<String>,
pub position: Option<PositionDto>,
#[serde(rename = "publicInputPortCount")]
pub public_input_port_count: Option<i32>,
#[serde(rename = "publicOutputPortCount")]
pub public_output_port_count: Option<i32>,
#[serde(rename = "runningCount")]
pub running_count: Option<i32>,
#[serde(rename = "staleCount")]
pub stale_count: Option<i32>,
#[serde(rename = "statelessFlowTimeout")]
pub stateless_flow_timeout: Option<String>,
#[serde(rename = "statelessGroupScheduledState")]
pub stateless_group_scheduled_state: Option<String>,
#[serde(rename = "stoppedCount")]
pub stopped_count: Option<i32>,
#[serde(rename = "syncFailureCount")]
pub sync_failure_count: Option<i32>,
#[serde(rename = "upToDateCount")]
pub up_to_date_count: Option<i32>,
#[serde(rename = "versionControlInformation")]
pub version_control_information: Option<VersionControlInformationDto>,
#[serde(rename = "versionedComponentId")]
pub versioned_component_id: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ProcessGroupEntity {
#[serde(rename = "activeRemotePortCount")]
pub active_remote_port_count: Option<i32>,
pub bulletins: Option<Vec<BulletinEntity>>,
pub component: Option<ProcessGroupDto>,
#[serde(rename = "disabledCount")]
pub disabled_count: Option<i32>,
#[serde(rename = "disconnectedNodeAcknowledged")]
pub disconnected_node_acknowledged: Option<bool>,
pub id: Option<String>,
#[serde(rename = "inactiveRemotePortCount")]
pub inactive_remote_port_count: Option<i32>,
#[serde(rename = "inputPortCount")]
pub input_port_count: Option<i32>,
#[serde(rename = "invalidCount")]
pub invalid_count: Option<i32>,
#[serde(rename = "localInputPortCount")]
pub local_input_port_count: Option<i32>,
#[serde(rename = "localOutputPortCount")]
pub local_output_port_count: Option<i32>,
#[serde(rename = "locallyModifiedAndStaleCount")]
pub locally_modified_and_stale_count: Option<i32>,
#[serde(rename = "locallyModifiedCount")]
pub locally_modified_count: Option<i32>,
#[serde(rename = "outputPortCount")]
pub output_port_count: Option<i32>,
#[serde(rename = "parameterContext")]
pub parameter_context: Option<ParameterContextReferenceEntity>,
pub permissions: Option<PermissionsDto>,
pub position: Option<PositionDto>,
#[serde(rename = "processGroupUpdateStrategy")]
pub process_group_update_strategy: Option<String>,
#[serde(rename = "publicInputPortCount")]
pub public_input_port_count: Option<i32>,
#[serde(rename = "publicOutputPortCount")]
pub public_output_port_count: Option<i32>,
pub revision: Option<RevisionDto>,
#[serde(rename = "runningCount")]
pub running_count: Option<i32>,
#[serde(rename = "staleCount")]
pub stale_count: Option<i32>,
pub status: Option<ProcessGroupStatusDto>,
#[serde(rename = "stoppedCount")]
pub stopped_count: Option<i32>,
#[serde(rename = "syncFailureCount")]
pub sync_failure_count: Option<i32>,
#[serde(rename = "upToDateCount")]
pub up_to_date_count: Option<i32>,
pub uri: Option<String>,
#[serde(rename = "versionedFlowSnapshot")]
pub versioned_flow_snapshot: Option<RegisteredFlowSnapshot>,
#[serde(rename = "versionedFlowState")]
pub versioned_flow_state: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ProcessGroupFlowDto {
pub breadcrumb: Option<FlowBreadcrumbEntity>,
pub flow: Option<FlowDto>,
pub id: Option<String>,
#[serde(rename = "lastRefreshed")]
pub last_refreshed: Option<String>,
#[serde(rename = "parameterContext")]
pub parameter_context: Option<ParameterContextReferenceEntity>,
#[serde(rename = "parentGroupId")]
pub parent_group_id: Option<String>,
pub uri: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ProcessGroupFlowEntity {
pub permissions: Option<PermissionsDto>,
#[serde(rename = "processGroupFlow")]
pub process_group_flow: Option<ProcessGroupFlowDto>,
pub revision: Option<RevisionDto>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ProcessGroupImportEntity {
#[serde(rename = "disconnectedNodeAcknowledged")]
pub disconnected_node_acknowledged: Option<bool>,
#[serde(rename = "processGroupRevision")]
pub process_group_revision: Option<RevisionDto>,
#[serde(rename = "versionedFlowSnapshot")]
pub versioned_flow_snapshot: Option<RegisteredFlowSnapshot>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ProcessGroupNameDto {
pub id: Option<String>,
pub name: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ProcessGroupReplaceRequestDto {
pub complete: Option<bool>,
#[serde(rename = "failureReason")]
pub failure_reason: Option<String>,
#[serde(rename = "lastUpdated")]
pub last_updated: Option<String>,
#[serde(rename = "percentCompleted")]
pub percent_completed: Option<i32>,
#[serde(rename = "processGroupId")]
pub process_group_id: Option<String>,
#[serde(rename = "requestId")]
pub request_id: Option<String>,
pub state: Option<String>,
pub uri: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ProcessGroupReplaceRequestEntity {
#[serde(rename = "processGroupRevision")]
pub process_group_revision: Option<RevisionDto>,
pub request: Option<ProcessGroupReplaceRequestDto>,
#[serde(rename = "versionedFlowSnapshot")]
pub versioned_flow_snapshot: Option<RegisteredFlowSnapshot>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ProcessGroupStatusDto {
#[serde(rename = "aggregateSnapshot")]
pub aggregate_snapshot: Option<ProcessGroupStatusSnapshotDto>,
pub id: Option<String>,
pub name: Option<String>,
#[serde(rename = "nodeSnapshots")]
pub node_snapshots: Option<Vec<NodeProcessGroupStatusSnapshotDto>>,
#[serde(rename = "statsLastRefreshed")]
pub stats_last_refreshed: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ProcessGroupStatusEntity {
#[serde(rename = "canRead")]
pub can_read: Option<bool>,
#[serde(rename = "processGroupStatus")]
pub process_group_status: Option<ProcessGroupStatusDto>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ProcessGroupStatusSnapshotDto {
#[serde(rename = "activeThreadCount")]
pub active_thread_count: Option<i32>,
#[serde(rename = "bytesIn")]
pub bytes_in: Option<i64>,
#[serde(rename = "bytesOut")]
pub bytes_out: Option<i64>,
#[serde(rename = "bytesQueued")]
pub bytes_queued: Option<i64>,
#[serde(rename = "bytesRead")]
pub bytes_read: Option<i64>,
#[serde(rename = "bytesReceived")]
pub bytes_received: Option<i64>,
#[serde(rename = "bytesSent")]
pub bytes_sent: Option<i64>,
#[serde(rename = "bytesTransferred")]
pub bytes_transferred: Option<i64>,
#[serde(rename = "bytesWritten")]
pub bytes_written: Option<i64>,
#[serde(rename = "connectionStatusSnapshots")]
pub connection_status_snapshots: Option<Vec<ConnectionStatusSnapshotEntity>>,
#[serde(rename = "flowFilesIn")]
pub flow_files_in: Option<i32>,
#[serde(rename = "flowFilesOut")]
pub flow_files_out: Option<i32>,
#[serde(rename = "flowFilesQueued")]
pub flow_files_queued: Option<i32>,
#[serde(rename = "flowFilesReceived")]
pub flow_files_received: Option<i32>,
#[serde(rename = "flowFilesSent")]
pub flow_files_sent: Option<i32>,
#[serde(rename = "flowFilesTransferred")]
pub flow_files_transferred: Option<i32>,
pub id: Option<String>,
pub input: Option<String>,
#[serde(rename = "inputPortStatusSnapshots")]
pub input_port_status_snapshots: Option<Vec<PortStatusSnapshotEntity>>,
pub name: Option<String>,
pub output: Option<String>,
#[serde(rename = "outputPortStatusSnapshots")]
pub output_port_status_snapshots: Option<Vec<PortStatusSnapshotEntity>>,
#[serde(rename = "processGroupStatusSnapshots")]
pub process_group_status_snapshots: Option<Vec<ProcessGroupStatusSnapshotEntity>>,
#[serde(rename = "processingNanos")]
pub processing_nanos: Option<i64>,
#[serde(rename = "processingPerformanceStatus")]
pub processing_performance_status: Option<ProcessingPerformanceStatusDto>,
#[serde(rename = "processorStatusSnapshots")]
pub processor_status_snapshots: Option<Vec<ProcessorStatusSnapshotEntity>>,
pub queued: Option<String>,
#[serde(rename = "queuedCount")]
pub queued_count: Option<String>,
#[serde(rename = "queuedSize")]
pub queued_size: Option<String>,
pub read: Option<String>,
pub received: Option<String>,
#[serde(rename = "remoteProcessGroupStatusSnapshots")]
pub remote_process_group_status_snapshots: Option<Vec<RemoteProcessGroupStatusSnapshotEntity>>,
pub sent: Option<String>,
#[serde(rename = "statelessActiveThreadCount")]
pub stateless_active_thread_count: Option<i32>,
#[serde(rename = "terminatedThreadCount")]
pub terminated_thread_count: Option<i32>,
pub transferred: Option<String>,
#[serde(rename = "versionedFlowState")]
pub versioned_flow_state: Option<String>,
pub written: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ProcessGroupStatusSnapshotEntity {
#[serde(rename = "canRead")]
pub can_read: Option<bool>,
pub id: Option<String>,
#[serde(rename = "processGroupStatusSnapshot")]
pub process_group_status_snapshot: Option<ProcessGroupStatusSnapshotDto>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ProcessGroupUploadEntity {
#[serde(rename = "disconnectedNodeAcknowledged")]
pub disconnected_node_acknowledged: Option<bool>,
#[serde(rename = "flowSnapshot")]
pub flow_snapshot: Option<RegisteredFlowSnapshot>,
#[serde(rename = "groupId")]
pub group_id: Option<String>,
#[serde(rename = "groupName")]
pub group_name: Option<String>,
#[serde(rename = "positionDTO")]
pub position_d_t_o: Option<PositionDto>,
#[serde(rename = "revisionDTO")]
pub revision_d_t_o: Option<RevisionDto>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ProcessGroupsEntity {
#[serde(rename = "processGroups")]
pub process_groups: Option<Vec<ProcessGroupEntity>>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ProcessingPerformanceStatusDto {
#[serde(rename = "contentReadDuration")]
pub content_read_duration: Option<i64>,
#[serde(rename = "contentWriteDuration")]
pub content_write_duration: Option<i64>,
#[serde(rename = "cpuDuration")]
pub cpu_duration: Option<i64>,
#[serde(rename = "garbageCollectionDuration")]
pub garbage_collection_duration: Option<i64>,
pub identifier: Option<String>,
#[serde(rename = "sessionCommitDuration")]
pub session_commit_duration: Option<i64>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ProcessorConfigDto {
#[serde(rename = "annotationData")]
pub annotation_data: Option<String>,
#[serde(rename = "autoTerminatedRelationships")]
pub auto_terminated_relationships: Option<Vec<String>>,
#[serde(rename = "backoffMechanism")]
pub backoff_mechanism: Option<String>,
#[serde(rename = "bulletinLevel")]
pub bulletin_level: Option<String>,
pub comments: Option<String>,
#[serde(rename = "concurrentlySchedulableTaskCount")]
pub concurrently_schedulable_task_count: Option<i32>,
#[serde(rename = "customUiUrl")]
pub custom_ui_url: Option<String>,
#[serde(rename = "defaultConcurrentTasks")]
pub default_concurrent_tasks: Option<std::collections::HashMap<String, Option<String>>>,
#[serde(rename = "defaultSchedulingPeriod")]
pub default_scheduling_period: Option<std::collections::HashMap<String, Option<String>>>,
pub descriptors: Option<std::collections::HashMap<String, Option<PropertyDescriptorDto>>>,
#[serde(rename = "executionNode")]
pub execution_node: Option<String>,
#[serde(rename = "lossTolerant")]
pub loss_tolerant: Option<bool>,
#[serde(rename = "maxBackoffPeriod")]
pub max_backoff_period: Option<String>,
#[serde(rename = "penaltyDuration")]
pub penalty_duration: Option<String>,
pub properties: Option<std::collections::HashMap<String, Option<String>>>,
#[serde(rename = "retriedRelationships")]
pub retried_relationships: Option<Vec<String>>,
#[serde(rename = "retryCount")]
pub retry_count: Option<i32>,
#[serde(rename = "runDurationMillis")]
pub run_duration_millis: Option<i64>,
#[serde(rename = "schedulingPeriod")]
pub scheduling_period: Option<String>,
#[serde(rename = "schedulingStrategy")]
pub scheduling_strategy: Option<String>,
#[serde(rename = "sensitiveDynamicPropertyNames")]
pub sensitive_dynamic_property_names: Option<Vec<String>>,
#[serde(rename = "yieldDuration")]
pub yield_duration: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ProcessorConfiguration {
pub configuration: Option<String>,
#[serde(rename = "processorClassName")]
pub processor_class_name: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ProcessorDefinition {
#[serde(rename = "additionalDetails")]
pub additional_details: Option<bool>,
pub artifact: Option<String>,
#[serde(rename = "buildInfo")]
pub build_info: Option<BuildInfo>,
#[serde(rename = "defaultBulletinLevel")]
pub default_bulletin_level: Option<String>,
#[serde(rename = "defaultConcurrentTasksBySchedulingStrategy")]
pub default_concurrent_tasks_by_scheduling_strategy:
Option<std::collections::HashMap<String, Option<i32>>>,
#[serde(rename = "defaultPenaltyDuration")]
pub default_penalty_duration: Option<String>,
#[serde(rename = "defaultSchedulingPeriodBySchedulingStrategy")]
pub default_scheduling_period_by_scheduling_strategy:
Option<std::collections::HashMap<String, Option<String>>>,
#[serde(rename = "defaultSchedulingStrategy")]
pub default_scheduling_strategy: Option<String>,
#[serde(rename = "defaultYieldDuration")]
pub default_yield_duration: Option<String>,
pub deprecated: Option<bool>,
#[serde(rename = "deprecationAlternatives")]
pub deprecation_alternatives: Option<Vec<String>>,
#[serde(rename = "deprecationReason")]
pub deprecation_reason: Option<String>,
#[serde(rename = "dynamicProperties")]
pub dynamic_properties: Option<Vec<DynamicProperty>>,
#[serde(rename = "dynamicRelationship")]
pub dynamic_relationship: Option<DynamicRelationship>,
#[serde(rename = "explicitRestrictions")]
pub explicit_restrictions: Option<Vec<Restriction>>,
pub group: Option<String>,
#[serde(rename = "inputRequirement")]
pub input_requirement: Option<String>,
#[serde(rename = "multiProcessorUseCases")]
pub multi_processor_use_cases: Option<Vec<MultiProcessorUseCase>>,
#[serde(rename = "primaryNodeOnly")]
pub primary_node_only: Option<bool>,
#[serde(rename = "propertyDescriptors")]
pub property_descriptors: Option<std::collections::HashMap<String, Option<PropertyDescriptor>>>,
#[serde(rename = "providedApiImplementations")]
pub provided_api_implementations: Option<Vec<DefinedType>>,
#[serde(rename = "readsAttributes")]
pub reads_attributes: Option<Vec<Attribute>>,
pub restricted: Option<bool>,
#[serde(rename = "restrictedExplanation")]
pub restricted_explanation: Option<String>,
#[serde(rename = "seeAlso")]
pub see_also: Option<Vec<String>>,
#[serde(rename = "sideEffectFree")]
pub side_effect_free: Option<bool>,
pub stateful: Option<Stateful>,
#[serde(rename = "supportedRelationships")]
pub supported_relationships: Option<Vec<Relationship>>,
#[serde(rename = "supportedSchedulingStrategies")]
pub supported_scheduling_strategies: Option<Vec<String>>,
#[serde(rename = "supportsBatching")]
pub supports_batching: Option<bool>,
#[serde(rename = "supportsDynamicProperties")]
pub supports_dynamic_properties: Option<bool>,
#[serde(rename = "supportsDynamicRelationships")]
pub supports_dynamic_relationships: Option<bool>,
#[serde(rename = "supportsSensitiveDynamicProperties")]
pub supports_sensitive_dynamic_properties: Option<bool>,
#[serde(rename = "systemResourceConsiderations")]
pub system_resource_considerations: Option<Vec<SystemResourceConsideration>>,
pub tags: Option<Vec<String>>,
#[serde(rename = "triggerSerially")]
pub trigger_serially: Option<bool>,
#[serde(rename = "triggerWhenAnyDestinationAvailable")]
pub trigger_when_any_destination_available: Option<bool>,
#[serde(rename = "triggerWhenEmpty")]
pub trigger_when_empty: Option<bool>,
pub r#type: Option<String>,
#[serde(rename = "typeDescription")]
pub type_description: Option<String>,
#[serde(rename = "useCases")]
pub use_cases: Option<Vec<UseCase>>,
pub version: Option<String>,
#[serde(rename = "writesAttributes")]
pub writes_attributes: Option<Vec<Attribute>>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ProcessorDto {
pub bundle: Option<BundleDto>,
pub config: Option<ProcessorConfigDto>,
pub deprecated: Option<bool>,
pub description: Option<String>,
#[serde(rename = "executionNodeRestricted")]
pub execution_node_restricted: Option<bool>,
#[serde(rename = "extensionMissing")]
pub extension_missing: Option<bool>,
pub id: Option<String>,
#[serde(rename = "inputRequirement")]
pub input_requirement: Option<String>,
#[serde(rename = "multipleVersionsAvailable")]
pub multiple_versions_available: Option<bool>,
pub name: Option<String>,
#[serde(rename = "parentGroupId")]
pub parent_group_id: Option<String>,
#[serde(rename = "persistsState")]
pub persists_state: Option<bool>,
#[serde(rename = "physicalState")]
pub physical_state: Option<String>,
pub position: Option<PositionDto>,
pub relationships: Option<Vec<RelationshipDto>>,
pub restricted: Option<bool>,
pub state: Option<String>,
pub style: Option<std::collections::HashMap<String, Option<String>>>,
#[serde(rename = "supportsBatching")]
pub supports_batching: Option<bool>,
#[serde(rename = "supportsParallelProcessing")]
pub supports_parallel_processing: Option<bool>,
#[serde(rename = "supportsSensitiveDynamicProperties")]
pub supports_sensitive_dynamic_properties: Option<bool>,
pub r#type: Option<String>,
#[serde(rename = "validationErrors")]
pub validation_errors: Option<Vec<String>>,
#[serde(rename = "validationStatus")]
pub validation_status: Option<String>,
#[serde(rename = "versionedComponentId")]
pub versioned_component_id: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ProcessorEntity {
pub bulletins: Option<Vec<BulletinEntity>>,
pub component: Option<ProcessorDto>,
#[serde(rename = "disconnectedNodeAcknowledged")]
pub disconnected_node_acknowledged: Option<bool>,
pub id: Option<String>,
#[serde(rename = "inputRequirement")]
pub input_requirement: Option<String>,
#[serde(rename = "operatePermissions")]
pub operate_permissions: Option<PermissionsDto>,
pub permissions: Option<PermissionsDto>,
#[serde(rename = "physicalState")]
pub physical_state: Option<String>,
pub position: Option<PositionDto>,
pub revision: Option<RevisionDto>,
pub status: Option<ProcessorStatusDto>,
pub uri: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ProcessorRunStatusDetailsDto {
#[serde(rename = "activeThreadCount")]
pub active_thread_count: Option<i32>,
pub id: Option<String>,
pub name: Option<String>,
#[serde(rename = "runStatus")]
pub run_status: Option<String>,
#[serde(rename = "validationErrors")]
pub validation_errors: Option<Vec<String>>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ProcessorRunStatusDetailsEntity {
pub permissions: Option<PermissionsDto>,
pub revision: Option<RevisionDto>,
#[serde(rename = "runStatusDetails")]
pub run_status_details: Option<ProcessorRunStatusDetailsDto>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ProcessorRunStatusEntity {
#[serde(rename = "disconnectedNodeAcknowledged")]
pub disconnected_node_acknowledged: Option<bool>,
pub revision: Option<RevisionDto>,
pub state: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ProcessorStatusDto {
#[serde(rename = "aggregateSnapshot")]
pub aggregate_snapshot: Option<ProcessorStatusSnapshotDto>,
#[serde(rename = "groupId")]
pub group_id: Option<String>,
pub id: Option<String>,
pub name: Option<String>,
#[serde(rename = "nodeSnapshots")]
pub node_snapshots: Option<Vec<NodeProcessorStatusSnapshotDto>>,
#[serde(rename = "runStatus")]
pub run_status: Option<String>,
#[serde(rename = "statsLastRefreshed")]
pub stats_last_refreshed: Option<String>,
pub r#type: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ProcessorStatusEntity {
#[serde(rename = "canRead")]
pub can_read: Option<bool>,
#[serde(rename = "processorStatus")]
pub processor_status: Option<ProcessorStatusDto>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ProcessorStatusSnapshotDto {
#[serde(rename = "activeThreadCount")]
pub active_thread_count: Option<i32>,
#[serde(rename = "bytesIn")]
pub bytes_in: Option<i64>,
#[serde(rename = "bytesOut")]
pub bytes_out: Option<i64>,
#[serde(rename = "bytesRead")]
pub bytes_read: Option<i64>,
#[serde(rename = "bytesWritten")]
pub bytes_written: Option<i64>,
#[serde(rename = "executionNode")]
pub execution_node: Option<String>,
#[serde(rename = "flowFilesIn")]
pub flow_files_in: Option<i32>,
#[serde(rename = "flowFilesOut")]
pub flow_files_out: Option<i32>,
#[serde(rename = "groupId")]
pub group_id: Option<String>,
pub id: Option<String>,
pub input: Option<String>,
pub name: Option<String>,
pub output: Option<String>,
#[serde(rename = "processingPerformanceStatus")]
pub processing_performance_status: Option<ProcessingPerformanceStatusDto>,
pub read: Option<String>,
#[serde(rename = "runStatus")]
pub run_status: Option<String>,
#[serde(rename = "taskCount")]
pub task_count: Option<i32>,
pub tasks: Option<String>,
#[serde(rename = "tasksDuration")]
pub tasks_duration: Option<String>,
#[serde(rename = "tasksDurationNanos")]
pub tasks_duration_nanos: Option<i64>,
#[serde(rename = "terminatedThreadCount")]
pub terminated_thread_count: Option<i32>,
pub r#type: Option<String>,
pub written: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ProcessorStatusSnapshotEntity {
#[serde(rename = "canRead")]
pub can_read: Option<bool>,
pub id: Option<String>,
#[serde(rename = "processorStatusSnapshot")]
pub processor_status_snapshot: Option<ProcessorStatusSnapshotDto>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ProcessorTypesEntity {
#[serde(rename = "processorTypes")]
pub processor_types: Option<Vec<DocumentedTypeDto>>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ProcessorsEntity {
pub processors: Option<Vec<ProcessorEntity>>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ProcessorsRunStatusDetailsEntity {
#[serde(rename = "runStatusDetails")]
pub run_status_details: Option<Vec<ProcessorRunStatusDetailsEntity>>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PropertyAllowableValue {
pub description: Option<String>,
#[serde(rename = "displayName")]
pub display_name: Option<String>,
pub value: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PropertyDependency {
#[serde(rename = "dependentValues")]
pub dependent_values: Option<Vec<String>>,
#[serde(rename = "propertyDisplayName")]
pub property_display_name: Option<String>,
#[serde(rename = "propertyName")]
pub property_name: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PropertyDependencyDto {
#[serde(rename = "dependentValues")]
pub dependent_values: Option<Vec<String>>,
#[serde(rename = "propertyName")]
pub property_name: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PropertyDescriptor {
#[serde(rename = "allowableValues")]
pub allowable_values: Option<Vec<PropertyAllowableValue>>,
#[serde(rename = "defaultValue")]
pub default_value: Option<String>,
pub dependencies: Option<Vec<PropertyDependency>>,
pub description: Option<String>,
#[serde(rename = "displayName")]
pub display_name: Option<String>,
pub dynamic: Option<bool>,
#[serde(rename = "expressionLanguageScope")]
pub expression_language_scope: Option<String>,
#[serde(rename = "expressionLanguageScopeDescription")]
pub expression_language_scope_description: Option<String>,
#[serde(rename = "listenPortDefinition")]
pub listen_port_definition: Option<PropertyListenPortDefinition>,
pub name: Option<String>,
pub required: Option<bool>,
#[serde(rename = "resourceDefinition")]
pub resource_definition: Option<PropertyResourceDefinition>,
pub sensitive: Option<bool>,
#[serde(rename = "typeProvidedByValue")]
pub type_provided_by_value: Option<DefinedType>,
#[serde(rename = "validRegex")]
pub valid_regex: Option<String>,
pub validator: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PropertyDescriptorDto {
#[serde(rename = "allowableValues")]
pub allowable_values: Option<Vec<AllowableValueEntity>>,
#[serde(rename = "defaultValue")]
pub default_value: Option<String>,
pub dependencies: Option<Vec<PropertyDependencyDto>>,
pub description: Option<String>,
#[serde(rename = "displayName")]
pub display_name: Option<String>,
pub dynamic: Option<bool>,
#[serde(rename = "expressionLanguageScope")]
pub expression_language_scope: Option<String>,
#[serde(rename = "identifiesControllerService")]
pub identifies_controller_service: Option<String>,
#[serde(rename = "identifiesControllerServiceBundle")]
pub identifies_controller_service_bundle: Option<BundleDto>,
pub name: Option<String>,
pub required: Option<bool>,
pub sensitive: Option<bool>,
#[serde(rename = "supportsEl")]
pub supports_el: Option<bool>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub(crate) struct PropertyDescriptorEntity {
pub property_descriptor: Option<PropertyDescriptorDto>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PropertyHistoryDto {
#[serde(rename = "previousValues")]
pub previous_values: Option<Vec<PreviousValueDto>>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PropertyListenPortDefinition {
#[serde(rename = "applicationProtocols")]
pub application_protocols: Option<Vec<String>>,
#[serde(rename = "transportProtocol")]
pub transport_protocol: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PropertyResourceDefinition {
pub cardinality: Option<String>,
#[serde(rename = "resourceTypes")]
pub resource_types: Option<Vec<String>>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ProvenanceDto {
pub expiration: Option<String>,
pub finished: Option<bool>,
pub id: Option<String>,
#[serde(rename = "percentCompleted")]
pub percent_completed: Option<i32>,
pub request: Option<ProvenanceRequestDto>,
pub results: Option<ProvenanceResultsDto>,
#[serde(rename = "submissionTime")]
pub submission_time: Option<String>,
pub uri: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub(crate) struct ProvenanceEntity {
pub provenance: Option<ProvenanceDto>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ProvenanceEventDto {
#[serde(rename = "alternateIdentifierUri")]
pub alternate_identifier_uri: Option<String>,
pub attributes: Option<Vec<AttributeDto>>,
#[serde(rename = "childUuids")]
pub child_uuids: Option<Vec<String>>,
#[serde(rename = "clusterNodeAddress")]
pub cluster_node_address: Option<String>,
#[serde(rename = "clusterNodeId")]
pub cluster_node_id: Option<String>,
#[serde(rename = "componentId")]
pub component_id: Option<String>,
#[serde(rename = "componentName")]
pub component_name: Option<String>,
#[serde(rename = "componentType")]
pub component_type: Option<String>,
#[serde(rename = "contentEqual")]
pub content_equal: Option<bool>,
pub details: Option<String>,
#[serde(rename = "eventDuration")]
pub event_duration: Option<i64>,
#[serde(rename = "eventId")]
pub event_id: Option<i64>,
#[serde(rename = "eventTime")]
pub event_time: Option<String>,
#[serde(rename = "eventTimestamp")]
pub event_timestamp: Option<String>,
#[serde(rename = "eventType")]
pub event_type: Option<String>,
#[serde(rename = "fileSize")]
pub file_size: Option<String>,
#[serde(rename = "fileSizeBytes")]
pub file_size_bytes: Option<i64>,
#[serde(rename = "flowFileUuid")]
pub flow_file_uuid: Option<String>,
#[serde(rename = "groupId")]
pub group_id: Option<String>,
pub id: Option<String>,
#[serde(rename = "inputContentAvailable")]
pub input_content_available: Option<bool>,
#[serde(rename = "inputContentClaimContainer")]
pub input_content_claim_container: Option<String>,
#[serde(rename = "inputContentClaimFileSize")]
pub input_content_claim_file_size: Option<String>,
#[serde(rename = "inputContentClaimFileSizeBytes")]
pub input_content_claim_file_size_bytes: Option<i64>,
#[serde(rename = "inputContentClaimIdentifier")]
pub input_content_claim_identifier: Option<String>,
#[serde(rename = "inputContentClaimOffset")]
pub input_content_claim_offset: Option<i64>,
#[serde(rename = "inputContentClaimSection")]
pub input_content_claim_section: Option<String>,
#[serde(rename = "lineageDuration")]
pub lineage_duration: Option<i64>,
#[serde(rename = "outputContentAvailable")]
pub output_content_available: Option<bool>,
#[serde(rename = "outputContentClaimContainer")]
pub output_content_claim_container: Option<String>,
#[serde(rename = "outputContentClaimFileSize")]
pub output_content_claim_file_size: Option<String>,
#[serde(rename = "outputContentClaimFileSizeBytes")]
pub output_content_claim_file_size_bytes: Option<i64>,
#[serde(rename = "outputContentClaimIdentifier")]
pub output_content_claim_identifier: Option<String>,
#[serde(rename = "outputContentClaimOffset")]
pub output_content_claim_offset: Option<i64>,
#[serde(rename = "outputContentClaimSection")]
pub output_content_claim_section: Option<String>,
#[serde(rename = "parentUuids")]
pub parent_uuids: Option<Vec<String>>,
pub relationship: Option<String>,
#[serde(rename = "replayAvailable")]
pub replay_available: Option<bool>,
#[serde(rename = "replayExplanation")]
pub replay_explanation: Option<String>,
#[serde(rename = "sourceConnectionIdentifier")]
pub source_connection_identifier: Option<String>,
#[serde(rename = "sourceSystemFlowFileId")]
pub source_system_flow_file_id: Option<String>,
#[serde(rename = "transitUri")]
pub transit_uri: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub(crate) struct ProvenanceEventEntity {
pub provenance_event: Option<ProvenanceEventDto>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ProvenanceLinkDto {
#[serde(rename = "flowFileUuid")]
pub flow_file_uuid: Option<String>,
pub millis: Option<i64>,
#[serde(rename = "sourceId")]
pub source_id: Option<String>,
#[serde(rename = "targetId")]
pub target_id: Option<String>,
pub timestamp: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ProvenanceNodeDto {
#[serde(rename = "childUuids")]
pub child_uuids: Option<Vec<String>>,
#[serde(rename = "clusterNodeIdentifier")]
pub cluster_node_identifier: Option<String>,
#[serde(rename = "componentType")]
pub component_type: Option<String>,
#[serde(rename = "eventType")]
pub event_type: Option<String>,
#[serde(rename = "flowFileUuid")]
pub flow_file_uuid: Option<String>,
pub id: Option<String>,
pub millis: Option<i64>,
#[serde(rename = "parentUuids")]
pub parent_uuids: Option<Vec<String>>,
pub timestamp: Option<String>,
pub r#type: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ProvenanceOptionsDto {
#[serde(rename = "searchableFields")]
pub searchable_fields: Option<Vec<ProvenanceSearchableFieldDto>>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub(crate) struct ProvenanceOptionsEntity {
pub provenance_options: Option<ProvenanceOptionsDto>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ProvenanceRequestDto {
#[serde(rename = "clusterNodeId")]
pub cluster_node_id: Option<String>,
#[serde(rename = "endDate")]
pub end_date: Option<String>,
#[serde(rename = "incrementalResults")]
pub incremental_results: Option<bool>,
#[serde(rename = "maxResults")]
pub max_results: Option<i32>,
#[serde(rename = "maximumFileSize")]
pub maximum_file_size: Option<String>,
#[serde(rename = "minimumFileSize")]
pub minimum_file_size: Option<String>,
#[serde(rename = "searchTerms")]
pub search_terms: Option<std::collections::HashMap<String, Option<ProvenanceSearchValueDto>>>,
#[serde(rename = "startDate")]
pub start_date: Option<String>,
pub summarize: Option<bool>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ProvenanceResultsDto {
pub errors: Option<Vec<String>>,
pub generated: Option<String>,
#[serde(rename = "oldestEvent")]
pub oldest_event: Option<String>,
#[serde(rename = "provenanceEvents")]
pub provenance_events: Option<Vec<ProvenanceEventDto>>,
#[serde(rename = "timeOffset")]
pub time_offset: Option<i32>,
pub total: Option<String>,
#[serde(rename = "totalCount")]
pub total_count: Option<i64>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ProvenanceSearchValueDto {
pub inverse: Option<bool>,
pub value: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ProvenanceSearchableFieldDto {
pub field: Option<String>,
pub id: Option<String>,
pub label: Option<String>,
pub r#type: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct QueueSizeDto {
#[serde(rename = "byteCount")]
pub byte_count: Option<i64>,
#[serde(rename = "objectCount")]
pub object_count: Option<i32>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct RegisteredFlow {
pub branch: Option<String>,
#[serde(rename = "bucketIdentifier")]
pub bucket_identifier: Option<String>,
#[serde(rename = "bucketName")]
pub bucket_name: Option<String>,
#[serde(rename = "createdTimestamp")]
pub created_timestamp: Option<i64>,
pub description: Option<String>,
pub identifier: Option<String>,
#[serde(rename = "lastModifiedTimestamp")]
pub last_modified_timestamp: Option<i64>,
pub name: Option<String>,
pub permissions: Option<FlowRegistryPermissions>,
#[serde(rename = "versionCount")]
pub version_count: Option<i64>,
#[serde(rename = "versionInfo")]
pub version_info: Option<RegisteredFlowVersionInfo>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct RegisteredFlowSnapshot {
pub bucket: Option<FlowRegistryBucket>,
#[serde(rename = "externalControllerServices")]
pub external_controller_services:
Option<std::collections::HashMap<String, Option<ExternalControllerServiceReference>>>,
pub flow: Option<RegisteredFlow>,
#[serde(rename = "flowContents")]
pub flow_contents: Option<VersionedProcessGroup>,
#[serde(rename = "flowEncodingVersion")]
pub flow_encoding_version: Option<String>,
pub latest: Option<bool>,
#[serde(rename = "parameterContexts")]
pub parameter_contexts:
Option<std::collections::HashMap<String, Option<VersionedParameterContext>>>,
#[serde(rename = "parameterProviders")]
pub parameter_providers:
Option<std::collections::HashMap<String, Option<ParameterProviderReference>>>,
#[serde(rename = "snapshotMetadata")]
pub snapshot_metadata: Option<RegisteredFlowSnapshotMetadata>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct RegisteredFlowSnapshotMetadata {
pub author: Option<String>,
pub branch: Option<String>,
#[serde(rename = "bucketIdentifier")]
pub bucket_identifier: Option<String>,
pub comments: Option<String>,
#[serde(rename = "flowIdentifier")]
pub flow_identifier: Option<String>,
#[serde(rename = "flowName")]
pub flow_name: Option<String>,
#[serde(rename = "registryIdentifier")]
pub registry_identifier: Option<String>,
#[serde(rename = "registryName")]
pub registry_name: Option<String>,
pub timestamp: Option<i64>,
pub version: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct RegisteredFlowVersionInfo {
pub version: Option<i64>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct Relationship {
pub description: Option<String>,
pub name: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct RelationshipDto {
#[serde(rename = "autoTerminate")]
pub auto_terminate: Option<bool>,
pub description: Option<String>,
pub name: Option<String>,
pub retry: Option<bool>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct RemotePortRunStatusEntity {
#[serde(rename = "disconnectedNodeAcknowledged")]
pub disconnected_node_acknowledged: Option<bool>,
pub revision: Option<RevisionDto>,
pub state: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct RemoteProcessGroupContentsDto {
#[serde(rename = "inputPorts")]
pub input_ports: Option<Vec<RemoteProcessGroupPortDto>>,
#[serde(rename = "outputPorts")]
pub output_ports: Option<Vec<RemoteProcessGroupPortDto>>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct RemoteProcessGroupDto {
#[serde(rename = "activeRemoteInputPortCount")]
pub active_remote_input_port_count: Option<i32>,
#[serde(rename = "activeRemoteOutputPortCount")]
pub active_remote_output_port_count: Option<i32>,
#[serde(rename = "authorizationIssues")]
pub authorization_issues: Option<Vec<String>>,
pub comments: Option<String>,
#[serde(rename = "communicationsTimeout")]
pub communications_timeout: Option<String>,
pub contents: Option<RemoteProcessGroupContentsDto>,
#[serde(rename = "flowRefreshed")]
pub flow_refreshed: Option<String>,
pub id: Option<String>,
#[serde(rename = "inactiveRemoteInputPortCount")]
pub inactive_remote_input_port_count: Option<i32>,
#[serde(rename = "inactiveRemoteOutputPortCount")]
pub inactive_remote_output_port_count: Option<i32>,
#[serde(rename = "inputPortCount")]
pub input_port_count: Option<i32>,
#[serde(rename = "localNetworkInterface")]
pub local_network_interface: Option<String>,
pub name: Option<String>,
#[serde(rename = "outputPortCount")]
pub output_port_count: Option<i32>,
#[serde(rename = "parentGroupId")]
pub parent_group_id: Option<String>,
pub position: Option<PositionDto>,
#[serde(rename = "proxyHost")]
pub proxy_host: Option<String>,
#[serde(rename = "proxyPassword")]
pub proxy_password: Option<String>,
#[serde(rename = "proxyPort")]
pub proxy_port: Option<i32>,
#[serde(rename = "proxyUser")]
pub proxy_user: Option<String>,
#[serde(rename = "targetSecure")]
pub target_secure: Option<bool>,
#[serde(rename = "targetUri")]
pub target_uri: Option<String>,
#[serde(rename = "targetUris")]
pub target_uris: Option<String>,
pub transmitting: Option<bool>,
#[serde(rename = "transportProtocol")]
pub transport_protocol: Option<String>,
#[serde(rename = "validationErrors")]
pub validation_errors: Option<Vec<String>>,
#[serde(rename = "versionedComponentId")]
pub versioned_component_id: Option<String>,
#[serde(rename = "yieldDuration")]
pub yield_duration: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct RemoteProcessGroupEntity {
pub bulletins: Option<Vec<BulletinEntity>>,
pub component: Option<RemoteProcessGroupDto>,
#[serde(rename = "disconnectedNodeAcknowledged")]
pub disconnected_node_acknowledged: Option<bool>,
pub id: Option<String>,
#[serde(rename = "inputPortCount")]
pub input_port_count: Option<i32>,
#[serde(rename = "operatePermissions")]
pub operate_permissions: Option<PermissionsDto>,
#[serde(rename = "outputPortCount")]
pub output_port_count: Option<i32>,
pub permissions: Option<PermissionsDto>,
pub position: Option<PositionDto>,
pub revision: Option<RevisionDto>,
pub status: Option<RemoteProcessGroupStatusDto>,
pub uri: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct RemoteProcessGroupPortDto {
#[serde(rename = "batchSettings")]
pub batch_settings: Option<BatchSettingsDto>,
pub comments: Option<String>,
#[serde(rename = "concurrentlySchedulableTaskCount")]
pub concurrently_schedulable_task_count: Option<i32>,
pub connected: Option<bool>,
pub exists: Option<bool>,
#[serde(rename = "groupId")]
pub group_id: Option<String>,
pub id: Option<String>,
pub name: Option<String>,
#[serde(rename = "targetId")]
pub target_id: Option<String>,
#[serde(rename = "targetRunning")]
pub target_running: Option<bool>,
pub transmitting: Option<bool>,
#[serde(rename = "useCompression")]
pub use_compression: Option<bool>,
#[serde(rename = "versionedComponentId")]
pub versioned_component_id: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct RemoteProcessGroupPortEntity {
pub bulletins: Option<Vec<BulletinEntity>>,
#[serde(rename = "disconnectedNodeAcknowledged")]
pub disconnected_node_acknowledged: Option<bool>,
pub id: Option<String>,
#[serde(rename = "operatePermissions")]
pub operate_permissions: Option<PermissionsDto>,
pub permissions: Option<PermissionsDto>,
pub position: Option<PositionDto>,
#[serde(rename = "remoteProcessGroupPort")]
pub remote_process_group_port: Option<RemoteProcessGroupPortDto>,
pub revision: Option<RevisionDto>,
pub uri: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct RemoteProcessGroupStatusDto {
#[serde(rename = "aggregateSnapshot")]
pub aggregate_snapshot: Option<RemoteProcessGroupStatusSnapshotDto>,
#[serde(rename = "groupId")]
pub group_id: Option<String>,
pub id: Option<String>,
pub name: Option<String>,
#[serde(rename = "nodeSnapshots")]
pub node_snapshots: Option<Vec<NodeRemoteProcessGroupStatusSnapshotDto>>,
#[serde(rename = "statsLastRefreshed")]
pub stats_last_refreshed: Option<String>,
#[serde(rename = "targetUri")]
pub target_uri: Option<String>,
#[serde(rename = "transmissionStatus")]
pub transmission_status: Option<String>,
#[serde(rename = "validationStatus")]
pub validation_status: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct RemoteProcessGroupStatusEntity {
#[serde(rename = "canRead")]
pub can_read: Option<bool>,
#[serde(rename = "remoteProcessGroupStatus")]
pub remote_process_group_status: Option<RemoteProcessGroupStatusDto>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct RemoteProcessGroupStatusSnapshotDto {
#[serde(rename = "activeThreadCount")]
pub active_thread_count: Option<i32>,
#[serde(rename = "bytesReceived")]
pub bytes_received: Option<i64>,
#[serde(rename = "bytesSent")]
pub bytes_sent: Option<i64>,
#[serde(rename = "flowFilesReceived")]
pub flow_files_received: Option<i32>,
#[serde(rename = "flowFilesSent")]
pub flow_files_sent: Option<i32>,
#[serde(rename = "groupId")]
pub group_id: Option<String>,
pub id: Option<String>,
pub name: Option<String>,
pub received: Option<String>,
pub sent: Option<String>,
#[serde(rename = "targetUri")]
pub target_uri: Option<String>,
#[serde(rename = "transmissionStatus")]
pub transmission_status: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct RemoteProcessGroupStatusSnapshotEntity {
#[serde(rename = "canRead")]
pub can_read: Option<bool>,
pub id: Option<String>,
#[serde(rename = "remoteProcessGroupStatusSnapshot")]
pub remote_process_group_status_snapshot: Option<RemoteProcessGroupStatusSnapshotDto>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct RemoteProcessGroupsEntity {
#[serde(rename = "remoteProcessGroups")]
pub remote_process_groups: Option<Vec<RemoteProcessGroupEntity>>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ReplayLastEventRequestEntity {
#[serde(rename = "componentId")]
pub component_id: Option<String>,
pub nodes: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ReplayLastEventResponseEntity {
#[serde(rename = "aggregateSnapshot")]
pub aggregate_snapshot: Option<ReplayLastEventSnapshotDto>,
#[serde(rename = "componentId")]
pub component_id: Option<String>,
#[serde(rename = "nodeSnapshots")]
pub node_snapshots: Option<Vec<NodeReplayLastEventSnapshotDto>>,
pub nodes: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ReplayLastEventSnapshotDto {
#[serde(rename = "eventAvailable")]
pub event_available: Option<bool>,
#[serde(rename = "eventsReplayed")]
pub events_replayed: Option<Vec<i64>>,
#[serde(rename = "failureExplanation")]
pub failure_explanation: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ReportingTaskDefinition {
#[serde(rename = "additionalDetails")]
pub additional_details: Option<bool>,
pub artifact: Option<String>,
#[serde(rename = "buildInfo")]
pub build_info: Option<BuildInfo>,
#[serde(rename = "defaultSchedulingPeriodBySchedulingStrategy")]
pub default_scheduling_period_by_scheduling_strategy:
Option<std::collections::HashMap<String, Option<String>>>,
#[serde(rename = "defaultSchedulingStrategy")]
pub default_scheduling_strategy: Option<String>,
pub deprecated: Option<bool>,
#[serde(rename = "deprecationAlternatives")]
pub deprecation_alternatives: Option<Vec<String>>,
#[serde(rename = "deprecationReason")]
pub deprecation_reason: Option<String>,
#[serde(rename = "dynamicProperties")]
pub dynamic_properties: Option<Vec<DynamicProperty>>,
#[serde(rename = "explicitRestrictions")]
pub explicit_restrictions: Option<Vec<Restriction>>,
pub group: Option<String>,
#[serde(rename = "propertyDescriptors")]
pub property_descriptors: Option<std::collections::HashMap<String, Option<PropertyDescriptor>>>,
#[serde(rename = "providedApiImplementations")]
pub provided_api_implementations: Option<Vec<DefinedType>>,
pub restricted: Option<bool>,
#[serde(rename = "restrictedExplanation")]
pub restricted_explanation: Option<String>,
#[serde(rename = "seeAlso")]
pub see_also: Option<Vec<String>>,
pub stateful: Option<Stateful>,
#[serde(rename = "supportedSchedulingStrategies")]
pub supported_scheduling_strategies: Option<Vec<String>>,
#[serde(rename = "supportsDynamicProperties")]
pub supports_dynamic_properties: Option<bool>,
#[serde(rename = "supportsSensitiveDynamicProperties")]
pub supports_sensitive_dynamic_properties: Option<bool>,
#[serde(rename = "systemResourceConsiderations")]
pub system_resource_considerations: Option<Vec<SystemResourceConsideration>>,
pub tags: Option<Vec<String>>,
pub r#type: Option<String>,
#[serde(rename = "typeDescription")]
pub type_description: Option<String>,
pub version: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ReportingTaskDto {
#[serde(rename = "activeThreadCount")]
pub active_thread_count: Option<i32>,
#[serde(rename = "annotationData")]
pub annotation_data: Option<String>,
pub bundle: Option<BundleDto>,
pub comments: Option<String>,
#[serde(rename = "customUiUrl")]
pub custom_ui_url: Option<String>,
#[serde(rename = "defaultSchedulingPeriod")]
pub default_scheduling_period: Option<std::collections::HashMap<String, Option<String>>>,
pub deprecated: Option<bool>,
pub descriptors: Option<std::collections::HashMap<String, Option<PropertyDescriptorDto>>>,
#[serde(rename = "extensionMissing")]
pub extension_missing: Option<bool>,
pub id: Option<String>,
#[serde(rename = "multipleVersionsAvailable")]
pub multiple_versions_available: Option<bool>,
pub name: Option<String>,
#[serde(rename = "parentGroupId")]
pub parent_group_id: Option<String>,
#[serde(rename = "persistsState")]
pub persists_state: Option<bool>,
pub position: Option<PositionDto>,
pub properties: Option<std::collections::HashMap<String, Option<String>>>,
pub restricted: Option<bool>,
#[serde(rename = "schedulingPeriod")]
pub scheduling_period: Option<String>,
#[serde(rename = "schedulingStrategy")]
pub scheduling_strategy: Option<String>,
#[serde(rename = "sensitiveDynamicPropertyNames")]
pub sensitive_dynamic_property_names: Option<Vec<String>>,
pub state: Option<String>,
#[serde(rename = "supportsSensitiveDynamicProperties")]
pub supports_sensitive_dynamic_properties: Option<bool>,
pub r#type: Option<String>,
#[serde(rename = "validationErrors")]
pub validation_errors: Option<Vec<String>>,
#[serde(rename = "validationStatus")]
pub validation_status: Option<String>,
#[serde(rename = "versionedComponentId")]
pub versioned_component_id: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ReportingTaskEntity {
pub bulletins: Option<Vec<BulletinEntity>>,
pub component: Option<ReportingTaskDto>,
#[serde(rename = "disconnectedNodeAcknowledged")]
pub disconnected_node_acknowledged: Option<bool>,
pub id: Option<String>,
#[serde(rename = "operatePermissions")]
pub operate_permissions: Option<PermissionsDto>,
pub permissions: Option<PermissionsDto>,
pub position: Option<PositionDto>,
pub revision: Option<RevisionDto>,
pub status: Option<ReportingTaskStatusDto>,
pub uri: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ReportingTaskRunStatusEntity {
#[serde(rename = "disconnectedNodeAcknowledged")]
pub disconnected_node_acknowledged: Option<bool>,
pub revision: Option<RevisionDto>,
pub state: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ReportingTaskStatusDto {
#[serde(rename = "activeThreadCount")]
pub active_thread_count: Option<i32>,
#[serde(rename = "runStatus")]
pub run_status: Option<String>,
#[serde(rename = "validationStatus")]
pub validation_status: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ReportingTaskTypesEntity {
#[serde(rename = "reportingTaskTypes")]
pub reporting_task_types: Option<Vec<DocumentedTypeDto>>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ReportingTasksEntity {
#[serde(rename = "currentTime")]
pub current_time: Option<String>,
#[serde(rename = "reportingTasks")]
pub reporting_tasks: Option<Vec<ReportingTaskEntity>>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct RequiredPermissionDto {
pub id: Option<String>,
pub label: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ResourceClaimDetailsDto {
#[serde(rename = "awaitingDestruction")]
pub awaiting_destruction: Option<bool>,
#[serde(rename = "claimantCount")]
pub claimant_count: Option<i32>,
pub container: Option<String>,
pub identifier: Option<String>,
#[serde(rename = "inUse")]
pub in_use: Option<bool>,
pub section: Option<String>,
pub writable: Option<bool>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ResourceDto {
pub identifier: Option<String>,
pub name: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ResourcesEntity {
pub resources: Option<Vec<ResourceDto>>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct Restriction {
pub explanation: Option<String>,
#[serde(rename = "requiredPermission")]
pub required_permission: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct RevisionDto {
#[serde(rename = "clientId")]
pub client_id: Option<String>,
#[serde(rename = "lastModifier")]
pub last_modifier: Option<String>,
pub version: Option<i64>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct RunStatusDetailsRequestEntity {
#[serde(rename = "processorIds")]
pub processor_ids: Option<Vec<String>>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct RuntimeManifest {
#[serde(rename = "agentType")]
pub agent_type: Option<String>,
#[serde(rename = "buildInfo")]
pub build_info: Option<BuildInfo>,
pub bundles: Option<Vec<Bundle>>,
pub identifier: Option<String>,
#[serde(rename = "schedulingDefaults")]
pub scheduling_defaults: Option<SchedulingDefaults>,
pub version: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub(crate) struct RuntimeManifestEntity {
pub runtime_manifest: Option<RuntimeManifest>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ScheduleComponentsEntity {
pub components: Option<std::collections::HashMap<String, Option<RevisionDto>>>,
#[serde(rename = "disconnectedNodeAcknowledged")]
pub disconnected_node_acknowledged: Option<bool>,
pub id: Option<String>,
pub state: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct SchedulingDefaults {
#[serde(rename = "defaultConcurrentTasksBySchedulingStrategy")]
pub default_concurrent_tasks_by_scheduling_strategy:
Option<std::collections::HashMap<String, Option<i32>>>,
#[serde(rename = "defaultMaxConcurrentTasks")]
pub default_max_concurrent_tasks: Option<String>,
#[serde(rename = "defaultRunDurationNanos")]
pub default_run_duration_nanos: Option<i64>,
#[serde(rename = "defaultSchedulingPeriodMillis")]
pub default_scheduling_period_millis: Option<i64>,
#[serde(rename = "defaultSchedulingPeriodsBySchedulingStrategy")]
pub default_scheduling_periods_by_scheduling_strategy:
Option<std::collections::HashMap<String, Option<String>>>,
#[serde(rename = "defaultSchedulingStrategy")]
pub default_scheduling_strategy: Option<String>,
#[serde(rename = "penalizationPeriodMillis")]
pub penalization_period_millis: Option<i64>,
#[serde(rename = "yieldDurationMillis")]
pub yield_duration_millis: Option<i64>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct SearchResultGroupDto {
pub id: Option<String>,
pub name: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct SearchResultsDto {
#[serde(rename = "connectionResults")]
pub connection_results: Option<Vec<ComponentSearchResultDto>>,
#[serde(rename = "controllerServiceNodeResults")]
pub controller_service_node_results: Option<Vec<ComponentSearchResultDto>>,
#[serde(rename = "funnelResults")]
pub funnel_results: Option<Vec<ComponentSearchResultDto>>,
#[serde(rename = "inputPortResults")]
pub input_port_results: Option<Vec<ComponentSearchResultDto>>,
#[serde(rename = "labelResults")]
pub label_results: Option<Vec<ComponentSearchResultDto>>,
#[serde(rename = "outputPortResults")]
pub output_port_results: Option<Vec<ComponentSearchResultDto>>,
#[serde(rename = "parameterContextResults")]
pub parameter_context_results: Option<Vec<ComponentSearchResultDto>>,
#[serde(rename = "parameterProviderNodeResults")]
pub parameter_provider_node_results: Option<Vec<ComponentSearchResultDto>>,
#[serde(rename = "parameterResults")]
pub parameter_results: Option<Vec<ComponentSearchResultDto>>,
#[serde(rename = "processGroupResults")]
pub process_group_results: Option<Vec<ComponentSearchResultDto>>,
#[serde(rename = "processorResults")]
pub processor_results: Option<Vec<ComponentSearchResultDto>>,
#[serde(rename = "remoteProcessGroupResults")]
pub remote_process_group_results: Option<Vec<ComponentSearchResultDto>>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub(crate) struct SearchResultsEntity {
pub search_results_d_t_o: Option<SearchResultsDto>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct SnippetDto {
pub connections: Option<std::collections::HashMap<String, Option<RevisionDto>>>,
pub funnels: Option<std::collections::HashMap<String, Option<RevisionDto>>>,
pub id: Option<String>,
#[serde(rename = "inputPorts")]
pub input_ports: Option<std::collections::HashMap<String, Option<RevisionDto>>>,
pub labels: Option<std::collections::HashMap<String, Option<RevisionDto>>>,
#[serde(rename = "outputPorts")]
pub output_ports: Option<std::collections::HashMap<String, Option<RevisionDto>>>,
#[serde(rename = "parentGroupId")]
pub parent_group_id: Option<String>,
#[serde(rename = "processGroups")]
pub process_groups: Option<std::collections::HashMap<String, Option<RevisionDto>>>,
pub processors: Option<std::collections::HashMap<String, Option<RevisionDto>>>,
#[serde(rename = "remoteProcessGroups")]
pub remote_process_groups: Option<std::collections::HashMap<String, Option<RevisionDto>>>,
pub uri: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct SnippetEntity {
#[serde(rename = "disconnectedNodeAcknowledged")]
pub disconnected_node_acknowledged: Option<bool>,
pub snippet: Option<SnippetDto>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct StartVersionControlRequestEntity {
#[serde(rename = "disconnectedNodeAcknowledged")]
pub disconnected_node_acknowledged: Option<bool>,
#[serde(rename = "processGroupRevision")]
pub process_group_revision: Option<RevisionDto>,
#[serde(rename = "versionedFlow")]
pub versioned_flow: Option<VersionedFlowDto>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct StateEntryDto {
#[serde(rename = "clusterNodeAddress")]
pub cluster_node_address: Option<String>,
#[serde(rename = "clusterNodeId")]
pub cluster_node_id: Option<String>,
pub key: Option<String>,
pub value: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct StateMapDto {
pub scope: Option<String>,
pub state: Option<Vec<StateEntryDto>>,
#[serde(rename = "totalEntryCount")]
pub total_entry_count: Option<i32>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct Stateful {
pub description: Option<String>,
pub scopes: Option<Vec<String>>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct StatusDescriptorDto {
pub description: Option<String>,
pub field: Option<String>,
pub formatter: Option<String>,
pub label: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct StatusHistoryDto {
#[serde(rename = "aggregateSnapshots")]
pub aggregate_snapshots: Option<Vec<StatusSnapshotDto>>,
#[serde(rename = "componentDetails")]
pub component_details: Option<std::collections::HashMap<String, Option<String>>>,
#[serde(rename = "fieldDescriptors")]
pub field_descriptors: Option<Vec<StatusDescriptorDto>>,
pub generated: Option<String>,
#[serde(rename = "nodeSnapshots")]
pub node_snapshots: Option<Vec<NodeStatusSnapshotsDto>>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct StatusHistoryEntity {
#[serde(rename = "canRead")]
pub can_read: Option<bool>,
#[serde(rename = "statusHistory")]
pub status_history: Option<StatusHistoryDto>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct StatusSnapshotDto {
#[serde(rename = "statusMetrics")]
pub status_metrics: Option<std::collections::HashMap<String, Option<i64>>>,
pub timestamp: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct StorageUsageDto {
#[serde(rename = "freeSpace")]
pub free_space: Option<String>,
#[serde(rename = "freeSpaceBytes")]
pub free_space_bytes: Option<i64>,
pub identifier: Option<String>,
#[serde(rename = "totalSpace")]
pub total_space: Option<String>,
#[serde(rename = "totalSpaceBytes")]
pub total_space_bytes: Option<i64>,
#[serde(rename = "usedSpace")]
pub used_space: Option<String>,
#[serde(rename = "usedSpaceBytes")]
pub used_space_bytes: Option<i64>,
pub utilization: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct StreamingOutput {}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct SubmitReplayRequestEntity {
#[serde(rename = "clusterNodeId")]
pub cluster_node_id: Option<String>,
#[serde(rename = "eventId")]
pub event_id: Option<i64>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct SupportedMimeTypesDto {
#[serde(rename = "displayName")]
pub display_name: Option<String>,
#[serde(rename = "mimeTypes")]
pub mime_types: Option<Vec<String>>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct SystemDiagnosticsDto {
#[serde(rename = "aggregateSnapshot")]
pub aggregate_snapshot: Option<SystemDiagnosticsSnapshotDto>,
#[serde(rename = "nodeSnapshots")]
pub node_snapshots: Option<Vec<NodeSystemDiagnosticsSnapshotDto>>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub(crate) struct SystemDiagnosticsEntity {
pub system_diagnostics: Option<SystemDiagnosticsDto>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct SystemDiagnosticsSnapshotDto {
#[serde(rename = "availableProcessors")]
pub available_processors: Option<i32>,
#[serde(rename = "contentRepositoryStorageUsage")]
pub content_repository_storage_usage: Option<Vec<StorageUsageDto>>,
#[serde(rename = "daemonThreads")]
pub daemon_threads: Option<i32>,
#[serde(rename = "flowFileRepositoryStorageUsage")]
pub flow_file_repository_storage_usage: Option<StorageUsageDto>,
#[serde(rename = "freeHeap")]
pub free_heap: Option<String>,
#[serde(rename = "freeHeapBytes")]
pub free_heap_bytes: Option<i64>,
#[serde(rename = "freeNonHeap")]
pub free_non_heap: Option<String>,
#[serde(rename = "freeNonHeapBytes")]
pub free_non_heap_bytes: Option<i64>,
#[serde(rename = "garbageCollection")]
pub garbage_collection: Option<Vec<GarbageCollectionDto>>,
#[serde(rename = "heapUtilization")]
pub heap_utilization: Option<String>,
#[serde(rename = "maxHeap")]
pub max_heap: Option<String>,
#[serde(rename = "maxHeapBytes")]
pub max_heap_bytes: Option<i64>,
#[serde(rename = "maxNonHeap")]
pub max_non_heap: Option<String>,
#[serde(rename = "maxNonHeapBytes")]
pub max_non_heap_bytes: Option<i64>,
#[serde(rename = "nonHeapUtilization")]
pub non_heap_utilization: Option<String>,
#[serde(rename = "processorLoadAverage")]
pub processor_load_average: Option<f64>,
#[serde(rename = "provenanceRepositoryStorageUsage")]
pub provenance_repository_storage_usage: Option<Vec<StorageUsageDto>>,
#[serde(rename = "resourceClaimDetails")]
pub resource_claim_details: Option<Vec<ResourceClaimDetailsDto>>,
#[serde(rename = "statsLastRefreshed")]
pub stats_last_refreshed: Option<String>,
#[serde(rename = "totalHeap")]
pub total_heap: Option<String>,
#[serde(rename = "totalHeapBytes")]
pub total_heap_bytes: Option<i64>,
#[serde(rename = "totalNonHeap")]
pub total_non_heap: Option<String>,
#[serde(rename = "totalNonHeapBytes")]
pub total_non_heap_bytes: Option<i64>,
#[serde(rename = "totalThreads")]
pub total_threads: Option<i32>,
pub uptime: Option<String>,
#[serde(rename = "usedHeap")]
pub used_heap: Option<String>,
#[serde(rename = "usedHeapBytes")]
pub used_heap_bytes: Option<i64>,
#[serde(rename = "usedNonHeap")]
pub used_non_heap: Option<String>,
#[serde(rename = "usedNonHeapBytes")]
pub used_non_heap_bytes: Option<i64>,
#[serde(rename = "versionInfo")]
pub version_info: Option<VersionInfoDto>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct SystemResourceConsideration {
pub description: Option<String>,
pub resource: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct TenantDto {
pub configurable: Option<bool>,
pub id: Option<String>,
pub identity: Option<String>,
#[serde(rename = "parentGroupId")]
pub parent_group_id: Option<String>,
pub position: Option<PositionDto>,
#[serde(rename = "versionedComponentId")]
pub versioned_component_id: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct TenantEntity {
pub bulletins: Option<Vec<BulletinEntity>>,
pub component: Option<TenantDto>,
#[serde(rename = "disconnectedNodeAcknowledged")]
pub disconnected_node_acknowledged: Option<bool>,
pub id: Option<String>,
pub permissions: Option<PermissionsDto>,
pub position: Option<PositionDto>,
pub revision: Option<RevisionDto>,
pub uri: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct TenantsEntity {
#[serde(rename = "userGroups")]
pub user_groups: Option<Vec<TenantEntity>>,
pub users: Option<Vec<TenantEntity>>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct TransactionResultEntity {
#[serde(rename = "flowFileSent")]
pub flow_file_sent: Option<i32>,
pub message: Option<String>,
#[serde(rename = "responseCode")]
pub response_code: Option<i32>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct UpdateControllerServiceReferenceRequestEntity {
#[serde(rename = "disconnectedNodeAcknowledged")]
pub disconnected_node_acknowledged: Option<bool>,
pub id: Option<String>,
#[serde(rename = "referencingComponentRevisions")]
pub referencing_component_revisions:
Option<std::collections::HashMap<String, Option<RevisionDto>>>,
pub state: Option<String>,
#[serde(rename = "uiOnly")]
pub ui_only: Option<bool>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct UseCase {
pub configuration: Option<String>,
pub description: Option<String>,
#[serde(rename = "inputRequirement")]
pub input_requirement: Option<String>,
pub keywords: Option<Vec<String>>,
pub notes: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct UserDto {
#[serde(rename = "accessPolicies")]
pub access_policies: Option<Vec<AccessPolicySummaryEntity>>,
pub configurable: Option<bool>,
pub id: Option<String>,
pub identity: Option<String>,
#[serde(rename = "parentGroupId")]
pub parent_group_id: Option<String>,
pub position: Option<PositionDto>,
#[serde(rename = "userGroups")]
pub user_groups: Option<Vec<TenantEntity>>,
#[serde(rename = "versionedComponentId")]
pub versioned_component_id: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct UserEntity {
pub bulletins: Option<Vec<BulletinEntity>>,
pub component: Option<UserDto>,
#[serde(rename = "disconnectedNodeAcknowledged")]
pub disconnected_node_acknowledged: Option<bool>,
pub id: Option<String>,
pub permissions: Option<PermissionsDto>,
pub position: Option<PositionDto>,
pub revision: Option<RevisionDto>,
pub uri: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct UserGroupDto {
#[serde(rename = "accessPolicies")]
pub access_policies: Option<Vec<AccessPolicyEntity>>,
pub configurable: Option<bool>,
pub id: Option<String>,
pub identity: Option<String>,
#[serde(rename = "parentGroupId")]
pub parent_group_id: Option<String>,
pub position: Option<PositionDto>,
pub users: Option<Vec<TenantEntity>>,
#[serde(rename = "versionedComponentId")]
pub versioned_component_id: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct UserGroupEntity {
pub bulletins: Option<Vec<BulletinEntity>>,
pub component: Option<UserGroupDto>,
#[serde(rename = "disconnectedNodeAcknowledged")]
pub disconnected_node_acknowledged: Option<bool>,
pub id: Option<String>,
pub permissions: Option<PermissionsDto>,
pub position: Option<PositionDto>,
pub revision: Option<RevisionDto>,
pub uri: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct UserGroupsEntity {
#[serde(rename = "userGroups")]
pub user_groups: Option<Vec<UserGroupEntity>>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct UsersEntity {
pub generated: Option<String>,
pub users: Option<Vec<UserEntity>>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct VerifyConfigRequestDto {
pub attributes: Option<std::collections::HashMap<String, Option<String>>>,
pub complete: Option<bool>,
#[serde(rename = "componentId")]
pub component_id: Option<String>,
#[serde(rename = "failureReason")]
pub failure_reason: Option<String>,
#[serde(rename = "lastUpdated")]
pub last_updated: Option<String>,
#[serde(rename = "percentCompleted")]
pub percent_completed: Option<i32>,
pub properties: Option<std::collections::HashMap<String, Option<String>>>,
#[serde(rename = "requestId")]
pub request_id: Option<String>,
pub results: Option<Vec<ConfigVerificationResultDto>>,
pub state: Option<String>,
#[serde(rename = "submissionTime")]
pub submission_time: Option<String>,
#[serde(rename = "updateSteps")]
pub update_steps: Option<Vec<VerifyConfigUpdateStepDto>>,
pub uri: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub(crate) struct VerifyConfigRequestEntity {
pub request: Option<VerifyConfigRequestDto>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct VerifyConfigUpdateStepDto {
pub complete: Option<bool>,
pub description: Option<String>,
#[serde(rename = "failureReason")]
pub failure_reason: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct VersionControlComponentMappingEntity {
#[serde(rename = "disconnectedNodeAcknowledged")]
pub disconnected_node_acknowledged: Option<bool>,
#[serde(rename = "processGroupRevision")]
pub process_group_revision: Option<RevisionDto>,
#[serde(rename = "versionControlComponentMapping")]
pub version_control_component_mapping:
Option<std::collections::HashMap<String, Option<String>>>,
#[serde(rename = "versionControlInformation")]
pub version_control_information: Option<VersionControlInformationDto>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct VersionControlInformationDto {
pub branch: Option<String>,
#[serde(rename = "bucketId")]
pub bucket_id: Option<String>,
#[serde(rename = "bucketName")]
pub bucket_name: Option<String>,
#[serde(rename = "flowDescription")]
pub flow_description: Option<String>,
#[serde(rename = "flowId")]
pub flow_id: Option<String>,
#[serde(rename = "flowName")]
pub flow_name: Option<String>,
#[serde(rename = "groupId")]
pub group_id: Option<String>,
#[serde(rename = "registryId")]
pub registry_id: Option<String>,
#[serde(rename = "registryName")]
pub registry_name: Option<String>,
pub state: Option<String>,
#[serde(rename = "stateExplanation")]
pub state_explanation: Option<String>,
#[serde(rename = "storageLocation")]
pub storage_location: Option<String>,
pub version: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct VersionControlInformationEntity {
#[serde(rename = "disconnectedNodeAcknowledged")]
pub disconnected_node_acknowledged: Option<bool>,
#[serde(rename = "processGroupRevision")]
pub process_group_revision: Option<RevisionDto>,
#[serde(rename = "versionControlInformation")]
pub version_control_information: Option<VersionControlInformationDto>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct VersionInfoDto {
#[serde(rename = "buildBranch")]
pub build_branch: Option<String>,
#[serde(rename = "buildRevision")]
pub build_revision: Option<String>,
#[serde(rename = "buildTag")]
pub build_tag: Option<String>,
#[serde(rename = "buildTimestamp")]
pub build_timestamp: Option<String>,
#[serde(rename = "javaVendor")]
pub java_vendor: Option<String>,
#[serde(rename = "javaVersion")]
pub java_version: Option<String>,
#[serde(rename = "niFiVersion")]
pub ni_fi_version: Option<String>,
#[serde(rename = "osArchitecture")]
pub os_architecture: Option<String>,
#[serde(rename = "osName")]
pub os_name: Option<String>,
#[serde(rename = "osVersion")]
pub os_version: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct VersionedAsset {
pub identifier: Option<String>,
pub name: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct VersionedConnection {
#[serde(rename = "backPressureDataSizeThreshold")]
pub back_pressure_data_size_threshold: Option<String>,
#[serde(rename = "backPressureObjectThreshold")]
pub back_pressure_object_threshold: Option<i64>,
pub bends: Option<Vec<Position>>,
pub comments: Option<String>,
#[serde(rename = "componentType")]
pub component_type: Option<String>,
pub destination: Option<ConnectableComponent>,
#[serde(rename = "flowFileExpiration")]
pub flow_file_expiration: Option<String>,
#[serde(rename = "groupIdentifier")]
pub group_identifier: Option<String>,
pub identifier: Option<String>,
#[serde(rename = "instanceIdentifier")]
pub instance_identifier: Option<String>,
#[serde(rename = "labelIndex")]
pub label_index: Option<i32>,
#[serde(rename = "loadBalanceCompression")]
pub load_balance_compression: Option<String>,
#[serde(rename = "loadBalanceStrategy")]
pub load_balance_strategy: Option<String>,
pub name: Option<String>,
#[serde(rename = "partitioningAttribute")]
pub partitioning_attribute: Option<String>,
pub position: Option<Position>,
pub prioritizers: Option<Vec<String>>,
#[serde(rename = "selectedRelationships")]
pub selected_relationships: Option<Vec<String>>,
pub source: Option<ConnectableComponent>,
#[serde(rename = "zIndex")]
pub z_index: Option<i64>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct VersionedControllerService {
#[serde(rename = "annotationData")]
pub annotation_data: Option<String>,
#[serde(rename = "bulletinLevel")]
pub bulletin_level: Option<String>,
pub bundle: Option<Bundle>,
pub comments: Option<String>,
#[serde(rename = "componentType")]
pub component_type: Option<String>,
#[serde(rename = "controllerServiceApis")]
pub controller_service_apis: Option<Vec<ControllerServiceAPI>>,
#[serde(rename = "groupIdentifier")]
pub group_identifier: Option<String>,
pub identifier: Option<String>,
#[serde(rename = "instanceIdentifier")]
pub instance_identifier: Option<String>,
pub name: Option<String>,
pub position: Option<Position>,
pub properties: Option<std::collections::HashMap<String, Option<String>>>,
#[serde(rename = "propertyDescriptors")]
pub property_descriptors:
Option<std::collections::HashMap<String, Option<VersionedPropertyDescriptor>>>,
#[serde(rename = "scheduledState")]
pub scheduled_state: Option<String>,
pub r#type: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct VersionedFlowCoordinates {
pub branch: Option<String>,
#[serde(rename = "bucketId")]
pub bucket_id: Option<String>,
#[serde(rename = "flowId")]
pub flow_id: Option<String>,
pub latest: Option<bool>,
#[serde(rename = "registryId")]
pub registry_id: Option<String>,
#[serde(rename = "storageLocation")]
pub storage_location: Option<String>,
pub version: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct VersionedFlowDto {
pub action: Option<String>,
pub branch: Option<String>,
#[serde(rename = "bucketId")]
pub bucket_id: Option<String>,
pub comments: Option<String>,
pub description: Option<String>,
#[serde(rename = "flowId")]
pub flow_id: Option<String>,
#[serde(rename = "flowName")]
pub flow_name: Option<String>,
#[serde(rename = "registryId")]
pub registry_id: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub(crate) struct VersionedFlowEntity {
pub versioned_flow: Option<VersionedFlowDto>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct VersionedFlowSnapshotEntity {
#[serde(rename = "disconnectedNodeAcknowledged")]
pub disconnected_node_acknowledged: Option<bool>,
#[serde(rename = "processGroupRevision")]
pub process_group_revision: Option<RevisionDto>,
#[serde(rename = "registryId")]
pub registry_id: Option<String>,
#[serde(rename = "updateDescendantVersionedFlows")]
pub update_descendant_versioned_flows: Option<bool>,
#[serde(rename = "versionedFlow")]
pub versioned_flow: Option<RegisteredFlowSnapshot>,
#[serde(rename = "versionedFlowSnapshot")]
pub versioned_flow_snapshot: Option<RegisteredFlowSnapshot>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct VersionedFlowSnapshotMetadataEntity {
#[serde(rename = "registryId")]
pub registry_id: Option<String>,
#[serde(rename = "versionedFlowSnapshotMetadata")]
pub versioned_flow_snapshot_metadata: Option<RegisteredFlowSnapshotMetadata>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct VersionedFlowSnapshotMetadataSetEntity {
#[serde(rename = "versionedFlowSnapshotMetadataSet")]
pub versioned_flow_snapshot_metadata_set: Option<Vec<VersionedFlowSnapshotMetadataEntity>>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct VersionedFlowUpdateRequestDto {
pub complete: Option<bool>,
#[serde(rename = "failureReason")]
pub failure_reason: Option<String>,
#[serde(rename = "lastUpdated")]
pub last_updated: Option<String>,
#[serde(rename = "percentCompleted")]
pub percent_completed: Option<i32>,
#[serde(rename = "processGroupId")]
pub process_group_id: Option<String>,
#[serde(rename = "requestId")]
pub request_id: Option<String>,
pub state: Option<String>,
pub uri: Option<String>,
#[serde(rename = "versionControlInformation")]
pub version_control_information: Option<VersionControlInformationDto>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct VersionedFlowUpdateRequestEntity {
#[serde(rename = "processGroupRevision")]
pub process_group_revision: Option<RevisionDto>,
pub request: Option<VersionedFlowUpdateRequestDto>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct VersionedFlowsEntity {
#[serde(rename = "versionedFlows")]
pub versioned_flows: Option<Vec<VersionedFlowEntity>>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct VersionedFunnel {
pub comments: Option<String>,
#[serde(rename = "componentType")]
pub component_type: Option<String>,
#[serde(rename = "groupIdentifier")]
pub group_identifier: Option<String>,
pub identifier: Option<String>,
#[serde(rename = "instanceIdentifier")]
pub instance_identifier: Option<String>,
pub name: Option<String>,
pub position: Option<Position>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct VersionedLabel {
pub comments: Option<String>,
#[serde(rename = "componentType")]
pub component_type: Option<String>,
#[serde(rename = "groupIdentifier")]
pub group_identifier: Option<String>,
pub height: Option<f64>,
pub identifier: Option<String>,
#[serde(rename = "instanceIdentifier")]
pub instance_identifier: Option<String>,
pub label: Option<String>,
pub name: Option<String>,
pub position: Option<Position>,
pub style: Option<std::collections::HashMap<String, Option<String>>>,
pub width: Option<f64>,
#[serde(rename = "zIndex")]
pub z_index: Option<i64>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct VersionedListenPortDefinition {
#[serde(rename = "applicationProtocols")]
pub application_protocols: Option<Vec<String>>,
#[serde(rename = "transportProtocol")]
pub transport_protocol: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct VersionedParameter {
pub description: Option<String>,
pub name: Option<String>,
pub provided: Option<bool>,
#[serde(rename = "referencedAssets")]
pub referenced_assets: Option<Vec<VersionedAsset>>,
pub sensitive: Option<bool>,
pub value: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct VersionedParameterContext {
pub comments: Option<String>,
#[serde(rename = "componentType")]
pub component_type: Option<String>,
pub description: Option<String>,
#[serde(rename = "groupIdentifier")]
pub group_identifier: Option<String>,
pub identifier: Option<String>,
#[serde(rename = "inheritedParameterContexts")]
pub inherited_parameter_contexts: Option<Vec<String>>,
#[serde(rename = "instanceIdentifier")]
pub instance_identifier: Option<String>,
pub name: Option<String>,
#[serde(rename = "parameterGroupName")]
pub parameter_group_name: Option<String>,
#[serde(rename = "parameterProvider")]
pub parameter_provider: Option<String>,
pub parameters: Option<Vec<VersionedParameter>>,
pub position: Option<Position>,
pub synchronized: Option<bool>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct VersionedPort {
#[serde(rename = "allowRemoteAccess")]
pub allow_remote_access: Option<bool>,
pub comments: Option<String>,
#[serde(rename = "componentType")]
pub component_type: Option<String>,
#[serde(rename = "concurrentlySchedulableTaskCount")]
pub concurrently_schedulable_task_count: Option<i32>,
#[serde(rename = "groupIdentifier")]
pub group_identifier: Option<String>,
pub identifier: Option<String>,
#[serde(rename = "instanceIdentifier")]
pub instance_identifier: Option<String>,
pub name: Option<String>,
#[serde(rename = "portFunction")]
pub port_function: Option<String>,
pub position: Option<Position>,
#[serde(rename = "scheduledState")]
pub scheduled_state: Option<String>,
pub r#type: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct VersionedProcessGroup {
pub comments: Option<String>,
#[serde(rename = "componentType")]
pub component_type: Option<String>,
pub connections: Option<Vec<VersionedConnection>>,
#[serde(rename = "controllerServices")]
pub controller_services: Option<Vec<VersionedControllerService>>,
#[serde(rename = "defaultBackPressureDataSizeThreshold")]
pub default_back_pressure_data_size_threshold: Option<String>,
#[serde(rename = "defaultBackPressureObjectThreshold")]
pub default_back_pressure_object_threshold: Option<i64>,
#[serde(rename = "defaultFlowFileExpiration")]
pub default_flow_file_expiration: Option<String>,
#[serde(rename = "executionEngine")]
pub execution_engine: Option<String>,
#[serde(rename = "flowFileConcurrency")]
pub flow_file_concurrency: Option<String>,
#[serde(rename = "flowFileOutboundPolicy")]
pub flow_file_outbound_policy: Option<String>,
pub funnels: Option<Vec<VersionedFunnel>>,
#[serde(rename = "groupIdentifier")]
pub group_identifier: Option<String>,
pub identifier: Option<String>,
#[serde(rename = "inputPorts")]
pub input_ports: Option<Vec<VersionedPort>>,
#[serde(rename = "instanceIdentifier")]
pub instance_identifier: Option<String>,
pub labels: Option<Vec<VersionedLabel>>,
#[serde(rename = "logFileSuffix")]
pub log_file_suffix: Option<String>,
#[serde(rename = "maxConcurrentTasks")]
pub max_concurrent_tasks: Option<i32>,
pub name: Option<String>,
#[serde(rename = "outputPorts")]
pub output_ports: Option<Vec<VersionedPort>>,
#[serde(rename = "parameterContextName")]
pub parameter_context_name: Option<String>,
pub position: Option<Position>,
#[serde(rename = "processGroups")]
pub process_groups: Option<Vec<Box<VersionedProcessGroup>>>,
pub processors: Option<Vec<VersionedProcessor>>,
#[serde(rename = "remoteProcessGroups")]
pub remote_process_groups: Option<Vec<VersionedRemoteProcessGroup>>,
#[serde(rename = "scheduledState")]
pub scheduled_state: Option<String>,
#[serde(rename = "statelessFlowTimeout")]
pub stateless_flow_timeout: Option<String>,
#[serde(rename = "versionedFlowCoordinates")]
pub versioned_flow_coordinates: Option<VersionedFlowCoordinates>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct VersionedProcessor {
#[serde(rename = "annotationData")]
pub annotation_data: Option<String>,
#[serde(rename = "autoTerminatedRelationships")]
pub auto_terminated_relationships: Option<Vec<String>>,
#[serde(rename = "backoffMechanism")]
pub backoff_mechanism: Option<String>,
#[serde(rename = "bulletinLevel")]
pub bulletin_level: Option<String>,
pub bundle: Option<Bundle>,
pub comments: Option<String>,
#[serde(rename = "componentType")]
pub component_type: Option<String>,
#[serde(rename = "concurrentlySchedulableTaskCount")]
pub concurrently_schedulable_task_count: Option<i32>,
#[serde(rename = "executionNode")]
pub execution_node: Option<String>,
#[serde(rename = "groupIdentifier")]
pub group_identifier: Option<String>,
pub identifier: Option<String>,
#[serde(rename = "instanceIdentifier")]
pub instance_identifier: Option<String>,
#[serde(rename = "maxBackoffPeriod")]
pub max_backoff_period: Option<String>,
pub name: Option<String>,
#[serde(rename = "penaltyDuration")]
pub penalty_duration: Option<String>,
pub position: Option<Position>,
pub properties: Option<std::collections::HashMap<String, Option<String>>>,
#[serde(rename = "propertyDescriptors")]
pub property_descriptors:
Option<std::collections::HashMap<String, Option<VersionedPropertyDescriptor>>>,
#[serde(rename = "retriedRelationships")]
pub retried_relationships: Option<Vec<String>>,
#[serde(rename = "retryCount")]
pub retry_count: Option<i32>,
#[serde(rename = "runDurationMillis")]
pub run_duration_millis: Option<i64>,
#[serde(rename = "scheduledState")]
pub scheduled_state: Option<String>,
#[serde(rename = "schedulingPeriod")]
pub scheduling_period: Option<String>,
#[serde(rename = "schedulingStrategy")]
pub scheduling_strategy: Option<String>,
pub style: Option<std::collections::HashMap<String, Option<String>>>,
pub r#type: Option<String>,
#[serde(rename = "yieldDuration")]
pub yield_duration: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct VersionedPropertyDescriptor {
#[serde(rename = "displayName")]
pub display_name: Option<String>,
pub dynamic: Option<bool>,
#[serde(rename = "identifiesControllerService")]
pub identifies_controller_service: Option<bool>,
#[serde(rename = "listenPortDefinition")]
pub listen_port_definition: Option<VersionedListenPortDefinition>,
pub name: Option<String>,
#[serde(rename = "resourceDefinition")]
pub resource_definition: Option<VersionedResourceDefinition>,
pub sensitive: Option<bool>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct VersionedRemoteGroupPort {
#[serde(rename = "batchSize")]
pub batch_size: Option<BatchSize>,
pub comments: Option<String>,
#[serde(rename = "componentType")]
pub component_type: Option<String>,
#[serde(rename = "concurrentlySchedulableTaskCount")]
pub concurrently_schedulable_task_count: Option<i32>,
#[serde(rename = "groupIdentifier")]
pub group_identifier: Option<String>,
pub identifier: Option<String>,
#[serde(rename = "instanceIdentifier")]
pub instance_identifier: Option<String>,
pub name: Option<String>,
pub position: Option<Position>,
#[serde(rename = "remoteGroupId")]
pub remote_group_id: Option<String>,
#[serde(rename = "scheduledState")]
pub scheduled_state: Option<String>,
#[serde(rename = "targetId")]
pub target_id: Option<String>,
#[serde(rename = "useCompression")]
pub use_compression: Option<bool>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct VersionedRemoteProcessGroup {
pub comments: Option<String>,
#[serde(rename = "communicationsTimeout")]
pub communications_timeout: Option<String>,
#[serde(rename = "componentType")]
pub component_type: Option<String>,
#[serde(rename = "groupIdentifier")]
pub group_identifier: Option<String>,
pub identifier: Option<String>,
#[serde(rename = "inputPorts")]
pub input_ports: Option<Vec<VersionedRemoteGroupPort>>,
#[serde(rename = "instanceIdentifier")]
pub instance_identifier: Option<String>,
#[serde(rename = "localNetworkInterface")]
pub local_network_interface: Option<String>,
pub name: Option<String>,
#[serde(rename = "outputPorts")]
pub output_ports: Option<Vec<VersionedRemoteGroupPort>>,
pub position: Option<Position>,
#[serde(rename = "proxyHost")]
pub proxy_host: Option<String>,
#[serde(rename = "proxyPassword")]
pub proxy_password: Option<String>,
#[serde(rename = "proxyPort")]
pub proxy_port: Option<i32>,
#[serde(rename = "proxyUser")]
pub proxy_user: Option<String>,
#[serde(rename = "targetUris")]
pub target_uris: Option<String>,
#[serde(rename = "transportProtocol")]
pub transport_protocol: Option<String>,
#[serde(rename = "yieldDuration")]
pub yield_duration: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct VersionedReportingTask {
#[serde(rename = "annotationData")]
pub annotation_data: Option<String>,
pub bundle: Option<Bundle>,
pub comments: Option<String>,
#[serde(rename = "componentType")]
pub component_type: Option<String>,
#[serde(rename = "groupIdentifier")]
pub group_identifier: Option<String>,
pub identifier: Option<String>,
#[serde(rename = "instanceIdentifier")]
pub instance_identifier: Option<String>,
pub name: Option<String>,
pub position: Option<Position>,
pub properties: Option<std::collections::HashMap<String, Option<String>>>,
#[serde(rename = "propertyDescriptors")]
pub property_descriptors:
Option<std::collections::HashMap<String, Option<VersionedPropertyDescriptor>>>,
#[serde(rename = "scheduledState")]
pub scheduled_state: Option<String>,
#[serde(rename = "schedulingPeriod")]
pub scheduling_period: Option<String>,
#[serde(rename = "schedulingStrategy")]
pub scheduling_strategy: Option<String>,
pub r#type: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct VersionedReportingTaskImportRequestEntity {
#[serde(rename = "disconnectedNodeAcknowledged")]
pub disconnected_node_acknowledged: Option<bool>,
#[serde(rename = "reportingTaskSnapshot")]
pub reporting_task_snapshot: Option<VersionedReportingTaskSnapshot>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct VersionedReportingTaskImportResponseEntity {
#[serde(rename = "controllerServices")]
pub controller_services: Option<Vec<ControllerServiceEntity>>,
#[serde(rename = "reportingTasks")]
pub reporting_tasks: Option<Vec<ReportingTaskEntity>>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct VersionedReportingTaskSnapshot {
#[serde(rename = "controllerServices")]
pub controller_services: Option<Vec<VersionedControllerService>>,
#[serde(rename = "reportingTasks")]
pub reporting_tasks: Option<Vec<VersionedReportingTask>>,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct VersionedResourceDefinition {
pub cardinality: Option<String>,
#[serde(rename = "resourceTypes")]
pub resource_types: Option<Vec<String>>,
}