├── .gitignore ├── .parlour ├── .ruby-version ├── .tool-versions ├── CHANGELOG.md ├── Gemfile ├── Gemfile.lock ├── LICENSE ├── README.md ├── Rakefile ├── bin └── tapioca ├── kube-dsl.gemspec ├── lib ├── kube-dsl.rb └── kube-dsl │ ├── allow_blank.rb │ ├── array_field_res.rb │ ├── builder.rb │ ├── default_field_res.rb │ ├── dsl.rb │ ├── dsl │ ├── admissionregistration.rb │ ├── admissionregistration │ │ ├── v1.rb │ │ └── v1 │ │ │ ├── mutating_webhook.rb │ │ │ ├── mutating_webhook_configuration.rb │ │ │ ├── mutating_webhook_configuration_list.rb │ │ │ ├── rule_with_operations.rb │ │ │ ├── service_reference.rb │ │ │ ├── validating_webhook.rb │ │ │ ├── validating_webhook_configuration.rb │ │ │ ├── validating_webhook_configuration_list.rb │ │ │ └── webhook_client_config.rb │ ├── apiextensions.rb │ ├── apiextensions │ │ ├── v1.rb │ │ └── v1 │ │ │ ├── custom_resource_column_definition.rb │ │ │ ├── custom_resource_conversion.rb │ │ │ ├── custom_resource_definition.rb │ │ │ ├── custom_resource_definition_condition.rb │ │ │ ├── custom_resource_definition_list.rb │ │ │ ├── custom_resource_definition_names.rb │ │ │ ├── custom_resource_definition_spec.rb │ │ │ ├── custom_resource_definition_status.rb │ │ │ ├── custom_resource_definition_version.rb │ │ │ ├── custom_resource_subresource_scale.rb │ │ │ ├── custom_resource_subresources.rb │ │ │ ├── custom_resource_validation.rb │ │ │ ├── external_documentation.rb │ │ │ ├── json.rb │ │ │ ├── json_schema_props.rb │ │ │ ├── service_reference.rb │ │ │ ├── validation_rule.rb │ │ │ ├── webhook_client_config.rb │ │ │ └── webhook_conversion.rb │ ├── apiregistration.rb │ ├── apiregistration │ │ ├── v1.rb │ │ └── v1 │ │ │ ├── api_service.rb │ │ │ ├── api_service_condition.rb │ │ │ ├── api_service_list.rb │ │ │ ├── api_service_spec.rb │ │ │ ├── api_service_status.rb │ │ │ └── service_reference.rb │ ├── apiserverinternal.rb │ ├── apiserverinternal │ │ ├── v1alpha1.rb │ │ └── v1alpha1 │ │ │ ├── server_storage_version.rb │ │ │ ├── storage_version.rb │ │ │ ├── storage_version_condition.rb │ │ │ ├── storage_version_list.rb │ │ │ └── storage_version_status.rb │ ├── apps.rb │ ├── apps │ │ ├── v1.rb │ │ └── v1 │ │ │ ├── controller_revision.rb │ │ │ ├── controller_revision_list.rb │ │ │ ├── daemon_set.rb │ │ │ ├── daemon_set_condition.rb │ │ │ ├── daemon_set_list.rb │ │ │ ├── daemon_set_spec.rb │ │ │ ├── daemon_set_status.rb │ │ │ ├── daemon_set_update_strategy.rb │ │ │ ├── deployment.rb │ │ │ ├── deployment_condition.rb │ │ │ ├── deployment_list.rb │ │ │ ├── deployment_spec.rb │ │ │ ├── deployment_status.rb │ │ │ ├── deployment_strategy.rb │ │ │ ├── replica_set.rb │ │ │ ├── replica_set_condition.rb │ │ │ ├── replica_set_list.rb │ │ │ ├── replica_set_spec.rb │ │ │ ├── replica_set_status.rb │ │ │ ├── rolling_update_daemon_set.rb │ │ │ ├── rolling_update_deployment.rb │ │ │ ├── rolling_update_stateful_set_strategy.rb │ │ │ ├── stateful_set.rb │ │ │ ├── stateful_set_condition.rb │ │ │ ├── stateful_set_list.rb │ │ │ ├── stateful_set_persistent_volume_claim_retention_policy.rb │ │ │ ├── stateful_set_spec.rb │ │ │ ├── stateful_set_status.rb │ │ │ └── stateful_set_update_strategy.rb │ ├── authentication.rb │ ├── authentication │ │ ├── v1.rb │ │ └── v1 │ │ │ ├── bound_object_reference.rb │ │ │ ├── token_request.rb │ │ │ ├── token_request_spec.rb │ │ │ ├── token_request_status.rb │ │ │ ├── token_review.rb │ │ │ ├── token_review_spec.rb │ │ │ ├── token_review_status.rb │ │ │ └── user_info.rb │ ├── authorization.rb │ ├── authorization │ │ ├── v1.rb │ │ └── v1 │ │ │ ├── local_subject_access_review.rb │ │ │ ├── non_resource_attributes.rb │ │ │ ├── non_resource_rule.rb │ │ │ ├── resource_attributes.rb │ │ │ ├── resource_rule.rb │ │ │ ├── self_subject_access_review.rb │ │ │ ├── self_subject_access_review_spec.rb │ │ │ ├── self_subject_rules_review.rb │ │ │ ├── self_subject_rules_review_spec.rb │ │ │ ├── subject_access_review.rb │ │ │ ├── subject_access_review_spec.rb │ │ │ ├── subject_access_review_status.rb │ │ │ └── subject_rules_review_status.rb │ ├── autoscaling.rb │ ├── autoscaling │ │ ├── v1.rb │ │ ├── v1 │ │ │ ├── cross_version_object_reference.rb │ │ │ ├── horizontal_pod_autoscaler.rb │ │ │ ├── horizontal_pod_autoscaler_list.rb │ │ │ ├── horizontal_pod_autoscaler_spec.rb │ │ │ ├── horizontal_pod_autoscaler_status.rb │ │ │ ├── scale.rb │ │ │ ├── scale_spec.rb │ │ │ └── scale_status.rb │ │ ├── v2.rb │ │ ├── v2 │ │ │ ├── container_resource_metric_source.rb │ │ │ ├── container_resource_metric_status.rb │ │ │ ├── cross_version_object_reference.rb │ │ │ ├── external_metric_source.rb │ │ │ ├── external_metric_status.rb │ │ │ ├── horizontal_pod_autoscaler.rb │ │ │ ├── horizontal_pod_autoscaler_behavior.rb │ │ │ ├── horizontal_pod_autoscaler_condition.rb │ │ │ ├── horizontal_pod_autoscaler_list.rb │ │ │ ├── horizontal_pod_autoscaler_spec.rb │ │ │ ├── horizontal_pod_autoscaler_status.rb │ │ │ ├── hpa_scaling_policy.rb │ │ │ ├── hpa_scaling_rules.rb │ │ │ ├── metric_identifier.rb │ │ │ ├── metric_spec.rb │ │ │ ├── metric_status.rb │ │ │ ├── metric_target.rb │ │ │ ├── metric_value_status.rb │ │ │ ├── object_metric_source.rb │ │ │ ├── object_metric_status.rb │ │ │ ├── pods_metric_source.rb │ │ │ ├── pods_metric_status.rb │ │ │ ├── resource_metric_source.rb │ │ │ └── resource_metric_status.rb │ │ ├── v2beta1.rb │ │ ├── v2beta1 │ │ │ ├── container_resource_metric_source.rb │ │ │ ├── container_resource_metric_status.rb │ │ │ ├── cross_version_object_reference.rb │ │ │ ├── external_metric_source.rb │ │ │ ├── external_metric_status.rb │ │ │ ├── horizontal_pod_autoscaler.rb │ │ │ ├── horizontal_pod_autoscaler_condition.rb │ │ │ ├── horizontal_pod_autoscaler_list.rb │ │ │ ├── horizontal_pod_autoscaler_spec.rb │ │ │ ├── horizontal_pod_autoscaler_status.rb │ │ │ ├── metric_spec.rb │ │ │ ├── metric_status.rb │ │ │ ├── object_metric_source.rb │ │ │ ├── object_metric_status.rb │ │ │ ├── pods_metric_source.rb │ │ │ ├── pods_metric_status.rb │ │ │ ├── resource_metric_source.rb │ │ │ └── resource_metric_status.rb │ │ ├── v2beta2.rb │ │ └── v2beta2 │ │ │ ├── container_resource_metric_source.rb │ │ │ ├── container_resource_metric_status.rb │ │ │ ├── cross_version_object_reference.rb │ │ │ ├── external_metric_source.rb │ │ │ ├── external_metric_status.rb │ │ │ ├── horizontal_pod_autoscaler.rb │ │ │ ├── horizontal_pod_autoscaler_behavior.rb │ │ │ ├── horizontal_pod_autoscaler_condition.rb │ │ │ ├── horizontal_pod_autoscaler_list.rb │ │ │ ├── horizontal_pod_autoscaler_spec.rb │ │ │ ├── horizontal_pod_autoscaler_status.rb │ │ │ ├── hpa_scaling_policy.rb │ │ │ ├── hpa_scaling_rules.rb │ │ │ ├── metric_identifier.rb │ │ │ ├── metric_spec.rb │ │ │ ├── metric_status.rb │ │ │ ├── metric_target.rb │ │ │ ├── metric_value_status.rb │ │ │ ├── object_metric_source.rb │ │ │ ├── object_metric_status.rb │ │ │ ├── pods_metric_source.rb │ │ │ ├── pods_metric_status.rb │ │ │ ├── resource_metric_source.rb │ │ │ └── resource_metric_status.rb │ ├── batch.rb │ ├── batch │ │ ├── v1.rb │ │ ├── v1 │ │ │ ├── cron_job.rb │ │ │ ├── cron_job_list.rb │ │ │ ├── cron_job_spec.rb │ │ │ ├── cron_job_status.rb │ │ │ ├── job.rb │ │ │ ├── job_condition.rb │ │ │ ├── job_list.rb │ │ │ ├── job_spec.rb │ │ │ ├── job_status.rb │ │ │ ├── job_template_spec.rb │ │ │ └── uncounted_terminated_pods.rb │ │ ├── v1beta1.rb │ │ └── v1beta1 │ │ │ ├── cron_job.rb │ │ │ ├── cron_job_list.rb │ │ │ ├── cron_job_spec.rb │ │ │ ├── cron_job_status.rb │ │ │ └── job_template_spec.rb │ ├── certificates.rb │ ├── certificates │ │ ├── v1.rb │ │ └── v1 │ │ │ ├── certificate_signing_request.rb │ │ │ ├── certificate_signing_request_condition.rb │ │ │ ├── certificate_signing_request_list.rb │ │ │ ├── certificate_signing_request_spec.rb │ │ │ └── certificate_signing_request_status.rb │ ├── coordination.rb │ ├── coordination │ │ ├── v1.rb │ │ └── v1 │ │ │ ├── lease.rb │ │ │ ├── lease_list.rb │ │ │ └── lease_spec.rb │ ├── discovery.rb │ ├── discovery │ │ ├── v1.rb │ │ ├── v1 │ │ │ ├── endpoint.rb │ │ │ ├── endpoint_conditions.rb │ │ │ ├── endpoint_hints.rb │ │ │ ├── endpoint_port.rb │ │ │ ├── endpoint_slice.rb │ │ │ ├── endpoint_slice_list.rb │ │ │ └── for_zone.rb │ │ ├── v1beta1.rb │ │ └── v1beta1 │ │ │ ├── endpoint.rb │ │ │ ├── endpoint_conditions.rb │ │ │ ├── endpoint_hints.rb │ │ │ ├── endpoint_port.rb │ │ │ ├── endpoint_slice.rb │ │ │ ├── endpoint_slice_list.rb │ │ │ └── for_zone.rb │ ├── events.rb │ ├── events │ │ ├── v1.rb │ │ ├── v1 │ │ │ ├── event.rb │ │ │ ├── event_list.rb │ │ │ └── event_series.rb │ │ ├── v1beta1.rb │ │ └── v1beta1 │ │ │ ├── event.rb │ │ │ ├── event_list.rb │ │ │ └── event_series.rb │ ├── flowcontrol.rb │ ├── flowcontrol │ │ ├── v1beta1.rb │ │ ├── v1beta1 │ │ │ ├── flow_distinguisher_method.rb │ │ │ ├── flow_schema.rb │ │ │ ├── flow_schema_condition.rb │ │ │ ├── flow_schema_list.rb │ │ │ ├── flow_schema_spec.rb │ │ │ ├── flow_schema_status.rb │ │ │ ├── group_subject.rb │ │ │ ├── limit_response.rb │ │ │ ├── limited_priority_level_configuration.rb │ │ │ ├── non_resource_policy_rule.rb │ │ │ ├── policy_rules_with_subjects.rb │ │ │ ├── priority_level_configuration.rb │ │ │ ├── priority_level_configuration_condition.rb │ │ │ ├── priority_level_configuration_list.rb │ │ │ ├── priority_level_configuration_reference.rb │ │ │ ├── priority_level_configuration_spec.rb │ │ │ ├── priority_level_configuration_status.rb │ │ │ ├── queuing_configuration.rb │ │ │ ├── resource_policy_rule.rb │ │ │ ├── service_account_subject.rb │ │ │ ├── subject.rb │ │ │ └── user_subject.rb │ │ ├── v1beta2.rb │ │ └── v1beta2 │ │ │ ├── flow_distinguisher_method.rb │ │ │ ├── flow_schema.rb │ │ │ ├── flow_schema_condition.rb │ │ │ ├── flow_schema_list.rb │ │ │ ├── flow_schema_spec.rb │ │ │ ├── flow_schema_status.rb │ │ │ ├── group_subject.rb │ │ │ ├── limit_response.rb │ │ │ ├── limited_priority_level_configuration.rb │ │ │ ├── non_resource_policy_rule.rb │ │ │ ├── policy_rules_with_subjects.rb │ │ │ ├── priority_level_configuration.rb │ │ │ ├── priority_level_configuration_condition.rb │ │ │ ├── priority_level_configuration_list.rb │ │ │ ├── priority_level_configuration_reference.rb │ │ │ ├── priority_level_configuration_spec.rb │ │ │ ├── priority_level_configuration_status.rb │ │ │ ├── queuing_configuration.rb │ │ │ ├── resource_policy_rule.rb │ │ │ ├── service_account_subject.rb │ │ │ ├── subject.rb │ │ │ └── user_subject.rb │ ├── meta.rb │ ├── meta │ │ ├── v1.rb │ │ └── v1 │ │ │ ├── api_group.rb │ │ │ ├── api_group_list.rb │ │ │ ├── api_resource.rb │ │ │ ├── api_resource_list.rb │ │ │ ├── api_versions.rb │ │ │ ├── condition.rb │ │ │ ├── delete_options.rb │ │ │ ├── group_version_for_discovery.rb │ │ │ ├── label_selector.rb │ │ │ ├── label_selector_requirement.rb │ │ │ ├── list_meta.rb │ │ │ ├── managed_fields_entry.rb │ │ │ ├── object_meta.rb │ │ │ ├── owner_reference.rb │ │ │ ├── preconditions.rb │ │ │ ├── server_address_by_client_cidr.rb │ │ │ ├── status.rb │ │ │ ├── status_cause.rb │ │ │ ├── status_details.rb │ │ │ └── watch_event.rb │ ├── networking.rb │ ├── networking │ │ ├── v1.rb │ │ └── v1 │ │ │ ├── http_ingress_path.rb │ │ │ ├── http_ingress_rule_value.rb │ │ │ ├── ingress.rb │ │ │ ├── ingress_backend.rb │ │ │ ├── ingress_class.rb │ │ │ ├── ingress_class_list.rb │ │ │ ├── ingress_class_parameters_reference.rb │ │ │ ├── ingress_class_spec.rb │ │ │ ├── ingress_list.rb │ │ │ ├── ingress_rule.rb │ │ │ ├── ingress_service_backend.rb │ │ │ ├── ingress_spec.rb │ │ │ ├── ingress_status.rb │ │ │ ├── ingress_tls.rb │ │ │ ├── ip_block.rb │ │ │ ├── network_policy.rb │ │ │ ├── network_policy_egress_rule.rb │ │ │ ├── network_policy_ingress_rule.rb │ │ │ ├── network_policy_list.rb │ │ │ ├── network_policy_peer.rb │ │ │ ├── network_policy_port.rb │ │ │ ├── network_policy_spec.rb │ │ │ └── service_backend_port.rb │ ├── node.rb │ ├── node │ │ ├── v1.rb │ │ ├── v1 │ │ │ ├── overhead.rb │ │ │ ├── runtime_class.rb │ │ │ ├── runtime_class_list.rb │ │ │ └── scheduling.rb │ │ ├── v1alpha1.rb │ │ ├── v1alpha1 │ │ │ ├── overhead.rb │ │ │ ├── runtime_class.rb │ │ │ ├── runtime_class_list.rb │ │ │ ├── runtime_class_spec.rb │ │ │ └── scheduling.rb │ │ ├── v1beta1.rb │ │ └── v1beta1 │ │ │ ├── overhead.rb │ │ │ ├── runtime_class.rb │ │ │ ├── runtime_class_list.rb │ │ │ └── scheduling.rb │ ├── pkg.rb │ ├── policy.rb │ ├── policy │ │ ├── v1.rb │ │ ├── v1 │ │ │ ├── eviction.rb │ │ │ ├── pod_disruption_budget.rb │ │ │ ├── pod_disruption_budget_list.rb │ │ │ ├── pod_disruption_budget_spec.rb │ │ │ └── pod_disruption_budget_status.rb │ │ ├── v1beta1.rb │ │ └── v1beta1 │ │ │ ├── allowed_csi_driver.rb │ │ │ ├── allowed_flex_volume.rb │ │ │ ├── allowed_host_path.rb │ │ │ ├── fs_group_strategy_options.rb │ │ │ ├── host_port_range.rb │ │ │ ├── id_range.rb │ │ │ ├── pod_disruption_budget.rb │ │ │ ├── pod_disruption_budget_list.rb │ │ │ ├── pod_disruption_budget_spec.rb │ │ │ ├── pod_disruption_budget_status.rb │ │ │ ├── pod_security_policy.rb │ │ │ ├── pod_security_policy_list.rb │ │ │ ├── pod_security_policy_spec.rb │ │ │ ├── run_as_group_strategy_options.rb │ │ │ ├── run_as_user_strategy_options.rb │ │ │ ├── runtime_class_strategy_options.rb │ │ │ ├── se_linux_strategy_options.rb │ │ │ └── supplemental_groups_strategy_options.rb │ ├── rbac.rb │ ├── rbac │ │ ├── v1.rb │ │ └── v1 │ │ │ ├── aggregation_rule.rb │ │ │ ├── cluster_role.rb │ │ │ ├── cluster_role_binding.rb │ │ │ ├── cluster_role_binding_list.rb │ │ │ ├── cluster_role_list.rb │ │ │ ├── policy_rule.rb │ │ │ ├── role.rb │ │ │ ├── role_binding.rb │ │ │ ├── role_binding_list.rb │ │ │ ├── role_list.rb │ │ │ ├── role_ref.rb │ │ │ └── subject.rb │ ├── scheduling.rb │ ├── scheduling │ │ ├── v1.rb │ │ └── v1 │ │ │ ├── priority_class.rb │ │ │ └── priority_class_list.rb │ ├── storage.rb │ ├── storage │ │ ├── v1.rb │ │ ├── v1 │ │ │ ├── csi_driver.rb │ │ │ ├── csi_driver_list.rb │ │ │ ├── csi_driver_spec.rb │ │ │ ├── csi_node.rb │ │ │ ├── csi_node_driver.rb │ │ │ ├── csi_node_list.rb │ │ │ ├── csi_node_spec.rb │ │ │ ├── storage_class.rb │ │ │ ├── storage_class_list.rb │ │ │ ├── token_request.rb │ │ │ ├── volume_attachment.rb │ │ │ ├── volume_attachment_list.rb │ │ │ ├── volume_attachment_source.rb │ │ │ ├── volume_attachment_spec.rb │ │ │ ├── volume_attachment_status.rb │ │ │ ├── volume_error.rb │ │ │ └── volume_node_resources.rb │ │ ├── v1alpha1.rb │ │ ├── v1alpha1 │ │ │ ├── csi_storage_capacity.rb │ │ │ └── csi_storage_capacity_list.rb │ │ ├── v1beta1.rb │ │ └── v1beta1 │ │ │ ├── csi_storage_capacity.rb │ │ │ └── csi_storage_capacity_list.rb │ ├── v1.rb │ └── v1 │ │ ├── affinity.rb │ │ ├── attached_volume.rb │ │ ├── aws_elastic_block_store_volume_source.rb │ │ ├── azure_disk_volume_source.rb │ │ ├── azure_file_persistent_volume_source.rb │ │ ├── azure_file_volume_source.rb │ │ ├── binding.rb │ │ ├── capabilities.rb │ │ ├── ceph_fs_persistent_volume_source.rb │ │ ├── ceph_fs_volume_source.rb │ │ ├── cinder_persistent_volume_source.rb │ │ ├── cinder_volume_source.rb │ │ ├── client_ip_config.rb │ │ ├── component_condition.rb │ │ ├── component_status.rb │ │ ├── component_status_list.rb │ │ ├── config_map.rb │ │ ├── config_map_env_source.rb │ │ ├── config_map_key_selector.rb │ │ ├── config_map_list.rb │ │ ├── config_map_node_config_source.rb │ │ ├── config_map_projection.rb │ │ ├── config_map_volume_source.rb │ │ ├── container.rb │ │ ├── container_image.rb │ │ ├── container_port.rb │ │ ├── container_state.rb │ │ ├── container_state_running.rb │ │ ├── container_state_terminated.rb │ │ ├── container_state_waiting.rb │ │ ├── container_status.rb │ │ ├── csi_persistent_volume_source.rb │ │ ├── csi_volume_source.rb │ │ ├── daemon_endpoint.rb │ │ ├── downward_api_projection.rb │ │ ├── downward_api_volume_file.rb │ │ ├── downward_api_volume_source.rb │ │ ├── empty_dir_volume_source.rb │ │ ├── endpoint_address.rb │ │ ├── endpoint_port.rb │ │ ├── endpoint_subset.rb │ │ ├── endpoints.rb │ │ ├── endpoints_list.rb │ │ ├── env_from_source.rb │ │ ├── env_var.rb │ │ ├── env_var_source.rb │ │ ├── ephemeral_container.rb │ │ ├── ephemeral_volume_source.rb │ │ ├── event.rb │ │ ├── event_list.rb │ │ ├── event_series.rb │ │ ├── event_source.rb │ │ ├── exec_action.rb │ │ ├── fc_volume_source.rb │ │ ├── flex_persistent_volume_source.rb │ │ ├── flex_volume_source.rb │ │ ├── flocker_volume_source.rb │ │ ├── gce_persistent_disk_volume_source.rb │ │ ├── git_repo_volume_source.rb │ │ ├── glusterfs_persistent_volume_source.rb │ │ ├── glusterfs_volume_source.rb │ │ ├── grpc_action.rb │ │ ├── host_alias.rb │ │ ├── host_path_volume_source.rb │ │ ├── http_get_action.rb │ │ ├── http_header.rb │ │ ├── iscsi_persistent_volume_source.rb │ │ ├── iscsi_volume_source.rb │ │ ├── key_to_path.rb │ │ ├── lifecycle.rb │ │ ├── lifecycle_handler.rb │ │ ├── limit_range.rb │ │ ├── limit_range_item.rb │ │ ├── limit_range_list.rb │ │ ├── limit_range_spec.rb │ │ ├── load_balancer_ingress.rb │ │ ├── load_balancer_status.rb │ │ ├── local_object_reference.rb │ │ ├── local_volume_source.rb │ │ ├── namespace.rb │ │ ├── namespace_condition.rb │ │ ├── namespace_list.rb │ │ ├── namespace_spec.rb │ │ ├── namespace_status.rb │ │ ├── nfs_volume_source.rb │ │ ├── node.rb │ │ ├── node_address.rb │ │ ├── node_affinity.rb │ │ ├── node_condition.rb │ │ ├── node_config_source.rb │ │ ├── node_config_status.rb │ │ ├── node_daemon_endpoints.rb │ │ ├── node_list.rb │ │ ├── node_selector.rb │ │ ├── node_selector_requirement.rb │ │ ├── node_selector_term.rb │ │ ├── node_spec.rb │ │ ├── node_status.rb │ │ ├── node_system_info.rb │ │ ├── object_field_selector.rb │ │ ├── object_reference.rb │ │ ├── persistent_volume.rb │ │ ├── persistent_volume_claim.rb │ │ ├── persistent_volume_claim_condition.rb │ │ ├── persistent_volume_claim_list.rb │ │ ├── persistent_volume_claim_spec.rb │ │ ├── persistent_volume_claim_status.rb │ │ ├── persistent_volume_claim_template.rb │ │ ├── persistent_volume_claim_volume_source.rb │ │ ├── persistent_volume_list.rb │ │ ├── persistent_volume_spec.rb │ │ ├── persistent_volume_status.rb │ │ ├── photon_persistent_disk_volume_source.rb │ │ ├── pod.rb │ │ ├── pod_affinity.rb │ │ ├── pod_affinity_term.rb │ │ ├── pod_anti_affinity.rb │ │ ├── pod_condition.rb │ │ ├── pod_dns_config.rb │ │ ├── pod_dns_config_option.rb │ │ ├── pod_ip.rb │ │ ├── pod_list.rb │ │ ├── pod_os.rb │ │ ├── pod_readiness_gate.rb │ │ ├── pod_security_context.rb │ │ ├── pod_spec.rb │ │ ├── pod_status.rb │ │ ├── pod_template.rb │ │ ├── pod_template_list.rb │ │ ├── pod_template_spec.rb │ │ ├── port_status.rb │ │ ├── portworx_volume_source.rb │ │ ├── preferred_scheduling_term.rb │ │ ├── probe.rb │ │ ├── projected_volume_source.rb │ │ ├── quobyte_volume_source.rb │ │ ├── rbd_persistent_volume_source.rb │ │ ├── rbd_volume_source.rb │ │ ├── replication_controller.rb │ │ ├── replication_controller_condition.rb │ │ ├── replication_controller_list.rb │ │ ├── replication_controller_spec.rb │ │ ├── replication_controller_status.rb │ │ ├── resource_field_selector.rb │ │ ├── resource_quota.rb │ │ ├── resource_quota_list.rb │ │ ├── resource_quota_spec.rb │ │ ├── resource_quota_status.rb │ │ ├── resource_requirements.rb │ │ ├── scale_io_persistent_volume_source.rb │ │ ├── scale_io_volume_source.rb │ │ ├── scope_selector.rb │ │ ├── scoped_resource_selector_requirement.rb │ │ ├── se_linux_options.rb │ │ ├── seccomp_profile.rb │ │ ├── secret.rb │ │ ├── secret_env_source.rb │ │ ├── secret_key_selector.rb │ │ ├── secret_list.rb │ │ ├── secret_projection.rb │ │ ├── secret_reference.rb │ │ ├── secret_volume_source.rb │ │ ├── security_context.rb │ │ ├── service.rb │ │ ├── service_account.rb │ │ ├── service_account_list.rb │ │ ├── service_account_token_projection.rb │ │ ├── service_list.rb │ │ ├── service_port.rb │ │ ├── service_spec.rb │ │ ├── service_status.rb │ │ ├── session_affinity_config.rb │ │ ├── storage_os_persistent_volume_source.rb │ │ ├── storage_os_volume_source.rb │ │ ├── sysctl.rb │ │ ├── taint.rb │ │ ├── tcp_socket_action.rb │ │ ├── toleration.rb │ │ ├── topology_selector_label_requirement.rb │ │ ├── topology_selector_term.rb │ │ ├── topology_spread_constraint.rb │ │ ├── typed_local_object_reference.rb │ │ ├── volume.rb │ │ ├── volume_device.rb │ │ ├── volume_mount.rb │ │ ├── volume_node_affinity.rb │ │ ├── volume_projection.rb │ │ ├── vsphere_virtual_disk_volume_source.rb │ │ ├── weighted_pod_affinity_term.rb │ │ └── windows_security_context_options.rb │ ├── dsl_object.rb │ ├── entrypoint.rb │ ├── entrypoint_builder.rb │ ├── external_ref.rb │ ├── external_resource_meta.rb │ ├── field_res.rb │ ├── generator.rb │ ├── inflector.rb │ ├── inline_ref.rb │ ├── key_value_field_res.rb │ ├── key_value_fields.rb │ ├── object_field_res.rb │ ├── rbi_helpers.rb │ ├── ref.rb │ ├── resource.rb │ ├── resource_meta.rb │ ├── serialize_handler.rb │ ├── string_helpers.rb │ ├── validations.rb │ ├── value_fields.rb │ └── version.rb ├── rbi └── kube-dsl.rbi └── sorbet ├── config ├── rbi ├── gems │ ├── ast@2.4.2.rbi │ ├── byebug@11.1.3.rbi │ ├── coderay@1.1.3.rbi │ ├── commander@4.6.0.rbi │ ├── curdle@1.2.2.rbi │ ├── diff-lcs@1.5.0.rbi │ ├── dry-inflector@0.3.0.rbi │ ├── highline@2.0.3.rbi │ ├── method_source@1.0.0.rbi │ ├── netrc@0.11.0.rbi │ ├── parallel@1.23.0.rbi │ ├── parlour@8.1.0.rbi │ ├── parser@3.2.2.1.rbi │ ├── pry-byebug@3.10.1.rbi │ ├── pry@0.14.2.rbi │ ├── rainbow@3.1.1.rbi │ ├── rake@13.0.6.rbi │ ├── rspec-core@3.12.2.rbi │ ├── rspec-expectations@3.12.3.rbi │ ├── rspec-mocks@3.12.5.rbi │ ├── rspec-support@3.12.0.rbi │ ├── rspec@3.12.0.rbi │ ├── spoom@1.2.1.rbi │ ├── thor@1.2.2.rbi │ ├── unparser@0.6.7.rbi │ ├── yard-sorbet@0.8.1.rbi │ └── yard@0.9.34.rbi ├── kube-dsl │ ├── dsl │ │ ├── admissionregistration │ │ │ └── v1 │ │ │ │ ├── mutating_webhook.rbi │ │ │ │ ├── mutating_webhook_configuration.rbi │ │ │ │ ├── mutating_webhook_configuration_list.rbi │ │ │ │ ├── rule_with_operations.rbi │ │ │ │ ├── service_reference.rbi │ │ │ │ ├── validating_webhook.rbi │ │ │ │ ├── validating_webhook_configuration.rbi │ │ │ │ ├── validating_webhook_configuration_list.rbi │ │ │ │ └── webhook_client_config.rbi │ │ ├── apiextensions │ │ │ └── v1 │ │ │ │ ├── custom_resource_column_definition.rbi │ │ │ │ ├── custom_resource_conversion.rbi │ │ │ │ ├── custom_resource_definition.rbi │ │ │ │ ├── custom_resource_definition_condition.rbi │ │ │ │ ├── custom_resource_definition_list.rbi │ │ │ │ ├── custom_resource_definition_names.rbi │ │ │ │ ├── custom_resource_definition_spec.rbi │ │ │ │ ├── custom_resource_definition_status.rbi │ │ │ │ ├── custom_resource_definition_version.rbi │ │ │ │ ├── custom_resource_subresource_scale.rbi │ │ │ │ ├── custom_resource_subresources.rbi │ │ │ │ ├── custom_resource_validation.rbi │ │ │ │ ├── external_documentation.rbi │ │ │ │ ├── json.rbi │ │ │ │ ├── json_schema_props.rbi │ │ │ │ ├── service_reference.rbi │ │ │ │ ├── validation_rule.rbi │ │ │ │ ├── webhook_client_config.rbi │ │ │ │ └── webhook_conversion.rbi │ │ ├── apiregistration │ │ │ └── v1 │ │ │ │ ├── api_service.rbi │ │ │ │ ├── api_service_condition.rbi │ │ │ │ ├── api_service_list.rbi │ │ │ │ ├── api_service_spec.rbi │ │ │ │ ├── api_service_status.rbi │ │ │ │ └── service_reference.rbi │ │ ├── apiserverinternal │ │ │ └── v1alpha1 │ │ │ │ ├── server_storage_version.rbi │ │ │ │ ├── storage_version.rbi │ │ │ │ ├── storage_version_condition.rbi │ │ │ │ ├── storage_version_list.rbi │ │ │ │ └── storage_version_status.rbi │ │ ├── apps │ │ │ └── v1 │ │ │ │ ├── controller_revision.rbi │ │ │ │ ├── controller_revision_list.rbi │ │ │ │ ├── daemon_set.rbi │ │ │ │ ├── daemon_set_condition.rbi │ │ │ │ ├── daemon_set_list.rbi │ │ │ │ ├── daemon_set_spec.rbi │ │ │ │ ├── daemon_set_status.rbi │ │ │ │ ├── daemon_set_update_strategy.rbi │ │ │ │ ├── deployment.rbi │ │ │ │ ├── deployment_condition.rbi │ │ │ │ ├── deployment_list.rbi │ │ │ │ ├── deployment_spec.rbi │ │ │ │ ├── deployment_status.rbi │ │ │ │ ├── deployment_strategy.rbi │ │ │ │ ├── replica_set.rbi │ │ │ │ ├── replica_set_condition.rbi │ │ │ │ ├── replica_set_list.rbi │ │ │ │ ├── replica_set_spec.rbi │ │ │ │ ├── replica_set_status.rbi │ │ │ │ ├── rolling_update_daemon_set.rbi │ │ │ │ ├── rolling_update_deployment.rbi │ │ │ │ ├── rolling_update_stateful_set_strategy.rbi │ │ │ │ ├── stateful_set.rbi │ │ │ │ ├── stateful_set_condition.rbi │ │ │ │ ├── stateful_set_list.rbi │ │ │ │ ├── stateful_set_persistent_volume_claim_retention_policy.rbi │ │ │ │ ├── stateful_set_spec.rbi │ │ │ │ ├── stateful_set_status.rbi │ │ │ │ └── stateful_set_update_strategy.rbi │ │ ├── authentication │ │ │ └── v1 │ │ │ │ ├── bound_object_reference.rbi │ │ │ │ ├── token_request.rbi │ │ │ │ ├── token_request_spec.rbi │ │ │ │ ├── token_request_status.rbi │ │ │ │ ├── token_review.rbi │ │ │ │ ├── token_review_spec.rbi │ │ │ │ ├── token_review_status.rbi │ │ │ │ └── user_info.rbi │ │ ├── authorization │ │ │ └── v1 │ │ │ │ ├── local_subject_access_review.rbi │ │ │ │ ├── non_resource_attributes.rbi │ │ │ │ ├── non_resource_rule.rbi │ │ │ │ ├── resource_attributes.rbi │ │ │ │ ├── resource_rule.rbi │ │ │ │ ├── self_subject_access_review.rbi │ │ │ │ ├── self_subject_access_review_spec.rbi │ │ │ │ ├── self_subject_rules_review.rbi │ │ │ │ ├── self_subject_rules_review_spec.rbi │ │ │ │ ├── subject_access_review.rbi │ │ │ │ ├── subject_access_review_spec.rbi │ │ │ │ ├── subject_access_review_status.rbi │ │ │ │ └── subject_rules_review_status.rbi │ │ ├── autoscaling │ │ │ ├── v1 │ │ │ │ ├── cross_version_object_reference.rbi │ │ │ │ ├── horizontal_pod_autoscaler.rbi │ │ │ │ ├── horizontal_pod_autoscaler_list.rbi │ │ │ │ ├── horizontal_pod_autoscaler_spec.rbi │ │ │ │ ├── horizontal_pod_autoscaler_status.rbi │ │ │ │ ├── scale.rbi │ │ │ │ ├── scale_spec.rbi │ │ │ │ └── scale_status.rbi │ │ │ ├── v2 │ │ │ │ ├── container_resource_metric_source.rbi │ │ │ │ ├── container_resource_metric_status.rbi │ │ │ │ ├── cross_version_object_reference.rbi │ │ │ │ ├── external_metric_source.rbi │ │ │ │ ├── external_metric_status.rbi │ │ │ │ ├── horizontal_pod_autoscaler.rbi │ │ │ │ ├── horizontal_pod_autoscaler_behavior.rbi │ │ │ │ ├── horizontal_pod_autoscaler_condition.rbi │ │ │ │ ├── horizontal_pod_autoscaler_list.rbi │ │ │ │ ├── horizontal_pod_autoscaler_spec.rbi │ │ │ │ ├── horizontal_pod_autoscaler_status.rbi │ │ │ │ ├── hpa_scaling_policy.rbi │ │ │ │ ├── hpa_scaling_rules.rbi │ │ │ │ ├── metric_identifier.rbi │ │ │ │ ├── metric_spec.rbi │ │ │ │ ├── metric_status.rbi │ │ │ │ ├── metric_target.rbi │ │ │ │ ├── metric_value_status.rbi │ │ │ │ ├── object_metric_source.rbi │ │ │ │ ├── object_metric_status.rbi │ │ │ │ ├── pods_metric_source.rbi │ │ │ │ ├── pods_metric_status.rbi │ │ │ │ ├── resource_metric_source.rbi │ │ │ │ └── resource_metric_status.rbi │ │ │ ├── v2beta1 │ │ │ │ ├── container_resource_metric_source.rbi │ │ │ │ ├── container_resource_metric_status.rbi │ │ │ │ ├── cross_version_object_reference.rbi │ │ │ │ ├── external_metric_source.rbi │ │ │ │ ├── external_metric_status.rbi │ │ │ │ ├── horizontal_pod_autoscaler.rbi │ │ │ │ ├── horizontal_pod_autoscaler_condition.rbi │ │ │ │ ├── horizontal_pod_autoscaler_list.rbi │ │ │ │ ├── horizontal_pod_autoscaler_spec.rbi │ │ │ │ ├── horizontal_pod_autoscaler_status.rbi │ │ │ │ ├── metric_spec.rbi │ │ │ │ ├── metric_status.rbi │ │ │ │ ├── object_metric_source.rbi │ │ │ │ ├── object_metric_status.rbi │ │ │ │ ├── pods_metric_source.rbi │ │ │ │ ├── pods_metric_status.rbi │ │ │ │ ├── resource_metric_source.rbi │ │ │ │ └── resource_metric_status.rbi │ │ │ └── v2beta2 │ │ │ │ ├── container_resource_metric_source.rbi │ │ │ │ ├── container_resource_metric_status.rbi │ │ │ │ ├── cross_version_object_reference.rbi │ │ │ │ ├── external_metric_source.rbi │ │ │ │ ├── external_metric_status.rbi │ │ │ │ ├── horizontal_pod_autoscaler.rbi │ │ │ │ ├── horizontal_pod_autoscaler_behavior.rbi │ │ │ │ ├── horizontal_pod_autoscaler_condition.rbi │ │ │ │ ├── horizontal_pod_autoscaler_list.rbi │ │ │ │ ├── horizontal_pod_autoscaler_spec.rbi │ │ │ │ ├── horizontal_pod_autoscaler_status.rbi │ │ │ │ ├── hpa_scaling_policy.rbi │ │ │ │ ├── hpa_scaling_rules.rbi │ │ │ │ ├── metric_identifier.rbi │ │ │ │ ├── metric_spec.rbi │ │ │ │ ├── metric_status.rbi │ │ │ │ ├── metric_target.rbi │ │ │ │ ├── metric_value_status.rbi │ │ │ │ ├── object_metric_source.rbi │ │ │ │ ├── object_metric_status.rbi │ │ │ │ ├── pods_metric_source.rbi │ │ │ │ ├── pods_metric_status.rbi │ │ │ │ ├── resource_metric_source.rbi │ │ │ │ └── resource_metric_status.rbi │ │ ├── batch │ │ │ ├── v1 │ │ │ │ ├── cron_job.rbi │ │ │ │ ├── cron_job_list.rbi │ │ │ │ ├── cron_job_spec.rbi │ │ │ │ ├── cron_job_status.rbi │ │ │ │ ├── job.rbi │ │ │ │ ├── job_condition.rbi │ │ │ │ ├── job_list.rbi │ │ │ │ ├── job_spec.rbi │ │ │ │ ├── job_status.rbi │ │ │ │ ├── job_template_spec.rbi │ │ │ │ └── uncounted_terminated_pods.rbi │ │ │ └── v1beta1 │ │ │ │ ├── cron_job.rbi │ │ │ │ ├── cron_job_list.rbi │ │ │ │ ├── cron_job_spec.rbi │ │ │ │ ├── cron_job_status.rbi │ │ │ │ └── job_template_spec.rbi │ │ ├── certificates │ │ │ └── v1 │ │ │ │ ├── certificate_signing_request.rbi │ │ │ │ ├── certificate_signing_request_condition.rbi │ │ │ │ ├── certificate_signing_request_list.rbi │ │ │ │ ├── certificate_signing_request_spec.rbi │ │ │ │ └── certificate_signing_request_status.rbi │ │ ├── coordination │ │ │ └── v1 │ │ │ │ ├── lease.rbi │ │ │ │ ├── lease_list.rbi │ │ │ │ └── lease_spec.rbi │ │ ├── discovery │ │ │ ├── v1 │ │ │ │ ├── endpoint.rbi │ │ │ │ ├── endpoint_conditions.rbi │ │ │ │ ├── endpoint_hints.rbi │ │ │ │ ├── endpoint_port.rbi │ │ │ │ ├── endpoint_slice.rbi │ │ │ │ ├── endpoint_slice_list.rbi │ │ │ │ └── for_zone.rbi │ │ │ └── v1beta1 │ │ │ │ ├── endpoint.rbi │ │ │ │ ├── endpoint_conditions.rbi │ │ │ │ ├── endpoint_hints.rbi │ │ │ │ ├── endpoint_port.rbi │ │ │ │ ├── endpoint_slice.rbi │ │ │ │ ├── endpoint_slice_list.rbi │ │ │ │ └── for_zone.rbi │ │ ├── events │ │ │ ├── v1 │ │ │ │ ├── event.rbi │ │ │ │ ├── event_list.rbi │ │ │ │ └── event_series.rbi │ │ │ └── v1beta1 │ │ │ │ ├── event.rbi │ │ │ │ ├── event_list.rbi │ │ │ │ └── event_series.rbi │ │ ├── flowcontrol │ │ │ ├── v1beta1 │ │ │ │ ├── flow_distinguisher_method.rbi │ │ │ │ ├── flow_schema.rbi │ │ │ │ ├── flow_schema_condition.rbi │ │ │ │ ├── flow_schema_list.rbi │ │ │ │ ├── flow_schema_spec.rbi │ │ │ │ ├── flow_schema_status.rbi │ │ │ │ ├── group_subject.rbi │ │ │ │ ├── limit_response.rbi │ │ │ │ ├── limited_priority_level_configuration.rbi │ │ │ │ ├── non_resource_policy_rule.rbi │ │ │ │ ├── policy_rules_with_subjects.rbi │ │ │ │ ├── priority_level_configuration.rbi │ │ │ │ ├── priority_level_configuration_condition.rbi │ │ │ │ ├── priority_level_configuration_list.rbi │ │ │ │ ├── priority_level_configuration_reference.rbi │ │ │ │ ├── priority_level_configuration_spec.rbi │ │ │ │ ├── priority_level_configuration_status.rbi │ │ │ │ ├── queuing_configuration.rbi │ │ │ │ ├── resource_policy_rule.rbi │ │ │ │ ├── service_account_subject.rbi │ │ │ │ ├── subject.rbi │ │ │ │ └── user_subject.rbi │ │ │ └── v1beta2 │ │ │ │ ├── flow_distinguisher_method.rbi │ │ │ │ ├── flow_schema.rbi │ │ │ │ ├── flow_schema_condition.rbi │ │ │ │ ├── flow_schema_list.rbi │ │ │ │ ├── flow_schema_spec.rbi │ │ │ │ ├── flow_schema_status.rbi │ │ │ │ ├── group_subject.rbi │ │ │ │ ├── limit_response.rbi │ │ │ │ ├── limited_priority_level_configuration.rbi │ │ │ │ ├── non_resource_policy_rule.rbi │ │ │ │ ├── policy_rules_with_subjects.rbi │ │ │ │ ├── priority_level_configuration.rbi │ │ │ │ ├── priority_level_configuration_condition.rbi │ │ │ │ ├── priority_level_configuration_list.rbi │ │ │ │ ├── priority_level_configuration_reference.rbi │ │ │ │ ├── priority_level_configuration_spec.rbi │ │ │ │ ├── priority_level_configuration_status.rbi │ │ │ │ ├── queuing_configuration.rbi │ │ │ │ ├── resource_policy_rule.rbi │ │ │ │ ├── service_account_subject.rbi │ │ │ │ ├── subject.rbi │ │ │ │ └── user_subject.rbi │ │ ├── meta │ │ │ └── v1 │ │ │ │ ├── api_group.rbi │ │ │ │ ├── api_group_list.rbi │ │ │ │ ├── api_resource.rbi │ │ │ │ ├── api_resource_list.rbi │ │ │ │ ├── api_versions.rbi │ │ │ │ ├── condition.rbi │ │ │ │ ├── delete_options.rbi │ │ │ │ ├── group_version_for_discovery.rbi │ │ │ │ ├── label_selector.rbi │ │ │ │ ├── label_selector_requirement.rbi │ │ │ │ ├── list_meta.rbi │ │ │ │ ├── managed_fields_entry.rbi │ │ │ │ ├── object_meta.rbi │ │ │ │ ├── owner_reference.rbi │ │ │ │ ├── preconditions.rbi │ │ │ │ ├── server_address_by_client_cidr.rbi │ │ │ │ ├── status.rbi │ │ │ │ ├── status_cause.rbi │ │ │ │ ├── status_details.rbi │ │ │ │ └── watch_event.rbi │ │ ├── networking │ │ │ └── v1 │ │ │ │ ├── http_ingress_path.rbi │ │ │ │ ├── http_ingress_rule_value.rbi │ │ │ │ ├── ingress.rbi │ │ │ │ ├── ingress_backend.rbi │ │ │ │ ├── ingress_class.rbi │ │ │ │ ├── ingress_class_list.rbi │ │ │ │ ├── ingress_class_parameters_reference.rbi │ │ │ │ ├── ingress_class_spec.rbi │ │ │ │ ├── ingress_list.rbi │ │ │ │ ├── ingress_rule.rbi │ │ │ │ ├── ingress_service_backend.rbi │ │ │ │ ├── ingress_spec.rbi │ │ │ │ ├── ingress_status.rbi │ │ │ │ ├── ingress_tls.rbi │ │ │ │ ├── ip_block.rbi │ │ │ │ ├── network_policy.rbi │ │ │ │ ├── network_policy_egress_rule.rbi │ │ │ │ ├── network_policy_ingress_rule.rbi │ │ │ │ ├── network_policy_list.rbi │ │ │ │ ├── network_policy_peer.rbi │ │ │ │ ├── network_policy_port.rbi │ │ │ │ ├── network_policy_spec.rbi │ │ │ │ └── service_backend_port.rbi │ │ ├── node │ │ │ ├── v1 │ │ │ │ ├── overhead.rbi │ │ │ │ ├── runtime_class.rbi │ │ │ │ ├── runtime_class_list.rbi │ │ │ │ └── scheduling.rbi │ │ │ ├── v1alpha1 │ │ │ │ ├── overhead.rbi │ │ │ │ ├── runtime_class.rbi │ │ │ │ ├── runtime_class_list.rbi │ │ │ │ ├── runtime_class_spec.rbi │ │ │ │ └── scheduling.rbi │ │ │ └── v1beta1 │ │ │ │ ├── overhead.rbi │ │ │ │ ├── runtime_class.rbi │ │ │ │ ├── runtime_class_list.rbi │ │ │ │ └── scheduling.rbi │ │ ├── policy │ │ │ ├── v1 │ │ │ │ ├── eviction.rbi │ │ │ │ ├── pod_disruption_budget.rbi │ │ │ │ ├── pod_disruption_budget_list.rbi │ │ │ │ ├── pod_disruption_budget_spec.rbi │ │ │ │ └── pod_disruption_budget_status.rbi │ │ │ └── v1beta1 │ │ │ │ ├── allowed_csi_driver.rbi │ │ │ │ ├── allowed_flex_volume.rbi │ │ │ │ ├── allowed_host_path.rbi │ │ │ │ ├── fs_group_strategy_options.rbi │ │ │ │ ├── host_port_range.rbi │ │ │ │ ├── id_range.rbi │ │ │ │ ├── pod_disruption_budget.rbi │ │ │ │ ├── pod_disruption_budget_list.rbi │ │ │ │ ├── pod_disruption_budget_spec.rbi │ │ │ │ ├── pod_disruption_budget_status.rbi │ │ │ │ ├── pod_security_policy.rbi │ │ │ │ ├── pod_security_policy_list.rbi │ │ │ │ ├── pod_security_policy_spec.rbi │ │ │ │ ├── run_as_group_strategy_options.rbi │ │ │ │ ├── run_as_user_strategy_options.rbi │ │ │ │ ├── runtime_class_strategy_options.rbi │ │ │ │ ├── se_linux_strategy_options.rbi │ │ │ │ └── supplemental_groups_strategy_options.rbi │ │ ├── rbac │ │ │ └── v1 │ │ │ │ ├── aggregation_rule.rbi │ │ │ │ ├── cluster_role.rbi │ │ │ │ ├── cluster_role_binding.rbi │ │ │ │ ├── cluster_role_binding_list.rbi │ │ │ │ ├── cluster_role_list.rbi │ │ │ │ ├── policy_rule.rbi │ │ │ │ ├── role.rbi │ │ │ │ ├── role_binding.rbi │ │ │ │ ├── role_binding_list.rbi │ │ │ │ ├── role_list.rbi │ │ │ │ ├── role_ref.rbi │ │ │ │ └── subject.rbi │ │ ├── scheduling │ │ │ └── v1 │ │ │ │ ├── priority_class.rbi │ │ │ │ └── priority_class_list.rbi │ │ ├── storage │ │ │ ├── v1 │ │ │ │ ├── csi_driver.rbi │ │ │ │ ├── csi_driver_list.rbi │ │ │ │ ├── csi_driver_spec.rbi │ │ │ │ ├── csi_node.rbi │ │ │ │ ├── csi_node_driver.rbi │ │ │ │ ├── csi_node_list.rbi │ │ │ │ ├── csi_node_spec.rbi │ │ │ │ ├── storage_class.rbi │ │ │ │ ├── storage_class_list.rbi │ │ │ │ ├── token_request.rbi │ │ │ │ ├── volume_attachment.rbi │ │ │ │ ├── volume_attachment_list.rbi │ │ │ │ ├── volume_attachment_source.rbi │ │ │ │ ├── volume_attachment_spec.rbi │ │ │ │ ├── volume_attachment_status.rbi │ │ │ │ ├── volume_error.rbi │ │ │ │ └── volume_node_resources.rbi │ │ │ ├── v1alpha1 │ │ │ │ ├── csi_storage_capacity.rbi │ │ │ │ └── csi_storage_capacity_list.rbi │ │ │ └── v1beta1 │ │ │ │ ├── csi_storage_capacity.rbi │ │ │ │ └── csi_storage_capacity_list.rbi │ │ └── v1 │ │ │ ├── affinity.rbi │ │ │ ├── attached_volume.rbi │ │ │ ├── aws_elastic_block_store_volume_source.rbi │ │ │ ├── azure_disk_volume_source.rbi │ │ │ ├── azure_file_persistent_volume_source.rbi │ │ │ ├── azure_file_volume_source.rbi │ │ │ ├── binding.rbi │ │ │ ├── capabilities.rbi │ │ │ ├── ceph_fs_persistent_volume_source.rbi │ │ │ ├── ceph_fs_volume_source.rbi │ │ │ ├── cinder_persistent_volume_source.rbi │ │ │ ├── cinder_volume_source.rbi │ │ │ ├── client_ip_config.rbi │ │ │ ├── component_condition.rbi │ │ │ ├── component_status.rbi │ │ │ ├── component_status_list.rbi │ │ │ ├── config_map.rbi │ │ │ ├── config_map_env_source.rbi │ │ │ ├── config_map_key_selector.rbi │ │ │ ├── config_map_list.rbi │ │ │ ├── config_map_node_config_source.rbi │ │ │ ├── config_map_projection.rbi │ │ │ ├── config_map_volume_source.rbi │ │ │ ├── container.rbi │ │ │ ├── container_image.rbi │ │ │ ├── container_port.rbi │ │ │ ├── container_state.rbi │ │ │ ├── container_state_running.rbi │ │ │ ├── container_state_terminated.rbi │ │ │ ├── container_state_waiting.rbi │ │ │ ├── container_status.rbi │ │ │ ├── csi_persistent_volume_source.rbi │ │ │ ├── csi_volume_source.rbi │ │ │ ├── daemon_endpoint.rbi │ │ │ ├── downward_api_projection.rbi │ │ │ ├── downward_api_volume_file.rbi │ │ │ ├── downward_api_volume_source.rbi │ │ │ ├── empty_dir_volume_source.rbi │ │ │ ├── endpoint_address.rbi │ │ │ ├── endpoint_port.rbi │ │ │ ├── endpoint_subset.rbi │ │ │ ├── endpoints.rbi │ │ │ ├── endpoints_list.rbi │ │ │ ├── env_from_source.rbi │ │ │ ├── env_var.rbi │ │ │ ├── env_var_source.rbi │ │ │ ├── ephemeral_container.rbi │ │ │ ├── ephemeral_volume_source.rbi │ │ │ ├── event.rbi │ │ │ ├── event_list.rbi │ │ │ ├── event_series.rbi │ │ │ ├── event_source.rbi │ │ │ ├── exec_action.rbi │ │ │ ├── fc_volume_source.rbi │ │ │ ├── flex_persistent_volume_source.rbi │ │ │ ├── flex_volume_source.rbi │ │ │ ├── flocker_volume_source.rbi │ │ │ ├── gce_persistent_disk_volume_source.rbi │ │ │ ├── git_repo_volume_source.rbi │ │ │ ├── glusterfs_persistent_volume_source.rbi │ │ │ ├── glusterfs_volume_source.rbi │ │ │ ├── grpc_action.rbi │ │ │ ├── host_alias.rbi │ │ │ ├── host_path_volume_source.rbi │ │ │ ├── http_get_action.rbi │ │ │ ├── http_header.rbi │ │ │ ├── iscsi_persistent_volume_source.rbi │ │ │ ├── iscsi_volume_source.rbi │ │ │ ├── key_to_path.rbi │ │ │ ├── lifecycle.rbi │ │ │ ├── lifecycle_handler.rbi │ │ │ ├── limit_range.rbi │ │ │ ├── limit_range_item.rbi │ │ │ ├── limit_range_list.rbi │ │ │ ├── limit_range_spec.rbi │ │ │ ├── load_balancer_ingress.rbi │ │ │ ├── load_balancer_status.rbi │ │ │ ├── local_object_reference.rbi │ │ │ ├── local_volume_source.rbi │ │ │ ├── namespace.rbi │ │ │ ├── namespace_condition.rbi │ │ │ ├── namespace_list.rbi │ │ │ ├── namespace_spec.rbi │ │ │ ├── namespace_status.rbi │ │ │ ├── nfs_volume_source.rbi │ │ │ ├── node.rbi │ │ │ ├── node_address.rbi │ │ │ ├── node_affinity.rbi │ │ │ ├── node_condition.rbi │ │ │ ├── node_config_source.rbi │ │ │ ├── node_config_status.rbi │ │ │ ├── node_daemon_endpoints.rbi │ │ │ ├── node_list.rbi │ │ │ ├── node_selector.rbi │ │ │ ├── node_selector_requirement.rbi │ │ │ ├── node_selector_term.rbi │ │ │ ├── node_spec.rbi │ │ │ ├── node_status.rbi │ │ │ ├── node_system_info.rbi │ │ │ ├── object_field_selector.rbi │ │ │ ├── object_reference.rbi │ │ │ ├── persistent_volume.rbi │ │ │ ├── persistent_volume_claim.rbi │ │ │ ├── persistent_volume_claim_condition.rbi │ │ │ ├── persistent_volume_claim_list.rbi │ │ │ ├── persistent_volume_claim_spec.rbi │ │ │ ├── persistent_volume_claim_status.rbi │ │ │ ├── persistent_volume_claim_template.rbi │ │ │ ├── persistent_volume_claim_volume_source.rbi │ │ │ ├── persistent_volume_list.rbi │ │ │ ├── persistent_volume_spec.rbi │ │ │ ├── persistent_volume_status.rbi │ │ │ ├── photon_persistent_disk_volume_source.rbi │ │ │ ├── pod.rbi │ │ │ ├── pod_affinity.rbi │ │ │ ├── pod_affinity_term.rbi │ │ │ ├── pod_anti_affinity.rbi │ │ │ ├── pod_condition.rbi │ │ │ ├── pod_dns_config.rbi │ │ │ ├── pod_dns_config_option.rbi │ │ │ ├── pod_ip.rbi │ │ │ ├── pod_list.rbi │ │ │ ├── pod_os.rbi │ │ │ ├── pod_readiness_gate.rbi │ │ │ ├── pod_security_context.rbi │ │ │ ├── pod_spec.rbi │ │ │ ├── pod_status.rbi │ │ │ ├── pod_template.rbi │ │ │ ├── pod_template_list.rbi │ │ │ ├── pod_template_spec.rbi │ │ │ ├── port_status.rbi │ │ │ ├── portworx_volume_source.rbi │ │ │ ├── preferred_scheduling_term.rbi │ │ │ ├── probe.rbi │ │ │ ├── projected_volume_source.rbi │ │ │ ├── quobyte_volume_source.rbi │ │ │ ├── rbd_persistent_volume_source.rbi │ │ │ ├── rbd_volume_source.rbi │ │ │ ├── replication_controller.rbi │ │ │ ├── replication_controller_condition.rbi │ │ │ ├── replication_controller_list.rbi │ │ │ ├── replication_controller_spec.rbi │ │ │ ├── replication_controller_status.rbi │ │ │ ├── resource_field_selector.rbi │ │ │ ├── resource_quota.rbi │ │ │ ├── resource_quota_list.rbi │ │ │ ├── resource_quota_spec.rbi │ │ │ ├── resource_quota_status.rbi │ │ │ ├── resource_requirements.rbi │ │ │ ├── scale_io_persistent_volume_source.rbi │ │ │ ├── scale_io_volume_source.rbi │ │ │ ├── scope_selector.rbi │ │ │ ├── scoped_resource_selector_requirement.rbi │ │ │ ├── se_linux_options.rbi │ │ │ ├── seccomp_profile.rbi │ │ │ ├── secret.rbi │ │ │ ├── secret_env_source.rbi │ │ │ ├── secret_key_selector.rbi │ │ │ ├── secret_list.rbi │ │ │ ├── secret_projection.rbi │ │ │ ├── secret_reference.rbi │ │ │ ├── secret_volume_source.rbi │ │ │ ├── security_context.rbi │ │ │ ├── service.rbi │ │ │ ├── service_account.rbi │ │ │ ├── service_account_list.rbi │ │ │ ├── service_account_token_projection.rbi │ │ │ ├── service_list.rbi │ │ │ ├── service_port.rbi │ │ │ ├── service_spec.rbi │ │ │ ├── service_status.rbi │ │ │ ├── session_affinity_config.rbi │ │ │ ├── storage_os_persistent_volume_source.rbi │ │ │ ├── storage_os_volume_source.rbi │ │ │ ├── sysctl.rbi │ │ │ ├── taint.rbi │ │ │ ├── tcp_socket_action.rbi │ │ │ ├── toleration.rbi │ │ │ ├── topology_selector_label_requirement.rbi │ │ │ ├── topology_selector_term.rbi │ │ │ ├── topology_spread_constraint.rbi │ │ │ ├── typed_local_object_reference.rbi │ │ │ ├── volume.rbi │ │ │ ├── volume_device.rbi │ │ │ ├── volume_mount.rbi │ │ │ ├── volume_node_affinity.rbi │ │ │ ├── volume_projection.rbi │ │ │ ├── vsphere_virtual_disk_volume_source.rbi │ │ │ ├── weighted_pod_affinity_term.rbi │ │ │ └── windows_security_context_options.rbi │ └── entrypoint.rbi ├── validations.rbi └── value_fields.rbi └── tapioca ├── config.yml └── require.rb /.gitignore: -------------------------------------------------------------------------------- 1 | pkg/ 2 | vendor/ 3 | -------------------------------------------------------------------------------- /.parlour: -------------------------------------------------------------------------------- 1 | parser: 2 | # Don't exclude the `sorbet` directory, overriding the default 3 | excluded_paths: [] 4 | 5 | # Look only in the kube-dsl types directory 6 | included_paths: 7 | - ./sorbet/rbi/kube-dsl 8 | - ./lib/kube-dsl/dsl_object.rb 9 | - ./lib/kube-dsl/resource.rb 10 | - ./lib/kube-dsl/value_fields.rb 11 | - ./lib/kube-dsl/validations.rb 12 | - ./lib/kube-dsl/key_value_fields.rb 13 | -------------------------------------------------------------------------------- /.ruby-version: -------------------------------------------------------------------------------- 1 | 3.3.5 2 | -------------------------------------------------------------------------------- /.tool-versions: -------------------------------------------------------------------------------- 1 | ruby 3.3.5 2 | -------------------------------------------------------------------------------- /Gemfile: -------------------------------------------------------------------------------- 1 | source 'https://rubygems.org' 2 | 3 | gemspec 4 | 5 | group :development, :test do 6 | gem 'pry-byebug' 7 | gem 'rake' 8 | end 9 | 10 | group :development do 11 | # lock to a specific version to prevent breaking CI when new versions come out 12 | gem 'sorbet', '= 0.5.11865' 13 | gem 'tapioca', '~> 0.16' 14 | gem 'parlour', '~> 8.0' 15 | gem 'curdle', '~> 1.2' 16 | end 17 | 18 | group :test do 19 | gem 'rspec', '~> 3.0' 20 | end 21 | -------------------------------------------------------------------------------- /bin/tapioca: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env ruby 2 | # frozen_string_literal: true 3 | 4 | # 5 | # This file was generated by Bundler. 6 | # 7 | # The application 'tapioca' is installed as part of a gem, and 8 | # this file is here to facilitate running it. 9 | # 10 | 11 | require "pathname" 12 | ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile", 13 | Pathname.new(__FILE__).realpath) 14 | 15 | bundle_binstub = File.expand_path("../bundle", __FILE__) 16 | 17 | if File.file?(bundle_binstub) 18 | if File.read(bundle_binstub, 300) =~ /This file was generated by Bundler/ 19 | load(bundle_binstub) 20 | else 21 | abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run. 22 | Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.") 23 | end 24 | end 25 | 26 | require "rubygems" 27 | require "bundler/setup" 28 | 29 | load Gem.bin_path("tapioca", "tapioca") 30 | -------------------------------------------------------------------------------- /kube-dsl.gemspec: -------------------------------------------------------------------------------- 1 | $:.unshift File.join(File.dirname(__FILE__), 'lib') 2 | require 'kube-dsl/version' 3 | 4 | Gem::Specification.new do |s| 5 | s.name = 'kube-dsl' 6 | s.version = ::KubeDSL::VERSION 7 | s.authors = ['Cameron Dutro'] 8 | s.email = ['camertron@gmail.com'] 9 | s.homepage = 'http://github.com/getkuby/kube-dsl' 10 | 11 | s.description = s.summary = 'A Ruby DSL for defining Kubernetes resources.' 12 | 13 | s.add_dependency 'dry-inflector', '>= 0.2.1', '< 2' 14 | 15 | s.require_path = 'lib' 16 | s.files = Dir['{lib,spec,rbi}/**/*', 'Gemfile', 'LICENSE', 'CHANGELOG.md', 'README.md', 'Rakefile', 'kube-dsl.gemspec'] 17 | end 18 | -------------------------------------------------------------------------------- /lib/kube-dsl/allow_blank.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | module KubeDSL 3 | class AllowBlank 4 | attr_reader :value 5 | 6 | def initialize(value) 7 | @value = value 8 | end 9 | end 10 | end -------------------------------------------------------------------------------- /lib/kube-dsl/default_field_res.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | require 'json' 3 | 4 | module KubeDSL 5 | class DefaultFieldRes 6 | include StringHelpers 7 | 8 | attr_reader :name, :res, :allowed_values 9 | 10 | def initialize(name, res, allowed_values) 11 | @name = name 12 | @res = res 13 | @allowed_values = allowed_values 14 | end 15 | 16 | def fields_to_ruby(_inflector) 17 | [] 18 | end 19 | 20 | def fields_to_rbi(_inflector) 21 | [] 22 | end 23 | 24 | def validations(_inflector) 25 | [] 26 | end 27 | 28 | def serialize_call(_inflector) 29 | # use JSON.generate to add quotes around strings, etc 30 | JSON.generate(allowed_values.first) 31 | end 32 | end 33 | end 34 | -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/admissionregistration.rb: -------------------------------------------------------------------------------- 1 | module KubeDSL::DSL::Admissionregistration 2 | autoload :V1, 'kube-dsl/dsl/admissionregistration/v1' 3 | end 4 | -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/apiextensions.rb: -------------------------------------------------------------------------------- 1 | module KubeDSL::DSL::Apiextensions 2 | autoload :V1, 'kube-dsl/dsl/apiextensions/v1' 3 | end 4 | -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/apiextensions/v1/custom_resource_conversion.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Apiextensions 6 | module V1 7 | class CustomResourceConversion < ::KubeDSL::DSLObject 8 | value_field :strategy 9 | object_field(:webhook) { KubeDSL::DSL::Apiextensions::V1::WebhookConversion.new } 10 | 11 | validates :strategy, field: { format: :string }, presence: false 12 | validates :webhook, object: { kind_of: KubeDSL::DSL::Apiextensions::V1::WebhookConversion } 13 | 14 | def serialize 15 | {}.tap do |result| 16 | result[:strategy] = strategy 17 | result[:webhook] = webhook.serialize 18 | end 19 | end 20 | 21 | def kind_sym 22 | :custom_resource_conversion 23 | end 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/apiextensions/v1/custom_resource_subresources.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Apiextensions 6 | module V1 7 | class CustomResourceSubresources < ::KubeDSL::DSLObject 8 | object_field(:scale) { KubeDSL::DSL::Apiextensions::V1::CustomResourceSubresourceScale.new } 9 | value_field :status 10 | 11 | validates :scale, object: { kind_of: KubeDSL::DSL::Apiextensions::V1::CustomResourceSubresourceScale } 12 | validates :status, field: { format: :string }, presence: false 13 | 14 | def serialize 15 | {}.tap do |result| 16 | result[:scale] = scale.serialize 17 | result[:status] = status 18 | end 19 | end 20 | 21 | def kind_sym 22 | :custom_resource_subresources 23 | end 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/apiextensions/v1/custom_resource_validation.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Apiextensions 6 | module V1 7 | class CustomResourceValidation < ::KubeDSL::DSLObject 8 | object_field(:open_apiv3_schema) { KubeDSL::DSL::Apiextensions::V1::JSONSchemaProps.new } 9 | 10 | validates :open_apiv3_schema, object: { kind_of: KubeDSL::DSL::Apiextensions::V1::JSONSchemaProps } 11 | 12 | def serialize 13 | {}.tap do |result| 14 | result[:openAPIV3Schema] = open_apiv3_schema.serialize 15 | end 16 | end 17 | 18 | def kind_sym 19 | :custom_resource_validation 20 | end 21 | end 22 | end 23 | end 24 | end 25 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/apiextensions/v1/external_documentation.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Apiextensions 6 | module V1 7 | class ExternalDocumentation < ::KubeDSL::DSLObject 8 | value_field :description 9 | value_field :url 10 | 11 | validates :description, field: { format: :string }, presence: false 12 | validates :url, field: { format: :string }, presence: false 13 | 14 | def serialize 15 | {}.tap do |result| 16 | result[:description] = description 17 | result[:url] = url 18 | end 19 | end 20 | 21 | def kind_sym 22 | :external_documentation 23 | end 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/apiextensions/v1/json.rb: -------------------------------------------------------------------------------- 1 | # typed: strict 2 | 3 | module KubeDSL::DSL::Apiextensions::V1 4 | class JSON < ::KubeDSL::DSLObject 5 | def serialize 6 | @value 7 | end 8 | 9 | def value(val = nil) 10 | if val 11 | @value = val 12 | end 13 | 14 | @value 15 | end 16 | 17 | def kind_sym 18 | :JSON 19 | end 20 | end 21 | end 22 | -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/apiextensions/v1/validation_rule.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Apiextensions 6 | module V1 7 | class ValidationRule < ::KubeDSL::DSLObject 8 | value_field :message 9 | value_field :rule 10 | 11 | validates :message, field: { format: :string }, presence: false 12 | validates :rule, field: { format: :string }, presence: false 13 | 14 | def serialize 15 | {}.tap do |result| 16 | result[:message] = message 17 | result[:rule] = rule 18 | end 19 | end 20 | 21 | def kind_sym 22 | :validation_rule 23 | end 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/apiregistration.rb: -------------------------------------------------------------------------------- 1 | module KubeDSL::DSL::Apiregistration 2 | autoload :V1, 'kube-dsl/dsl/apiregistration/v1' 3 | end 4 | -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/apiregistration/v1.rb: -------------------------------------------------------------------------------- 1 | module KubeDSL::DSL::Apiregistration::V1 2 | autoload :APIService, 'kube-dsl/dsl/apiregistration/v1/api_service' 3 | autoload :APIServiceCondition, 'kube-dsl/dsl/apiregistration/v1/api_service_condition' 4 | autoload :APIServiceList, 'kube-dsl/dsl/apiregistration/v1/api_service_list' 5 | autoload :APIServiceSpec, 'kube-dsl/dsl/apiregistration/v1/api_service_spec' 6 | autoload :APIServiceStatus, 'kube-dsl/dsl/apiregistration/v1/api_service_status' 7 | autoload :ServiceReference, 'kube-dsl/dsl/apiregistration/v1/service_reference' 8 | end 9 | -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/apiregistration/v1/api_service_status.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Apiregistration 6 | module V1 7 | class APIServiceStatus < ::KubeDSL::DSLObject 8 | array_field(:condition) { KubeDSL::DSL::Apiregistration::V1::APIServiceCondition.new } 9 | 10 | validates :conditions, array: { kind_of: KubeDSL::DSL::Apiregistration::V1::APIServiceCondition }, presence: false 11 | 12 | def serialize 13 | {}.tap do |result| 14 | result[:conditions] = conditions.map(&:serialize) 15 | end 16 | end 17 | 18 | def kind_sym 19 | :api_service_status 20 | end 21 | end 22 | end 23 | end 24 | end 25 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/apiregistration/v1/service_reference.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Apiregistration 6 | module V1 7 | class ServiceReference < ::KubeDSL::DSLObject 8 | value_field :name 9 | value_field :namespace 10 | value_field :port 11 | 12 | validates :name, field: { format: :string }, presence: false 13 | validates :namespace, field: { format: :string }, presence: false 14 | validates :port, field: { format: :integer }, presence: false 15 | 16 | def serialize 17 | {}.tap do |result| 18 | result[:name] = name 19 | result[:namespace] = namespace 20 | result[:port] = port 21 | end 22 | end 23 | 24 | def kind_sym 25 | :service_reference 26 | end 27 | end 28 | end 29 | end 30 | end 31 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/apiserverinternal.rb: -------------------------------------------------------------------------------- 1 | module KubeDSL::DSL::Apiserverinternal 2 | autoload :V1alpha1, 'kube-dsl/dsl/apiserverinternal/v1alpha1' 3 | end 4 | -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/apiserverinternal/v1alpha1.rb: -------------------------------------------------------------------------------- 1 | module KubeDSL::DSL::Apiserverinternal::V1alpha1 2 | autoload :ServerStorageVersion, 'kube-dsl/dsl/apiserverinternal/v1alpha1/server_storage_version' 3 | autoload :StorageVersion, 'kube-dsl/dsl/apiserverinternal/v1alpha1/storage_version' 4 | autoload :StorageVersionCondition, 'kube-dsl/dsl/apiserverinternal/v1alpha1/storage_version_condition' 5 | autoload :StorageVersionList, 'kube-dsl/dsl/apiserverinternal/v1alpha1/storage_version_list' 6 | autoload :StorageVersionStatus, 'kube-dsl/dsl/apiserverinternal/v1alpha1/storage_version_status' 7 | end 8 | -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/apps.rb: -------------------------------------------------------------------------------- 1 | module KubeDSL::DSL::Apps 2 | autoload :V1, 'kube-dsl/dsl/apps/v1' 3 | end 4 | -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/apps/v1/daemon_set_update_strategy.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Apps 6 | module V1 7 | class DaemonSetUpdateStrategy < ::KubeDSL::DSLObject 8 | object_field(:rolling_update) { KubeDSL::DSL::Apps::V1::RollingUpdateDaemonSet.new } 9 | value_field :type 10 | 11 | validates :rolling_update, object: { kind_of: KubeDSL::DSL::Apps::V1::RollingUpdateDaemonSet } 12 | validates :type, field: { format: :string }, presence: false 13 | 14 | def serialize 15 | {}.tap do |result| 16 | result[:rollingUpdate] = rolling_update.serialize 17 | result[:type] = type 18 | end 19 | end 20 | 21 | def kind_sym 22 | :daemon_set_update_strategy 23 | end 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/apps/v1/deployment_strategy.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Apps 6 | module V1 7 | class DeploymentStrategy < ::KubeDSL::DSLObject 8 | object_field(:rolling_update) { KubeDSL::DSL::Apps::V1::RollingUpdateDeployment.new } 9 | value_field :type 10 | 11 | validates :rolling_update, object: { kind_of: KubeDSL::DSL::Apps::V1::RollingUpdateDeployment } 12 | validates :type, field: { format: :string }, presence: false 13 | 14 | def serialize 15 | {}.tap do |result| 16 | result[:rollingUpdate] = rolling_update.serialize 17 | result[:type] = type 18 | end 19 | end 20 | 21 | def kind_sym 22 | :deployment_strategy 23 | end 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/apps/v1/rolling_update_daemon_set.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Apps 6 | module V1 7 | class RollingUpdateDaemonSet < ::KubeDSL::DSLObject 8 | value_field :max_surge 9 | value_field :max_unavailable 10 | 11 | validates :max_surge, field: { format: :string }, presence: false 12 | validates :max_unavailable, field: { format: :string }, presence: false 13 | 14 | def serialize 15 | {}.tap do |result| 16 | result[:maxSurge] = max_surge 17 | result[:maxUnavailable] = max_unavailable 18 | end 19 | end 20 | 21 | def kind_sym 22 | :rolling_update_daemon_set 23 | end 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/apps/v1/rolling_update_deployment.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Apps 6 | module V1 7 | class RollingUpdateDeployment < ::KubeDSL::DSLObject 8 | value_field :max_surge 9 | value_field :max_unavailable 10 | 11 | validates :max_surge, field: { format: :string }, presence: false 12 | validates :max_unavailable, field: { format: :string }, presence: false 13 | 14 | def serialize 15 | {}.tap do |result| 16 | result[:maxSurge] = max_surge 17 | result[:maxUnavailable] = max_unavailable 18 | end 19 | end 20 | 21 | def kind_sym 22 | :rolling_update_deployment 23 | end 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/apps/v1/rolling_update_stateful_set_strategy.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Apps 6 | module V1 7 | class RollingUpdateStatefulSetStrategy < ::KubeDSL::DSLObject 8 | value_field :partition 9 | 10 | validates :partition, field: { format: :integer }, presence: false 11 | 12 | def serialize 13 | {}.tap do |result| 14 | result[:partition] = partition 15 | end 16 | end 17 | 18 | def kind_sym 19 | :rolling_update_stateful_set_strategy 20 | end 21 | end 22 | end 23 | end 24 | end 25 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/apps/v1/stateful_set_persistent_volume_claim_retention_policy.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Apps 6 | module V1 7 | class StatefulSetPersistentVolumeClaimRetentionPolicy < ::KubeDSL::DSLObject 8 | value_field :when_deleted 9 | value_field :when_scaled 10 | 11 | validates :when_deleted, field: { format: :string }, presence: false 12 | validates :when_scaled, field: { format: :string }, presence: false 13 | 14 | def serialize 15 | {}.tap do |result| 16 | result[:whenDeleted] = when_deleted 17 | result[:whenScaled] = when_scaled 18 | end 19 | end 20 | 21 | def kind_sym 22 | :stateful_set_persistent_volume_claim_retention_policy 23 | end 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/apps/v1/stateful_set_update_strategy.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Apps 6 | module V1 7 | class StatefulSetUpdateStrategy < ::KubeDSL::DSLObject 8 | object_field(:rolling_update) { KubeDSL::DSL::Apps::V1::RollingUpdateStatefulSetStrategy.new } 9 | value_field :type 10 | 11 | validates :rolling_update, object: { kind_of: KubeDSL::DSL::Apps::V1::RollingUpdateStatefulSetStrategy } 12 | validates :type, field: { format: :string }, presence: false 13 | 14 | def serialize 15 | {}.tap do |result| 16 | result[:rollingUpdate] = rolling_update.serialize 17 | result[:type] = type 18 | end 19 | end 20 | 21 | def kind_sym 22 | :stateful_set_update_strategy 23 | end 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/authentication.rb: -------------------------------------------------------------------------------- 1 | module KubeDSL::DSL::Authentication 2 | autoload :V1, 'kube-dsl/dsl/authentication/v1' 3 | end 4 | -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/authentication/v1.rb: -------------------------------------------------------------------------------- 1 | module KubeDSL::DSL::Authentication::V1 2 | autoload :BoundObjectReference, 'kube-dsl/dsl/authentication/v1/bound_object_reference' 3 | autoload :TokenRequest, 'kube-dsl/dsl/authentication/v1/token_request' 4 | autoload :TokenRequestSpec, 'kube-dsl/dsl/authentication/v1/token_request_spec' 5 | autoload :TokenRequestStatus, 'kube-dsl/dsl/authentication/v1/token_request_status' 6 | autoload :TokenReview, 'kube-dsl/dsl/authentication/v1/token_review' 7 | autoload :TokenReviewSpec, 'kube-dsl/dsl/authentication/v1/token_review_spec' 8 | autoload :TokenReviewStatus, 'kube-dsl/dsl/authentication/v1/token_review_status' 9 | autoload :UserInfo, 'kube-dsl/dsl/authentication/v1/user_info' 10 | end 11 | -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/authentication/v1/token_request_status.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Authentication 6 | module V1 7 | class TokenRequestStatus < ::KubeDSL::DSLObject 8 | value_field :expiration_timestamp 9 | value_field :token 10 | 11 | validates :expiration_timestamp, field: { format: :string }, presence: false 12 | validates :token, field: { format: :string }, presence: false 13 | 14 | def serialize 15 | {}.tap do |result| 16 | result[:expirationTimestamp] = expiration_timestamp 17 | result[:token] = token 18 | end 19 | end 20 | 21 | def kind_sym 22 | :token_request_status 23 | end 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/authentication/v1/token_review_spec.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Authentication 6 | module V1 7 | class TokenReviewSpec < ::KubeDSL::DSLObject 8 | value_field :audiences 9 | value_field :token 10 | 11 | validates :audiences, field: { format: :string }, presence: false 12 | validates :token, field: { format: :string }, presence: false 13 | 14 | def serialize 15 | {}.tap do |result| 16 | result[:audiences] = audiences 17 | result[:token] = token 18 | end 19 | end 20 | 21 | def kind_sym 22 | :token_review_spec 23 | end 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/authorization.rb: -------------------------------------------------------------------------------- 1 | module KubeDSL::DSL::Authorization 2 | autoload :V1, 'kube-dsl/dsl/authorization/v1' 3 | end 4 | -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/authorization/v1/non_resource_attributes.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Authorization 6 | module V1 7 | class NonResourceAttributes < ::KubeDSL::DSLObject 8 | value_field :path 9 | value_field :verb 10 | 11 | validates :path, field: { format: :string }, presence: false 12 | validates :verb, field: { format: :string }, presence: false 13 | 14 | def serialize 15 | {}.tap do |result| 16 | result[:path] = path 17 | result[:verb] = verb 18 | end 19 | end 20 | 21 | def kind_sym 22 | :non_resource_attributes 23 | end 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/authorization/v1/non_resource_rule.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Authorization 6 | module V1 7 | class NonResourceRule < ::KubeDSL::DSLObject 8 | value_field :non_resource_ur_ls 9 | value_field :verbs 10 | 11 | validates :non_resource_ur_ls, field: { format: :string }, presence: false 12 | validates :verbs, field: { format: :string }, presence: false 13 | 14 | def serialize 15 | {}.tap do |result| 16 | result[:nonResourceURLs] = non_resource_ur_ls 17 | result[:verbs] = verbs 18 | end 19 | end 20 | 21 | def kind_sym 22 | :non_resource_rule 23 | end 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/authorization/v1/self_subject_rules_review_spec.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Authorization 6 | module V1 7 | class SelfSubjectRulesReviewSpec < ::KubeDSL::DSLObject 8 | value_field :namespace 9 | 10 | validates :namespace, field: { format: :string }, presence: false 11 | 12 | def serialize 13 | {}.tap do |result| 14 | result[:namespace] = namespace 15 | end 16 | end 17 | 18 | def kind_sym 19 | :self_subject_rules_review_spec 20 | end 21 | end 22 | end 23 | end 24 | end 25 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/autoscaling.rb: -------------------------------------------------------------------------------- 1 | module KubeDSL::DSL::Autoscaling 2 | autoload :V1, 'kube-dsl/dsl/autoscaling/v1' 3 | autoload :V2, 'kube-dsl/dsl/autoscaling/v2' 4 | autoload :V2beta1, 'kube-dsl/dsl/autoscaling/v2beta1' 5 | autoload :V2beta2, 'kube-dsl/dsl/autoscaling/v2beta2' 6 | end 7 | -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/autoscaling/v1.rb: -------------------------------------------------------------------------------- 1 | module KubeDSL::DSL::Autoscaling::V1 2 | autoload :CrossVersionObjectReference, 'kube-dsl/dsl/autoscaling/v1/cross_version_object_reference' 3 | autoload :HorizontalPodAutoscaler, 'kube-dsl/dsl/autoscaling/v1/horizontal_pod_autoscaler' 4 | autoload :HorizontalPodAutoscalerList, 'kube-dsl/dsl/autoscaling/v1/horizontal_pod_autoscaler_list' 5 | autoload :HorizontalPodAutoscalerSpec, 'kube-dsl/dsl/autoscaling/v1/horizontal_pod_autoscaler_spec' 6 | autoload :HorizontalPodAutoscalerStatus, 'kube-dsl/dsl/autoscaling/v1/horizontal_pod_autoscaler_status' 7 | autoload :Scale, 'kube-dsl/dsl/autoscaling/v1/scale' 8 | autoload :ScaleSpec, 'kube-dsl/dsl/autoscaling/v1/scale_spec' 9 | autoload :ScaleStatus, 'kube-dsl/dsl/autoscaling/v1/scale_status' 10 | end 11 | -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/autoscaling/v1/scale_spec.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Autoscaling 6 | module V1 7 | class ScaleSpec < ::KubeDSL::DSLObject 8 | value_field :replicas 9 | 10 | validates :replicas, field: { format: :integer }, presence: false 11 | 12 | def serialize 13 | {}.tap do |result| 14 | result[:replicas] = replicas 15 | end 16 | end 17 | 18 | def kind_sym 19 | :scale_spec 20 | end 21 | end 22 | end 23 | end 24 | end 25 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/autoscaling/v1/scale_status.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Autoscaling 6 | module V1 7 | class ScaleStatus < ::KubeDSL::DSLObject 8 | value_field :replicas 9 | value_field :selector 10 | 11 | validates :replicas, field: { format: :integer }, presence: false 12 | validates :selector, field: { format: :string }, presence: false 13 | 14 | def serialize 15 | {}.tap do |result| 16 | result[:replicas] = replicas 17 | result[:selector] = selector 18 | end 19 | end 20 | 21 | def kind_sym 22 | :scale_status 23 | end 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/autoscaling/v2/external_metric_source.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Autoscaling 6 | module V2 7 | class ExternalMetricSource < ::KubeDSL::DSLObject 8 | object_field(:metric) { KubeDSL::DSL::Autoscaling::V2::MetricIdentifier.new } 9 | object_field(:target) { KubeDSL::DSL::Autoscaling::V2::MetricTarget.new } 10 | 11 | validates :metric, object: { kind_of: KubeDSL::DSL::Autoscaling::V2::MetricIdentifier } 12 | validates :target, object: { kind_of: KubeDSL::DSL::Autoscaling::V2::MetricTarget } 13 | 14 | def serialize 15 | {}.tap do |result| 16 | result[:metric] = metric.serialize 17 | result[:target] = target.serialize 18 | end 19 | end 20 | 21 | def kind_sym 22 | :external_metric_source 23 | end 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/autoscaling/v2/hpa_scaling_policy.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Autoscaling 6 | module V2 7 | class HPAScalingPolicy < ::KubeDSL::DSLObject 8 | value_field :period_seconds 9 | value_field :type 10 | value_field :value 11 | 12 | validates :period_seconds, field: { format: :integer }, presence: false 13 | validates :type, field: { format: :string }, presence: false 14 | validates :value, field: { format: :integer }, presence: false 15 | 16 | def serialize 17 | {}.tap do |result| 18 | result[:periodSeconds] = period_seconds 19 | result[:type] = type 20 | result[:value] = value 21 | end 22 | end 23 | 24 | def kind_sym 25 | :hpa_scaling_policy 26 | end 27 | end 28 | end 29 | end 30 | end 31 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/autoscaling/v2/metric_identifier.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Autoscaling 6 | module V2 7 | class MetricIdentifier < ::KubeDSL::DSLObject 8 | value_field :name 9 | object_field(:selector) { KubeDSL::DSL::Meta::V1::LabelSelector.new } 10 | 11 | validates :name, field: { format: :string }, presence: false 12 | validates :selector, object: { kind_of: KubeDSL::DSL::Meta::V1::LabelSelector } 13 | 14 | def serialize 15 | {}.tap do |result| 16 | result[:name] = name 17 | result[:selector] = selector.serialize 18 | end 19 | end 20 | 21 | def kind_sym 22 | :metric_identifier 23 | end 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/autoscaling/v2/pods_metric_source.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Autoscaling 6 | module V2 7 | class PodsMetricSource < ::KubeDSL::DSLObject 8 | object_field(:metric) { KubeDSL::DSL::Autoscaling::V2::MetricIdentifier.new } 9 | object_field(:target) { KubeDSL::DSL::Autoscaling::V2::MetricTarget.new } 10 | 11 | validates :metric, object: { kind_of: KubeDSL::DSL::Autoscaling::V2::MetricIdentifier } 12 | validates :target, object: { kind_of: KubeDSL::DSL::Autoscaling::V2::MetricTarget } 13 | 14 | def serialize 15 | {}.tap do |result| 16 | result[:metric] = metric.serialize 17 | result[:target] = target.serialize 18 | end 19 | end 20 | 21 | def kind_sym 22 | :pods_metric_source 23 | end 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/autoscaling/v2/resource_metric_source.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Autoscaling 6 | module V2 7 | class ResourceMetricSource < ::KubeDSL::DSLObject 8 | value_field :name 9 | object_field(:target) { KubeDSL::DSL::Autoscaling::V2::MetricTarget.new } 10 | 11 | validates :name, field: { format: :string }, presence: false 12 | validates :target, object: { kind_of: KubeDSL::DSL::Autoscaling::V2::MetricTarget } 13 | 14 | def serialize 15 | {}.tap do |result| 16 | result[:name] = name 17 | result[:target] = target.serialize 18 | end 19 | end 20 | 21 | def kind_sym 22 | :resource_metric_source 23 | end 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/autoscaling/v2/resource_metric_status.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Autoscaling 6 | module V2 7 | class ResourceMetricStatus < ::KubeDSL::DSLObject 8 | object_field(:current) { KubeDSL::DSL::Autoscaling::V2::MetricValueStatus.new } 9 | value_field :name 10 | 11 | validates :current, object: { kind_of: KubeDSL::DSL::Autoscaling::V2::MetricValueStatus } 12 | validates :name, field: { format: :string }, presence: false 13 | 14 | def serialize 15 | {}.tap do |result| 16 | result[:current] = current.serialize 17 | result[:name] = name 18 | end 19 | end 20 | 21 | def kind_sym 22 | :resource_metric_status 23 | end 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/autoscaling/v2beta2/hpa_scaling_policy.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Autoscaling 6 | module V2beta2 7 | class HPAScalingPolicy < ::KubeDSL::DSLObject 8 | value_field :period_seconds 9 | value_field :type 10 | value_field :value 11 | 12 | validates :period_seconds, field: { format: :integer }, presence: false 13 | validates :type, field: { format: :string }, presence: false 14 | validates :value, field: { format: :integer }, presence: false 15 | 16 | def serialize 17 | {}.tap do |result| 18 | result[:periodSeconds] = period_seconds 19 | result[:type] = type 20 | result[:value] = value 21 | end 22 | end 23 | 24 | def kind_sym 25 | :hpa_scaling_policy 26 | end 27 | end 28 | end 29 | end 30 | end 31 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/autoscaling/v2beta2/metric_identifier.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Autoscaling 6 | module V2beta2 7 | class MetricIdentifier < ::KubeDSL::DSLObject 8 | value_field :name 9 | object_field(:selector) { KubeDSL::DSL::Meta::V1::LabelSelector.new } 10 | 11 | validates :name, field: { format: :string }, presence: false 12 | validates :selector, object: { kind_of: KubeDSL::DSL::Meta::V1::LabelSelector } 13 | 14 | def serialize 15 | {}.tap do |result| 16 | result[:name] = name 17 | result[:selector] = selector.serialize 18 | end 19 | end 20 | 21 | def kind_sym 22 | :metric_identifier 23 | end 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/autoscaling/v2beta2/resource_metric_source.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Autoscaling 6 | module V2beta2 7 | class ResourceMetricSource < ::KubeDSL::DSLObject 8 | value_field :name 9 | object_field(:target) { KubeDSL::DSL::Autoscaling::V2beta2::MetricTarget.new } 10 | 11 | validates :name, field: { format: :string }, presence: false 12 | validates :target, object: { kind_of: KubeDSL::DSL::Autoscaling::V2beta2::MetricTarget } 13 | 14 | def serialize 15 | {}.tap do |result| 16 | result[:name] = name 17 | result[:target] = target.serialize 18 | end 19 | end 20 | 21 | def kind_sym 22 | :resource_metric_source 23 | end 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/autoscaling/v2beta2/resource_metric_status.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Autoscaling 6 | module V2beta2 7 | class ResourceMetricStatus < ::KubeDSL::DSLObject 8 | object_field(:current) { KubeDSL::DSL::Autoscaling::V2beta2::MetricValueStatus.new } 9 | value_field :name 10 | 11 | validates :current, object: { kind_of: KubeDSL::DSL::Autoscaling::V2beta2::MetricValueStatus } 12 | validates :name, field: { format: :string }, presence: false 13 | 14 | def serialize 15 | {}.tap do |result| 16 | result[:current] = current.serialize 17 | result[:name] = name 18 | end 19 | end 20 | 21 | def kind_sym 22 | :resource_metric_status 23 | end 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/batch.rb: -------------------------------------------------------------------------------- 1 | module KubeDSL::DSL::Batch 2 | autoload :V1, 'kube-dsl/dsl/batch/v1' 3 | autoload :V1beta1, 'kube-dsl/dsl/batch/v1beta1' 4 | end 5 | -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/batch/v1.rb: -------------------------------------------------------------------------------- 1 | module KubeDSL::DSL::Batch::V1 2 | autoload :CronJob, 'kube-dsl/dsl/batch/v1/cron_job' 3 | autoload :CronJobList, 'kube-dsl/dsl/batch/v1/cron_job_list' 4 | autoload :CronJobSpec, 'kube-dsl/dsl/batch/v1/cron_job_spec' 5 | autoload :CronJobStatus, 'kube-dsl/dsl/batch/v1/cron_job_status' 6 | autoload :Job, 'kube-dsl/dsl/batch/v1/job' 7 | autoload :JobCondition, 'kube-dsl/dsl/batch/v1/job_condition' 8 | autoload :JobList, 'kube-dsl/dsl/batch/v1/job_list' 9 | autoload :JobSpec, 'kube-dsl/dsl/batch/v1/job_spec' 10 | autoload :JobStatus, 'kube-dsl/dsl/batch/v1/job_status' 11 | autoload :JobTemplateSpec, 'kube-dsl/dsl/batch/v1/job_template_spec' 12 | autoload :UncountedTerminatedPods, 'kube-dsl/dsl/batch/v1/uncounted_terminated_pods' 13 | end 14 | -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/batch/v1/job_template_spec.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Batch 6 | module V1 7 | class JobTemplateSpec < ::KubeDSL::DSLObject 8 | object_field(:metadata) { KubeDSL::DSL::Meta::V1::ObjectMeta.new } 9 | object_field(:spec) { KubeDSL::DSL::Batch::V1::JobSpec.new } 10 | 11 | validates :metadata, object: { kind_of: KubeDSL::DSL::Meta::V1::ObjectMeta } 12 | validates :spec, object: { kind_of: KubeDSL::DSL::Batch::V1::JobSpec } 13 | 14 | def serialize 15 | {}.tap do |result| 16 | result[:metadata] = metadata.serialize 17 | result[:spec] = spec.serialize 18 | end 19 | end 20 | 21 | def kind_sym 22 | :job_template_spec 23 | end 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/batch/v1/uncounted_terminated_pods.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Batch 6 | module V1 7 | class UncountedTerminatedPods < ::KubeDSL::DSLObject 8 | value_field :failed 9 | value_field :succeeded 10 | 11 | validates :failed, field: { format: :string }, presence: false 12 | validates :succeeded, field: { format: :string }, presence: false 13 | 14 | def serialize 15 | {}.tap do |result| 16 | result[:failed] = failed 17 | result[:succeeded] = succeeded 18 | end 19 | end 20 | 21 | def kind_sym 22 | :uncounted_terminated_pods 23 | end 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/batch/v1beta1.rb: -------------------------------------------------------------------------------- 1 | module KubeDSL::DSL::Batch::V1beta1 2 | autoload :CronJob, 'kube-dsl/dsl/batch/v1beta1/cron_job' 3 | autoload :CronJobList, 'kube-dsl/dsl/batch/v1beta1/cron_job_list' 4 | autoload :CronJobSpec, 'kube-dsl/dsl/batch/v1beta1/cron_job_spec' 5 | autoload :CronJobStatus, 'kube-dsl/dsl/batch/v1beta1/cron_job_status' 6 | autoload :JobTemplateSpec, 'kube-dsl/dsl/batch/v1beta1/job_template_spec' 7 | end 8 | -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/batch/v1beta1/job_template_spec.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Batch 6 | module V1beta1 7 | class JobTemplateSpec < ::KubeDSL::DSLObject 8 | object_field(:metadata) { KubeDSL::DSL::Meta::V1::ObjectMeta.new } 9 | object_field(:spec) { KubeDSL::DSL::Batch::V1::JobSpec.new } 10 | 11 | validates :metadata, object: { kind_of: KubeDSL::DSL::Meta::V1::ObjectMeta } 12 | validates :spec, object: { kind_of: KubeDSL::DSL::Batch::V1::JobSpec } 13 | 14 | def serialize 15 | {}.tap do |result| 16 | result[:metadata] = metadata.serialize 17 | result[:spec] = spec.serialize 18 | end 19 | end 20 | 21 | def kind_sym 22 | :job_template_spec 23 | end 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/certificates.rb: -------------------------------------------------------------------------------- 1 | module KubeDSL::DSL::Certificates 2 | autoload :V1, 'kube-dsl/dsl/certificates/v1' 3 | end 4 | -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/certificates/v1.rb: -------------------------------------------------------------------------------- 1 | module KubeDSL::DSL::Certificates::V1 2 | autoload :CertificateSigningRequest, 'kube-dsl/dsl/certificates/v1/certificate_signing_request' 3 | autoload :CertificateSigningRequestCondition, 'kube-dsl/dsl/certificates/v1/certificate_signing_request_condition' 4 | autoload :CertificateSigningRequestList, 'kube-dsl/dsl/certificates/v1/certificate_signing_request_list' 5 | autoload :CertificateSigningRequestSpec, 'kube-dsl/dsl/certificates/v1/certificate_signing_request_spec' 6 | autoload :CertificateSigningRequestStatus, 'kube-dsl/dsl/certificates/v1/certificate_signing_request_status' 7 | end 8 | -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/coordination.rb: -------------------------------------------------------------------------------- 1 | module KubeDSL::DSL::Coordination 2 | autoload :V1, 'kube-dsl/dsl/coordination/v1' 3 | end 4 | -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/coordination/v1.rb: -------------------------------------------------------------------------------- 1 | module KubeDSL::DSL::Coordination::V1 2 | autoload :Lease, 'kube-dsl/dsl/coordination/v1/lease' 3 | autoload :LeaseList, 'kube-dsl/dsl/coordination/v1/lease_list' 4 | autoload :LeaseSpec, 'kube-dsl/dsl/coordination/v1/lease_spec' 5 | end 6 | -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/discovery.rb: -------------------------------------------------------------------------------- 1 | module KubeDSL::DSL::Discovery 2 | autoload :V1, 'kube-dsl/dsl/discovery/v1' 3 | autoload :V1beta1, 'kube-dsl/dsl/discovery/v1beta1' 4 | end 5 | -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/discovery/v1.rb: -------------------------------------------------------------------------------- 1 | module KubeDSL::DSL::Discovery::V1 2 | autoload :Endpoint, 'kube-dsl/dsl/discovery/v1/endpoint' 3 | autoload :EndpointConditions, 'kube-dsl/dsl/discovery/v1/endpoint_conditions' 4 | autoload :EndpointHints, 'kube-dsl/dsl/discovery/v1/endpoint_hints' 5 | autoload :EndpointPort, 'kube-dsl/dsl/discovery/v1/endpoint_port' 6 | autoload :EndpointSlice, 'kube-dsl/dsl/discovery/v1/endpoint_slice' 7 | autoload :EndpointSliceList, 'kube-dsl/dsl/discovery/v1/endpoint_slice_list' 8 | autoload :ForZone, 'kube-dsl/dsl/discovery/v1/for_zone' 9 | end 10 | -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/discovery/v1/endpoint_conditions.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Discovery 6 | module V1 7 | class EndpointConditions < ::KubeDSL::DSLObject 8 | value_field :ready 9 | value_field :serving 10 | value_field :terminating 11 | 12 | validates :ready, field: { format: :boolean }, presence: false 13 | validates :serving, field: { format: :boolean }, presence: false 14 | validates :terminating, field: { format: :boolean }, presence: false 15 | 16 | def serialize 17 | {}.tap do |result| 18 | result[:ready] = ready 19 | result[:serving] = serving 20 | result[:terminating] = terminating 21 | end 22 | end 23 | 24 | def kind_sym 25 | :endpoint_conditions 26 | end 27 | end 28 | end 29 | end 30 | end 31 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/discovery/v1/endpoint_hints.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Discovery 6 | module V1 7 | class EndpointHints < ::KubeDSL::DSLObject 8 | array_field(:for_zone) { KubeDSL::DSL::Discovery::V1::ForZone.new } 9 | 10 | validates :for_zones, array: { kind_of: KubeDSL::DSL::Discovery::V1::ForZone }, presence: false 11 | 12 | def serialize 13 | {}.tap do |result| 14 | result[:forZones] = for_zones.map(&:serialize) 15 | end 16 | end 17 | 18 | def kind_sym 19 | :endpoint_hints 20 | end 21 | end 22 | end 23 | end 24 | end 25 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/discovery/v1/for_zone.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Discovery 6 | module V1 7 | class ForZone < ::KubeDSL::DSLObject 8 | value_field :name 9 | 10 | validates :name, field: { format: :string }, presence: false 11 | 12 | def serialize 13 | {}.tap do |result| 14 | result[:name] = name 15 | end 16 | end 17 | 18 | def kind_sym 19 | :for_zone 20 | end 21 | end 22 | end 23 | end 24 | end 25 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/discovery/v1beta1.rb: -------------------------------------------------------------------------------- 1 | module KubeDSL::DSL::Discovery::V1beta1 2 | autoload :Endpoint, 'kube-dsl/dsl/discovery/v1beta1/endpoint' 3 | autoload :EndpointConditions, 'kube-dsl/dsl/discovery/v1beta1/endpoint_conditions' 4 | autoload :EndpointHints, 'kube-dsl/dsl/discovery/v1beta1/endpoint_hints' 5 | autoload :EndpointPort, 'kube-dsl/dsl/discovery/v1beta1/endpoint_port' 6 | autoload :EndpointSlice, 'kube-dsl/dsl/discovery/v1beta1/endpoint_slice' 7 | autoload :EndpointSliceList, 'kube-dsl/dsl/discovery/v1beta1/endpoint_slice_list' 8 | autoload :ForZone, 'kube-dsl/dsl/discovery/v1beta1/for_zone' 9 | end 10 | -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/discovery/v1beta1/endpoint_hints.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Discovery 6 | module V1beta1 7 | class EndpointHints < ::KubeDSL::DSLObject 8 | array_field(:for_zone) { KubeDSL::DSL::Discovery::V1beta1::ForZone.new } 9 | 10 | validates :for_zones, array: { kind_of: KubeDSL::DSL::Discovery::V1beta1::ForZone }, presence: false 11 | 12 | def serialize 13 | {}.tap do |result| 14 | result[:forZones] = for_zones.map(&:serialize) 15 | end 16 | end 17 | 18 | def kind_sym 19 | :endpoint_hints 20 | end 21 | end 22 | end 23 | end 24 | end 25 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/discovery/v1beta1/for_zone.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Discovery 6 | module V1beta1 7 | class ForZone < ::KubeDSL::DSLObject 8 | value_field :name 9 | 10 | validates :name, field: { format: :string }, presence: false 11 | 12 | def serialize 13 | {}.tap do |result| 14 | result[:name] = name 15 | end 16 | end 17 | 18 | def kind_sym 19 | :for_zone 20 | end 21 | end 22 | end 23 | end 24 | end 25 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/events.rb: -------------------------------------------------------------------------------- 1 | module KubeDSL::DSL::Events 2 | autoload :V1, 'kube-dsl/dsl/events/v1' 3 | autoload :V1beta1, 'kube-dsl/dsl/events/v1beta1' 4 | end 5 | -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/events/v1.rb: -------------------------------------------------------------------------------- 1 | module KubeDSL::DSL::Events::V1 2 | autoload :Event, 'kube-dsl/dsl/events/v1/event' 3 | autoload :EventList, 'kube-dsl/dsl/events/v1/event_list' 4 | autoload :EventSeries, 'kube-dsl/dsl/events/v1/event_series' 5 | end 6 | -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/events/v1/event_series.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Events 6 | module V1 7 | class EventSeries < ::KubeDSL::DSLObject 8 | value_field :count 9 | value_field :last_observed_time 10 | 11 | validates :count, field: { format: :integer }, presence: false 12 | validates :last_observed_time, field: { format: :string }, presence: false 13 | 14 | def serialize 15 | {}.tap do |result| 16 | result[:count] = count 17 | result[:lastObservedTime] = last_observed_time 18 | end 19 | end 20 | 21 | def kind_sym 22 | :event_series 23 | end 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/events/v1beta1.rb: -------------------------------------------------------------------------------- 1 | module KubeDSL::DSL::Events::V1beta1 2 | autoload :Event, 'kube-dsl/dsl/events/v1beta1/event' 3 | autoload :EventList, 'kube-dsl/dsl/events/v1beta1/event_list' 4 | autoload :EventSeries, 'kube-dsl/dsl/events/v1beta1/event_series' 5 | end 6 | -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/events/v1beta1/event_series.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Events 6 | module V1beta1 7 | class EventSeries < ::KubeDSL::DSLObject 8 | value_field :count 9 | value_field :last_observed_time 10 | 11 | validates :count, field: { format: :integer }, presence: false 12 | validates :last_observed_time, field: { format: :string }, presence: false 13 | 14 | def serialize 15 | {}.tap do |result| 16 | result[:count] = count 17 | result[:lastObservedTime] = last_observed_time 18 | end 19 | end 20 | 21 | def kind_sym 22 | :event_series 23 | end 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/flowcontrol.rb: -------------------------------------------------------------------------------- 1 | module KubeDSL::DSL::Flowcontrol 2 | autoload :V1beta1, 'kube-dsl/dsl/flowcontrol/v1beta1' 3 | autoload :V1beta2, 'kube-dsl/dsl/flowcontrol/v1beta2' 4 | end 5 | -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/flowcontrol/v1beta1/flow_distinguisher_method.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Flowcontrol 6 | module V1beta1 7 | class FlowDistinguisherMethod < ::KubeDSL::DSLObject 8 | value_field :type 9 | 10 | validates :type, field: { format: :string }, presence: false 11 | 12 | def serialize 13 | {}.tap do |result| 14 | result[:type] = type 15 | end 16 | end 17 | 18 | def kind_sym 19 | :flow_distinguisher_method 20 | end 21 | end 22 | end 23 | end 24 | end 25 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/flowcontrol/v1beta1/flow_schema_status.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Flowcontrol 6 | module V1beta1 7 | class FlowSchemaStatus < ::KubeDSL::DSLObject 8 | array_field(:condition) { KubeDSL::DSL::Flowcontrol::V1beta1::FlowSchemaCondition.new } 9 | 10 | validates :conditions, array: { kind_of: KubeDSL::DSL::Flowcontrol::V1beta1::FlowSchemaCondition }, presence: false 11 | 12 | def serialize 13 | {}.tap do |result| 14 | result[:conditions] = conditions.map(&:serialize) 15 | end 16 | end 17 | 18 | def kind_sym 19 | :flow_schema_status 20 | end 21 | end 22 | end 23 | end 24 | end 25 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/flowcontrol/v1beta1/group_subject.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Flowcontrol 6 | module V1beta1 7 | class GroupSubject < ::KubeDSL::DSLObject 8 | value_field :name 9 | 10 | validates :name, field: { format: :string }, presence: false 11 | 12 | def serialize 13 | {}.tap do |result| 14 | result[:name] = name 15 | end 16 | end 17 | 18 | def kind_sym 19 | :group_subject 20 | end 21 | end 22 | end 23 | end 24 | end 25 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/flowcontrol/v1beta1/limit_response.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Flowcontrol 6 | module V1beta1 7 | class LimitResponse < ::KubeDSL::DSLObject 8 | object_field(:queuing) { KubeDSL::DSL::Flowcontrol::V1beta1::QueuingConfiguration.new } 9 | value_field :type 10 | 11 | validates :queuing, object: { kind_of: KubeDSL::DSL::Flowcontrol::V1beta1::QueuingConfiguration } 12 | validates :type, field: { format: :string }, presence: false 13 | 14 | def serialize 15 | {}.tap do |result| 16 | result[:queuing] = queuing.serialize 17 | result[:type] = type 18 | end 19 | end 20 | 21 | def kind_sym 22 | :limit_response 23 | end 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/flowcontrol/v1beta1/non_resource_policy_rule.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Flowcontrol 6 | module V1beta1 7 | class NonResourcePolicyRule < ::KubeDSL::DSLObject 8 | value_field :non_resource_ur_ls 9 | value_field :verbs 10 | 11 | validates :non_resource_ur_ls, field: { format: :string }, presence: false 12 | validates :verbs, field: { format: :string }, presence: false 13 | 14 | def serialize 15 | {}.tap do |result| 16 | result[:nonResourceURLs] = non_resource_ur_ls 17 | result[:verbs] = verbs 18 | end 19 | end 20 | 21 | def kind_sym 22 | :non_resource_policy_rule 23 | end 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/flowcontrol/v1beta1/priority_level_configuration_reference.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Flowcontrol 6 | module V1beta1 7 | class PriorityLevelConfigurationReference < ::KubeDSL::DSLObject 8 | value_field :name 9 | 10 | validates :name, field: { format: :string }, presence: false 11 | 12 | def serialize 13 | {}.tap do |result| 14 | result[:name] = name 15 | end 16 | end 17 | 18 | def kind_sym 19 | :priority_level_configuration_reference 20 | end 21 | end 22 | end 23 | end 24 | end 25 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/flowcontrol/v1beta1/priority_level_configuration_spec.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Flowcontrol 6 | module V1beta1 7 | class PriorityLevelConfigurationSpec < ::KubeDSL::DSLObject 8 | object_field(:limited) { KubeDSL::DSL::Flowcontrol::V1beta1::LimitedPriorityLevelConfiguration.new } 9 | value_field :type 10 | 11 | validates :limited, object: { kind_of: KubeDSL::DSL::Flowcontrol::V1beta1::LimitedPriorityLevelConfiguration } 12 | validates :type, field: { format: :string }, presence: false 13 | 14 | def serialize 15 | {}.tap do |result| 16 | result[:limited] = limited.serialize 17 | result[:type] = type 18 | end 19 | end 20 | 21 | def kind_sym 22 | :priority_level_configuration_spec 23 | end 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/flowcontrol/v1beta1/priority_level_configuration_status.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Flowcontrol 6 | module V1beta1 7 | class PriorityLevelConfigurationStatus < ::KubeDSL::DSLObject 8 | array_field(:condition) { KubeDSL::DSL::Flowcontrol::V1beta1::PriorityLevelConfigurationCondition.new } 9 | 10 | validates :conditions, array: { kind_of: KubeDSL::DSL::Flowcontrol::V1beta1::PriorityLevelConfigurationCondition }, presence: false 11 | 12 | def serialize 13 | {}.tap do |result| 14 | result[:conditions] = conditions.map(&:serialize) 15 | end 16 | end 17 | 18 | def kind_sym 19 | :priority_level_configuration_status 20 | end 21 | end 22 | end 23 | end 24 | end 25 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/flowcontrol/v1beta1/service_account_subject.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Flowcontrol 6 | module V1beta1 7 | class ServiceAccountSubject < ::KubeDSL::DSLObject 8 | value_field :name 9 | value_field :namespace 10 | 11 | validates :name, field: { format: :string }, presence: false 12 | validates :namespace, field: { format: :string }, presence: false 13 | 14 | def serialize 15 | {}.tap do |result| 16 | result[:name] = name 17 | result[:namespace] = namespace 18 | end 19 | end 20 | 21 | def kind_sym 22 | :service_account_subject 23 | end 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/flowcontrol/v1beta1/user_subject.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Flowcontrol 6 | module V1beta1 7 | class UserSubject < ::KubeDSL::DSLObject 8 | value_field :name 9 | 10 | validates :name, field: { format: :string }, presence: false 11 | 12 | def serialize 13 | {}.tap do |result| 14 | result[:name] = name 15 | end 16 | end 17 | 18 | def kind_sym 19 | :user_subject 20 | end 21 | end 22 | end 23 | end 24 | end 25 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/flowcontrol/v1beta2/flow_distinguisher_method.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Flowcontrol 6 | module V1beta2 7 | class FlowDistinguisherMethod < ::KubeDSL::DSLObject 8 | value_field :type 9 | 10 | validates :type, field: { format: :string }, presence: false 11 | 12 | def serialize 13 | {}.tap do |result| 14 | result[:type] = type 15 | end 16 | end 17 | 18 | def kind_sym 19 | :flow_distinguisher_method 20 | end 21 | end 22 | end 23 | end 24 | end 25 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/flowcontrol/v1beta2/flow_schema_status.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Flowcontrol 6 | module V1beta2 7 | class FlowSchemaStatus < ::KubeDSL::DSLObject 8 | array_field(:condition) { KubeDSL::DSL::Flowcontrol::V1beta2::FlowSchemaCondition.new } 9 | 10 | validates :conditions, array: { kind_of: KubeDSL::DSL::Flowcontrol::V1beta2::FlowSchemaCondition }, presence: false 11 | 12 | def serialize 13 | {}.tap do |result| 14 | result[:conditions] = conditions.map(&:serialize) 15 | end 16 | end 17 | 18 | def kind_sym 19 | :flow_schema_status 20 | end 21 | end 22 | end 23 | end 24 | end 25 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/flowcontrol/v1beta2/group_subject.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Flowcontrol 6 | module V1beta2 7 | class GroupSubject < ::KubeDSL::DSLObject 8 | value_field :name 9 | 10 | validates :name, field: { format: :string }, presence: false 11 | 12 | def serialize 13 | {}.tap do |result| 14 | result[:name] = name 15 | end 16 | end 17 | 18 | def kind_sym 19 | :group_subject 20 | end 21 | end 22 | end 23 | end 24 | end 25 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/flowcontrol/v1beta2/limit_response.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Flowcontrol 6 | module V1beta2 7 | class LimitResponse < ::KubeDSL::DSLObject 8 | object_field(:queuing) { KubeDSL::DSL::Flowcontrol::V1beta2::QueuingConfiguration.new } 9 | value_field :type 10 | 11 | validates :queuing, object: { kind_of: KubeDSL::DSL::Flowcontrol::V1beta2::QueuingConfiguration } 12 | validates :type, field: { format: :string }, presence: false 13 | 14 | def serialize 15 | {}.tap do |result| 16 | result[:queuing] = queuing.serialize 17 | result[:type] = type 18 | end 19 | end 20 | 21 | def kind_sym 22 | :limit_response 23 | end 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/flowcontrol/v1beta2/non_resource_policy_rule.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Flowcontrol 6 | module V1beta2 7 | class NonResourcePolicyRule < ::KubeDSL::DSLObject 8 | value_field :non_resource_ur_ls 9 | value_field :verbs 10 | 11 | validates :non_resource_ur_ls, field: { format: :string }, presence: false 12 | validates :verbs, field: { format: :string }, presence: false 13 | 14 | def serialize 15 | {}.tap do |result| 16 | result[:nonResourceURLs] = non_resource_ur_ls 17 | result[:verbs] = verbs 18 | end 19 | end 20 | 21 | def kind_sym 22 | :non_resource_policy_rule 23 | end 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/flowcontrol/v1beta2/priority_level_configuration_reference.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Flowcontrol 6 | module V1beta2 7 | class PriorityLevelConfigurationReference < ::KubeDSL::DSLObject 8 | value_field :name 9 | 10 | validates :name, field: { format: :string }, presence: false 11 | 12 | def serialize 13 | {}.tap do |result| 14 | result[:name] = name 15 | end 16 | end 17 | 18 | def kind_sym 19 | :priority_level_configuration_reference 20 | end 21 | end 22 | end 23 | end 24 | end 25 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/flowcontrol/v1beta2/priority_level_configuration_spec.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Flowcontrol 6 | module V1beta2 7 | class PriorityLevelConfigurationSpec < ::KubeDSL::DSLObject 8 | object_field(:limited) { KubeDSL::DSL::Flowcontrol::V1beta2::LimitedPriorityLevelConfiguration.new } 9 | value_field :type 10 | 11 | validates :limited, object: { kind_of: KubeDSL::DSL::Flowcontrol::V1beta2::LimitedPriorityLevelConfiguration } 12 | validates :type, field: { format: :string }, presence: false 13 | 14 | def serialize 15 | {}.tap do |result| 16 | result[:limited] = limited.serialize 17 | result[:type] = type 18 | end 19 | end 20 | 21 | def kind_sym 22 | :priority_level_configuration_spec 23 | end 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/flowcontrol/v1beta2/priority_level_configuration_status.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Flowcontrol 6 | module V1beta2 7 | class PriorityLevelConfigurationStatus < ::KubeDSL::DSLObject 8 | array_field(:condition) { KubeDSL::DSL::Flowcontrol::V1beta2::PriorityLevelConfigurationCondition.new } 9 | 10 | validates :conditions, array: { kind_of: KubeDSL::DSL::Flowcontrol::V1beta2::PriorityLevelConfigurationCondition }, presence: false 11 | 12 | def serialize 13 | {}.tap do |result| 14 | result[:conditions] = conditions.map(&:serialize) 15 | end 16 | end 17 | 18 | def kind_sym 19 | :priority_level_configuration_status 20 | end 21 | end 22 | end 23 | end 24 | end 25 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/flowcontrol/v1beta2/service_account_subject.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Flowcontrol 6 | module V1beta2 7 | class ServiceAccountSubject < ::KubeDSL::DSLObject 8 | value_field :name 9 | value_field :namespace 10 | 11 | validates :name, field: { format: :string }, presence: false 12 | validates :namespace, field: { format: :string }, presence: false 13 | 14 | def serialize 15 | {}.tap do |result| 16 | result[:name] = name 17 | result[:namespace] = namespace 18 | end 19 | end 20 | 21 | def kind_sym 22 | :service_account_subject 23 | end 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/flowcontrol/v1beta2/user_subject.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Flowcontrol 6 | module V1beta2 7 | class UserSubject < ::KubeDSL::DSLObject 8 | value_field :name 9 | 10 | validates :name, field: { format: :string }, presence: false 11 | 12 | def serialize 13 | {}.tap do |result| 14 | result[:name] = name 15 | end 16 | end 17 | 18 | def kind_sym 19 | :user_subject 20 | end 21 | end 22 | end 23 | end 24 | end 25 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/meta.rb: -------------------------------------------------------------------------------- 1 | module KubeDSL::DSL::Meta 2 | autoload :V1, 'kube-dsl/dsl/meta/v1' 3 | end 4 | -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/meta/v1/api_group_list.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Meta 6 | module V1 7 | class APIGroupList < ::KubeDSL::DSLObject 8 | array_field(:group) { KubeDSL::DSL::Meta::V1::APIGroup.new } 9 | 10 | validates :groups, array: { kind_of: KubeDSL::DSL::Meta::V1::APIGroup }, presence: false 11 | 12 | def serialize 13 | {}.tap do |result| 14 | result[:apiVersion] = "v1" 15 | result[:groups] = groups.map(&:serialize) 16 | result[:kind] = "APIGroupList" 17 | end 18 | end 19 | 20 | def kind_sym 21 | :api_group_list 22 | end 23 | end 24 | end 25 | end 26 | end 27 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/meta/v1/group_version_for_discovery.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Meta 6 | module V1 7 | class GroupVersionForDiscovery < ::KubeDSL::DSLObject 8 | value_field :group_version 9 | value_field :version 10 | 11 | validates :group_version, field: { format: :string }, presence: false 12 | validates :version, field: { format: :string }, presence: false 13 | 14 | def serialize 15 | {}.tap do |result| 16 | result[:groupVersion] = group_version 17 | result[:version] = version 18 | end 19 | end 20 | 21 | def kind_sym 22 | :group_version_for_discovery 23 | end 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/meta/v1/label_selector_requirement.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Meta 6 | module V1 7 | class LabelSelectorRequirement < ::KubeDSL::DSLObject 8 | value_field :key 9 | value_field :operator 10 | value_field :values 11 | 12 | validates :key, field: { format: :string }, presence: false 13 | validates :operator, field: { format: :string }, presence: false 14 | validates :values, field: { format: :string }, presence: false 15 | 16 | def serialize 17 | {}.tap do |result| 18 | result[:key] = key 19 | result[:operator] = operator 20 | result[:values] = values 21 | end 22 | end 23 | 24 | def kind_sym 25 | :label_selector_requirement 26 | end 27 | end 28 | end 29 | end 30 | end 31 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/meta/v1/preconditions.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Meta 6 | module V1 7 | class Preconditions < ::KubeDSL::DSLObject 8 | value_field :resource_version 9 | value_field :uid 10 | 11 | validates :resource_version, field: { format: :string }, presence: false 12 | validates :uid, field: { format: :string }, presence: false 13 | 14 | def serialize 15 | {}.tap do |result| 16 | result[:resourceVersion] = resource_version 17 | result[:uid] = uid 18 | end 19 | end 20 | 21 | def kind_sym 22 | :preconditions 23 | end 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/meta/v1/server_address_by_client_cidr.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Meta 6 | module V1 7 | class ServerAddressByClientCIDR < ::KubeDSL::DSLObject 8 | value_field :client_cidr 9 | value_field :server_address 10 | 11 | validates :client_cidr, field: { format: :string }, presence: false 12 | validates :server_address, field: { format: :string }, presence: false 13 | 14 | def serialize 15 | {}.tap do |result| 16 | result[:clientCIDR] = client_cidr 17 | result[:serverAddress] = server_address 18 | end 19 | end 20 | 21 | def kind_sym 22 | :server_address_by_client_cidr 23 | end 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/meta/v1/status_cause.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Meta 6 | module V1 7 | class StatusCause < ::KubeDSL::DSLObject 8 | value_field :field 9 | value_field :message 10 | value_field :reason 11 | 12 | validates :field, field: { format: :string }, presence: false 13 | validates :message, field: { format: :string }, presence: false 14 | validates :reason, field: { format: :string }, presence: false 15 | 16 | def serialize 17 | {}.tap do |result| 18 | result[:field] = field 19 | result[:message] = message 20 | result[:reason] = reason 21 | end 22 | end 23 | 24 | def kind_sym 25 | :status_cause 26 | end 27 | end 28 | end 29 | end 30 | end 31 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/meta/v1/watch_event.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Meta 6 | module V1 7 | class WatchEvent < ::KubeDSL::DSLObject 8 | value_field :object 9 | value_field :type 10 | 11 | validates :object, field: { format: :string }, presence: false 12 | validates :type, field: { format: :string }, presence: false 13 | 14 | def serialize 15 | {}.tap do |result| 16 | result[:object] = object 17 | result[:type] = type 18 | end 19 | end 20 | 21 | def kind_sym 22 | :watch_event 23 | end 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/networking.rb: -------------------------------------------------------------------------------- 1 | module KubeDSL::DSL::Networking 2 | autoload :V1, 'kube-dsl/dsl/networking/v1' 3 | end 4 | -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/networking/v1/http_ingress_rule_value.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Networking 6 | module V1 7 | class HTTPIngressRuleValue < ::KubeDSL::DSLObject 8 | array_field(:path) { KubeDSL::DSL::Networking::V1::HTTPIngressPath.new } 9 | 10 | validates :paths, array: { kind_of: KubeDSL::DSL::Networking::V1::HTTPIngressPath }, presence: false 11 | 12 | def serialize 13 | {}.tap do |result| 14 | result[:paths] = paths.map(&:serialize) 15 | end 16 | end 17 | 18 | def kind_sym 19 | :http_ingress_rule_value 20 | end 21 | end 22 | end 23 | end 24 | end 25 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/networking/v1/ingress_backend.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Networking 6 | module V1 7 | class IngressBackend < ::KubeDSL::DSLObject 8 | object_field(:resource) { KubeDSL::DSL::V1::TypedLocalObjectReference.new } 9 | object_field(:service) { KubeDSL::DSL::Networking::V1::IngressServiceBackend.new } 10 | 11 | validates :resource, object: { kind_of: KubeDSL::DSL::V1::TypedLocalObjectReference } 12 | validates :service, object: { kind_of: KubeDSL::DSL::Networking::V1::IngressServiceBackend } 13 | 14 | def serialize 15 | {}.tap do |result| 16 | result[:resource] = resource.serialize 17 | result[:service] = service.serialize 18 | end 19 | end 20 | 21 | def kind_sym 22 | :ingress_backend 23 | end 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/networking/v1/ingress_class_spec.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Networking 6 | module V1 7 | class IngressClassSpec < ::KubeDSL::DSLObject 8 | value_field :controller 9 | object_field(:parameters) { KubeDSL::DSL::Networking::V1::IngressClassParametersReference.new } 10 | 11 | validates :controller, field: { format: :string }, presence: false 12 | validates :parameters, object: { kind_of: KubeDSL::DSL::Networking::V1::IngressClassParametersReference } 13 | 14 | def serialize 15 | {}.tap do |result| 16 | result[:controller] = controller 17 | result[:parameters] = parameters.serialize 18 | end 19 | end 20 | 21 | def kind_sym 22 | :ingress_class_spec 23 | end 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/networking/v1/ingress_rule.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Networking 6 | module V1 7 | class IngressRule < ::KubeDSL::DSLObject 8 | value_field :host 9 | object_field(:http) { KubeDSL::DSL::Networking::V1::HTTPIngressRuleValue.new } 10 | 11 | validates :host, field: { format: :string }, presence: false 12 | validates :http, object: { kind_of: KubeDSL::DSL::Networking::V1::HTTPIngressRuleValue } 13 | 14 | def serialize 15 | {}.tap do |result| 16 | result[:host] = host 17 | result[:http] = http.serialize 18 | end 19 | end 20 | 21 | def kind_sym 22 | :ingress_rule 23 | end 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/networking/v1/ingress_service_backend.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Networking 6 | module V1 7 | class IngressServiceBackend < ::KubeDSL::DSLObject 8 | value_field :name 9 | object_field(:port) { KubeDSL::DSL::Networking::V1::ServiceBackendPort.new } 10 | 11 | validates :name, field: { format: :string }, presence: false 12 | validates :port, object: { kind_of: KubeDSL::DSL::Networking::V1::ServiceBackendPort } 13 | 14 | def serialize 15 | {}.tap do |result| 16 | result[:name] = name 17 | result[:port] = port.serialize 18 | end 19 | end 20 | 21 | def kind_sym 22 | :ingress_service_backend 23 | end 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/networking/v1/ingress_status.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Networking 6 | module V1 7 | class IngressStatus < ::KubeDSL::DSLObject 8 | object_field(:load_balancer) { KubeDSL::DSL::V1::LoadBalancerStatus.new } 9 | 10 | validates :load_balancer, object: { kind_of: KubeDSL::DSL::V1::LoadBalancerStatus } 11 | 12 | def serialize 13 | {}.tap do |result| 14 | result[:loadBalancer] = load_balancer.serialize 15 | end 16 | end 17 | 18 | def kind_sym 19 | :ingress_status 20 | end 21 | end 22 | end 23 | end 24 | end 25 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/networking/v1/ingress_tls.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Networking 6 | module V1 7 | class IngressTLS < ::KubeDSL::DSLObject 8 | value_field :hosts 9 | value_field :secret_name 10 | 11 | validates :hosts, field: { format: :string }, presence: false 12 | validates :secret_name, field: { format: :string }, presence: false 13 | 14 | def serialize 15 | {}.tap do |result| 16 | result[:hosts] = hosts 17 | result[:secretName] = secret_name 18 | end 19 | end 20 | 21 | def kind_sym 22 | :ingress_tls 23 | end 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/networking/v1/ip_block.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Networking 6 | module V1 7 | class IPBlock < ::KubeDSL::DSLObject 8 | value_field :cidr 9 | value_field :except 10 | 11 | validates :cidr, field: { format: :string }, presence: false 12 | validates :except, field: { format: :string }, presence: false 13 | 14 | def serialize 15 | {}.tap do |result| 16 | result[:cidr] = cidr 17 | result[:except] = except 18 | end 19 | end 20 | 21 | def kind_sym 22 | :ip_block 23 | end 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/networking/v1/network_policy_port.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Networking 6 | module V1 7 | class NetworkPolicyPort < ::KubeDSL::DSLObject 8 | value_field :end_port 9 | value_field :port 10 | value_field :protocol 11 | 12 | validates :end_port, field: { format: :integer }, presence: false 13 | validates :port, field: { format: :string }, presence: false 14 | validates :protocol, field: { format: :string }, presence: false 15 | 16 | def serialize 17 | {}.tap do |result| 18 | result[:endPort] = end_port 19 | result[:port] = port 20 | result[:protocol] = protocol 21 | end 22 | end 23 | 24 | def kind_sym 25 | :network_policy_port 26 | end 27 | end 28 | end 29 | end 30 | end 31 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/networking/v1/service_backend_port.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Networking 6 | module V1 7 | class ServiceBackendPort < ::KubeDSL::DSLObject 8 | value_field :name 9 | value_field :number 10 | 11 | validates :name, field: { format: :string }, presence: false 12 | validates :number, field: { format: :integer }, presence: false 13 | 14 | def serialize 15 | {}.tap do |result| 16 | result[:name] = name 17 | result[:number] = number 18 | end 19 | end 20 | 21 | def kind_sym 22 | :service_backend_port 23 | end 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/node.rb: -------------------------------------------------------------------------------- 1 | module KubeDSL::DSL::Node 2 | autoload :V1, 'kube-dsl/dsl/node/v1' 3 | autoload :V1alpha1, 'kube-dsl/dsl/node/v1alpha1' 4 | autoload :V1beta1, 'kube-dsl/dsl/node/v1beta1' 5 | end 6 | -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/node/v1.rb: -------------------------------------------------------------------------------- 1 | module KubeDSL::DSL::Node::V1 2 | autoload :Overhead, 'kube-dsl/dsl/node/v1/overhead' 3 | autoload :RuntimeClass, 'kube-dsl/dsl/node/v1/runtime_class' 4 | autoload :RuntimeClassList, 'kube-dsl/dsl/node/v1/runtime_class_list' 5 | autoload :Scheduling, 'kube-dsl/dsl/node/v1/scheduling' 6 | end 7 | -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/node/v1alpha1.rb: -------------------------------------------------------------------------------- 1 | module KubeDSL::DSL::Node::V1alpha1 2 | autoload :Overhead, 'kube-dsl/dsl/node/v1alpha1/overhead' 3 | autoload :RuntimeClass, 'kube-dsl/dsl/node/v1alpha1/runtime_class' 4 | autoload :RuntimeClassList, 'kube-dsl/dsl/node/v1alpha1/runtime_class_list' 5 | autoload :RuntimeClassSpec, 'kube-dsl/dsl/node/v1alpha1/runtime_class_spec' 6 | autoload :Scheduling, 'kube-dsl/dsl/node/v1alpha1/scheduling' 7 | end 8 | -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/node/v1alpha1/overhead.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Node 6 | module V1alpha1 7 | class Overhead < ::KubeDSL::DSLObject 8 | key_value_field(:pod_fixed, format: :string) 9 | 10 | validates :pod_fixed, kv: { value_format: :string }, presence: false 11 | 12 | def serialize 13 | {}.tap do |result| 14 | result[:podFixed] = pod_fixed.serialize 15 | end 16 | end 17 | 18 | def kind_sym 19 | :overhead 20 | end 21 | end 22 | end 23 | end 24 | end 25 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/node/v1alpha1/scheduling.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Node 6 | module V1alpha1 7 | class Scheduling < ::KubeDSL::DSLObject 8 | key_value_field(:node_selector, format: :string) 9 | array_field(:toleration) { KubeDSL::DSL::V1::Toleration.new } 10 | 11 | validates :node_selector, kv: { value_format: :string }, presence: false 12 | validates :tolerations, array: { kind_of: KubeDSL::DSL::V1::Toleration }, presence: false 13 | 14 | def serialize 15 | {}.tap do |result| 16 | result[:nodeSelector] = node_selector.serialize 17 | result[:tolerations] = tolerations.map(&:serialize) 18 | end 19 | end 20 | 21 | def kind_sym 22 | :scheduling 23 | end 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/node/v1beta1.rb: -------------------------------------------------------------------------------- 1 | module KubeDSL::DSL::Node::V1beta1 2 | autoload :Overhead, 'kube-dsl/dsl/node/v1beta1/overhead' 3 | autoload :RuntimeClass, 'kube-dsl/dsl/node/v1beta1/runtime_class' 4 | autoload :RuntimeClassList, 'kube-dsl/dsl/node/v1beta1/runtime_class_list' 5 | autoload :Scheduling, 'kube-dsl/dsl/node/v1beta1/scheduling' 6 | end 7 | -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/node/v1beta1/overhead.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Node 6 | module V1beta1 7 | class Overhead < ::KubeDSL::DSLObject 8 | key_value_field(:pod_fixed, format: :string) 9 | 10 | validates :pod_fixed, kv: { value_format: :string }, presence: false 11 | 12 | def serialize 13 | {}.tap do |result| 14 | result[:podFixed] = pod_fixed.serialize 15 | end 16 | end 17 | 18 | def kind_sym 19 | :overhead 20 | end 21 | end 22 | end 23 | end 24 | end 25 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/node/v1beta1/scheduling.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Node 6 | module V1beta1 7 | class Scheduling < ::KubeDSL::DSLObject 8 | key_value_field(:node_selector, format: :string) 9 | array_field(:toleration) { KubeDSL::DSL::V1::Toleration.new } 10 | 11 | validates :node_selector, kv: { value_format: :string }, presence: false 12 | validates :tolerations, array: { kind_of: KubeDSL::DSL::V1::Toleration }, presence: false 13 | 14 | def serialize 15 | {}.tap do |result| 16 | result[:nodeSelector] = node_selector.serialize 17 | result[:tolerations] = tolerations.map(&:serialize) 18 | end 19 | end 20 | 21 | def kind_sym 22 | :scheduling 23 | end 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/pkg.rb: -------------------------------------------------------------------------------- 1 | module KubeDSL::DSL::Pkg 2 | autoload :Version, 'kube-dsl/dsl/pkg/version' 3 | end 4 | -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/policy.rb: -------------------------------------------------------------------------------- 1 | module KubeDSL::DSL::Policy 2 | autoload :V1, 'kube-dsl/dsl/policy/v1' 3 | autoload :V1beta1, 'kube-dsl/dsl/policy/v1beta1' 4 | end 5 | -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/policy/v1.rb: -------------------------------------------------------------------------------- 1 | module KubeDSL::DSL::Policy::V1 2 | autoload :Eviction, 'kube-dsl/dsl/policy/v1/eviction' 3 | autoload :PodDisruptionBudget, 'kube-dsl/dsl/policy/v1/pod_disruption_budget' 4 | autoload :PodDisruptionBudgetList, 'kube-dsl/dsl/policy/v1/pod_disruption_budget_list' 5 | autoload :PodDisruptionBudgetSpec, 'kube-dsl/dsl/policy/v1/pod_disruption_budget_spec' 6 | autoload :PodDisruptionBudgetStatus, 'kube-dsl/dsl/policy/v1/pod_disruption_budget_status' 7 | end 8 | -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/policy/v1beta1/allowed_csi_driver.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Policy 6 | module V1beta1 7 | class AllowedCSIDriver < ::KubeDSL::DSLObject 8 | value_field :name 9 | 10 | validates :name, field: { format: :string }, presence: false 11 | 12 | def serialize 13 | {}.tap do |result| 14 | result[:name] = name 15 | end 16 | end 17 | 18 | def kind_sym 19 | :allowed_csi_driver 20 | end 21 | end 22 | end 23 | end 24 | end 25 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/policy/v1beta1/allowed_flex_volume.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Policy 6 | module V1beta1 7 | class AllowedFlexVolume < ::KubeDSL::DSLObject 8 | value_field :driver 9 | 10 | validates :driver, field: { format: :string }, presence: false 11 | 12 | def serialize 13 | {}.tap do |result| 14 | result[:driver] = driver 15 | end 16 | end 17 | 18 | def kind_sym 19 | :allowed_flex_volume 20 | end 21 | end 22 | end 23 | end 24 | end 25 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/policy/v1beta1/allowed_host_path.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Policy 6 | module V1beta1 7 | class AllowedHostPath < ::KubeDSL::DSLObject 8 | value_field :path_prefix 9 | value_field :read_only 10 | 11 | validates :path_prefix, field: { format: :string }, presence: false 12 | validates :read_only, field: { format: :boolean }, presence: false 13 | 14 | def serialize 15 | {}.tap do |result| 16 | result[:pathPrefix] = path_prefix 17 | result[:readOnly] = read_only 18 | end 19 | end 20 | 21 | def kind_sym 22 | :allowed_host_path 23 | end 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/policy/v1beta1/fs_group_strategy_options.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Policy 6 | module V1beta1 7 | class FSGroupStrategyOptions < ::KubeDSL::DSLObject 8 | array_field(:range) { KubeDSL::DSL::Policy::V1beta1::IDRange.new } 9 | value_field :rule 10 | 11 | validates :ranges, array: { kind_of: KubeDSL::DSL::Policy::V1beta1::IDRange }, presence: false 12 | validates :rule, field: { format: :string }, presence: false 13 | 14 | def serialize 15 | {}.tap do |result| 16 | result[:ranges] = ranges.map(&:serialize) 17 | result[:rule] = rule 18 | end 19 | end 20 | 21 | def kind_sym 22 | :fs_group_strategy_options 23 | end 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/policy/v1beta1/host_port_range.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Policy 6 | module V1beta1 7 | class HostPortRange < ::KubeDSL::DSLObject 8 | value_field :max 9 | value_field :min 10 | 11 | validates :max, field: { format: :integer }, presence: false 12 | validates :min, field: { format: :integer }, presence: false 13 | 14 | def serialize 15 | {}.tap do |result| 16 | result[:max] = max 17 | result[:min] = min 18 | end 19 | end 20 | 21 | def kind_sym 22 | :host_port_range 23 | end 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/policy/v1beta1/id_range.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Policy 6 | module V1beta1 7 | class IDRange < ::KubeDSL::DSLObject 8 | value_field :max 9 | value_field :min 10 | 11 | validates :max, field: { format: :integer }, presence: false 12 | validates :min, field: { format: :integer }, presence: false 13 | 14 | def serialize 15 | {}.tap do |result| 16 | result[:max] = max 17 | result[:min] = min 18 | end 19 | end 20 | 21 | def kind_sym 22 | :id_range 23 | end 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/policy/v1beta1/run_as_group_strategy_options.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Policy 6 | module V1beta1 7 | class RunAsGroupStrategyOptions < ::KubeDSL::DSLObject 8 | array_field(:range) { KubeDSL::DSL::Policy::V1beta1::IDRange.new } 9 | value_field :rule 10 | 11 | validates :ranges, array: { kind_of: KubeDSL::DSL::Policy::V1beta1::IDRange }, presence: false 12 | validates :rule, field: { format: :string }, presence: false 13 | 14 | def serialize 15 | {}.tap do |result| 16 | result[:ranges] = ranges.map(&:serialize) 17 | result[:rule] = rule 18 | end 19 | end 20 | 21 | def kind_sym 22 | :run_as_group_strategy_options 23 | end 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/policy/v1beta1/run_as_user_strategy_options.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Policy 6 | module V1beta1 7 | class RunAsUserStrategyOptions < ::KubeDSL::DSLObject 8 | array_field(:range) { KubeDSL::DSL::Policy::V1beta1::IDRange.new } 9 | value_field :rule 10 | 11 | validates :ranges, array: { kind_of: KubeDSL::DSL::Policy::V1beta1::IDRange }, presence: false 12 | validates :rule, field: { format: :string }, presence: false 13 | 14 | def serialize 15 | {}.tap do |result| 16 | result[:ranges] = ranges.map(&:serialize) 17 | result[:rule] = rule 18 | end 19 | end 20 | 21 | def kind_sym 22 | :run_as_user_strategy_options 23 | end 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/policy/v1beta1/se_linux_strategy_options.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Policy 6 | module V1beta1 7 | class SELinuxStrategyOptions < ::KubeDSL::DSLObject 8 | value_field :rule 9 | object_field(:se_linux_options) { KubeDSL::DSL::V1::SELinuxOptions.new } 10 | 11 | validates :rule, field: { format: :string }, presence: false 12 | validates :se_linux_options, object: { kind_of: KubeDSL::DSL::V1::SELinuxOptions } 13 | 14 | def serialize 15 | {}.tap do |result| 16 | result[:rule] = rule 17 | result[:seLinuxOptions] = se_linux_options.serialize 18 | end 19 | end 20 | 21 | def kind_sym 22 | :se_linux_strategy_options 23 | end 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/policy/v1beta1/supplemental_groups_strategy_options.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Policy 6 | module V1beta1 7 | class SupplementalGroupsStrategyOptions < ::KubeDSL::DSLObject 8 | array_field(:range) { KubeDSL::DSL::Policy::V1beta1::IDRange.new } 9 | value_field :rule 10 | 11 | validates :ranges, array: { kind_of: KubeDSL::DSL::Policy::V1beta1::IDRange }, presence: false 12 | validates :rule, field: { format: :string }, presence: false 13 | 14 | def serialize 15 | {}.tap do |result| 16 | result[:ranges] = ranges.map(&:serialize) 17 | result[:rule] = rule 18 | end 19 | end 20 | 21 | def kind_sym 22 | :supplemental_groups_strategy_options 23 | end 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/rbac.rb: -------------------------------------------------------------------------------- 1 | module KubeDSL::DSL::Rbac 2 | autoload :V1, 'kube-dsl/dsl/rbac/v1' 3 | end 4 | -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/rbac/v1.rb: -------------------------------------------------------------------------------- 1 | module KubeDSL::DSL::Rbac::V1 2 | autoload :AggregationRule, 'kube-dsl/dsl/rbac/v1/aggregation_rule' 3 | autoload :ClusterRole, 'kube-dsl/dsl/rbac/v1/cluster_role' 4 | autoload :ClusterRoleBinding, 'kube-dsl/dsl/rbac/v1/cluster_role_binding' 5 | autoload :ClusterRoleBindingList, 'kube-dsl/dsl/rbac/v1/cluster_role_binding_list' 6 | autoload :ClusterRoleList, 'kube-dsl/dsl/rbac/v1/cluster_role_list' 7 | autoload :PolicyRule, 'kube-dsl/dsl/rbac/v1/policy_rule' 8 | autoload :Role, 'kube-dsl/dsl/rbac/v1/role' 9 | autoload :RoleBinding, 'kube-dsl/dsl/rbac/v1/role_binding' 10 | autoload :RoleBindingList, 'kube-dsl/dsl/rbac/v1/role_binding_list' 11 | autoload :RoleList, 'kube-dsl/dsl/rbac/v1/role_list' 12 | autoload :RoleRef, 'kube-dsl/dsl/rbac/v1/role_ref' 13 | autoload :Subject, 'kube-dsl/dsl/rbac/v1/subject' 14 | end 15 | -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/rbac/v1/aggregation_rule.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Rbac 6 | module V1 7 | class AggregationRule < ::KubeDSL::DSLObject 8 | array_field(:cluster_role_selector) { KubeDSL::DSL::Meta::V1::LabelSelector.new } 9 | 10 | validates :cluster_role_selectors, array: { kind_of: KubeDSL::DSL::Meta::V1::LabelSelector }, presence: false 11 | 12 | def serialize 13 | {}.tap do |result| 14 | result[:clusterRoleSelectors] = cluster_role_selectors.map(&:serialize) 15 | end 16 | end 17 | 18 | def kind_sym 19 | :aggregation_rule 20 | end 21 | end 22 | end 23 | end 24 | end 25 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/rbac/v1/role_ref.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Rbac 6 | module V1 7 | class RoleRef < ::KubeDSL::DSLObject 8 | value_field :api_group 9 | value_field :kind 10 | value_field :name 11 | 12 | validates :api_group, field: { format: :string }, presence: false 13 | validates :kind, field: { format: :string }, presence: false 14 | validates :name, field: { format: :string }, presence: false 15 | 16 | def serialize 17 | {}.tap do |result| 18 | result[:apiGroup] = api_group 19 | result[:kind] = kind 20 | result[:name] = name 21 | end 22 | end 23 | 24 | def kind_sym 25 | :role_ref 26 | end 27 | end 28 | end 29 | end 30 | end 31 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/scheduling.rb: -------------------------------------------------------------------------------- 1 | module KubeDSL::DSL::Scheduling 2 | autoload :V1, 'kube-dsl/dsl/scheduling/v1' 3 | end 4 | -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/scheduling/v1.rb: -------------------------------------------------------------------------------- 1 | module KubeDSL::DSL::Scheduling::V1 2 | autoload :PriorityClass, 'kube-dsl/dsl/scheduling/v1/priority_class' 3 | autoload :PriorityClassList, 'kube-dsl/dsl/scheduling/v1/priority_class_list' 4 | end 5 | -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/storage.rb: -------------------------------------------------------------------------------- 1 | module KubeDSL::DSL::Storage 2 | autoload :V1, 'kube-dsl/dsl/storage/v1' 3 | autoload :V1alpha1, 'kube-dsl/dsl/storage/v1alpha1' 4 | autoload :V1beta1, 'kube-dsl/dsl/storage/v1beta1' 5 | end 6 | -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/storage/v1/csi_node_spec.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Storage 6 | module V1 7 | class CSINodeSpec < ::KubeDSL::DSLObject 8 | array_field(:driver) { KubeDSL::DSL::Storage::V1::CSINodeDriver.new } 9 | 10 | validates :drivers, array: { kind_of: KubeDSL::DSL::Storage::V1::CSINodeDriver }, presence: false 11 | 12 | def serialize 13 | {}.tap do |result| 14 | result[:drivers] = drivers.map(&:serialize) 15 | end 16 | end 17 | 18 | def kind_sym 19 | :csi_node_spec 20 | end 21 | end 22 | end 23 | end 24 | end 25 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/storage/v1/token_request.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Storage 6 | module V1 7 | class TokenRequest < ::KubeDSL::DSLObject 8 | value_field :audience 9 | value_field :expiration_seconds 10 | 11 | validates :audience, field: { format: :string }, presence: false 12 | validates :expiration_seconds, field: { format: :integer }, presence: false 13 | 14 | def serialize 15 | {}.tap do |result| 16 | result[:audience] = audience 17 | result[:expirationSeconds] = expiration_seconds 18 | end 19 | end 20 | 21 | def kind_sym 22 | :token_request 23 | end 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/storage/v1/volume_error.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Storage 6 | module V1 7 | class VolumeError < ::KubeDSL::DSLObject 8 | value_field :message 9 | value_field :time 10 | 11 | validates :message, field: { format: :string }, presence: false 12 | validates :time, field: { format: :string }, presence: false 13 | 14 | def serialize 15 | {}.tap do |result| 16 | result[:message] = message 17 | result[:time] = time 18 | end 19 | end 20 | 21 | def kind_sym 22 | :volume_error 23 | end 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/storage/v1/volume_node_resources.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module Storage 6 | module V1 7 | class VolumeNodeResources < ::KubeDSL::DSLObject 8 | value_field :count 9 | 10 | validates :count, field: { format: :integer }, presence: false 11 | 12 | def serialize 13 | {}.tap do |result| 14 | result[:count] = count 15 | end 16 | end 17 | 18 | def kind_sym 19 | :volume_node_resources 20 | end 21 | end 22 | end 23 | end 24 | end 25 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/storage/v1alpha1.rb: -------------------------------------------------------------------------------- 1 | module KubeDSL::DSL::Storage::V1alpha1 2 | autoload :CSIStorageCapacity, 'kube-dsl/dsl/storage/v1alpha1/csi_storage_capacity' 3 | autoload :CSIStorageCapacityList, 'kube-dsl/dsl/storage/v1alpha1/csi_storage_capacity_list' 4 | end 5 | -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/storage/v1beta1.rb: -------------------------------------------------------------------------------- 1 | module KubeDSL::DSL::Storage::V1beta1 2 | autoload :CSIStorageCapacity, 'kube-dsl/dsl/storage/v1beta1/csi_storage_capacity' 3 | autoload :CSIStorageCapacityList, 'kube-dsl/dsl/storage/v1beta1/csi_storage_capacity_list' 4 | end 5 | -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/attached_volume.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class AttachedVolume < ::KubeDSL::DSLObject 7 | value_field :device_path 8 | value_field :name 9 | 10 | validates :device_path, field: { format: :string }, presence: false 11 | validates :name, field: { format: :string }, presence: false 12 | 13 | def serialize 14 | {}.tap do |result| 15 | result[:devicePath] = device_path 16 | result[:name] = name 17 | end 18 | end 19 | 20 | def kind_sym 21 | :attached_volume 22 | end 23 | end 24 | end 25 | end 26 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/azure_file_volume_source.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class AzureFileVolumeSource < ::KubeDSL::DSLObject 7 | value_field :read_only 8 | value_field :secret_name 9 | value_field :share_name 10 | 11 | validates :read_only, field: { format: :boolean }, presence: false 12 | validates :secret_name, field: { format: :string }, presence: false 13 | validates :share_name, field: { format: :string }, presence: false 14 | 15 | def serialize 16 | {}.tap do |result| 17 | result[:readOnly] = read_only 18 | result[:secretName] = secret_name 19 | result[:shareName] = share_name 20 | end 21 | end 22 | 23 | def kind_sym 24 | :azure_file_volume_source 25 | end 26 | end 27 | end 28 | end 29 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/binding.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class Binding < ::KubeDSL::DSLObject 7 | object_field(:metadata) { KubeDSL::DSL::Meta::V1::ObjectMeta.new } 8 | object_field(:target) { KubeDSL::DSL::V1::ObjectReference.new } 9 | 10 | validates :metadata, object: { kind_of: KubeDSL::DSL::Meta::V1::ObjectMeta } 11 | validates :target, object: { kind_of: KubeDSL::DSL::V1::ObjectReference } 12 | 13 | def serialize 14 | {}.tap do |result| 15 | result[:apiVersion] = "v1" 16 | result[:kind] = "Binding" 17 | result[:metadata] = metadata.serialize 18 | result[:target] = target.serialize 19 | end 20 | end 21 | 22 | def kind_sym 23 | :binding 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/capabilities.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class Capabilities < ::KubeDSL::DSLObject 7 | value_field :add 8 | value_field :drop 9 | 10 | validates :add, field: { format: :string }, presence: false 11 | validates :drop, field: { format: :string }, presence: false 12 | 13 | def serialize 14 | {}.tap do |result| 15 | result[:add] = add 16 | result[:drop] = drop 17 | end 18 | end 19 | 20 | def kind_sym 21 | :capabilities 22 | end 23 | end 24 | end 25 | end 26 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/client_ip_config.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class ClientIPConfig < ::KubeDSL::DSLObject 7 | value_field :timeout_seconds 8 | 9 | validates :timeout_seconds, field: { format: :integer }, presence: false 10 | 11 | def serialize 12 | {}.tap do |result| 13 | result[:timeoutSeconds] = timeout_seconds 14 | end 15 | end 16 | 17 | def kind_sym 18 | :client_ip_config 19 | end 20 | end 21 | end 22 | end 23 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/component_status.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class ComponentStatus < ::KubeDSL::DSLObject 7 | array_field(:condition) { KubeDSL::DSL::V1::ComponentCondition.new } 8 | object_field(:metadata) { KubeDSL::DSL::Meta::V1::ObjectMeta.new } 9 | 10 | validates :conditions, array: { kind_of: KubeDSL::DSL::V1::ComponentCondition }, presence: false 11 | validates :metadata, object: { kind_of: KubeDSL::DSL::Meta::V1::ObjectMeta } 12 | 13 | def serialize 14 | {}.tap do |result| 15 | result[:apiVersion] = "v1" 16 | result[:conditions] = conditions.map(&:serialize) 17 | result[:kind] = "ComponentStatus" 18 | result[:metadata] = metadata.serialize 19 | end 20 | end 21 | 22 | def kind_sym 23 | :component_status 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/component_status_list.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class ComponentStatusList < ::KubeDSL::DSLObject 7 | array_field(:item) { KubeDSL::DSL::V1::ComponentStatus.new } 8 | object_field(:metadata) { KubeDSL::DSL::Meta::V1::ListMeta.new } 9 | 10 | validates :items, array: { kind_of: KubeDSL::DSL::V1::ComponentStatus }, presence: false 11 | validates :metadata, object: { kind_of: KubeDSL::DSL::Meta::V1::ListMeta } 12 | 13 | def serialize 14 | {}.tap do |result| 15 | result[:apiVersion] = "v1" 16 | result[:items] = items.map(&:serialize) 17 | result[:kind] = "ComponentStatusList" 18 | result[:metadata] = metadata.serialize 19 | end 20 | end 21 | 22 | def kind_sym 23 | :component_status_list 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/config_map_env_source.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class ConfigMapEnvSource < ::KubeDSL::DSLObject 7 | value_field :name 8 | value_field :optional 9 | 10 | validates :name, field: { format: :string }, presence: false 11 | validates :optional, field: { format: :boolean }, presence: false 12 | 13 | def serialize 14 | {}.tap do |result| 15 | result[:name] = name 16 | result[:optional] = optional 17 | end 18 | end 19 | 20 | def kind_sym 21 | :config_map_env_source 22 | end 23 | end 24 | end 25 | end 26 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/config_map_key_selector.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class ConfigMapKeySelector < ::KubeDSL::DSLObject 7 | value_field :key 8 | value_field :name 9 | value_field :optional 10 | 11 | validates :key, field: { format: :string }, presence: false 12 | validates :name, field: { format: :string }, presence: false 13 | validates :optional, field: { format: :boolean }, presence: false 14 | 15 | def serialize 16 | {}.tap do |result| 17 | result[:key] = key 18 | result[:name] = name 19 | result[:optional] = optional 20 | end 21 | end 22 | 23 | def kind_sym 24 | :config_map_key_selector 25 | end 26 | end 27 | end 28 | end 29 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/config_map_list.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class ConfigMapList < ::KubeDSL::DSLObject 7 | array_field(:item) { KubeDSL::DSL::V1::ConfigMap.new } 8 | object_field(:metadata) { KubeDSL::DSL::Meta::V1::ListMeta.new } 9 | 10 | validates :items, array: { kind_of: KubeDSL::DSL::V1::ConfigMap }, presence: false 11 | validates :metadata, object: { kind_of: KubeDSL::DSL::Meta::V1::ListMeta } 12 | 13 | def serialize 14 | {}.tap do |result| 15 | result[:apiVersion] = "v1" 16 | result[:items] = items.map(&:serialize) 17 | result[:kind] = "ConfigMapList" 18 | result[:metadata] = metadata.serialize 19 | end 20 | end 21 | 22 | def kind_sym 23 | :config_map_list 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/config_map_projection.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class ConfigMapProjection < ::KubeDSL::DSLObject 7 | array_field(:item) { KubeDSL::DSL::V1::KeyToPath.new } 8 | value_field :name 9 | value_field :optional 10 | 11 | validates :items, array: { kind_of: KubeDSL::DSL::V1::KeyToPath }, presence: false 12 | validates :name, field: { format: :string }, presence: false 13 | validates :optional, field: { format: :boolean }, presence: false 14 | 15 | def serialize 16 | {}.tap do |result| 17 | result[:items] = items.map(&:serialize) 18 | result[:name] = name 19 | result[:optional] = optional 20 | end 21 | end 22 | 23 | def kind_sym 24 | :config_map_projection 25 | end 26 | end 27 | end 28 | end 29 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/container_image.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class ContainerImage < ::KubeDSL::DSLObject 7 | value_field :names 8 | value_field :size_bytes 9 | 10 | validates :names, field: { format: :string }, presence: false 11 | validates :size_bytes, field: { format: :integer }, presence: false 12 | 13 | def serialize 14 | {}.tap do |result| 15 | result[:names] = names 16 | result[:sizeBytes] = size_bytes 17 | end 18 | end 19 | 20 | def kind_sym 21 | :container_image 22 | end 23 | end 24 | end 25 | end 26 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/container_state_running.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class ContainerStateRunning < ::KubeDSL::DSLObject 7 | value_field :started_at 8 | 9 | validates :started_at, field: { format: :string }, presence: false 10 | 11 | def serialize 12 | {}.tap do |result| 13 | result[:startedAt] = started_at 14 | end 15 | end 16 | 17 | def kind_sym 18 | :container_state_running 19 | end 20 | end 21 | end 22 | end 23 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/container_state_waiting.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class ContainerStateWaiting < ::KubeDSL::DSLObject 7 | value_field :message 8 | value_field :reason 9 | 10 | validates :message, field: { format: :string }, presence: false 11 | validates :reason, field: { format: :string }, presence: false 12 | 13 | def serialize 14 | {}.tap do |result| 15 | result[:message] = message 16 | result[:reason] = reason 17 | end 18 | end 19 | 20 | def kind_sym 21 | :container_state_waiting 22 | end 23 | end 24 | end 25 | end 26 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/daemon_endpoint.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class DaemonEndpoint < ::KubeDSL::DSLObject 7 | value_field :port 8 | 9 | validates :port, field: { format: :integer }, presence: false 10 | 11 | def serialize 12 | {}.tap do |result| 13 | result[:Port] = port 14 | end 15 | end 16 | 17 | def kind_sym 18 | :daemon_endpoint 19 | end 20 | end 21 | end 22 | end 23 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/downward_api_projection.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class DownwardAPIProjection < ::KubeDSL::DSLObject 7 | array_field(:item) { KubeDSL::DSL::V1::DownwardAPIVolumeFile.new } 8 | 9 | validates :items, array: { kind_of: KubeDSL::DSL::V1::DownwardAPIVolumeFile }, presence: false 10 | 11 | def serialize 12 | {}.tap do |result| 13 | result[:items] = items.map(&:serialize) 14 | end 15 | end 16 | 17 | def kind_sym 18 | :downward_api_projection 19 | end 20 | end 21 | end 22 | end 23 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/downward_api_volume_source.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class DownwardAPIVolumeSource < ::KubeDSL::DSLObject 7 | value_field :default_mode 8 | array_field(:item) { KubeDSL::DSL::V1::DownwardAPIVolumeFile.new } 9 | 10 | validates :default_mode, field: { format: :integer }, presence: false 11 | validates :items, array: { kind_of: KubeDSL::DSL::V1::DownwardAPIVolumeFile }, presence: false 12 | 13 | def serialize 14 | {}.tap do |result| 15 | result[:defaultMode] = default_mode 16 | result[:items] = items.map(&:serialize) 17 | end 18 | end 19 | 20 | def kind_sym 21 | :downward_api_volume_source 22 | end 23 | end 24 | end 25 | end 26 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/empty_dir_volume_source.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class EmptyDirVolumeSource < ::KubeDSL::DSLObject 7 | value_field :medium 8 | value_field :size_limit 9 | 10 | validates :medium, field: { format: :string }, presence: false 11 | validates :size_limit, field: { format: :string }, presence: false 12 | 13 | def serialize 14 | {}.tap do |result| 15 | result[:medium] = medium 16 | result[:sizeLimit] = size_limit 17 | end 18 | end 19 | 20 | def kind_sym 21 | :empty_dir_volume_source 22 | end 23 | end 24 | end 25 | end 26 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/endpoints.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class Endpoints < ::KubeDSL::DSLObject 7 | object_field(:metadata) { KubeDSL::DSL::Meta::V1::ObjectMeta.new } 8 | array_field(:subset) { KubeDSL::DSL::V1::EndpointSubset.new } 9 | 10 | validates :metadata, object: { kind_of: KubeDSL::DSL::Meta::V1::ObjectMeta } 11 | validates :subsets, array: { kind_of: KubeDSL::DSL::V1::EndpointSubset }, presence: false 12 | 13 | def serialize 14 | {}.tap do |result| 15 | result[:apiVersion] = "v1" 16 | result[:kind] = "Endpoints" 17 | result[:metadata] = metadata.serialize 18 | result[:subsets] = subsets.map(&:serialize) 19 | end 20 | end 21 | 22 | def kind_sym 23 | :endpoints 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/endpoints_list.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class EndpointsList < ::KubeDSL::DSLObject 7 | array_field(:item) { KubeDSL::DSL::V1::Endpoints.new } 8 | object_field(:metadata) { KubeDSL::DSL::Meta::V1::ListMeta.new } 9 | 10 | validates :items, array: { kind_of: KubeDSL::DSL::V1::Endpoints }, presence: false 11 | validates :metadata, object: { kind_of: KubeDSL::DSL::Meta::V1::ListMeta } 12 | 13 | def serialize 14 | {}.tap do |result| 15 | result[:apiVersion] = "v1" 16 | result[:items] = items.map(&:serialize) 17 | result[:kind] = "EndpointsList" 18 | result[:metadata] = metadata.serialize 19 | end 20 | end 21 | 22 | def kind_sym 23 | :endpoints_list 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/env_var.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class EnvVar < ::KubeDSL::DSLObject 7 | value_field :name 8 | value_field :value 9 | object_field(:value_from) { KubeDSL::DSL::V1::EnvVarSource.new } 10 | 11 | validates :name, field: { format: :string }, presence: false 12 | validates :value, field: { format: :string }, presence: false 13 | validates :value_from, object: { kind_of: KubeDSL::DSL::V1::EnvVarSource } 14 | 15 | def serialize 16 | {}.tap do |result| 17 | result[:name] = name 18 | result[:value] = value 19 | result[:valueFrom] = value_from.serialize 20 | end 21 | end 22 | 23 | def kind_sym 24 | :env_var 25 | end 26 | end 27 | end 28 | end 29 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/ephemeral_volume_source.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class EphemeralVolumeSource < ::KubeDSL::DSLObject 7 | object_field(:volume_claim_template) { KubeDSL::DSL::V1::PersistentVolumeClaimTemplate.new } 8 | 9 | validates :volume_claim_template, object: { kind_of: KubeDSL::DSL::V1::PersistentVolumeClaimTemplate } 10 | 11 | def serialize 12 | {}.tap do |result| 13 | result[:volumeClaimTemplate] = volume_claim_template.serialize 14 | end 15 | end 16 | 17 | def kind_sym 18 | :ephemeral_volume_source 19 | end 20 | end 21 | end 22 | end 23 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/event_list.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class EventList < ::KubeDSL::DSLObject 7 | array_field(:item) { KubeDSL::DSL::V1::Event.new } 8 | object_field(:metadata) { KubeDSL::DSL::Meta::V1::ListMeta.new } 9 | 10 | validates :items, array: { kind_of: KubeDSL::DSL::V1::Event }, presence: false 11 | validates :metadata, object: { kind_of: KubeDSL::DSL::Meta::V1::ListMeta } 12 | 13 | def serialize 14 | {}.tap do |result| 15 | result[:apiVersion] = "v1" 16 | result[:items] = items.map(&:serialize) 17 | result[:kind] = "EventList" 18 | result[:metadata] = metadata.serialize 19 | end 20 | end 21 | 22 | def kind_sym 23 | :event_list 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/event_series.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class EventSeries < ::KubeDSL::DSLObject 7 | value_field :count 8 | value_field :last_observed_time 9 | 10 | validates :count, field: { format: :integer }, presence: false 11 | validates :last_observed_time, field: { format: :string }, presence: false 12 | 13 | def serialize 14 | {}.tap do |result| 15 | result[:count] = count 16 | result[:lastObservedTime] = last_observed_time 17 | end 18 | end 19 | 20 | def kind_sym 21 | :event_series 22 | end 23 | end 24 | end 25 | end 26 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/event_source.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class EventSource < ::KubeDSL::DSLObject 7 | value_field :component 8 | value_field :host 9 | 10 | validates :component, field: { format: :string }, presence: false 11 | validates :host, field: { format: :string }, presence: false 12 | 13 | def serialize 14 | {}.tap do |result| 15 | result[:component] = component 16 | result[:host] = host 17 | end 18 | end 19 | 20 | def kind_sym 21 | :event_source 22 | end 23 | end 24 | end 25 | end 26 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/exec_action.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class ExecAction < ::KubeDSL::DSLObject 7 | value_field :command 8 | 9 | validates :command, field: { format: :string }, presence: false 10 | 11 | def serialize 12 | {}.tap do |result| 13 | result[:command] = command 14 | end 15 | end 16 | 17 | def kind_sym 18 | :exec_action 19 | end 20 | end 21 | end 22 | end 23 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/flocker_volume_source.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class FlockerVolumeSource < ::KubeDSL::DSLObject 7 | value_field :dataset_name 8 | value_field :dataset_uuid 9 | 10 | validates :dataset_name, field: { format: :string }, presence: false 11 | validates :dataset_uuid, field: { format: :string }, presence: false 12 | 13 | def serialize 14 | {}.tap do |result| 15 | result[:datasetName] = dataset_name 16 | result[:datasetUUID] = dataset_uuid 17 | end 18 | end 19 | 20 | def kind_sym 21 | :flocker_volume_source 22 | end 23 | end 24 | end 25 | end 26 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/git_repo_volume_source.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class GitRepoVolumeSource < ::KubeDSL::DSLObject 7 | value_field :directory 8 | value_field :repository 9 | value_field :revision 10 | 11 | validates :directory, field: { format: :string }, presence: false 12 | validates :repository, field: { format: :string }, presence: false 13 | validates :revision, field: { format: :string }, presence: false 14 | 15 | def serialize 16 | {}.tap do |result| 17 | result[:directory] = directory 18 | result[:repository] = repository 19 | result[:revision] = revision 20 | end 21 | end 22 | 23 | def kind_sym 24 | :git_repo_volume_source 25 | end 26 | end 27 | end 28 | end 29 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/glusterfs_volume_source.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class GlusterfsVolumeSource < ::KubeDSL::DSLObject 7 | value_field :endpoints 8 | value_field :path 9 | value_field :read_only 10 | 11 | validates :endpoints, field: { format: :string }, presence: false 12 | validates :path, field: { format: :string }, presence: false 13 | validates :read_only, field: { format: :boolean }, presence: false 14 | 15 | def serialize 16 | {}.tap do |result| 17 | result[:endpoints] = endpoints 18 | result[:path] = path 19 | result[:readOnly] = read_only 20 | end 21 | end 22 | 23 | def kind_sym 24 | :glusterfs_volume_source 25 | end 26 | end 27 | end 28 | end 29 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/grpc_action.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class GRPCAction < ::KubeDSL::DSLObject 7 | value_field :port 8 | value_field :service 9 | 10 | validates :port, field: { format: :integer }, presence: false 11 | validates :service, field: { format: :string }, presence: false 12 | 13 | def serialize 14 | {}.tap do |result| 15 | result[:port] = port 16 | result[:service] = service 17 | end 18 | end 19 | 20 | def kind_sym 21 | :grpc_action 22 | end 23 | end 24 | end 25 | end 26 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/host_alias.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class HostAlias < ::KubeDSL::DSLObject 7 | value_field :hostnames 8 | value_field :ip 9 | 10 | validates :hostnames, field: { format: :string }, presence: false 11 | validates :ip, field: { format: :string }, presence: false 12 | 13 | def serialize 14 | {}.tap do |result| 15 | result[:hostnames] = hostnames 16 | result[:ip] = ip 17 | end 18 | end 19 | 20 | def kind_sym 21 | :host_alias 22 | end 23 | end 24 | end 25 | end 26 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/host_path_volume_source.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class HostPathVolumeSource < ::KubeDSL::DSLObject 7 | value_field :path 8 | value_field :type 9 | 10 | validates :path, field: { format: :string }, presence: false 11 | validates :type, field: { format: :string }, presence: false 12 | 13 | def serialize 14 | {}.tap do |result| 15 | result[:path] = path 16 | result[:type] = type 17 | end 18 | end 19 | 20 | def kind_sym 21 | :host_path_volume_source 22 | end 23 | end 24 | end 25 | end 26 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/http_header.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class HTTPHeader < ::KubeDSL::DSLObject 7 | value_field :name 8 | value_field :value 9 | 10 | validates :name, field: { format: :string }, presence: false 11 | validates :value, field: { format: :string }, presence: false 12 | 13 | def serialize 14 | {}.tap do |result| 15 | result[:name] = name 16 | result[:value] = value 17 | end 18 | end 19 | 20 | def kind_sym 21 | :http_header 22 | end 23 | end 24 | end 25 | end 26 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/key_to_path.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class KeyToPath < ::KubeDSL::DSLObject 7 | value_field :key 8 | value_field :mode 9 | value_field :path 10 | 11 | validates :key, field: { format: :string }, presence: false 12 | validates :mode, field: { format: :integer }, presence: false 13 | validates :path, field: { format: :string }, presence: false 14 | 15 | def serialize 16 | {}.tap do |result| 17 | result[:key] = key 18 | result[:mode] = mode 19 | result[:path] = path 20 | end 21 | end 22 | 23 | def kind_sym 24 | :key_to_path 25 | end 26 | end 27 | end 28 | end 29 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/lifecycle.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class Lifecycle < ::KubeDSL::DSLObject 7 | object_field(:post_start) { KubeDSL::DSL::V1::LifecycleHandler.new } 8 | object_field(:pre_stop) { KubeDSL::DSL::V1::LifecycleHandler.new } 9 | 10 | validates :post_start, object: { kind_of: KubeDSL::DSL::V1::LifecycleHandler } 11 | validates :pre_stop, object: { kind_of: KubeDSL::DSL::V1::LifecycleHandler } 12 | 13 | def serialize 14 | {}.tap do |result| 15 | result[:postStart] = post_start.serialize 16 | result[:preStop] = pre_stop.serialize 17 | end 18 | end 19 | 20 | def kind_sym 21 | :lifecycle 22 | end 23 | end 24 | end 25 | end 26 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/limit_range.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class LimitRange < ::KubeDSL::DSLObject 7 | object_field(:metadata) { KubeDSL::DSL::Meta::V1::ObjectMeta.new } 8 | object_field(:spec) { KubeDSL::DSL::V1::LimitRangeSpec.new } 9 | 10 | validates :metadata, object: { kind_of: KubeDSL::DSL::Meta::V1::ObjectMeta } 11 | validates :spec, object: { kind_of: KubeDSL::DSL::V1::LimitRangeSpec } 12 | 13 | def serialize 14 | {}.tap do |result| 15 | result[:apiVersion] = "v1" 16 | result[:kind] = "LimitRange" 17 | result[:metadata] = metadata.serialize 18 | result[:spec] = spec.serialize 19 | end 20 | end 21 | 22 | def kind_sym 23 | :limit_range 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/limit_range_list.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class LimitRangeList < ::KubeDSL::DSLObject 7 | array_field(:item) { KubeDSL::DSL::V1::LimitRange.new } 8 | object_field(:metadata) { KubeDSL::DSL::Meta::V1::ListMeta.new } 9 | 10 | validates :items, array: { kind_of: KubeDSL::DSL::V1::LimitRange }, presence: false 11 | validates :metadata, object: { kind_of: KubeDSL::DSL::Meta::V1::ListMeta } 12 | 13 | def serialize 14 | {}.tap do |result| 15 | result[:apiVersion] = "v1" 16 | result[:items] = items.map(&:serialize) 17 | result[:kind] = "LimitRangeList" 18 | result[:metadata] = metadata.serialize 19 | end 20 | end 21 | 22 | def kind_sym 23 | :limit_range_list 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/limit_range_spec.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class LimitRangeSpec < ::KubeDSL::DSLObject 7 | array_field(:limit) { KubeDSL::DSL::V1::LimitRangeItem.new } 8 | 9 | validates :limits, array: { kind_of: KubeDSL::DSL::V1::LimitRangeItem }, presence: false 10 | 11 | def serialize 12 | {}.tap do |result| 13 | result[:limits] = limits.map(&:serialize) 14 | end 15 | end 16 | 17 | def kind_sym 18 | :limit_range_spec 19 | end 20 | end 21 | end 22 | end 23 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/load_balancer_ingress.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class LoadBalancerIngress < ::KubeDSL::DSLObject 7 | value_field :hostname 8 | value_field :ip 9 | array_field(:port) { KubeDSL::DSL::V1::PortStatus.new } 10 | 11 | validates :hostname, field: { format: :string }, presence: false 12 | validates :ip, field: { format: :string }, presence: false 13 | validates :ports, array: { kind_of: KubeDSL::DSL::V1::PortStatus }, presence: false 14 | 15 | def serialize 16 | {}.tap do |result| 17 | result[:hostname] = hostname 18 | result[:ip] = ip 19 | result[:ports] = ports.map(&:serialize) 20 | end 21 | end 22 | 23 | def kind_sym 24 | :load_balancer_ingress 25 | end 26 | end 27 | end 28 | end 29 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/load_balancer_status.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class LoadBalancerStatus < ::KubeDSL::DSLObject 7 | array_field(:ingress) { KubeDSL::DSL::V1::LoadBalancerIngress.new } 8 | 9 | validates :ingresses, array: { kind_of: KubeDSL::DSL::V1::LoadBalancerIngress }, presence: false 10 | 11 | def serialize 12 | {}.tap do |result| 13 | result[:ingress] = ingresses.map(&:serialize) 14 | end 15 | end 16 | 17 | def kind_sym 18 | :load_balancer_status 19 | end 20 | end 21 | end 22 | end 23 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/local_object_reference.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class LocalObjectReference < ::KubeDSL::DSLObject 7 | value_field :name 8 | 9 | validates :name, field: { format: :string }, presence: false 10 | 11 | def serialize 12 | {}.tap do |result| 13 | result[:name] = name 14 | end 15 | end 16 | 17 | def kind_sym 18 | :local_object_reference 19 | end 20 | end 21 | end 22 | end 23 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/local_volume_source.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class LocalVolumeSource < ::KubeDSL::DSLObject 7 | value_field :fs_type 8 | value_field :path 9 | 10 | validates :fs_type, field: { format: :string }, presence: false 11 | validates :path, field: { format: :string }, presence: false 12 | 13 | def serialize 14 | {}.tap do |result| 15 | result[:fsType] = fs_type 16 | result[:path] = path 17 | end 18 | end 19 | 20 | def kind_sym 21 | :local_volume_source 22 | end 23 | end 24 | end 25 | end 26 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/namespace_list.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class NamespaceList < ::KubeDSL::DSLObject 7 | array_field(:item) { KubeDSL::DSL::V1::Namespace.new } 8 | object_field(:metadata) { KubeDSL::DSL::Meta::V1::ListMeta.new } 9 | 10 | validates :items, array: { kind_of: KubeDSL::DSL::V1::Namespace }, presence: false 11 | validates :metadata, object: { kind_of: KubeDSL::DSL::Meta::V1::ListMeta } 12 | 13 | def serialize 14 | {}.tap do |result| 15 | result[:apiVersion] = "v1" 16 | result[:items] = items.map(&:serialize) 17 | result[:kind] = "NamespaceList" 18 | result[:metadata] = metadata.serialize 19 | end 20 | end 21 | 22 | def kind_sym 23 | :namespace_list 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/namespace_spec.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class NamespaceSpec < ::KubeDSL::DSLObject 7 | value_field :finalizers 8 | 9 | validates :finalizers, field: { format: :string }, presence: false 10 | 11 | def serialize 12 | {}.tap do |result| 13 | result[:finalizers] = finalizers 14 | end 15 | end 16 | 17 | def kind_sym 18 | :namespace_spec 19 | end 20 | end 21 | end 22 | end 23 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/namespace_status.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class NamespaceStatus < ::KubeDSL::DSLObject 7 | array_field(:condition) { KubeDSL::DSL::V1::NamespaceCondition.new } 8 | value_field :phase 9 | 10 | validates :conditions, array: { kind_of: KubeDSL::DSL::V1::NamespaceCondition }, presence: false 11 | validates :phase, field: { format: :string }, presence: false 12 | 13 | def serialize 14 | {}.tap do |result| 15 | result[:conditions] = conditions.map(&:serialize) 16 | result[:phase] = phase 17 | end 18 | end 19 | 20 | def kind_sym 21 | :namespace_status 22 | end 23 | end 24 | end 25 | end 26 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/nfs_volume_source.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class NFSVolumeSource < ::KubeDSL::DSLObject 7 | value_field :path 8 | value_field :read_only 9 | value_field :server 10 | 11 | validates :path, field: { format: :string }, presence: false 12 | validates :read_only, field: { format: :boolean }, presence: false 13 | validates :server, field: { format: :string }, presence: false 14 | 15 | def serialize 16 | {}.tap do |result| 17 | result[:path] = path 18 | result[:readOnly] = read_only 19 | result[:server] = server 20 | end 21 | end 22 | 23 | def kind_sym 24 | :nfs_volume_source 25 | end 26 | end 27 | end 28 | end 29 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/node_address.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class NodeAddress < ::KubeDSL::DSLObject 7 | value_field :address 8 | value_field :type 9 | 10 | validates :address, field: { format: :string }, presence: false 11 | validates :type, field: { format: :string }, presence: false 12 | 13 | def serialize 14 | {}.tap do |result| 15 | result[:address] = address 16 | result[:type] = type 17 | end 18 | end 19 | 20 | def kind_sym 21 | :node_address 22 | end 23 | end 24 | end 25 | end 26 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/node_config_source.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class NodeConfigSource < ::KubeDSL::DSLObject 7 | object_field(:config_map) { KubeDSL::DSL::V1::ConfigMapNodeConfigSource.new } 8 | 9 | validates :config_map, object: { kind_of: KubeDSL::DSL::V1::ConfigMapNodeConfigSource } 10 | 11 | def serialize 12 | {}.tap do |result| 13 | result[:configMap] = config_map.serialize 14 | end 15 | end 16 | 17 | def kind_sym 18 | :node_config_source 19 | end 20 | end 21 | end 22 | end 23 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/node_daemon_endpoints.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class NodeDaemonEndpoints < ::KubeDSL::DSLObject 7 | object_field(:kubelet_endpoint) { KubeDSL::DSL::V1::DaemonEndpoint.new } 8 | 9 | validates :kubelet_endpoint, object: { kind_of: KubeDSL::DSL::V1::DaemonEndpoint } 10 | 11 | def serialize 12 | {}.tap do |result| 13 | result[:kubeletEndpoint] = kubelet_endpoint.serialize 14 | end 15 | end 16 | 17 | def kind_sym 18 | :node_daemon_endpoints 19 | end 20 | end 21 | end 22 | end 23 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/node_list.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class NodeList < ::KubeDSL::DSLObject 7 | array_field(:item) { KubeDSL::DSL::V1::Node.new } 8 | object_field(:metadata) { KubeDSL::DSL::Meta::V1::ListMeta.new } 9 | 10 | validates :items, array: { kind_of: KubeDSL::DSL::V1::Node }, presence: false 11 | validates :metadata, object: { kind_of: KubeDSL::DSL::Meta::V1::ListMeta } 12 | 13 | def serialize 14 | {}.tap do |result| 15 | result[:apiVersion] = "v1" 16 | result[:items] = items.map(&:serialize) 17 | result[:kind] = "NodeList" 18 | result[:metadata] = metadata.serialize 19 | end 20 | end 21 | 22 | def kind_sym 23 | :node_list 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/node_selector.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class NodeSelector < ::KubeDSL::DSLObject 7 | array_field(:node_selector_term) { KubeDSL::DSL::V1::NodeSelectorTerm.new } 8 | 9 | validates :node_selector_terms, array: { kind_of: KubeDSL::DSL::V1::NodeSelectorTerm }, presence: false 10 | 11 | def serialize 12 | {}.tap do |result| 13 | result[:nodeSelectorTerms] = node_selector_terms.map(&:serialize) 14 | end 15 | end 16 | 17 | def kind_sym 18 | :node_selector 19 | end 20 | end 21 | end 22 | end 23 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/node_selector_requirement.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class NodeSelectorRequirement < ::KubeDSL::DSLObject 7 | value_field :key 8 | value_field :operator 9 | value_field :values 10 | 11 | validates :key, field: { format: :string }, presence: false 12 | validates :operator, field: { format: :string }, presence: false 13 | validates :values, field: { format: :string }, presence: false 14 | 15 | def serialize 16 | {}.tap do |result| 17 | result[:key] = key 18 | result[:operator] = operator 19 | result[:values] = values 20 | end 21 | end 22 | 23 | def kind_sym 24 | :node_selector_requirement 25 | end 26 | end 27 | end 28 | end 29 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/node_selector_term.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class NodeSelectorTerm < ::KubeDSL::DSLObject 7 | array_field(:match_expression) { KubeDSL::DSL::V1::NodeSelectorRequirement.new } 8 | array_field(:match_field) { KubeDSL::DSL::V1::NodeSelectorRequirement.new } 9 | 10 | validates :match_expressions, array: { kind_of: KubeDSL::DSL::V1::NodeSelectorRequirement }, presence: false 11 | validates :match_fields, array: { kind_of: KubeDSL::DSL::V1::NodeSelectorRequirement }, presence: false 12 | 13 | def serialize 14 | {}.tap do |result| 15 | result[:matchExpressions] = match_expressions.map(&:serialize) 16 | result[:matchFields] = match_fields.map(&:serialize) 17 | end 18 | end 19 | 20 | def kind_sym 21 | :node_selector_term 22 | end 23 | end 24 | end 25 | end 26 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/object_field_selector.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class ObjectFieldSelector < ::KubeDSL::DSLObject 7 | value_field :api_version 8 | value_field :field_path 9 | 10 | validates :api_version, field: { format: :string }, presence: false 11 | validates :field_path, field: { format: :string }, presence: false 12 | 13 | def serialize 14 | {}.tap do |result| 15 | result[:apiVersion] = api_version 16 | result[:fieldPath] = field_path 17 | end 18 | end 19 | 20 | def kind_sym 21 | :object_field_selector 22 | end 23 | end 24 | end 25 | end 26 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/persistent_volume_claim_template.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class PersistentVolumeClaimTemplate < ::KubeDSL::DSLObject 7 | object_field(:metadata) { KubeDSL::DSL::Meta::V1::ObjectMeta.new } 8 | object_field(:spec) { KubeDSL::DSL::V1::PersistentVolumeClaimSpec.new } 9 | 10 | validates :metadata, object: { kind_of: KubeDSL::DSL::Meta::V1::ObjectMeta } 11 | validates :spec, object: { kind_of: KubeDSL::DSL::V1::PersistentVolumeClaimSpec } 12 | 13 | def serialize 14 | {}.tap do |result| 15 | result[:metadata] = metadata.serialize 16 | result[:spec] = spec.serialize 17 | end 18 | end 19 | 20 | def kind_sym 21 | :persistent_volume_claim_template 22 | end 23 | end 24 | end 25 | end 26 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/persistent_volume_claim_volume_source.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class PersistentVolumeClaimVolumeSource < ::KubeDSL::DSLObject 7 | value_field :claim_name 8 | value_field :read_only 9 | 10 | validates :claim_name, field: { format: :string }, presence: false 11 | validates :read_only, field: { format: :boolean }, presence: false 12 | 13 | def serialize 14 | {}.tap do |result| 15 | result[:claimName] = claim_name 16 | result[:readOnly] = read_only 17 | end 18 | end 19 | 20 | def kind_sym 21 | :persistent_volume_claim_volume_source 22 | end 23 | end 24 | end 25 | end 26 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/persistent_volume_list.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class PersistentVolumeList < ::KubeDSL::DSLObject 7 | array_field(:item) { KubeDSL::DSL::V1::PersistentVolume.new } 8 | object_field(:metadata) { KubeDSL::DSL::Meta::V1::ListMeta.new } 9 | 10 | validates :items, array: { kind_of: KubeDSL::DSL::V1::PersistentVolume }, presence: false 11 | validates :metadata, object: { kind_of: KubeDSL::DSL::Meta::V1::ListMeta } 12 | 13 | def serialize 14 | {}.tap do |result| 15 | result[:apiVersion] = "v1" 16 | result[:items] = items.map(&:serialize) 17 | result[:kind] = "PersistentVolumeList" 18 | result[:metadata] = metadata.serialize 19 | end 20 | end 21 | 22 | def kind_sym 23 | :persistent_volume_list 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/persistent_volume_status.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class PersistentVolumeStatus < ::KubeDSL::DSLObject 7 | value_field :message 8 | value_field :phase 9 | value_field :reason 10 | 11 | validates :message, field: { format: :string }, presence: false 12 | validates :phase, field: { format: :string }, presence: false 13 | validates :reason, field: { format: :string }, presence: false 14 | 15 | def serialize 16 | {}.tap do |result| 17 | result[:message] = message 18 | result[:phase] = phase 19 | result[:reason] = reason 20 | end 21 | end 22 | 23 | def kind_sym 24 | :persistent_volume_status 25 | end 26 | end 27 | end 28 | end 29 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/photon_persistent_disk_volume_source.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class PhotonPersistentDiskVolumeSource < ::KubeDSL::DSLObject 7 | value_field :fs_type 8 | value_field :pd_id 9 | 10 | validates :fs_type, field: { format: :string }, presence: false 11 | validates :pd_id, field: { format: :string }, presence: false 12 | 13 | def serialize 14 | {}.tap do |result| 15 | result[:fsType] = fs_type 16 | result[:pdID] = pd_id 17 | end 18 | end 19 | 20 | def kind_sym 21 | :photon_persistent_disk_volume_source 22 | end 23 | end 24 | end 25 | end 26 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/pod_dns_config.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class PodDNSConfig < ::KubeDSL::DSLObject 7 | value_field :nameservers 8 | array_field(:option) { KubeDSL::DSL::V1::PodDNSConfigOption.new } 9 | value_field :searches 10 | 11 | validates :nameservers, field: { format: :string }, presence: false 12 | validates :options, array: { kind_of: KubeDSL::DSL::V1::PodDNSConfigOption }, presence: false 13 | validates :searches, field: { format: :string }, presence: false 14 | 15 | def serialize 16 | {}.tap do |result| 17 | result[:nameservers] = nameservers 18 | result[:options] = options.map(&:serialize) 19 | result[:searches] = searches 20 | end 21 | end 22 | 23 | def kind_sym 24 | :pod_dns_config 25 | end 26 | end 27 | end 28 | end 29 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/pod_dns_config_option.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class PodDNSConfigOption < ::KubeDSL::DSLObject 7 | value_field :name 8 | value_field :value 9 | 10 | validates :name, field: { format: :string }, presence: false 11 | validates :value, field: { format: :string }, presence: false 12 | 13 | def serialize 14 | {}.tap do |result| 15 | result[:name] = name 16 | result[:value] = value 17 | end 18 | end 19 | 20 | def kind_sym 21 | :pod_dns_config_option 22 | end 23 | end 24 | end 25 | end 26 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/pod_ip.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class PodIP < ::KubeDSL::DSLObject 7 | value_field :ip 8 | 9 | validates :ip, field: { format: :string }, presence: false 10 | 11 | def serialize 12 | {}.tap do |result| 13 | result[:ip] = ip 14 | end 15 | end 16 | 17 | def kind_sym 18 | :pod_ip 19 | end 20 | end 21 | end 22 | end 23 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/pod_list.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class PodList < ::KubeDSL::DSLObject 7 | array_field(:item) { KubeDSL::DSL::V1::Pod.new } 8 | object_field(:metadata) { KubeDSL::DSL::Meta::V1::ListMeta.new } 9 | 10 | validates :items, array: { kind_of: KubeDSL::DSL::V1::Pod }, presence: false 11 | validates :metadata, object: { kind_of: KubeDSL::DSL::Meta::V1::ListMeta } 12 | 13 | def serialize 14 | {}.tap do |result| 15 | result[:apiVersion] = "v1" 16 | result[:items] = items.map(&:serialize) 17 | result[:kind] = "PodList" 18 | result[:metadata] = metadata.serialize 19 | end 20 | end 21 | 22 | def kind_sym 23 | :pod_list 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/pod_os.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class PodOS < ::KubeDSL::DSLObject 7 | value_field :name 8 | 9 | validates :name, field: { format: :string }, presence: false 10 | 11 | def serialize 12 | {}.tap do |result| 13 | result[:name] = name 14 | end 15 | end 16 | 17 | def kind_sym 18 | :pod_os 19 | end 20 | end 21 | end 22 | end 23 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/pod_readiness_gate.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class PodReadinessGate < ::KubeDSL::DSLObject 7 | value_field :condition_type 8 | 9 | validates :condition_type, field: { format: :string }, presence: false 10 | 11 | def serialize 12 | {}.tap do |result| 13 | result[:conditionType] = condition_type 14 | end 15 | end 16 | 17 | def kind_sym 18 | :pod_readiness_gate 19 | end 20 | end 21 | end 22 | end 23 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/pod_template.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class PodTemplate < ::KubeDSL::DSLObject 7 | object_field(:metadata) { KubeDSL::DSL::Meta::V1::ObjectMeta.new } 8 | object_field(:template) { KubeDSL::DSL::V1::PodTemplateSpec.new } 9 | 10 | validates :metadata, object: { kind_of: KubeDSL::DSL::Meta::V1::ObjectMeta } 11 | validates :template, object: { kind_of: KubeDSL::DSL::V1::PodTemplateSpec } 12 | 13 | def serialize 14 | {}.tap do |result| 15 | result[:apiVersion] = "v1" 16 | result[:kind] = "PodTemplate" 17 | result[:metadata] = metadata.serialize 18 | result[:template] = template.serialize 19 | end 20 | end 21 | 22 | def kind_sym 23 | :pod_template 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/pod_template_list.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class PodTemplateList < ::KubeDSL::DSLObject 7 | array_field(:item) { KubeDSL::DSL::V1::PodTemplate.new } 8 | object_field(:metadata) { KubeDSL::DSL::Meta::V1::ListMeta.new } 9 | 10 | validates :items, array: { kind_of: KubeDSL::DSL::V1::PodTemplate }, presence: false 11 | validates :metadata, object: { kind_of: KubeDSL::DSL::Meta::V1::ListMeta } 12 | 13 | def serialize 14 | {}.tap do |result| 15 | result[:apiVersion] = "v1" 16 | result[:items] = items.map(&:serialize) 17 | result[:kind] = "PodTemplateList" 18 | result[:metadata] = metadata.serialize 19 | end 20 | end 21 | 22 | def kind_sym 23 | :pod_template_list 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/pod_template_spec.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class PodTemplateSpec < ::KubeDSL::DSLObject 7 | object_field(:metadata) { KubeDSL::DSL::Meta::V1::ObjectMeta.new } 8 | object_field(:spec) { KubeDSL::DSL::V1::PodSpec.new } 9 | 10 | validates :metadata, object: { kind_of: KubeDSL::DSL::Meta::V1::ObjectMeta } 11 | validates :spec, object: { kind_of: KubeDSL::DSL::V1::PodSpec } 12 | 13 | def serialize 14 | {}.tap do |result| 15 | result[:metadata] = metadata.serialize 16 | result[:spec] = spec.serialize 17 | end 18 | end 19 | 20 | def kind_sym 21 | :pod_template_spec 22 | end 23 | end 24 | end 25 | end 26 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/port_status.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class PortStatus < ::KubeDSL::DSLObject 7 | value_field :error 8 | value_field :port 9 | value_field :protocol 10 | 11 | validates :error, field: { format: :string }, presence: false 12 | validates :port, field: { format: :integer }, presence: false 13 | validates :protocol, field: { format: :string }, presence: false 14 | 15 | def serialize 16 | {}.tap do |result| 17 | result[:error] = error 18 | result[:port] = port 19 | result[:protocol] = protocol 20 | end 21 | end 22 | 23 | def kind_sym 24 | :port_status 25 | end 26 | end 27 | end 28 | end 29 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/portworx_volume_source.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class PortworxVolumeSource < ::KubeDSL::DSLObject 7 | value_field :fs_type 8 | value_field :read_only 9 | value_field :volume_id 10 | 11 | validates :fs_type, field: { format: :string }, presence: false 12 | validates :read_only, field: { format: :boolean }, presence: false 13 | validates :volume_id, field: { format: :string }, presence: false 14 | 15 | def serialize 16 | {}.tap do |result| 17 | result[:fsType] = fs_type 18 | result[:readOnly] = read_only 19 | result[:volumeID] = volume_id 20 | end 21 | end 22 | 23 | def kind_sym 24 | :portworx_volume_source 25 | end 26 | end 27 | end 28 | end 29 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/preferred_scheduling_term.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class PreferredSchedulingTerm < ::KubeDSL::DSLObject 7 | object_field(:preference) { KubeDSL::DSL::V1::NodeSelectorTerm.new } 8 | value_field :weight 9 | 10 | validates :preference, object: { kind_of: KubeDSL::DSL::V1::NodeSelectorTerm } 11 | validates :weight, field: { format: :integer }, presence: false 12 | 13 | def serialize 14 | {}.tap do |result| 15 | result[:preference] = preference.serialize 16 | result[:weight] = weight 17 | end 18 | end 19 | 20 | def kind_sym 21 | :preferred_scheduling_term 22 | end 23 | end 24 | end 25 | end 26 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/projected_volume_source.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class ProjectedVolumeSource < ::KubeDSL::DSLObject 7 | value_field :default_mode 8 | array_field(:source) { KubeDSL::DSL::V1::VolumeProjection.new } 9 | 10 | validates :default_mode, field: { format: :integer }, presence: false 11 | validates :sources, array: { kind_of: KubeDSL::DSL::V1::VolumeProjection }, presence: false 12 | 13 | def serialize 14 | {}.tap do |result| 15 | result[:defaultMode] = default_mode 16 | result[:sources] = sources.map(&:serialize) 17 | end 18 | end 19 | 20 | def kind_sym 21 | :projected_volume_source 22 | end 23 | end 24 | end 25 | end 26 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/resource_field_selector.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class ResourceFieldSelector < ::KubeDSL::DSLObject 7 | value_field :container_name 8 | value_field :divisor 9 | value_field :resource 10 | 11 | validates :container_name, field: { format: :string }, presence: false 12 | validates :divisor, field: { format: :string }, presence: false 13 | validates :resource, field: { format: :string }, presence: false 14 | 15 | def serialize 16 | {}.tap do |result| 17 | result[:containerName] = container_name 18 | result[:divisor] = divisor 19 | result[:resource] = resource 20 | end 21 | end 22 | 23 | def kind_sym 24 | :resource_field_selector 25 | end 26 | end 27 | end 28 | end 29 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/resource_quota_list.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class ResourceQuotaList < ::KubeDSL::DSLObject 7 | array_field(:item) { KubeDSL::DSL::V1::ResourceQuota.new } 8 | object_field(:metadata) { KubeDSL::DSL::Meta::V1::ListMeta.new } 9 | 10 | validates :items, array: { kind_of: KubeDSL::DSL::V1::ResourceQuota }, presence: false 11 | validates :metadata, object: { kind_of: KubeDSL::DSL::Meta::V1::ListMeta } 12 | 13 | def serialize 14 | {}.tap do |result| 15 | result[:apiVersion] = "v1" 16 | result[:items] = items.map(&:serialize) 17 | result[:kind] = "ResourceQuotaList" 18 | result[:metadata] = metadata.serialize 19 | end 20 | end 21 | 22 | def kind_sym 23 | :resource_quota_list 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/resource_quota_spec.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class ResourceQuotaSpec < ::KubeDSL::DSLObject 7 | key_value_field(:hard, format: :string) 8 | object_field(:scope_selector) { KubeDSL::DSL::V1::ScopeSelector.new } 9 | value_field :scopes 10 | 11 | validates :hard, kv: { value_format: :string }, presence: false 12 | validates :scope_selector, object: { kind_of: KubeDSL::DSL::V1::ScopeSelector } 13 | validates :scopes, field: { format: :string }, presence: false 14 | 15 | def serialize 16 | {}.tap do |result| 17 | result[:hard] = hard.serialize 18 | result[:scopeSelector] = scope_selector.serialize 19 | result[:scopes] = scopes 20 | end 21 | end 22 | 23 | def kind_sym 24 | :resource_quota_spec 25 | end 26 | end 27 | end 28 | end 29 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/resource_quota_status.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class ResourceQuotaStatus < ::KubeDSL::DSLObject 7 | key_value_field(:hard, format: :string) 8 | key_value_field(:used, format: :string) 9 | 10 | validates :hard, kv: { value_format: :string }, presence: false 11 | validates :used, kv: { value_format: :string }, presence: false 12 | 13 | def serialize 14 | {}.tap do |result| 15 | result[:hard] = hard.serialize 16 | result[:used] = used.serialize 17 | end 18 | end 19 | 20 | def kind_sym 21 | :resource_quota_status 22 | end 23 | end 24 | end 25 | end 26 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/resource_requirements.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class ResourceRequirements < ::KubeDSL::DSLObject 7 | key_value_field(:limits, format: :string) 8 | key_value_field(:requests, format: :string) 9 | 10 | validates :limits, kv: { value_format: :string }, presence: false 11 | validates :requests, kv: { value_format: :string }, presence: false 12 | 13 | def serialize 14 | {}.tap do |result| 15 | result[:limits] = limits.serialize 16 | result[:requests] = requests.serialize 17 | end 18 | end 19 | 20 | def kind_sym 21 | :resource_requirements 22 | end 23 | end 24 | end 25 | end 26 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/scope_selector.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class ScopeSelector < ::KubeDSL::DSLObject 7 | array_field(:match_expression) { KubeDSL::DSL::V1::ScopedResourceSelectorRequirement.new } 8 | 9 | validates :match_expressions, array: { kind_of: KubeDSL::DSL::V1::ScopedResourceSelectorRequirement }, presence: false 10 | 11 | def serialize 12 | {}.tap do |result| 13 | result[:matchExpressions] = match_expressions.map(&:serialize) 14 | end 15 | end 16 | 17 | def kind_sym 18 | :scope_selector 19 | end 20 | end 21 | end 22 | end 23 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/scoped_resource_selector_requirement.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class ScopedResourceSelectorRequirement < ::KubeDSL::DSLObject 7 | value_field :operator 8 | value_field :scope_name 9 | value_field :values 10 | 11 | validates :operator, field: { format: :string }, presence: false 12 | validates :scope_name, field: { format: :string }, presence: false 13 | validates :values, field: { format: :string }, presence: false 14 | 15 | def serialize 16 | {}.tap do |result| 17 | result[:operator] = operator 18 | result[:scopeName] = scope_name 19 | result[:values] = values 20 | end 21 | end 22 | 23 | def kind_sym 24 | :scoped_resource_selector_requirement 25 | end 26 | end 27 | end 28 | end 29 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/se_linux_options.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class SELinuxOptions < ::KubeDSL::DSLObject 7 | value_field :level 8 | value_field :role 9 | value_field :type 10 | value_field :user 11 | 12 | validates :level, field: { format: :string }, presence: false 13 | validates :role, field: { format: :string }, presence: false 14 | validates :type, field: { format: :string }, presence: false 15 | validates :user, field: { format: :string }, presence: false 16 | 17 | def serialize 18 | {}.tap do |result| 19 | result[:level] = level 20 | result[:role] = role 21 | result[:type] = type 22 | result[:user] = user 23 | end 24 | end 25 | 26 | def kind_sym 27 | :se_linux_options 28 | end 29 | end 30 | end 31 | end 32 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/seccomp_profile.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class SeccompProfile < ::KubeDSL::DSLObject 7 | value_field :localhost_profile 8 | value_field :type 9 | 10 | validates :localhost_profile, field: { format: :string }, presence: false 11 | validates :type, field: { format: :string }, presence: false 12 | 13 | def serialize 14 | {}.tap do |result| 15 | result[:localhostProfile] = localhost_profile 16 | result[:type] = type 17 | end 18 | end 19 | 20 | def kind_sym 21 | :seccomp_profile 22 | end 23 | end 24 | end 25 | end 26 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/secret_env_source.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class SecretEnvSource < ::KubeDSL::DSLObject 7 | value_field :name 8 | value_field :optional 9 | 10 | validates :name, field: { format: :string }, presence: false 11 | validates :optional, field: { format: :boolean }, presence: false 12 | 13 | def serialize 14 | {}.tap do |result| 15 | result[:name] = name 16 | result[:optional] = optional 17 | end 18 | end 19 | 20 | def kind_sym 21 | :secret_env_source 22 | end 23 | end 24 | end 25 | end 26 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/secret_key_selector.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class SecretKeySelector < ::KubeDSL::DSLObject 7 | value_field :key 8 | value_field :name 9 | value_field :optional 10 | 11 | validates :key, field: { format: :string }, presence: false 12 | validates :name, field: { format: :string }, presence: false 13 | validates :optional, field: { format: :boolean }, presence: false 14 | 15 | def serialize 16 | {}.tap do |result| 17 | result[:key] = key 18 | result[:name] = name 19 | result[:optional] = optional 20 | end 21 | end 22 | 23 | def kind_sym 24 | :secret_key_selector 25 | end 26 | end 27 | end 28 | end 29 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/secret_list.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class SecretList < ::KubeDSL::DSLObject 7 | array_field(:item) { KubeDSL::DSL::V1::Secret.new } 8 | object_field(:metadata) { KubeDSL::DSL::Meta::V1::ListMeta.new } 9 | 10 | validates :items, array: { kind_of: KubeDSL::DSL::V1::Secret }, presence: false 11 | validates :metadata, object: { kind_of: KubeDSL::DSL::Meta::V1::ListMeta } 12 | 13 | def serialize 14 | {}.tap do |result| 15 | result[:apiVersion] = "v1" 16 | result[:items] = items.map(&:serialize) 17 | result[:kind] = "SecretList" 18 | result[:metadata] = metadata.serialize 19 | end 20 | end 21 | 22 | def kind_sym 23 | :secret_list 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/secret_projection.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class SecretProjection < ::KubeDSL::DSLObject 7 | array_field(:item) { KubeDSL::DSL::V1::KeyToPath.new } 8 | value_field :name 9 | value_field :optional 10 | 11 | validates :items, array: { kind_of: KubeDSL::DSL::V1::KeyToPath }, presence: false 12 | validates :name, field: { format: :string }, presence: false 13 | validates :optional, field: { format: :boolean }, presence: false 14 | 15 | def serialize 16 | {}.tap do |result| 17 | result[:items] = items.map(&:serialize) 18 | result[:name] = name 19 | result[:optional] = optional 20 | end 21 | end 22 | 23 | def kind_sym 24 | :secret_projection 25 | end 26 | end 27 | end 28 | end 29 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/secret_reference.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class SecretReference < ::KubeDSL::DSLObject 7 | value_field :name 8 | value_field :namespace 9 | 10 | validates :name, field: { format: :string }, presence: false 11 | validates :namespace, field: { format: :string }, presence: false 12 | 13 | def serialize 14 | {}.tap do |result| 15 | result[:name] = name 16 | result[:namespace] = namespace 17 | end 18 | end 19 | 20 | def kind_sym 21 | :secret_reference 22 | end 23 | end 24 | end 25 | end 26 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/service_account_list.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class ServiceAccountList < ::KubeDSL::DSLObject 7 | array_field(:item) { KubeDSL::DSL::V1::ServiceAccount.new } 8 | object_field(:metadata) { KubeDSL::DSL::Meta::V1::ListMeta.new } 9 | 10 | validates :items, array: { kind_of: KubeDSL::DSL::V1::ServiceAccount }, presence: false 11 | validates :metadata, object: { kind_of: KubeDSL::DSL::Meta::V1::ListMeta } 12 | 13 | def serialize 14 | {}.tap do |result| 15 | result[:apiVersion] = "v1" 16 | result[:items] = items.map(&:serialize) 17 | result[:kind] = "ServiceAccountList" 18 | result[:metadata] = metadata.serialize 19 | end 20 | end 21 | 22 | def kind_sym 23 | :service_account_list 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/service_account_token_projection.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class ServiceAccountTokenProjection < ::KubeDSL::DSLObject 7 | value_field :audience 8 | value_field :expiration_seconds 9 | value_field :path 10 | 11 | validates :audience, field: { format: :string }, presence: false 12 | validates :expiration_seconds, field: { format: :integer }, presence: false 13 | validates :path, field: { format: :string }, presence: false 14 | 15 | def serialize 16 | {}.tap do |result| 17 | result[:audience] = audience 18 | result[:expirationSeconds] = expiration_seconds 19 | result[:path] = path 20 | end 21 | end 22 | 23 | def kind_sym 24 | :service_account_token_projection 25 | end 26 | end 27 | end 28 | end 29 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/service_list.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class ServiceList < ::KubeDSL::DSLObject 7 | array_field(:item) { KubeDSL::DSL::V1::Service.new } 8 | object_field(:metadata) { KubeDSL::DSL::Meta::V1::ListMeta.new } 9 | 10 | validates :items, array: { kind_of: KubeDSL::DSL::V1::Service }, presence: false 11 | validates :metadata, object: { kind_of: KubeDSL::DSL::Meta::V1::ListMeta } 12 | 13 | def serialize 14 | {}.tap do |result| 15 | result[:apiVersion] = "v1" 16 | result[:items] = items.map(&:serialize) 17 | result[:kind] = "ServiceList" 18 | result[:metadata] = metadata.serialize 19 | end 20 | end 21 | 22 | def kind_sym 23 | :service_list 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/service_status.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class ServiceStatus < ::KubeDSL::DSLObject 7 | array_field(:condition) { KubeDSL::DSL::Meta::V1::Condition.new } 8 | object_field(:load_balancer) { KubeDSL::DSL::V1::LoadBalancerStatus.new } 9 | 10 | validates :conditions, array: { kind_of: KubeDSL::DSL::Meta::V1::Condition }, presence: false 11 | validates :load_balancer, object: { kind_of: KubeDSL::DSL::V1::LoadBalancerStatus } 12 | 13 | def serialize 14 | {}.tap do |result| 15 | result[:conditions] = conditions.map(&:serialize) 16 | result[:loadBalancer] = load_balancer.serialize 17 | end 18 | end 19 | 20 | def kind_sym 21 | :service_status 22 | end 23 | end 24 | end 25 | end 26 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/session_affinity_config.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class SessionAffinityConfig < ::KubeDSL::DSLObject 7 | object_field(:client_ip) { KubeDSL::DSL::V1::ClientIPConfig.new } 8 | 9 | validates :client_ip, object: { kind_of: KubeDSL::DSL::V1::ClientIPConfig } 10 | 11 | def serialize 12 | {}.tap do |result| 13 | result[:clientIP] = client_ip.serialize 14 | end 15 | end 16 | 17 | def kind_sym 18 | :session_affinity_config 19 | end 20 | end 21 | end 22 | end 23 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/sysctl.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class Sysctl < ::KubeDSL::DSLObject 7 | value_field :name 8 | value_field :value 9 | 10 | validates :name, field: { format: :string }, presence: false 11 | validates :value, field: { format: :string }, presence: false 12 | 13 | def serialize 14 | {}.tap do |result| 15 | result[:name] = name 16 | result[:value] = value 17 | end 18 | end 19 | 20 | def kind_sym 21 | :sysctl 22 | end 23 | end 24 | end 25 | end 26 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/taint.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class Taint < ::KubeDSL::DSLObject 7 | value_field :effect 8 | value_field :key 9 | value_field :time_added 10 | value_field :value 11 | 12 | validates :effect, field: { format: :string }, presence: false 13 | validates :key, field: { format: :string }, presence: false 14 | validates :time_added, field: { format: :string }, presence: false 15 | validates :value, field: { format: :string }, presence: false 16 | 17 | def serialize 18 | {}.tap do |result| 19 | result[:effect] = effect 20 | result[:key] = key 21 | result[:timeAdded] = time_added 22 | result[:value] = value 23 | end 24 | end 25 | 26 | def kind_sym 27 | :taint 28 | end 29 | end 30 | end 31 | end 32 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/tcp_socket_action.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class TCPSocketAction < ::KubeDSL::DSLObject 7 | value_field :host 8 | value_field :port 9 | 10 | validates :host, field: { format: :string }, presence: false 11 | validates :port, field: { format: :string }, presence: false 12 | 13 | def serialize 14 | {}.tap do |result| 15 | result[:host] = host 16 | result[:port] = port 17 | end 18 | end 19 | 20 | def kind_sym 21 | :tcp_socket_action 22 | end 23 | end 24 | end 25 | end 26 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/topology_selector_label_requirement.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class TopologySelectorLabelRequirement < ::KubeDSL::DSLObject 7 | value_field :key 8 | value_field :values 9 | 10 | validates :key, field: { format: :string }, presence: false 11 | validates :values, field: { format: :string }, presence: false 12 | 13 | def serialize 14 | {}.tap do |result| 15 | result[:key] = key 16 | result[:values] = values 17 | end 18 | end 19 | 20 | def kind_sym 21 | :topology_selector_label_requirement 22 | end 23 | end 24 | end 25 | end 26 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/topology_selector_term.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class TopologySelectorTerm < ::KubeDSL::DSLObject 7 | array_field(:match_label_expression) { KubeDSL::DSL::V1::TopologySelectorLabelRequirement.new } 8 | 9 | validates :match_label_expressions, array: { kind_of: KubeDSL::DSL::V1::TopologySelectorLabelRequirement }, presence: false 10 | 11 | def serialize 12 | {}.tap do |result| 13 | result[:matchLabelExpressions] = match_label_expressions.map(&:serialize) 14 | end 15 | end 16 | 17 | def kind_sym 18 | :topology_selector_term 19 | end 20 | end 21 | end 22 | end 23 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/typed_local_object_reference.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class TypedLocalObjectReference < ::KubeDSL::DSLObject 7 | value_field :api_group 8 | value_field :kind 9 | value_field :name 10 | 11 | validates :api_group, field: { format: :string }, presence: false 12 | validates :kind, field: { format: :string }, presence: false 13 | validates :name, field: { format: :string }, presence: false 14 | 15 | def serialize 16 | {}.tap do |result| 17 | result[:apiGroup] = api_group 18 | result[:kind] = kind 19 | result[:name] = name 20 | end 21 | end 22 | 23 | def kind_sym 24 | :typed_local_object_reference 25 | end 26 | end 27 | end 28 | end 29 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/volume_device.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class VolumeDevice < ::KubeDSL::DSLObject 7 | value_field :device_path 8 | value_field :name 9 | 10 | validates :device_path, field: { format: :string }, presence: false 11 | validates :name, field: { format: :string }, presence: false 12 | 13 | def serialize 14 | {}.tap do |result| 15 | result[:devicePath] = device_path 16 | result[:name] = name 17 | end 18 | end 19 | 20 | def kind_sym 21 | :volume_device 22 | end 23 | end 24 | end 25 | end 26 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/volume_node_affinity.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class VolumeNodeAffinity < ::KubeDSL::DSLObject 7 | object_field(:required) { KubeDSL::DSL::V1::NodeSelector.new } 8 | 9 | validates :required, object: { kind_of: KubeDSL::DSL::V1::NodeSelector } 10 | 11 | def serialize 12 | {}.tap do |result| 13 | result[:required] = required.serialize 14 | end 15 | end 16 | 17 | def kind_sym 18 | :volume_node_affinity 19 | end 20 | end 21 | end 22 | end 23 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl/v1/weighted_pod_affinity_term.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class WeightedPodAffinityTerm < ::KubeDSL::DSLObject 7 | object_field(:pod_affinity_term) { KubeDSL::DSL::V1::PodAffinityTerm.new } 8 | value_field :weight 9 | 10 | validates :pod_affinity_term, object: { kind_of: KubeDSL::DSL::V1::PodAffinityTerm } 11 | validates :weight, field: { format: :integer }, presence: false 12 | 13 | def serialize 14 | {}.tap do |result| 15 | result[:podAffinityTerm] = pod_affinity_term.serialize 16 | result[:weight] = weight 17 | end 18 | end 19 | 20 | def kind_sym 21 | :weighted_pod_affinity_term 22 | end 23 | end 24 | end 25 | end 26 | end -------------------------------------------------------------------------------- /lib/kube-dsl/dsl_object.rb: -------------------------------------------------------------------------------- 1 | # typed: strict 2 | 3 | module KubeDSL 4 | class DSLObject 5 | extend T::Sig 6 | 7 | extend ::KubeDSL::ValueFields 8 | extend ::KubeDSL::Validations 9 | 10 | T::Sig::WithoutRuntime.sig { params(block: T.nilable(T.proc.bind(::KubeDSL::DSLObject).void)).void } 11 | def initialize(&block) 12 | instance_eval(&block) if block 13 | end 14 | 15 | T::Sig::WithoutRuntime.sig { returns(::KubeDSL::Resource) } 16 | def to_resource 17 | ::KubeDSL::Resource.new(serialize) 18 | end 19 | 20 | T::Sig::WithoutRuntime.sig { returns(T.any(String, T::Array[T.untyped], T::Hash[T.untyped, T.untyped])) } 21 | def serialize 22 | raise NotImplementedError, "#{__method__} must be defined in subclasses" 23 | end 24 | end 25 | end 26 | -------------------------------------------------------------------------------- /lib/kube-dsl/external_ref.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | module KubeDSL 3 | class ExternalRef < Ref 4 | def meta 5 | @meta ||= ExternalResourceMeta.new(self) 6 | end 7 | 8 | def document 9 | {} 10 | end 11 | 12 | # assume external refs are always object fields 13 | def object? 14 | true 15 | end 16 | end 17 | end 18 | -------------------------------------------------------------------------------- /lib/kube-dsl/external_resource_meta.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | module KubeDSL 3 | class ExternalResourceMeta 4 | attr_reader :ref 5 | 6 | def initialize(ref) 7 | @ref = ref 8 | end 9 | 10 | def external? 11 | true 12 | end 13 | end 14 | end 15 | -------------------------------------------------------------------------------- /lib/kube-dsl/inflector.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | require 'dry/inflector' 3 | require 'singleton' 4 | 5 | module KubeDSL 6 | class Inflector 7 | include Singleton 8 | 9 | class << self 10 | def pluralize(*args) 11 | instance.inflector.pluralize(*args) 12 | end 13 | 14 | def singularize(*args) 15 | instance.inflector.singularize(*args) 16 | end 17 | end 18 | 19 | def inflector 20 | @inflector ||= Dry::Inflector.new do |inflections| 21 | inflections.plural('tls', 'tlses') 22 | inflections.singular('tls', 'tls') 23 | end 24 | end 25 | end 26 | end 27 | -------------------------------------------------------------------------------- /lib/kube-dsl/rbi_helpers.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | module KubeDSL 3 | module RbiHelpers 4 | include StringHelpers 5 | 6 | TYPE_MAP = { 7 | 'boolean' => 'T::Boolean', 8 | 'number' => 'T.any(Integer, Float)' 9 | } 10 | 11 | TYPE_MAP.freeze 12 | 13 | def rbi_type_for(type_str) 14 | TYPE_MAP.fetch(type_str) { capitalize(type_str) } 15 | end 16 | end 17 | end 18 | -------------------------------------------------------------------------------- /lib/kube-dsl/serialize_handler.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | module KubeDSL 4 | class SerializeHandler 5 | attr_reader :namespace, :version, :kind, :field, :block 6 | 7 | def initialize(namespace, version, kind, field, &block) 8 | @namespace = namespace 9 | @version = version 10 | @kind = kind 11 | @field = field 12 | @block = block 13 | end 14 | 15 | def matches?(ref, field) 16 | ref.namespace == namespace && 17 | ref.version == version && 18 | ref.kind == kind && 19 | field == self.field 20 | end 21 | 22 | def handle(res, inflector) 23 | block.call(res, inflector) 24 | end 25 | end 26 | end 27 | -------------------------------------------------------------------------------- /lib/kube-dsl/string_helpers.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | module KubeDSL 3 | module StringHelpers 4 | RUBY_KEYWORDS = %w( 5 | BEGIN END alias and begin break case class def defined? do else elsif 6 | end ensure false for if in module next nil not or redo rescue retry 7 | return self super then true undef unless until when while yield 8 | ) 9 | 10 | def capitalize(str) 11 | str.sub(/\A(.)/) { $1.upcase } 12 | end 13 | 14 | def underscore(str) 15 | str 16 | .gsub(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2') 17 | .gsub(/([a-z\d])([A-Z])/, '\1_\2') 18 | .gsub('-', '_') 19 | .downcase 20 | end 21 | 22 | def unkeywordify(str) 23 | if RUBY_KEYWORDS.include?(str) 24 | "#{str}_field" 25 | else 26 | str 27 | end 28 | end 29 | end 30 | 31 | StringHelpers.extend(StringHelpers) 32 | end 33 | -------------------------------------------------------------------------------- /lib/kube-dsl/version.rb: -------------------------------------------------------------------------------- 1 | # typed: strict 2 | 3 | module KubeDSL 4 | VERSION = '0.8.3' 5 | end 6 | -------------------------------------------------------------------------------- /sorbet/config: -------------------------------------------------------------------------------- 1 | --dir 2 | . 3 | --ignore=/vendor/bundle 4 | -------------------------------------------------------------------------------- /sorbet/rbi/gems/commander@4.6.0.rbi: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | # DO NOT EDIT MANUALLY 4 | # This is an autogenerated file for types exported from the `commander` gem. 5 | # Please instead update this file by running `bin/tapioca gem commander`. 6 | 7 | # THIS IS AN EMPTY RBI FILE. 8 | # see https://github.com/Shopify/tapioca#manually-requiring-parts-of-a-gem 9 | -------------------------------------------------------------------------------- /sorbet/rbi/gems/highline@2.0.3.rbi: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | # DO NOT EDIT MANUALLY 4 | # This is an autogenerated file for types exported from the `highline` gem. 5 | # Please instead update this file by running `bin/tapioca gem highline`. 6 | 7 | # THIS IS AN EMPTY RBI FILE. 8 | # see https://github.com/Shopify/tapioca#manually-requiring-parts-of-a-gem 9 | -------------------------------------------------------------------------------- /sorbet/rbi/gems/unparser@0.6.7.rbi: -------------------------------------------------------------------------------- 1 | # typed: true 2 | 3 | # DO NOT EDIT MANUALLY 4 | # This is an autogenerated file for types exported from the `unparser` gem. 5 | # Please instead update this file by running `bin/tapioca gem unparser`. 6 | 7 | # THIS IS AN EMPTY RBI FILE. 8 | # see https://github.com/Shopify/tapioca#manually-requiring-parts-of-a-gem 9 | -------------------------------------------------------------------------------- /sorbet/rbi/kube-dsl/dsl/apiextensions/v1/json.rbi: -------------------------------------------------------------------------------- 1 | # typed: strict 2 | 3 | module KubeDSL::DSL::Apiextensions::V1 4 | class JSON < ::KubeDSL::DSLObject 5 | JSONType = T.type_alias do 6 | T.any( 7 | T::Array[T.any(String, Integer, Float, T::Boolean, T::Array[T.untyped])], 8 | T::Hash[Symbol, T.any(String, Integer, Float, T::Boolean, T::Array[T.untyped], T::Hash[Symbol, T.untyped])] 9 | ) 10 | end 11 | 12 | sig { params(block: T.nilable(T.proc.void)).void } 13 | def initialize(&block) 14 | @value = T.let(@value, JSONType) 15 | end 16 | 17 | sig { returns(JSONType) } 18 | def serialize; end 19 | 20 | sig { returns(Symbol) } 21 | def kind_sym; end 22 | 23 | sig { params(val: T.nilable(JSONType)).returns(JSONType) } 24 | def value(val = nil); end 25 | end 26 | end 27 | -------------------------------------------------------------------------------- /sorbet/rbi/kube-dsl/dsl/autoscaling/v1/scale_spec.rbi: -------------------------------------------------------------------------------- 1 | # typed: strict 2 | 3 | module KubeDSL 4 | module DSL 5 | module Autoscaling 6 | module V1 7 | class ScaleSpec < ::KubeDSL::DSLObject 8 | extend KubeDSL::ValueFields::ClassMethods 9 | extend KubeDSL::Validations::ClassMethods 10 | include KubeDSL::ValueFields::InstanceMethods 11 | 12 | T::Sig::WithoutRuntime.sig { 13 | returns( 14 | T::Hash[Symbol, T.any(String, Integer, Float, T::Boolean, T::Array[T.untyped], T::Hash[Symbol, T.untyped])] 15 | ) 16 | } 17 | def serialize; end 18 | 19 | T::Sig::WithoutRuntime.sig { returns(Symbol) } 20 | def kind_sym; end 21 | 22 | T::Sig::WithoutRuntime.sig { params(val: T.nilable(Integer)).returns(T.nilable(Integer)) } 23 | def replicas(val = nil); end 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /sorbet/rbi/kube-dsl/dsl/discovery/v1/for_zone.rbi: -------------------------------------------------------------------------------- 1 | # typed: strict 2 | 3 | module KubeDSL 4 | module DSL 5 | module Discovery 6 | module V1 7 | class ForZone < ::KubeDSL::DSLObject 8 | extend KubeDSL::ValueFields::ClassMethods 9 | extend KubeDSL::Validations::ClassMethods 10 | include KubeDSL::ValueFields::InstanceMethods 11 | 12 | T::Sig::WithoutRuntime.sig { 13 | returns( 14 | T::Hash[Symbol, T.any(String, Integer, Float, T::Boolean, T::Array[T.untyped], T::Hash[Symbol, T.untyped])] 15 | ) 16 | } 17 | def serialize; end 18 | 19 | T::Sig::WithoutRuntime.sig { returns(Symbol) } 20 | def kind_sym; end 21 | 22 | T::Sig::WithoutRuntime.sig { params(val: T.nilable(String)).returns(T.nilable(String)) } 23 | def name(val = nil); end 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /sorbet/rbi/kube-dsl/dsl/discovery/v1beta1/for_zone.rbi: -------------------------------------------------------------------------------- 1 | # typed: strict 2 | 3 | module KubeDSL 4 | module DSL 5 | module Discovery 6 | module V1beta1 7 | class ForZone < ::KubeDSL::DSLObject 8 | extend KubeDSL::ValueFields::ClassMethods 9 | extend KubeDSL::Validations::ClassMethods 10 | include KubeDSL::ValueFields::InstanceMethods 11 | 12 | T::Sig::WithoutRuntime.sig { 13 | returns( 14 | T::Hash[Symbol, T.any(String, Integer, Float, T::Boolean, T::Array[T.untyped], T::Hash[Symbol, T.untyped])] 15 | ) 16 | } 17 | def serialize; end 18 | 19 | T::Sig::WithoutRuntime.sig { returns(Symbol) } 20 | def kind_sym; end 21 | 22 | T::Sig::WithoutRuntime.sig { params(val: T.nilable(String)).returns(T.nilable(String)) } 23 | def name(val = nil); end 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /sorbet/rbi/kube-dsl/dsl/flowcontrol/v1beta1/user_subject.rbi: -------------------------------------------------------------------------------- 1 | # typed: strict 2 | 3 | module KubeDSL 4 | module DSL 5 | module Flowcontrol 6 | module V1beta1 7 | class UserSubject < ::KubeDSL::DSLObject 8 | extend KubeDSL::ValueFields::ClassMethods 9 | extend KubeDSL::Validations::ClassMethods 10 | include KubeDSL::ValueFields::InstanceMethods 11 | 12 | T::Sig::WithoutRuntime.sig { 13 | returns( 14 | T::Hash[Symbol, T.any(String, Integer, Float, T::Boolean, T::Array[T.untyped], T::Hash[Symbol, T.untyped])] 15 | ) 16 | } 17 | def serialize; end 18 | 19 | T::Sig::WithoutRuntime.sig { returns(Symbol) } 20 | def kind_sym; end 21 | 22 | T::Sig::WithoutRuntime.sig { params(val: T.nilable(String)).returns(T.nilable(String)) } 23 | def name(val = nil); end 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /sorbet/rbi/kube-dsl/dsl/flowcontrol/v1beta2/user_subject.rbi: -------------------------------------------------------------------------------- 1 | # typed: strict 2 | 3 | module KubeDSL 4 | module DSL 5 | module Flowcontrol 6 | module V1beta2 7 | class UserSubject < ::KubeDSL::DSLObject 8 | extend KubeDSL::ValueFields::ClassMethods 9 | extend KubeDSL::Validations::ClassMethods 10 | include KubeDSL::ValueFields::InstanceMethods 11 | 12 | T::Sig::WithoutRuntime.sig { 13 | returns( 14 | T::Hash[Symbol, T.any(String, Integer, Float, T::Boolean, T::Array[T.untyped], T::Hash[Symbol, T.untyped])] 15 | ) 16 | } 17 | def serialize; end 18 | 19 | T::Sig::WithoutRuntime.sig { returns(Symbol) } 20 | def kind_sym; end 21 | 22 | T::Sig::WithoutRuntime.sig { params(val: T.nilable(String)).returns(T.nilable(String)) } 23 | def name(val = nil); end 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /sorbet/rbi/kube-dsl/dsl/policy/v1beta1/allowed_csi_driver.rbi: -------------------------------------------------------------------------------- 1 | # typed: strict 2 | 3 | module KubeDSL 4 | module DSL 5 | module Policy 6 | module V1beta1 7 | class AllowedCSIDriver < ::KubeDSL::DSLObject 8 | extend KubeDSL::ValueFields::ClassMethods 9 | extend KubeDSL::Validations::ClassMethods 10 | include KubeDSL::ValueFields::InstanceMethods 11 | 12 | T::Sig::WithoutRuntime.sig { 13 | returns( 14 | T::Hash[Symbol, T.any(String, Integer, Float, T::Boolean, T::Array[T.untyped], T::Hash[Symbol, T.untyped])] 15 | ) 16 | } 17 | def serialize; end 18 | 19 | T::Sig::WithoutRuntime.sig { returns(Symbol) } 20 | def kind_sym; end 21 | 22 | T::Sig::WithoutRuntime.sig { params(val: T.nilable(String)).returns(T.nilable(String)) } 23 | def name(val = nil); end 24 | end 25 | end 26 | end 27 | end 28 | end -------------------------------------------------------------------------------- /sorbet/rbi/kube-dsl/dsl/v1/client_ip_config.rbi: -------------------------------------------------------------------------------- 1 | # typed: strict 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class ClientIPConfig < ::KubeDSL::DSLObject 7 | extend KubeDSL::ValueFields::ClassMethods 8 | extend KubeDSL::Validations::ClassMethods 9 | include KubeDSL::ValueFields::InstanceMethods 10 | 11 | T::Sig::WithoutRuntime.sig { 12 | returns( 13 | T::Hash[Symbol, T.any(String, Integer, Float, T::Boolean, T::Array[T.untyped], T::Hash[Symbol, T.untyped])] 14 | ) 15 | } 16 | def serialize; end 17 | 18 | T::Sig::WithoutRuntime.sig { returns(Symbol) } 19 | def kind_sym; end 20 | 21 | T::Sig::WithoutRuntime.sig { params(val: T.nilable(Integer)).returns(T.nilable(Integer)) } 22 | def timeout_seconds(val = nil); end 23 | end 24 | end 25 | end 26 | end -------------------------------------------------------------------------------- /sorbet/rbi/kube-dsl/dsl/v1/container_state_running.rbi: -------------------------------------------------------------------------------- 1 | # typed: strict 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class ContainerStateRunning < ::KubeDSL::DSLObject 7 | extend KubeDSL::ValueFields::ClassMethods 8 | extend KubeDSL::Validations::ClassMethods 9 | include KubeDSL::ValueFields::InstanceMethods 10 | 11 | T::Sig::WithoutRuntime.sig { 12 | returns( 13 | T::Hash[Symbol, T.any(String, Integer, Float, T::Boolean, T::Array[T.untyped], T::Hash[Symbol, T.untyped])] 14 | ) 15 | } 16 | def serialize; end 17 | 18 | T::Sig::WithoutRuntime.sig { returns(Symbol) } 19 | def kind_sym; end 20 | 21 | T::Sig::WithoutRuntime.sig { params(val: T.nilable(String)).returns(T.nilable(String)) } 22 | def started_at(val = nil); end 23 | end 24 | end 25 | end 26 | end -------------------------------------------------------------------------------- /sorbet/rbi/kube-dsl/dsl/v1/daemon_endpoint.rbi: -------------------------------------------------------------------------------- 1 | # typed: strict 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class DaemonEndpoint < ::KubeDSL::DSLObject 7 | extend KubeDSL::ValueFields::ClassMethods 8 | extend KubeDSL::Validations::ClassMethods 9 | include KubeDSL::ValueFields::InstanceMethods 10 | 11 | T::Sig::WithoutRuntime.sig { 12 | returns( 13 | T::Hash[Symbol, T.any(String, Integer, Float, T::Boolean, T::Array[T.untyped], T::Hash[Symbol, T.untyped])] 14 | ) 15 | } 16 | def serialize; end 17 | 18 | T::Sig::WithoutRuntime.sig { returns(Symbol) } 19 | def kind_sym; end 20 | 21 | T::Sig::WithoutRuntime.sig { params(val: T.nilable(Integer)).returns(T.nilable(Integer)) } 22 | def port(val = nil); end 23 | end 24 | end 25 | end 26 | end -------------------------------------------------------------------------------- /sorbet/rbi/kube-dsl/dsl/v1/exec_action.rbi: -------------------------------------------------------------------------------- 1 | # typed: strict 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class ExecAction < ::KubeDSL::DSLObject 7 | extend KubeDSL::ValueFields::ClassMethods 8 | extend KubeDSL::Validations::ClassMethods 9 | include KubeDSL::ValueFields::InstanceMethods 10 | 11 | T::Sig::WithoutRuntime.sig { 12 | returns( 13 | T::Hash[Symbol, T.any(String, Integer, Float, T::Boolean, T::Array[T.untyped], T::Hash[Symbol, T.untyped])] 14 | ) 15 | } 16 | def serialize; end 17 | 18 | T::Sig::WithoutRuntime.sig { returns(Symbol) } 19 | def kind_sym; end 20 | 21 | T::Sig::WithoutRuntime.sig { params(val: T.nilable(String)).returns(T.nilable(String)) } 22 | def command(val = nil); end 23 | end 24 | end 25 | end 26 | end -------------------------------------------------------------------------------- /sorbet/rbi/kube-dsl/dsl/v1/local_object_reference.rbi: -------------------------------------------------------------------------------- 1 | # typed: strict 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class LocalObjectReference < ::KubeDSL::DSLObject 7 | extend KubeDSL::ValueFields::ClassMethods 8 | extend KubeDSL::Validations::ClassMethods 9 | include KubeDSL::ValueFields::InstanceMethods 10 | 11 | T::Sig::WithoutRuntime.sig { 12 | returns( 13 | T::Hash[Symbol, T.any(String, Integer, Float, T::Boolean, T::Array[T.untyped], T::Hash[Symbol, T.untyped])] 14 | ) 15 | } 16 | def serialize; end 17 | 18 | T::Sig::WithoutRuntime.sig { returns(Symbol) } 19 | def kind_sym; end 20 | 21 | T::Sig::WithoutRuntime.sig { params(val: T.nilable(String)).returns(T.nilable(String)) } 22 | def name(val = nil); end 23 | end 24 | end 25 | end 26 | end -------------------------------------------------------------------------------- /sorbet/rbi/kube-dsl/dsl/v1/namespace_spec.rbi: -------------------------------------------------------------------------------- 1 | # typed: strict 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class NamespaceSpec < ::KubeDSL::DSLObject 7 | extend KubeDSL::ValueFields::ClassMethods 8 | extend KubeDSL::Validations::ClassMethods 9 | include KubeDSL::ValueFields::InstanceMethods 10 | 11 | T::Sig::WithoutRuntime.sig { 12 | returns( 13 | T::Hash[Symbol, T.any(String, Integer, Float, T::Boolean, T::Array[T.untyped], T::Hash[Symbol, T.untyped])] 14 | ) 15 | } 16 | def serialize; end 17 | 18 | T::Sig::WithoutRuntime.sig { returns(Symbol) } 19 | def kind_sym; end 20 | 21 | T::Sig::WithoutRuntime.sig { params(val: T.nilable(String)).returns(T.nilable(String)) } 22 | def finalizers(val = nil); end 23 | end 24 | end 25 | end 26 | end -------------------------------------------------------------------------------- /sorbet/rbi/kube-dsl/dsl/v1/pod_ip.rbi: -------------------------------------------------------------------------------- 1 | # typed: strict 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class PodIP < ::KubeDSL::DSLObject 7 | extend KubeDSL::ValueFields::ClassMethods 8 | extend KubeDSL::Validations::ClassMethods 9 | include KubeDSL::ValueFields::InstanceMethods 10 | 11 | T::Sig::WithoutRuntime.sig { 12 | returns( 13 | T::Hash[Symbol, T.any(String, Integer, Float, T::Boolean, T::Array[T.untyped], T::Hash[Symbol, T.untyped])] 14 | ) 15 | } 16 | def serialize; end 17 | 18 | T::Sig::WithoutRuntime.sig { returns(Symbol) } 19 | def kind_sym; end 20 | 21 | T::Sig::WithoutRuntime.sig { params(val: T.nilable(String)).returns(T.nilable(String)) } 22 | def ip(val = nil); end 23 | end 24 | end 25 | end 26 | end -------------------------------------------------------------------------------- /sorbet/rbi/kube-dsl/dsl/v1/pod_os.rbi: -------------------------------------------------------------------------------- 1 | # typed: strict 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class PodOS < ::KubeDSL::DSLObject 7 | extend KubeDSL::ValueFields::ClassMethods 8 | extend KubeDSL::Validations::ClassMethods 9 | include KubeDSL::ValueFields::InstanceMethods 10 | 11 | T::Sig::WithoutRuntime.sig { 12 | returns( 13 | T::Hash[Symbol, T.any(String, Integer, Float, T::Boolean, T::Array[T.untyped], T::Hash[Symbol, T.untyped])] 14 | ) 15 | } 16 | def serialize; end 17 | 18 | T::Sig::WithoutRuntime.sig { returns(Symbol) } 19 | def kind_sym; end 20 | 21 | T::Sig::WithoutRuntime.sig { params(val: T.nilable(String)).returns(T.nilable(String)) } 22 | def name(val = nil); end 23 | end 24 | end 25 | end 26 | end -------------------------------------------------------------------------------- /sorbet/rbi/kube-dsl/dsl/v1/pod_readiness_gate.rbi: -------------------------------------------------------------------------------- 1 | # typed: strict 2 | 3 | module KubeDSL 4 | module DSL 5 | module V1 6 | class PodReadinessGate < ::KubeDSL::DSLObject 7 | extend KubeDSL::ValueFields::ClassMethods 8 | extend KubeDSL::Validations::ClassMethods 9 | include KubeDSL::ValueFields::InstanceMethods 10 | 11 | T::Sig::WithoutRuntime.sig { 12 | returns( 13 | T::Hash[Symbol, T.any(String, Integer, Float, T::Boolean, T::Array[T.untyped], T::Hash[Symbol, T.untyped])] 14 | ) 15 | } 16 | def serialize; end 17 | 18 | T::Sig::WithoutRuntime.sig { returns(Symbol) } 19 | def kind_sym; end 20 | 21 | T::Sig::WithoutRuntime.sig { params(val: T.nilable(String)).returns(T.nilable(String)) } 22 | def condition_type(val = nil); end 23 | end 24 | end 25 | end 26 | end -------------------------------------------------------------------------------- /sorbet/rbi/validations.rbi: -------------------------------------------------------------------------------- 1 | # typed: strict 2 | 3 | module KubeDSL 4 | module Validations 5 | module ClassMethods 6 | sig { params(field_name: T.untyped, options: T.untyped).returns(T.untyped) } 7 | def validates(field_name, options); end 8 | end 9 | end 10 | end 11 | -------------------------------------------------------------------------------- /sorbet/tapioca/config.yml: -------------------------------------------------------------------------------- 1 | gem: 2 | # Add your `gem` command parameters here: 3 | # 4 | exclude: 5 | - tapioca 6 | - rbi 7 | # doc: true 8 | # workers: 5 9 | dsl: 10 | # Add your `dsl` command parameters here: 11 | # 12 | # exclude: 13 | # - SomeGeneratorName 14 | # workers: 5 15 | -------------------------------------------------------------------------------- /sorbet/tapioca/require.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | # frozen_string_literal: true 3 | 4 | # Add your extra requires here (`bin/tapioca require` can be used to boostrap this list) 5 | --------------------------------------------------------------------------------