kuby-redis 0.1.0 → 0.2.0

data/lib/kuby/redis/dsl/databases/v1/redis_failover_spec_redis_image_pull_secrets.rb

@@ -0,0 +1,27 @@
+# typed: true
+
+module Kuby
+  module Redis
+    module DSL
+      module Databases
+        module V1
+          class RedisFailoverSpecRedisImagePullSecrets < ::KubeDSL::DSLObject
+            value_field :name
+
+            validates :name, field: { format: :string }, presence: false
+
+            def serialize
+              {}.tap do |result|
+                result[:name] = name
+              end
+            end
+
+            def kind_sym
+              :redis_failover_spec_redis_image_pull_secrets
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kuby/redis/dsl/databases/v1/redis_failover_spec_redis_resources.rb

@@ -0,0 +1,30 @@
+# typed: true
+
+module Kuby
+  module Redis
+    module DSL
+      module Databases
+        module V1
+          class RedisFailoverSpecRedisResources < ::KubeDSL::DSLObject
+            key_value_field(:requests, format: :string)
+            key_value_field(:limits, format: :string)
+
+            validates :requests, kv: { value_format: :string }, presence: true
+            validates :limits, kv: { value_format: :string }, presence: true
+
+            def serialize
+              {}.tap do |result|
+                result[:requests] = requests.serialize
+                result[:limits] = limits.serialize
+              end
+            end
+
+            def kind_sym
+              :redis_failover_spec_redis_resources
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kuby/redis/dsl/databases/v1/redis_failover_spec_redis_security_context.rb

@@ -0,0 +1,54 @@
+# typed: true
+
+module Kuby
+  module Redis
+    module DSL
+      module Databases
+        module V1
+          class RedisFailoverSpecRedisSecurityContext < ::KubeDSL::DSLObject
+            object_field(:seccomp_profile) { Kuby::Redis::DSL::Databases::V1::RedisFailoverSpecRedisSecurityContextSeccompProfile.new }
+            value_field :run_as_group
+            value_field :run_as_user
+            value_field :supplemental_groups
+            value_field :fs_group
+            array_field(:sysctl) { Kuby::Redis::DSL::Databases::V1::RedisFailoverSpecRedisSecurityContextSysctls.new }
+            value_field :run_as_non_root
+            object_field(:windows_options) { Kuby::Redis::DSL::Databases::V1::RedisFailoverSpecRedisSecurityContextWindowsOptions.new }
+            object_field(:se_linux_options) { Kuby::Redis::DSL::Databases::V1::RedisFailoverSpecRedisSecurityContextSeLinuxOptions.new }
+            value_field :fs_group_change_policy
+
+            validates :seccomp_profile, object: { kind_of: Kuby::Redis::DSL::Databases::V1::RedisFailoverSpecRedisSecurityContextSeccompProfile }
+            validates :run_as_group, field: { format: :integer }, presence: true
+            validates :run_as_user, field: { format: :integer }, presence: true
+            validates :supplemental_groups, field: { format: :integer }, presence: false
+            validates :fs_group, field: { format: :integer }, presence: true
+            validates :sysctls, array: { kind_of: Kuby::Redis::DSL::Databases::V1::RedisFailoverSpecRedisSecurityContextSysctls }, presence: false
+            validates :run_as_non_root, field: { format: :boolean }, presence: true
+            validates :windows_options, object: { kind_of: Kuby::Redis::DSL::Databases::V1::RedisFailoverSpecRedisSecurityContextWindowsOptions }
+            validates :se_linux_options, object: { kind_of: Kuby::Redis::DSL::Databases::V1::RedisFailoverSpecRedisSecurityContextSeLinuxOptions }
+            validates :fs_group_change_policy, field: { format: :string }, presence: false
+
+            def serialize
+              {}.tap do |result|
+                result[:seccompProfile] = seccomp_profile.serialize
+                result[:runAsGroup] = run_as_group
+                result[:runAsUser] = run_as_user
+                result[:supplementalGroups] = supplemental_groups
+                result[:fsGroup] = fs_group
+                result[:sysctls] = sysctls.map(&:serialize)
+                result[:runAsNonRoot] = run_as_non_root
+                result[:windowsOptions] = windows_options.serialize
+                result[:seLinuxOptions] = se_linux_options.serialize
+                result[:fsGroupChangePolicy] = fs_group_change_policy
+              end
+            end
+
+            def kind_sym
+              :redis_failover_spec_redis_security_context
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kuby/redis/dsl/databases/v1/redis_failover_spec_redis_security_context_se_linux_options.rb

@@ -0,0 +1,36 @@
+# typed: true
+
+module Kuby
+  module Redis
+    module DSL
+      module Databases
+        module V1
+          class RedisFailoverSpecRedisSecurityContextSeLinuxOptions < ::KubeDSL::DSLObject
+            value_field :type
+            value_field :role
+            value_field :user
+            value_field :level
+
+            validates :type, field: { format: :string }, presence: false
+            validates :role, field: { format: :string }, presence: false
+            validates :user, field: { format: :string }, presence: false
+            validates :level, field: { format: :string }, presence: false
+
+            def serialize
+              {}.tap do |result|
+                result[:type] = type
+                result[:role] = role
+                result[:user] = user
+                result[:level] = level
+              end
+            end
+
+            def kind_sym
+              :redis_failover_spec_redis_security_context_se_linux_options
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kuby/redis/dsl/databases/v1/redis_failover_spec_redis_security_context_seccomp_profile.rb

@@ -0,0 +1,30 @@
+# typed: true
+
+module Kuby
+  module Redis
+    module DSL
+      module Databases
+        module V1
+          class RedisFailoverSpecRedisSecurityContextSeccompProfile < ::KubeDSL::DSLObject
+            value_field :localhost_profile
+            value_field :type
+
+            validates :localhost_profile, field: { format: :string }, presence: false
+            validates :type, field: { format: :string }, presence: true
+
+            def serialize
+              {}.tap do |result|
+                result[:localhostProfile] = localhost_profile
+                result[:type] = type
+              end
+            end
+
+            def kind_sym
+              :redis_failover_spec_redis_security_context_seccomp_profile
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kuby/redis/dsl/databases/v1/redis_failover_spec_redis_security_context_sysctls.rb

@@ -0,0 +1,30 @@
+# typed: true
+
+module Kuby
+  module Redis
+    module DSL
+      module Databases
+        module V1
+          class RedisFailoverSpecRedisSecurityContextSysctls < ::KubeDSL::DSLObject
+            value_field :name
+            value_field :value
+
+            validates :name, field: { format: :string }, presence: true
+            validates :value, field: { format: :string }, presence: true
+
+            def serialize
+              {}.tap do |result|
+                result[:name] = name
+                result[:value] = value
+              end
+            end
+
+            def kind_sym
+              :redis_failover_spec_redis_security_context_sysctls
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kuby/redis/dsl/databases/v1/redis_failover_spec_redis_security_context_windows_options.rb

@@ -0,0 +1,36 @@
+# typed: true
+
+module Kuby
+  module Redis
+    module DSL
+      module Databases
+        module V1
+          class RedisFailoverSpecRedisSecurityContextWindowsOptions < ::KubeDSL::DSLObject
+            value_field :run_as_user_name
+            value_field :gmsa_credential_spec
+            value_field :gmsa_credential_spec_name
+            value_field :host_process
+
+            validates :run_as_user_name, field: { format: :string }, presence: false
+            validates :gmsa_credential_spec, field: { format: :string }, presence: false
+            validates :gmsa_credential_spec_name, field: { format: :string }, presence: false
+            validates :host_process, field: { format: :boolean }, presence: true
+
+            def serialize
+              {}.tap do |result|
+                result[:runAsUserName] = run_as_user_name
+                result[:gmsaCredentialSpec] = gmsa_credential_spec
+                result[:gmsaCredentialSpecName] = gmsa_credential_spec_name
+                result[:hostProcess] = host_process
+              end
+            end
+
+            def kind_sym
+              :redis_failover_spec_redis_security_context_windows_options
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kuby/redis/dsl/databases/v1/redis_failover_spec_redis_storage.rb

@@ -0,0 +1,33 @@
+# typed: true
+
+module Kuby
+  module Redis
+    module DSL
+      module Databases
+        module V1
+          class RedisFailoverSpecRedisStorage < ::KubeDSL::DSLObject
+            object_field(:empty_dir) { Kuby::Redis::DSL::Databases::V1::RedisFailoverSpecRedisStorageEmptyDir.new }
+            value_field :keep_after_deletion
+            object_field(:persistent_volume_claim) { Kuby::Redis::DSL::Databases::V1::RedisFailoverSpecRedisStoragePersistentVolumeClaim.new }
+
+            validates :empty_dir, object: { kind_of: Kuby::Redis::DSL::Databases::V1::RedisFailoverSpecRedisStorageEmptyDir }
+            validates :keep_after_deletion, field: { format: :boolean }, presence: true
+            validates :persistent_volume_claim, object: { kind_of: Kuby::Redis::DSL::Databases::V1::RedisFailoverSpecRedisStoragePersistentVolumeClaim }
+
+            def serialize
+              {}.tap do |result|
+                result[:emptyDir] = empty_dir.serialize
+                result[:keepAfterDeletion] = keep_after_deletion
+                result[:persistentVolumeClaim] = persistent_volume_claim.serialize
+              end
+            end
+
+            def kind_sym
+              :redis_failover_spec_redis_storage
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kuby/redis/dsl/databases/v1/redis_failover_spec_redis_storage_empty_dir.rb

@@ -0,0 +1,27 @@
+# typed: true
+
+module Kuby
+  module Redis
+    module DSL
+      module Databases
+        module V1
+          class RedisFailoverSpecRedisStorageEmptyDir < ::KubeDSL::DSLObject
+            value_field :medium
+
+            validates :medium, field: { format: :string }, presence: false
+
+            def serialize
+              {}.tap do |result|
+                result[:medium] = medium
+              end
+            end
+
+            def kind_sym
+              :redis_failover_spec_redis_storage_empty_dir
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kuby/redis/dsl/databases/v1/redis_failover_spec_redis_storage_persistent_volume_claim.rb

@@ -0,0 +1,39 @@
+# typed: true
+
+module Kuby
+  module Redis
+    module DSL
+      module Databases
+        module V1
+          class RedisFailoverSpecRedisStoragePersistentVolumeClaim < ::KubeDSL::DSLObject
+            object_field(:status) { Kuby::Redis::DSL::Databases::V1::RedisFailoverSpecRedisStoragePersistentVolumeClaimStatus.new }
+            value_field :kind
+            object_field(:spec) { Kuby::Redis::DSL::Databases::V1::RedisFailoverSpecRedisStoragePersistentVolumeClaimSpec.new }
+            value_field :api_version
+            object_field(:metadata) { Kuby::Redis::DSL::Databases::V1::RedisFailoverSpecRedisStoragePersistentVolumeClaimMetadata.new }
+
+            validates :status, object: { kind_of: Kuby::Redis::DSL::Databases::V1::RedisFailoverSpecRedisStoragePersistentVolumeClaimStatus }
+            validates :kind, field: { format: :string }, presence: false
+            validates :spec, object: { kind_of: Kuby::Redis::DSL::Databases::V1::RedisFailoverSpecRedisStoragePersistentVolumeClaimSpec }
+            validates :api_version, field: { format: :string }, presence: false
+            validates :metadata, object: { kind_of: Kuby::Redis::DSL::Databases::V1::RedisFailoverSpecRedisStoragePersistentVolumeClaimMetadata }
+
+            def serialize
+              {}.tap do |result|
+                result[:status] = status.serialize
+                result[:kind] = kind
+                result[:spec] = spec.serialize
+                result[:apiVersion] = api_version
+                result[:metadata] = metadata.serialize
+              end
+            end
+
+            def kind_sym
+              :redis_failover_spec_redis_storage_persistent_volume_claim
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kuby/redis/dsl/databases/v1/redis_failover_spec_redis_storage_persistent_volume_claim_metadata.rb

@@ -0,0 +1,33 @@
+# typed: true
+
+module Kuby
+  module Redis
+    module DSL
+      module Databases
+        module V1
+          class RedisFailoverSpecRedisStoragePersistentVolumeClaimMetadata < ::KubeDSL::DSLObject
+            key_value_field(:labels, format: :string)
+            key_value_field(:annotations, format: :string)
+            value_field :name
+
+            validates :labels, kv: { value_format: :string }, presence: true
+            validates :annotations, kv: { value_format: :string }, presence: true
+            validates :name, field: { format: :string }, presence: false
+
+            def serialize
+              {}.tap do |result|
+                result[:labels] = labels.serialize
+                result[:annotations] = annotations.serialize
+                result[:name] = name
+              end
+            end
+
+            def kind_sym
+              :redis_failover_spec_redis_storage_persistent_volume_claim_metadata
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kuby/redis/dsl/databases/v1/redis_failover_spec_redis_storage_persistent_volume_claim_spec.rb

@@ -0,0 +1,48 @@
+# typed: true
+
+module Kuby
+  module Redis
+    module DSL
+      module Databases
+        module V1
+          class RedisFailoverSpecRedisStoragePersistentVolumeClaimSpec < ::KubeDSL::DSLObject
+            value_field :storage_class_name
+            value_field :volume_mode
+            object_field(:selector) { Kuby::Redis::DSL::Databases::V1::RedisFailoverSpecRedisStoragePersistentVolumeClaimSpecSelector.new }
+            value_field :access_modes
+            object_field(:data_source_ref) { Kuby::Redis::DSL::Databases::V1::RedisFailoverSpecRedisStoragePersistentVolumeClaimSpecDataSourceRef.new }
+            object_field(:data_source) { Kuby::Redis::DSL::Databases::V1::RedisFailoverSpecRedisStoragePersistentVolumeClaimSpecDataSource.new }
+            value_field :volume_name
+            object_field(:resources) { Kuby::Redis::DSL::Databases::V1::RedisFailoverSpecRedisStoragePersistentVolumeClaimSpecResources.new }
+
+            validates :storage_class_name, field: { format: :string }, presence: false
+            validates :volume_mode, field: { format: :string }, presence: false
+            validates :selector, object: { kind_of: Kuby::Redis::DSL::Databases::V1::RedisFailoverSpecRedisStoragePersistentVolumeClaimSpecSelector }
+            validates :access_modes, field: { format: :string }, presence: false
+            validates :data_source_ref, object: { kind_of: Kuby::Redis::DSL::Databases::V1::RedisFailoverSpecRedisStoragePersistentVolumeClaimSpecDataSourceRef }
+            validates :data_source, object: { kind_of: Kuby::Redis::DSL::Databases::V1::RedisFailoverSpecRedisStoragePersistentVolumeClaimSpecDataSource }
+            validates :volume_name, field: { format: :string }, presence: false
+            validates :resources, object: { kind_of: Kuby::Redis::DSL::Databases::V1::RedisFailoverSpecRedisStoragePersistentVolumeClaimSpecResources }
+
+            def serialize
+              {}.tap do |result|
+                result[:storageClassName] = storage_class_name
+                result[:volumeMode] = volume_mode
+                result[:selector] = selector.serialize
+                result[:accessModes] = access_modes
+                result[:dataSourceRef] = data_source_ref.serialize
+                result[:dataSource] = data_source.serialize
+                result[:volumeName] = volume_name
+                result[:resources] = resources.serialize
+              end
+            end
+
+            def kind_sym
+              :redis_failover_spec_redis_storage_persistent_volume_claim_spec
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kuby/redis/dsl/databases/v1/redis_failover_spec_redis_storage_persistent_volume_claim_spec_data_source.rb

@@ -0,0 +1,33 @@
+# typed: true
+
+module Kuby
+  module Redis
+    module DSL
+      module Databases
+        module V1
+          class RedisFailoverSpecRedisStoragePersistentVolumeClaimSpecDataSource < ::KubeDSL::DSLObject
+            value_field :api_group
+            value_field :kind
+            value_field :name
+
+            validates :api_group, field: { format: :string }, presence: false
+            validates :kind, field: { format: :string }, presence: true
+            validates :name, field: { format: :string }, presence: true
+
+            def serialize
+              {}.tap do |result|
+                result[:apiGroup] = api_group
+                result[:kind] = kind
+                result[:name] = name
+              end
+            end
+
+            def kind_sym
+              :redis_failover_spec_redis_storage_persistent_volume_claim_spec_data_source
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kuby/redis/dsl/databases/v1/redis_failover_spec_redis_storage_persistent_volume_claim_spec_data_source_ref.rb

@@ -0,0 +1,33 @@
+# typed: true
+
+module Kuby
+  module Redis
+    module DSL
+      module Databases
+        module V1
+          class RedisFailoverSpecRedisStoragePersistentVolumeClaimSpecDataSourceRef < ::KubeDSL::DSLObject
+            value_field :api_group
+            value_field :kind
+            value_field :name
+
+            validates :api_group, field: { format: :string }, presence: false
+            validates :kind, field: { format: :string }, presence: true
+            validates :name, field: { format: :string }, presence: true
+
+            def serialize
+              {}.tap do |result|
+                result[:apiGroup] = api_group
+                result[:kind] = kind
+                result[:name] = name
+              end
+            end
+
+            def kind_sym
+              :redis_failover_spec_redis_storage_persistent_volume_claim_spec_data_source_ref
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kuby/redis/dsl/databases/v1/redis_failover_spec_redis_storage_persistent_volume_claim_spec_resources.rb

@@ -0,0 +1,30 @@
+# typed: true
+
+module Kuby
+  module Redis
+    module DSL
+      module Databases
+        module V1
+          class RedisFailoverSpecRedisStoragePersistentVolumeClaimSpecResources < ::KubeDSL::DSLObject
+            key_value_field(:requests, format: :string)
+            key_value_field(:limits, format: :string)
+
+            validates :requests, kv: { value_format: :string }, presence: true
+            validates :limits, kv: { value_format: :string }, presence: true
+
+            def serialize
+              {}.tap do |result|
+                result[:requests] = requests.serialize
+                result[:limits] = limits.serialize
+              end
+            end
+
+            def kind_sym
+              :redis_failover_spec_redis_storage_persistent_volume_claim_spec_resources
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kuby/redis/dsl/databases/v1/redis_failover_spec_redis_storage_persistent_volume_claim_spec_selector.rb

@@ -0,0 +1,30 @@
+# typed: true
+
+module Kuby
+  module Redis
+    module DSL
+      module Databases
+        module V1
+          class RedisFailoverSpecRedisStoragePersistentVolumeClaimSpecSelector < ::KubeDSL::DSLObject
+            key_value_field(:match_labels, format: :string)
+            array_field(:match_expression) { Kuby::Redis::DSL::Databases::V1::RedisFailoverSpecRedisStoragePersistentVolumeClaimSpecSelectorMatchExpressions.new }
+
+            validates :match_labels, kv: { value_format: :string }, presence: true
+            validates :match_expressions, array: { kind_of: Kuby::Redis::DSL::Databases::V1::RedisFailoverSpecRedisStoragePersistentVolumeClaimSpecSelectorMatchExpressions }, presence: false
+
+            def serialize
+              {}.tap do |result|
+                result[:matchLabels] = match_labels.serialize
+                result[:matchExpressions] = match_expressions.map(&:serialize)
+              end
+            end
+
+            def kind_sym
+              :redis_failover_spec_redis_storage_persistent_volume_claim_spec_selector
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kuby/redis/dsl/databases/v1/redis_failover_spec_redis_storage_persistent_volume_claim_spec_selector_match_expressions.rb

@@ -0,0 +1,33 @@
+# typed: true
+
+module Kuby
+  module Redis
+    module DSL
+      module Databases
+        module V1
+          class RedisFailoverSpecRedisStoragePersistentVolumeClaimSpecSelectorMatchExpressions < ::KubeDSL::DSLObject
+            value_field :operator
+            value_field :values
+            value_field :key
+
+            validates :operator, field: { format: :string }, presence: true
+            validates :values, field: { format: :string }, presence: false
+            validates :key, field: { format: :string }, presence: true
+
+            def serialize
+              {}.tap do |result|
+                result[:operator] = operator
+                result[:values] = values
+                result[:key] = key
+              end
+            end
+
+            def kind_sym
+              :redis_failover_spec_redis_storage_persistent_volume_claim_spec_selector_match_expressions
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kuby/redis/dsl/databases/v1/redis_failover_spec_redis_storage_persistent_volume_claim_status.rb

@@ -0,0 +1,36 @@
+# typed: true
+
+module Kuby
+  module Redis
+    module DSL
+      module Databases
+        module V1
+          class RedisFailoverSpecRedisStoragePersistentVolumeClaimStatus < ::KubeDSL::DSLObject
+            value_field :phase
+            value_field :access_modes
+            array_field(:condition) { Kuby::Redis::DSL::Databases::V1::RedisFailoverSpecRedisStoragePersistentVolumeClaimStatusConditions.new }
+            key_value_field(:capacity, format: :string)
+
+            validates :phase, field: { format: :string }, presence: false
+            validates :access_modes, field: { format: :string }, presence: false
+            validates :conditions, array: { kind_of: Kuby::Redis::DSL::Databases::V1::RedisFailoverSpecRedisStoragePersistentVolumeClaimStatusConditions }, presence: false
+            validates :capacity, kv: { value_format: :string }, presence: true
+
+            def serialize
+              {}.tap do |result|
+                result[:phase] = phase
+                result[:accessModes] = access_modes
+                result[:conditions] = conditions.map(&:serialize)
+                result[:capacity] = capacity.serialize
+              end
+            end
+
+            def kind_sym
+              :redis_failover_spec_redis_storage_persistent_volume_claim_status
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kuby/redis/dsl/databases/v1/redis_failover_spec_redis_storage_persistent_volume_claim_status_conditions.rb

@@ -0,0 +1,42 @@
+# typed: true
+
+module Kuby
+  module Redis
+    module DSL
+      module Databases
+        module V1
+          class RedisFailoverSpecRedisStoragePersistentVolumeClaimStatusConditions < ::KubeDSL::DSLObject
+            value_field :status
+            value_field :last_transition_time
+            value_field :reason
+            value_field :last_probe_time
+            value_field :message
+            value_field :type
+
+            validates :status, field: { format: :string }, presence: true
+            validates :last_transition_time, field: { format: :string }, presence: false
+            validates :reason, field: { format: :string }, presence: false
+            validates :last_probe_time, field: { format: :string }, presence: false
+            validates :message, field: { format: :string }, presence: false
+            validates :type, field: { format: :string }, presence: true
+
+            def serialize
+              {}.tap do |result|
+                result[:status] = status
+                result[:lastTransitionTime] = last_transition_time
+                result[:reason] = reason
+                result[:lastProbeTime] = last_probe_time
+                result[:message] = message
+                result[:type] = type
+              end
+            end
+
+            def kind_sym
+              :redis_failover_spec_redis_storage_persistent_volume_claim_status_conditions
+            end
+          end
+        end
+      end
+    end
+  end
+end