@bluedynamics/cdk8s-plone 0.1.23 → 0.1.24

package/lib/imports/vinyl.bluedynamics.eu.d.ts

@@ -0,0 +1,2419 @@
+import { ApiObject, ApiObjectMetadata, GroupVersionKind } from 'cdk8s';
+import { Construct } from 'constructs';
+/**
+ * VinylCache is the Schema for the vinylcaches API.
+It describes a complete Varnish cache cluster: replicas, backends, VCL configuration,
+clustering, and cache invalidation strategy.
+ *
+ * @schema VinylCache
+ */
+export declare class VinylCache extends ApiObject {
+    /**
+     * Returns the apiVersion and kind for "VinylCache"
+     */
+    static readonly GVK: GroupVersionKind;
+    /**
+     * Renders a Kubernetes manifest for "VinylCache".
+     *
+     * This can be used to inline resource manifests inside other objects (e.g. as templates).
+     *
+     * @param props initialization props
+     */
+    static manifest(props?: VinylCacheProps): any;
+    /**
+     * Defines a "VinylCache" API object
+     * @param scope the scope in which to define this object
+     * @param id a scope-local name for the object
+     * @param props initialization props
+     */
+    constructor(scope: Construct, id: string, props?: VinylCacheProps);
+    /**
+     * Renders the object to Kubernetes JSON.
+     */
+    toJson(): any;
+}
+/**
+ * VinylCache is the Schema for the vinylcaches API.
+ * It describes a complete Varnish cache cluster: replicas, backends, VCL configuration,
+ * clustering, and cache invalidation strategy.
+ *
+ * @schema VinylCache
+ */
+export interface VinylCacheProps {
+    /**
+     * @schema VinylCache#metadata
+     */
+    readonly metadata?: ApiObjectMetadata;
+    /**
+     * spec defines the desired state of the VinylCache cluster.
+     *
+     * @schema VinylCache#spec
+     */
+    readonly spec?: VinylCacheSpec;
+}
+/**
+ * Converts an object of type 'VinylCacheProps' to JSON representation.
+ */
+export declare function toJson_VinylCacheProps(obj: VinylCacheProps | undefined): Record<string, any> | undefined;
+/**
+ * spec defines the desired state of the VinylCache cluster.
+ *
+ * @schema VinylCacheSpec
+ */
+export interface VinylCacheSpec {
+    /**
+     * backends defines the upstream services Varnish will proxy to.
+     * At least one backend is required.
+     *
+     * @schema VinylCacheSpec#backends
+     */
+    readonly backends: VinylCacheSpecBackends[];
+    /**
+     * cluster configures Varnish clustering between pods.
+     *
+     * @schema VinylCacheSpec#cluster
+     */
+    readonly cluster?: VinylCacheSpecCluster;
+    /**
+     * debounce configures a grace period before applying endpoint changes to Varnish,
+     * preventing thundering-herd on rapid endpoint churn.
+     *
+     * @schema VinylCacheSpec#debounce
+     */
+    readonly debounce?: VinylCacheSpecDebounce;
+    /**
+     * director configures how Varnish distributes requests across backend endpoints.
+     *
+     * @schema VinylCacheSpec#director
+     */
+    readonly director?: VinylCacheSpecDirector;
+    /**
+     * image is the container image for the Varnish pods.
+     *
+     * @schema VinylCacheSpec#image
+     */
+    readonly image: string;
+    /**
+     * invalidation configures cache invalidation methods (PURGE, BAN, xkey).
+     *
+     * @schema VinylCacheSpec#invalidation
+     */
+    readonly invalidation?: VinylCacheSpecInvalidation;
+    /**
+     * monitoring configures Prometheus metrics and alerting rules.
+     *
+     * @schema VinylCacheSpec#monitoring
+     */
+    readonly monitoring?: VinylCacheSpecMonitoring;
+    /**
+     * pod configures pod-level scheduling and metadata.
+     *
+     * @schema VinylCacheSpec#pod
+     */
+    readonly pod?: VinylCacheSpecPod;
+    /**
+     * proxyProtocol enables PROXY protocol on a dedicated port for passing client IP.
+     *
+     * @schema VinylCacheSpec#proxyProtocol
+     */
+    readonly proxyProtocol?: VinylCacheSpecProxyProtocol;
+    /**
+     * replicas is the desired number of Varnish pods in the cluster.
+     *
+     * @schema VinylCacheSpec#replicas
+     */
+    readonly replicas: number;
+    /**
+     * resources sets CPU and memory requests/limits for the Varnish container.
+     *
+     * @schema VinylCacheSpec#resources
+     */
+    readonly resources?: VinylCacheSpecResources;
+    /**
+     * retry configures retry behaviour when VCL updates fail to apply.
+     *
+     * @schema VinylCacheSpec#retry
+     */
+    readonly retry?: VinylCacheSpecRetry;
+    /**
+     * service configures the Kubernetes Service created for traffic ingress.
+     *
+     * @schema VinylCacheSpec#service
+     */
+    readonly service?: VinylCacheSpecService;
+    /**
+     * storage configures one or more Varnish storage backends (malloc or file).
+     *
+     * @schema VinylCacheSpec#storage
+     */
+    readonly storage?: VinylCacheSpecStorage[];
+    /**
+     * varnishParameters are runtime parameters passed to varnishd via -p flags.
+     * Certain security-sensitive parameters are blocked by the admission webhook.
+     *
+     * @schema VinylCacheSpec#varnishParameters
+     */
+    readonly varnishParameters?: {
+        [key: string]: string;
+    };
+    /**
+     * vcl configures VCL generation: snippets injected into generated VCL subroutines,
+     * or a full VCL override.
+     *
+     * @schema VinylCacheSpec#vcl
+     */
+    readonly vcl?: VinylCacheSpecVcl;
+}
+/**
+ * Converts an object of type 'VinylCacheSpec' to JSON representation.
+ */
+export declare function toJson_VinylCacheSpec(obj: VinylCacheSpec | undefined): Record<string, any> | undefined;
+/**
+ * BackendSpec describes an upstream Kubernetes service used as a Varnish backend.
+ *
+ * @schema VinylCacheSpecBackends
+ */
+export interface VinylCacheSpecBackends {
+    /**
+     * connectionParameters configures backend connection pool timeouts and limits.
+     *
+     * @schema VinylCacheSpecBackends#connectionParameters
+     */
+    readonly connectionParameters?: VinylCacheSpecBackendsConnectionParameters;
+    /**
+     * name is the VCL identifier for this backend. Must match ^[a-zA-Z][a-zA-Z0-9_]*$.
+     *
+     * @schema VinylCacheSpecBackends#name
+     */
+    readonly name: string;
+    /**
+     * port overrides the service port used for this backend.
+     *
+     * @schema VinylCacheSpecBackends#port
+     */
+    readonly port?: number;
+    /**
+     * probe configures the Varnish backend health probe.
+     *
+     * @schema VinylCacheSpecBackends#probe
+     */
+    readonly probe?: VinylCacheSpecBackendsProbe;
+    /**
+     * serviceRef references the Kubernetes Service in the same namespace.
+     *
+     * @schema VinylCacheSpecBackends#serviceRef
+     */
+    readonly serviceRef: VinylCacheSpecBackendsServiceRef;
+    /**
+     * weight is the relative weight for the director. 0 means standby (fallback director).
+     *
+     * @schema VinylCacheSpecBackends#weight
+     */
+    readonly weight?: number;
+}
+/**
+ * Converts an object of type 'VinylCacheSpecBackends' to JSON representation.
+ */
+export declare function toJson_VinylCacheSpecBackends(obj: VinylCacheSpecBackends | undefined): Record<string, any> | undefined;
+/**
+ * cluster configures Varnish clustering between pods.
+ *
+ * @schema VinylCacheSpecCluster
+ */
+export interface VinylCacheSpecCluster {
+    /**
+     * enabled activates inter-pod clustering via a shard director.
+     *
+     * @schema VinylCacheSpecCluster#enabled
+     */
+    readonly enabled?: boolean;
+    /**
+     * peerRouting configures how requests are routed between Varnish peers.
+     *
+     * @schema VinylCacheSpecCluster#peerRouting
+     */
+    readonly peerRouting?: VinylCacheSpecClusterPeerRouting;
+}
+/**
+ * Converts an object of type 'VinylCacheSpecCluster' to JSON representation.
+ */
+export declare function toJson_VinylCacheSpecCluster(obj: VinylCacheSpecCluster | undefined): Record<string, any> | undefined;
+/**
+ * debounce configures a grace period before applying endpoint changes to Varnish,
+ * preventing thundering-herd on rapid endpoint churn.
+ *
+ * @schema VinylCacheSpecDebounce
+ */
+export interface VinylCacheSpecDebounce {
+    /**
+     * duration is the time to wait after the last endpoint change before pushing a VCL update.
+     * This prevents thundering-herd on rapid endpoint churn. Default: 5s.
+     *
+     * @schema VinylCacheSpecDebounce#duration
+     */
+    readonly duration?: string;
+}
+/**
+ * Converts an object of type 'VinylCacheSpecDebounce' to JSON representation.
+ */
+export declare function toJson_VinylCacheSpecDebounce(obj: VinylCacheSpecDebounce | undefined): Record<string, any> | undefined;
+/**
+ * director configures how Varnish distributes requests across backend endpoints.
+ *
+ * @schema VinylCacheSpecDirector
+ */
+export interface VinylCacheSpecDirector {
+    /**
+     * hash configures the hash director. Only used when type is "hash".
+     *
+     * @schema VinylCacheSpecDirector#hash
+     */
+    readonly hash?: VinylCacheSpecDirectorHash;
+    /**
+     * shard configures the shard director (consistent-hash). Only used when type is "shard".
+     *
+     * @schema VinylCacheSpecDirector#shard
+     */
+    readonly shard?: VinylCacheSpecDirectorShard;
+    /**
+     * type selects the Varnish director algorithm.
+     * "shard" (default) provides consistent hashing; "round_robin", "random", and "hash"
+     * are also supported.
+     *
+     * @schema VinylCacheSpecDirector#type
+     */
+    readonly type?: VinylCacheSpecDirectorType;
+}
+/**
+ * Converts an object of type 'VinylCacheSpecDirector' to JSON representation.
+ */
+export declare function toJson_VinylCacheSpecDirector(obj: VinylCacheSpecDirector | undefined): Record<string, any> | undefined;
+/**
+ * invalidation configures cache invalidation methods (PURGE, BAN, xkey).
+ *
+ * @schema VinylCacheSpecInvalidation
+ */
+export interface VinylCacheSpecInvalidation {
+    /**
+     * ban configures BAN-based cache invalidation.
+     *
+     * @schema VinylCacheSpecInvalidation#ban
+     */
+    readonly ban?: VinylCacheSpecInvalidationBan;
+    /**
+     * purge configures HTTP PURGE-based cache invalidation.
+     *
+     * @schema VinylCacheSpecInvalidation#purge
+     */
+    readonly purge?: VinylCacheSpecInvalidationPurge;
+    /**
+     * xkey configures xkey-based surrogate key invalidation (requires vmod_xkey).
+     *
+     * @schema VinylCacheSpecInvalidation#xkey
+     */
+    readonly xkey?: VinylCacheSpecInvalidationXkey;
+}
+/**
+ * Converts an object of type 'VinylCacheSpecInvalidation' to JSON representation.
+ */
+export declare function toJson_VinylCacheSpecInvalidation(obj: VinylCacheSpecInvalidation | undefined): Record<string, any> | undefined;
+/**
+ * monitoring configures Prometheus metrics and alerting rules.
+ *
+ * @schema VinylCacheSpecMonitoring
+ */
+export interface VinylCacheSpecMonitoring {
+    /**
+     * enabled activates Prometheus metrics scraping.
+     *
+     * @schema VinylCacheSpecMonitoring#enabled
+     */
+    readonly enabled?: boolean;
+    /**
+     * prometheusRules configures PrometheusRule objects for alerting.
+     *
+     * @schema VinylCacheSpecMonitoring#prometheusRules
+     */
+    readonly prometheusRules?: VinylCacheSpecMonitoringPrometheusRules;
+    /**
+     * serviceMonitor configures a ServiceMonitor for Prometheus Operator scraping.
+     *
+     * @schema VinylCacheSpecMonitoring#serviceMonitor
+     */
+    readonly serviceMonitor?: VinylCacheSpecMonitoringServiceMonitor;
+}
+/**
+ * Converts an object of type 'VinylCacheSpecMonitoring' to JSON representation.
+ */
+export declare function toJson_VinylCacheSpecMonitoring(obj: VinylCacheSpecMonitoring | undefined): Record<string, any> | undefined;
+/**
+ * pod configures pod-level scheduling and metadata.
+ *
+ * @schema VinylCacheSpecPod
+ */
+export interface VinylCacheSpecPod {
+    /**
+     * affinity configures pod affinity and anti-affinity scheduling rules.
+     *
+     * @schema VinylCacheSpecPod#affinity
+     */
+    readonly affinity?: VinylCacheSpecPodAffinity;
+    /**
+     * annotations are added to each Varnish pod.
+     *
+     * @schema VinylCacheSpecPod#annotations
+     */
+    readonly annotations?: {
+        [key: string]: string;
+    };
+    /**
+     * labels are added to each Varnish pod (merged with operator-managed labels).
+     *
+     * @schema VinylCacheSpecPod#labels
+     */
+    readonly labels?: {
+        [key: string]: string;
+    };
+    /**
+     * nodeSelector constrains pods to nodes matching all specified labels.
+     *
+     * @schema VinylCacheSpecPod#nodeSelector
+     */
+    readonly nodeSelector?: {
+        [key: string]: string;
+    };
+    /**
+     * priorityClassName is the name of the PriorityClass for Varnish pods.
+     *
+     * @schema VinylCacheSpecPod#priorityClassName
+     */
+    readonly priorityClassName?: string;
+    /**
+     * tolerations allow pods to be scheduled on tainted nodes.
+     *
+     * @schema VinylCacheSpecPod#tolerations
+     */
+    readonly tolerations?: VinylCacheSpecPodTolerations[];
+}
+/**
+ * Converts an object of type 'VinylCacheSpecPod' to JSON representation.
+ */
+export declare function toJson_VinylCacheSpecPod(obj: VinylCacheSpecPod | undefined): Record<string, any> | undefined;
+/**
+ * proxyProtocol enables PROXY protocol on a dedicated port for passing client IP.
+ *
+ * @schema VinylCacheSpecProxyProtocol
+ */
+export interface VinylCacheSpecProxyProtocol {
+    /**
+     * enabled activates PROXY protocol support.
+     *
+     * @schema VinylCacheSpecProxyProtocol#enabled
+     */
+    readonly enabled?: boolean;
+    /**
+     * port is the port on which PROXY protocol connections are accepted. Default: 8081.
+     *
+     * @schema VinylCacheSpecProxyProtocol#port
+     */
+    readonly port?: number;
+}
+/**
+ * Converts an object of type 'VinylCacheSpecProxyProtocol' to JSON representation.
+ */
+export declare function toJson_VinylCacheSpecProxyProtocol(obj: VinylCacheSpecProxyProtocol | undefined): Record<string, any> | undefined;
+/**
+ * resources sets CPU and memory requests/limits for the Varnish container.
+ *
+ * @schema VinylCacheSpecResources
+ */
+export interface VinylCacheSpecResources {
+    /**
+     * Claims lists the names of resources, defined in spec.resourceClaims,
+     * that are used by this container.
+     *
+     * This field depends on the
+     * DynamicResourceAllocation feature gate.
+     *
+     * This field is immutable. It can only be set for containers.
+     *
+     * @schema VinylCacheSpecResources#claims
+     */
+    readonly claims?: VinylCacheSpecResourcesClaims[];
+    /**
+     * Limits describes the maximum amount of compute resources allowed.
+     * More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/
+     *
+     * @schema VinylCacheSpecResources#limits
+     */
+    readonly limits?: {
+        [key: string]: VinylCacheSpecResourcesLimits;
+    };
+    /**
+     * Requests describes the minimum amount of compute resources required.
+     * If Requests is omitted for a container, it defaults to Limits if that is explicitly specified,
+     * otherwise to an implementation-defined value. Requests cannot exceed Limits.
+     * More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/
+     *
+     * @schema VinylCacheSpecResources#requests
+     */
+    readonly requests?: {
+        [key: string]: VinylCacheSpecResourcesRequests;
+    };
+}
+/**
+ * Converts an object of type 'VinylCacheSpecResources' to JSON representation.
+ */
+export declare function toJson_VinylCacheSpecResources(obj: VinylCacheSpecResources | undefined): Record<string, any> | undefined;
+/**
+ * retry configures retry behaviour when VCL updates fail to apply.
+ *
+ * @schema VinylCacheSpecRetry
+ */
+export interface VinylCacheSpecRetry {
+    /**
+     * backoffBase is the initial backoff duration between retry attempts. Default: 5s.
+     *
+     * @schema VinylCacheSpecRetry#backoffBase
+     */
+    readonly backoffBase?: string;
+    /**
+     * backoffMax is the maximum backoff duration (exponential backoff cap). Default: 5m.
+     *
+     * @schema VinylCacheSpecRetry#backoffMax
+     */
+    readonly backoffMax?: string;
+    /**
+     * maxAttempts is the maximum number of VCL push attempts before the operator
+     * transitions to Error phase. Default: 3.
+     *
+     * @schema VinylCacheSpecRetry#maxAttempts
+     */
+    readonly maxAttempts?: number;
+}
+/**
+ * Converts an object of type 'VinylCacheSpecRetry' to JSON representation.
+ */
+export declare function toJson_VinylCacheSpecRetry(obj: VinylCacheSpecRetry | undefined): Record<string, any> | undefined;
+/**
+ * service configures the Kubernetes Service created for traffic ingress.
+ *
+ * @schema VinylCacheSpecService
+ */
+export interface VinylCacheSpecService {
+    /**
+     * annotations are added to the Service object.
+     *
+     * @schema VinylCacheSpecService#annotations
+     */
+    readonly annotations?: {
+        [key: string]: string;
+    };
+    /**
+     * type sets the Kubernetes Service type (ClusterIP, NodePort, LoadBalancer).
+     *
+     * @schema VinylCacheSpecService#type
+     */
+    readonly type?: VinylCacheSpecServiceType;
+}
+/**
+ * Converts an object of type 'VinylCacheSpecService' to JSON representation.
+ */
+export declare function toJson_VinylCacheSpecService(obj: VinylCacheSpecService | undefined): Record<string, any> | undefined;
+/**
+ * StorageSpec configures a Varnish storage backend.
+ *
+ * @schema VinylCacheSpecStorage
+ */
+export interface VinylCacheSpecStorage {
+    /**
+     * name is the internal storage identifier used in varnishd -s arguments.
+     *
+     * @schema VinylCacheSpecStorage#name
+     */
+    readonly name: string;
+    /**
+     * path is the filesystem path for file-type storage.
+     *
+     * @schema VinylCacheSpecStorage#path
+     */
+    readonly path?: string;
+    /**
+     * size is the storage allocation as a Kubernetes resource quantity (e.g. "1Gi").
+     * The operator converts to bytes for varnishd.
+     *
+     * @schema VinylCacheSpecStorage#size
+     */
+    readonly size?: VinylCacheSpecStorageSize;
+    /**
+     * type is the storage backend type. Only "malloc" and "file" are permitted.
+     * "persistent", "umem", and "default" are rejected by the admission webhook.
+     *
+     * @schema VinylCacheSpecStorage#type
+     */
+    readonly type: VinylCacheSpecStorageType;
+}
+/**
+ * Converts an object of type 'VinylCacheSpecStorage' to JSON representation.
+ */
+export declare function toJson_VinylCacheSpecStorage(obj: VinylCacheSpecStorage | undefined): Record<string, any> | undefined;
+/**
+ * vcl configures VCL generation: snippets injected into generated VCL subroutines,
+ * or a full VCL override.
+ *
+ * @schema VinylCacheSpecVcl
+ */
+export interface VinylCacheSpecVcl {
+    /**
+     * fullOverride replaces the entire generated VCL with a custom VCL string.
+     * Use with caution — this disables all structured configuration.
+     *
+     * @schema VinylCacheSpecVcl#fullOverride
+     */
+    readonly fullOverride?: string;
+    /**
+     * snippets provides VCL code injected into each generated subroutine.
+     *
+     * @schema VinylCacheSpecVcl#snippets
+     */
+    readonly snippets?: VinylCacheSpecVclSnippets;
+}
+/**
+ * Converts an object of type 'VinylCacheSpecVcl' to JSON representation.
+ */
+export declare function toJson_VinylCacheSpecVcl(obj: VinylCacheSpecVcl | undefined): Record<string, any> | undefined;
+/**
+ * connectionParameters configures backend connection pool timeouts and limits.
+ *
+ * @schema VinylCacheSpecBackendsConnectionParameters
+ */
+export interface VinylCacheSpecBackendsConnectionParameters {
+    /**
+     * betweenBytesTimeout is the maximum time to wait between bytes of the response body.
+     *
+     * @schema VinylCacheSpecBackendsConnectionParameters#betweenBytesTimeout
+     */
+    readonly betweenBytesTimeout?: string;
+    /**
+     * connectTimeout is the maximum time to establish a TCP connection to the backend.
+     *
+     * @schema VinylCacheSpecBackendsConnectionParameters#connectTimeout
+     */
+    readonly connectTimeout?: string;
+    /**
+     * firstByteTimeout is the maximum time to wait for the first byte of the response.
+     *
+     * @schema VinylCacheSpecBackendsConnectionParameters#firstByteTimeout
+     */
+    readonly firstByteTimeout?: string;
+    /**
+     * idleTimeout is the maximum time an idle connection may be reused. Should be less
+     * than the backend's keep-alive timeout to avoid 503 races.
+     *
+     * @schema VinylCacheSpecBackendsConnectionParameters#idleTimeout
+     */
+    readonly idleTimeout?: string;
+    /**
+     * maxConnections is the maximum number of concurrent connections to the backend.
+     *
+     * @schema VinylCacheSpecBackendsConnectionParameters#maxConnections
+     */
+    readonly maxConnections?: number;
+}
+/**
+ * Converts an object of type 'VinylCacheSpecBackendsConnectionParameters' to JSON representation.
+ */
+export declare function toJson_VinylCacheSpecBackendsConnectionParameters(obj: VinylCacheSpecBackendsConnectionParameters | undefined): Record<string, any> | undefined;
+/**
+ * probe configures the Varnish backend health probe.
+ *
+ * @schema VinylCacheSpecBackendsProbe
+ */
+export interface VinylCacheSpecBackendsProbe {
+    /**
+     * expectedResponse is the expected HTTP response status code. Defaults to 200.
+     *
+     * @default 200.
+     * @schema VinylCacheSpecBackendsProbe#expectedResponse
+     */
+    readonly expectedResponse?: number;
+    /**
+     * interval is how often to probe the backend.
+     *
+     * @schema VinylCacheSpecBackendsProbe#interval
+     */
+    readonly interval?: string;
+    /**
+     * threshold is the minimum number of successful probes within the window for the backend
+     * to be considered healthy.
+     *
+     * @schema VinylCacheSpecBackendsProbe#threshold
+     */
+    readonly threshold?: number;
+    /**
+     * timeout is the maximum time to wait for a probe response.
+     *
+     * @schema VinylCacheSpecBackendsProbe#timeout
+     */
+    readonly timeout?: string;
+    /**
+     * url is the URL to probe. If empty, the backend's root path is used.
+     *
+     * @schema VinylCacheSpecBackendsProbe#url
+     */
+    readonly url?: string;
+    /**
+     * window is the number of most recent probes to consider for threshold evaluation.
+     *
+     * @schema VinylCacheSpecBackendsProbe#window
+     */
+    readonly window?: number;
+}
+/**
+ * Converts an object of type 'VinylCacheSpecBackendsProbe' to JSON representation.
+ */
+export declare function toJson_VinylCacheSpecBackendsProbe(obj: VinylCacheSpecBackendsProbe | undefined): Record<string, any> | undefined;
+/**
+ * serviceRef references the Kubernetes Service in the same namespace.
+ *
+ * @schema VinylCacheSpecBackendsServiceRef
+ */
+export interface VinylCacheSpecBackendsServiceRef {
+    /**
+     * name is the Kubernetes Service name.
+     *
+     * @schema VinylCacheSpecBackendsServiceRef#name
+     */
+    readonly name: string;
+}
+/**
+ * Converts an object of type 'VinylCacheSpecBackendsServiceRef' to JSON representation.
+ */
+export declare function toJson_VinylCacheSpecBackendsServiceRef(obj: VinylCacheSpecBackendsServiceRef | undefined): Record<string, any> | undefined;
+/**
+ * peerRouting configures how requests are routed between Varnish peers.
+ *
+ * @schema VinylCacheSpecClusterPeerRouting
+ */
+export interface VinylCacheSpecClusterPeerRouting {
+    /**
+     * type is the routing strategy between Varnish pods. Only "shard" is supported.
+     *
+     * @schema VinylCacheSpecClusterPeerRouting#type
+     */
+    readonly type?: VinylCacheSpecClusterPeerRoutingType;
+}
+/**
+ * Converts an object of type 'VinylCacheSpecClusterPeerRouting' to JSON representation.
+ */
+export declare function toJson_VinylCacheSpecClusterPeerRouting(obj: VinylCacheSpecClusterPeerRouting | undefined): Record<string, any> | undefined;
+/**
+ * hash configures the hash director. Only used when type is "hash".
+ *
+ * @schema VinylCacheSpecDirectorHash
+ */
+export interface VinylCacheSpecDirectorHash {
+    /**
+     * header is the request header name used as the hash key.
+     *
+     * @schema VinylCacheSpecDirectorHash#header
+     */
+    readonly header?: string;
+}
+/**
+ * Converts an object of type 'VinylCacheSpecDirectorHash' to JSON representation.
+ */
+export declare function toJson_VinylCacheSpecDirectorHash(obj: VinylCacheSpecDirectorHash | undefined): Record<string, any> | undefined;
+/**
+ * shard configures the shard director (consistent-hash). Only used when type is "shard".
+ *
+ * @schema VinylCacheSpecDirectorShard
+ */
+export interface VinylCacheSpecDirectorShard {
+    /**
+     * by determines what value is hashed for shard selection. "HASH" uses the Varnish
+     * hash (default); "URL" uses the request URL.
+     *
+     * @schema VinylCacheSpecDirectorShard#by
+     */
+    readonly by?: VinylCacheSpecDirectorShardBy;
+    /**
+     * healthy controls which backends the director considers when selecting a shard.
+     * "CHOSEN" (default) only considers the chosen backend healthy; "ALL" requires all
+     * backends to be healthy.
+     *
+     * @schema VinylCacheSpecDirectorShard#healthy
+     */
+    readonly healthy?: VinylCacheSpecDirectorShardHealthy;
+    /**
+     * rampup is the time after adding a backend before it receives its full share of traffic,
+     * preventing thundering-herd. Default: 30s.
+     *
+     * @schema VinylCacheSpecDirectorShard#rampup
+     */
+    readonly rampup?: string;
+    /**
+     * replicas is the number of Ketama replicas per backend in the hash ring. Default: 67.
+     *
+     * @schema VinylCacheSpecDirectorShard#replicas
+     */
+    readonly replicas?: number;
+    /**
+     * warmup is the proportion of requests (0.0–1.0) sent to the alternative backend
+     * to pre-populate its cache. Default: 0.1. Must be between 0.0 and 1.0.
+     *
+     * @schema VinylCacheSpecDirectorShard#warmup
+     */
+    readonly warmup?: number;
+}
+/**
+ * Converts an object of type 'VinylCacheSpecDirectorShard' to JSON representation.
+ */
+export declare function toJson_VinylCacheSpecDirectorShard(obj: VinylCacheSpecDirectorShard | undefined): Record<string, any> | undefined;
+/**
+ * type selects the Varnish director algorithm.
+ * "shard" (default) provides consistent hashing; "round_robin", "random", and "hash"
+ * are also supported.
+ *
+ * @schema VinylCacheSpecDirectorType
+ */
+export declare enum VinylCacheSpecDirectorType {
+    /** shard */
+    SHARD = "shard",
+    /** round_robin */
+    ROUND_UNDERSCORE_ROBIN = "round_robin",
+    /** random */
+    RANDOM = "random",
+    /** hash */
+    HASH = "hash"
+}
+/**
+ * ban configures BAN-based cache invalidation.
+ *
+ * @schema VinylCacheSpecInvalidationBan
+ */
+export interface VinylCacheSpecInvalidationBan {
+    /**
+     * allowedSources is a list of CIDR ranges permitted to send BAN requests.
+     *
+     * @schema VinylCacheSpecInvalidationBan#allowedSources
+     */
+    readonly allowedSources?: string[];
+    /**
+     * enabled activates the BAN invalidation handler.
+     *
+     * @schema VinylCacheSpecInvalidationBan#enabled
+     */
+    readonly enabled?: boolean;
+    /**
+     * rateLimitPerMinute limits BAN requests per minute. 0 means no limit.
+     *
+     * @schema VinylCacheSpecInvalidationBan#rateLimitPerMinute
+     */
+    readonly rateLimitPerMinute?: number;
+}
+/**
+ * Converts an object of type 'VinylCacheSpecInvalidationBan' to JSON representation.
+ */
+export declare function toJson_VinylCacheSpecInvalidationBan(obj: VinylCacheSpecInvalidationBan | undefined): Record<string, any> | undefined;
+/**
+ * purge configures HTTP PURGE-based cache invalidation.
+ *
+ * @schema VinylCacheSpecInvalidationPurge
+ */
+export interface VinylCacheSpecInvalidationPurge {
+    /**
+     * allowedSources is a list of CIDR ranges permitted to send PURGE requests.
+     * If empty, no source restriction is applied.
+     *
+     * @schema VinylCacheSpecInvalidationPurge#allowedSources
+     */
+    readonly allowedSources?: string[];
+    /**
+     * enabled activates the PURGE invalidation handler.
+     *
+     * @schema VinylCacheSpecInvalidationPurge#enabled
+     */
+    readonly enabled?: boolean;
+    /**
+     * soft enables soft purges, which mark objects as expired rather than removing them.
+     * This allows Varnish to serve stale content while revalidating. Default: true.
+     *
+     * @schema VinylCacheSpecInvalidationPurge#soft
+     */
+    readonly soft?: boolean;
+}
+/**
+ * Converts an object of type 'VinylCacheSpecInvalidationPurge' to JSON representation.
+ */
+export declare function toJson_VinylCacheSpecInvalidationPurge(obj: VinylCacheSpecInvalidationPurge | undefined): Record<string, any> | undefined;
+/**
+ * xkey configures xkey-based surrogate key invalidation (requires vmod_xkey).
+ *
+ * @schema VinylCacheSpecInvalidationXkey
+ */
+export interface VinylCacheSpecInvalidationXkey {
+    /**
+     * allowedSources is a list of CIDR ranges permitted to send xkey invalidation requests.
+     *
+     * @schema VinylCacheSpecInvalidationXkey#allowedSources
+     */
+    readonly allowedSources?: string[];
+    /**
+     * enabled activates xkey-based invalidation.
+     *
+     * @schema VinylCacheSpecInvalidationXkey#enabled
+     */
+    readonly enabled?: boolean;
+    /**
+     * softPurge enables soft purging via xkey. Default: true.
+     *
+     * @schema VinylCacheSpecInvalidationXkey#softPurge
+     */
+    readonly softPurge?: boolean;
+}
+/**
+ * Converts an object of type 'VinylCacheSpecInvalidationXkey' to JSON representation.
+ */
+export declare function toJson_VinylCacheSpecInvalidationXkey(obj: VinylCacheSpecInvalidationXkey | undefined): Record<string, any> | undefined;
+/**
+ * prometheusRules configures PrometheusRule objects for alerting.
+ *
+ * @schema VinylCacheSpecMonitoringPrometheusRules
+ */
+export interface VinylCacheSpecMonitoringPrometheusRules {
+    /**
+     * enabled creates a PrometheusRule with default alerting rules.
+     *
+     * @schema VinylCacheSpecMonitoringPrometheusRules#enabled
+     */
+    readonly enabled?: boolean;
+}
+/**
+ * Converts an object of type 'VinylCacheSpecMonitoringPrometheusRules' to JSON representation.
+ */
+export declare function toJson_VinylCacheSpecMonitoringPrometheusRules(obj: VinylCacheSpecMonitoringPrometheusRules | undefined): Record<string, any> | undefined;
+/**
+ * serviceMonitor configures a ServiceMonitor for Prometheus Operator scraping.
+ *
+ * @schema VinylCacheSpecMonitoringServiceMonitor
+ */
+export interface VinylCacheSpecMonitoringServiceMonitor {
+    /**
+     * enabled creates a ServiceMonitor targeting the Varnish metrics endpoint.
+     *
+     * @schema VinylCacheSpecMonitoringServiceMonitor#enabled
+     */
+    readonly enabled?: boolean;
+    /**
+     * interval is the scrape interval (e.g. "30s"). Defaults to the Prometheus global interval.
+     *
+     * @default the Prometheus global interval.
+     * @schema VinylCacheSpecMonitoringServiceMonitor#interval
+     */
+    readonly interval?: string;
+}
+/**
+ * Converts an object of type 'VinylCacheSpecMonitoringServiceMonitor' to JSON representation.
+ */
+export declare function toJson_VinylCacheSpecMonitoringServiceMonitor(obj: VinylCacheSpecMonitoringServiceMonitor | undefined): Record<string, any> | undefined;
+/**
+ * affinity configures pod affinity and anti-affinity scheduling rules.
+ *
+ * @schema VinylCacheSpecPodAffinity
+ */
+export interface VinylCacheSpecPodAffinity {
+    /**
+     * Describes node affinity scheduling rules for the pod.
+     *
+     * @schema VinylCacheSpecPodAffinity#nodeAffinity
+     */
+    readonly nodeAffinity?: VinylCacheSpecPodAffinityNodeAffinity;
+    /**
+     * Describes pod affinity scheduling rules (e.g. co-locate this pod in the same node, zone, etc. as some other pod(s)).
+     *
+     * @schema VinylCacheSpecPodAffinity#podAffinity
+     */
+    readonly podAffinity?: VinylCacheSpecPodAffinityPodAffinity;
+    /**
+     * Describes pod anti-affinity scheduling rules (e.g. avoid putting this pod in the same node, zone, etc. as some other pod(s)).
+     *
+     * @schema VinylCacheSpecPodAffinity#podAntiAffinity
+     */
+    readonly podAntiAffinity?: VinylCacheSpecPodAffinityPodAntiAffinity;
+}
+/**
+ * Converts an object of type 'VinylCacheSpecPodAffinity' to JSON representation.
+ */
+export declare function toJson_VinylCacheSpecPodAffinity(obj: VinylCacheSpecPodAffinity | undefined): Record<string, any> | undefined;
+/**
+ * The pod this Toleration is attached to tolerates any taint that matches
+ * the triple <key,value,effect> using the matching operator <operator>.
+ *
+ * @schema VinylCacheSpecPodTolerations
+ */
+export interface VinylCacheSpecPodTolerations {
+    /**
+     * Effect indicates the taint effect to match. Empty means match all taint effects.
+     * When specified, allowed values are NoSchedule, PreferNoSchedule and NoExecute.
+     *
+     * @schema VinylCacheSpecPodTolerations#effect
+     */
+    readonly effect?: string;
+    /**
+     * Key is the taint key that the toleration applies to. Empty means match all taint keys.
+     * If the key is empty, operator must be Exists; this combination means to match all values and all keys.
+     *
+     * @schema VinylCacheSpecPodTolerations#key
+     */
+    readonly key?: string;
+    /**
+     * Operator represents a key's relationship to the value.
+     * Valid operators are Exists, Equal, Lt, and Gt. Defaults to Equal.
+     * Exists is equivalent to wildcard for value, so that a pod can
+     * tolerate all taints of a particular category.
+     * Lt and Gt perform numeric comparisons (requires feature gate TaintTolerationComparisonOperators).
+     *
+     * @default Equal.
+     * @schema VinylCacheSpecPodTolerations#operator
+     */
+    readonly operator?: string;
+    /**
+     * TolerationSeconds represents the period of time the toleration (which must be
+     * of effect NoExecute, otherwise this field is ignored) tolerates the taint. By default,
+     * it is not set, which means tolerate the taint forever (do not evict). Zero and
+     * negative values will be treated as 0 (evict immediately) by the system.
+     *
+     * @schema VinylCacheSpecPodTolerations#tolerationSeconds
+     */
+    readonly tolerationSeconds?: number;
+    /**
+     * Value is the taint value the toleration matches to.
+     * If the operator is Exists, the value should be empty, otherwise just a regular string.
+     *
+     * @schema VinylCacheSpecPodTolerations#value
+     */
+    readonly value?: string;
+}
+/**
+ * Converts an object of type 'VinylCacheSpecPodTolerations' to JSON representation.
+ */
+export declare function toJson_VinylCacheSpecPodTolerations(obj: VinylCacheSpecPodTolerations | undefined): Record<string, any> | undefined;
+/**
+ * ResourceClaim references one entry in PodSpec.ResourceClaims.
+ *
+ * @schema VinylCacheSpecResourcesClaims
+ */
+export interface VinylCacheSpecResourcesClaims {
+    /**
+     * Name must match the name of one entry in pod.spec.resourceClaims of
+     * the Pod where this field is used. It makes that resource available
+     * inside a container.
+     *
+     * @schema VinylCacheSpecResourcesClaims#name
+     */
+    readonly name: string;
+    /**
+     * Request is the name chosen for a request in the referenced claim.
+     * If empty, everything from the claim is made available, otherwise
+     * only the result of this request.
+     *
+     * @schema VinylCacheSpecResourcesClaims#request
+     */
+    readonly request?: string;
+}
+/**
+ * Converts an object of type 'VinylCacheSpecResourcesClaims' to JSON representation.
+ */
+export declare function toJson_VinylCacheSpecResourcesClaims(obj: VinylCacheSpecResourcesClaims | undefined): Record<string, any> | undefined;
+/**
+ * @schema VinylCacheSpecResourcesLimits
+ */
+export declare class VinylCacheSpecResourcesLimits {
+    readonly value: number | string;
+    static fromNumber(value: number): VinylCacheSpecResourcesLimits;
+    static fromString(value: string): VinylCacheSpecResourcesLimits;
+    private constructor();
+}
+/**
+ * @schema VinylCacheSpecResourcesRequests
+ */
+export declare class VinylCacheSpecResourcesRequests {
+    readonly value: number | string;
+    static fromNumber(value: number): VinylCacheSpecResourcesRequests;
+    static fromString(value: string): VinylCacheSpecResourcesRequests;
+    private constructor();
+}
+/**
+ * type sets the Kubernetes Service type (ClusterIP, NodePort, LoadBalancer).
+ *
+ * @schema VinylCacheSpecServiceType
+ */
+export declare enum VinylCacheSpecServiceType {
+    /** ClusterIP */
+    CLUSTER_IP = "ClusterIP",
+    /** NodePort */
+    NODE_PORT = "NodePort",
+    /** LoadBalancer */
+    LOAD_BALANCER = "LoadBalancer"
+}
+/**
+ * size is the storage allocation as a Kubernetes resource quantity (e.g. "1Gi").
+ * The operator converts to bytes for varnishd.
+ *
+ * @schema VinylCacheSpecStorageSize
+ */
+export declare class VinylCacheSpecStorageSize {
+    readonly value: number | string;
+    static fromNumber(value: number): VinylCacheSpecStorageSize;
+    static fromString(value: string): VinylCacheSpecStorageSize;
+    private constructor();
+}
+/**
+ * type is the storage backend type. Only "malloc" and "file" are permitted.
+ * "persistent", "umem", and "default" are rejected by the admission webhook.
+ *
+ * @schema VinylCacheSpecStorageType
+ */
+export declare enum VinylCacheSpecStorageType {
+    /** malloc */
+    MALLOC = "malloc",
+    /** file */
+    FILE = "file"
+}
+/**
+ * snippets provides VCL code injected into each generated subroutine.
+ *
+ * @schema VinylCacheSpecVclSnippets
+ */
+export interface VinylCacheSpecVclSnippets {
+    /**
+     * header is inserted at the top of the VCL file, before any subroutines.
+     * Use for import statements and global declarations.
+     *
+     * @schema VinylCacheSpecVclSnippets#header
+     */
+    readonly header?: string;
+    /**
+     * vclBackendError is inserted into vcl_backend_error.
+     *
+     * @schema VinylCacheSpecVclSnippets#vclBackendError
+     */
+    readonly vclBackendError?: string;
+    /**
+     * vclBackendFetch is inserted into vcl_backend_fetch.
+     *
+     * @schema VinylCacheSpecVclSnippets#vclBackendFetch
+     */
+    readonly vclBackendFetch?: string;
+    /**
+     * vclBackendResponse is inserted into vcl_backend_response.
+     *
+     * @schema VinylCacheSpecVclSnippets#vclBackendResponse
+     */
+    readonly vclBackendResponse?: string;
+    /**
+     * vclDeliver is inserted into vcl_deliver.
+     *
+     * @schema VinylCacheSpecVclSnippets#vclDeliver
+     */
+    readonly vclDeliver?: string;
+    /**
+     * vclFini is inserted into vcl_fini.
+     *
+     * @schema VinylCacheSpecVclSnippets#vclFini
+     */
+    readonly vclFini?: string;
+    /**
+     * vclHash is inserted into vcl_hash.
+     *
+     * @schema VinylCacheSpecVclSnippets#vclHash
+     */
+    readonly vclHash?: string;
+    /**
+     * vclHit is inserted into vcl_hit.
+     *
+     * @schema VinylCacheSpecVclSnippets#vclHit
+     */
+    readonly vclHit?: string;
+    /**
+     * vclInit is inserted into the vcl_init subroutine after director initialisation.
+     *
+     * @schema VinylCacheSpecVclSnippets#vclInit
+     */
+    readonly vclInit?: string;
+    /**
+     * vclMiss is inserted into vcl_miss.
+     *
+     * @schema VinylCacheSpecVclSnippets#vclMiss
+     */
+    readonly vclMiss?: string;
+    /**
+     * vclPass is inserted into vcl_pass.
+     *
+     * @schema VinylCacheSpecVclSnippets#vclPass
+     */
+    readonly vclPass?: string;
+    /**
+     * vclPipe is inserted into vcl_pipe.
+     *
+     * @schema VinylCacheSpecVclSnippets#vclPipe
+     */
+    readonly vclPipe?: string;
+    /**
+     * vclPurge is inserted into vcl_purge.
+     *
+     * @schema VinylCacheSpecVclSnippets#vclPurge
+     */
+    readonly vclPurge?: string;
+    /**
+     * vclRecv is inserted into vcl_recv after generated routing logic, before return().
+     *
+     * @schema VinylCacheSpecVclSnippets#vclRecv
+     */
+    readonly vclRecv?: string;
+    /**
+     * vclSynth is inserted into vcl_synth.
+     *
+     * @schema VinylCacheSpecVclSnippets#vclSynth
+     */
+    readonly vclSynth?: string;
+}
+/**
+ * Converts an object of type 'VinylCacheSpecVclSnippets' to JSON representation.
+ */
+export declare function toJson_VinylCacheSpecVclSnippets(obj: VinylCacheSpecVclSnippets | undefined): Record<string, any> | undefined;
+/**
+ * type is the routing strategy between Varnish pods. Only "shard" is supported.
+ *
+ * @schema VinylCacheSpecClusterPeerRoutingType
+ */
+export declare enum VinylCacheSpecClusterPeerRoutingType {
+    /** shard */
+    SHARD = "shard"
+}
+/**
+ * by determines what value is hashed for shard selection. "HASH" uses the Varnish
+ * hash (default); "URL" uses the request URL.
+ *
+ * @schema VinylCacheSpecDirectorShardBy
+ */
+export declare enum VinylCacheSpecDirectorShardBy {
+    /** HASH */
+    HASH = "HASH",
+    /** URL */
+    URL = "URL"
+}
+/**
+ * healthy controls which backends the director considers when selecting a shard.
+ * "CHOSEN" (default) only considers the chosen backend healthy; "ALL" requires all
+ * backends to be healthy.
+ *
+ * @schema VinylCacheSpecDirectorShardHealthy
+ */
+export declare enum VinylCacheSpecDirectorShardHealthy {
+    /** CHOSEN */
+    CHOSEN = "CHOSEN",
+    /** ALL */
+    ALL = "ALL"
+}
+/**
+ * Describes node affinity scheduling rules for the pod.
+ *
+ * @schema VinylCacheSpecPodAffinityNodeAffinity
+ */
+export interface VinylCacheSpecPodAffinityNodeAffinity {
+    /**
+     * The scheduler will prefer to schedule pods to nodes that satisfy
+     * the affinity expressions specified by this field, but it may choose
+     * a node that violates one or more of the expressions. The node that is
+     * most preferred is the one with the greatest sum of weights, i.e.
+     * for each node that meets all of the scheduling requirements (resource
+     * request, requiredDuringScheduling affinity expressions, etc.),
+     * compute a sum by iterating through the elements of this field and adding
+     * "weight" to the sum if the node matches the corresponding matchExpressions; the
+     * node(s) with the highest sum are the most preferred.
+     *
+     * @schema VinylCacheSpecPodAffinityNodeAffinity#preferredDuringSchedulingIgnoredDuringExecution
+     */
+    readonly preferredDuringSchedulingIgnoredDuringExecution?: VinylCacheSpecPodAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecution[];
+    /**
+     * If the affinity requirements specified by this field are not met at
+     * scheduling time, the pod will not be scheduled onto the node.
+     * If the affinity requirements specified by this field cease to be met
+     * at some point during pod execution (e.g. due to an update), the system
+     * may or may not try to eventually evict the pod from its node.
+     *
+     * @schema VinylCacheSpecPodAffinityNodeAffinity#requiredDuringSchedulingIgnoredDuringExecution
+     */
+    readonly requiredDuringSchedulingIgnoredDuringExecution?: VinylCacheSpecPodAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecution;
+}
+/**
+ * Converts an object of type 'VinylCacheSpecPodAffinityNodeAffinity' to JSON representation.
+ */
+export declare function toJson_VinylCacheSpecPodAffinityNodeAffinity(obj: VinylCacheSpecPodAffinityNodeAffinity | undefined): Record<string, any> | undefined;
+/**
+ * Describes pod affinity scheduling rules (e.g. co-locate this pod in the same node, zone, etc. as some other pod(s)).
+ *
+ * @schema VinylCacheSpecPodAffinityPodAffinity
+ */
+export interface VinylCacheSpecPodAffinityPodAffinity {
+    /**
+     * The scheduler will prefer to schedule pods to nodes that satisfy
+     * the affinity expressions specified by this field, but it may choose
+     * a node that violates one or more of the expressions. The node that is
+     * most preferred is the one with the greatest sum of weights, i.e.
+     * for each node that meets all of the scheduling requirements (resource
+     * request, requiredDuringScheduling affinity expressions, etc.),
+     * compute a sum by iterating through the elements of this field and adding
+     * "weight" to the sum if the node has pods which matches the corresponding podAffinityTerm; the
+     * node(s) with the highest sum are the most preferred.
+     *
+     * @schema VinylCacheSpecPodAffinityPodAffinity#preferredDuringSchedulingIgnoredDuringExecution
+     */
+    readonly preferredDuringSchedulingIgnoredDuringExecution?: VinylCacheSpecPodAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecution[];
+    /**
+     * If the affinity requirements specified by this field are not met at
+     * scheduling time, the pod will not be scheduled onto the node.
+     * If the affinity requirements specified by this field cease to be met
+     * at some point during pod execution (e.g. due to a pod label update), the
+     * system may or may not try to eventually evict the pod from its node.
+     * When there are multiple elements, the lists of nodes corresponding to each
+     * podAffinityTerm are intersected, i.e. all terms must be satisfied.
+     *
+     * @schema VinylCacheSpecPodAffinityPodAffinity#requiredDuringSchedulingIgnoredDuringExecution
+     */
+    readonly requiredDuringSchedulingIgnoredDuringExecution?: VinylCacheSpecPodAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecution[];
+}
+/**
+ * Converts an object of type 'VinylCacheSpecPodAffinityPodAffinity' to JSON representation.
+ */
+export declare function toJson_VinylCacheSpecPodAffinityPodAffinity(obj: VinylCacheSpecPodAffinityPodAffinity | undefined): Record<string, any> | undefined;
+/**
+ * Describes pod anti-affinity scheduling rules (e.g. avoid putting this pod in the same node, zone, etc. as some other pod(s)).
+ *
+ * @schema VinylCacheSpecPodAffinityPodAntiAffinity
+ */
+export interface VinylCacheSpecPodAffinityPodAntiAffinity {
+    /**
+     * The scheduler will prefer to schedule pods to nodes that satisfy
+     * the anti-affinity expressions specified by this field, but it may choose
+     * a node that violates one or more of the expressions. The node that is
+     * most preferred is the one with the greatest sum of weights, i.e.
+     * for each node that meets all of the scheduling requirements (resource
+     * request, requiredDuringScheduling anti-affinity expressions, etc.),
+     * compute a sum by iterating through the elements of this field and subtracting
+     * "weight" from the sum if the node has pods which matches the corresponding podAffinityTerm; the
+     * node(s) with the highest sum are the most preferred.
+     *
+     * @schema VinylCacheSpecPodAffinityPodAntiAffinity#preferredDuringSchedulingIgnoredDuringExecution
+     */
+    readonly preferredDuringSchedulingIgnoredDuringExecution?: VinylCacheSpecPodAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecution[];
+    /**
+     * If the anti-affinity requirements specified by this field are not met at
+     * scheduling time, the pod will not be scheduled onto the node.
+     * If the anti-affinity requirements specified by this field cease to be met
+     * at some point during pod execution (e.g. due to a pod label update), the
+     * system may or may not try to eventually evict the pod from its node.
+     * When there are multiple elements, the lists of nodes corresponding to each
+     * podAffinityTerm are intersected, i.e. all terms must be satisfied.
+     *
+     * @schema VinylCacheSpecPodAffinityPodAntiAffinity#requiredDuringSchedulingIgnoredDuringExecution
+     */
+    readonly requiredDuringSchedulingIgnoredDuringExecution?: VinylCacheSpecPodAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecution[];
+}
+/**
+ * Converts an object of type 'VinylCacheSpecPodAffinityPodAntiAffinity' to JSON representation.
+ */
+export declare function toJson_VinylCacheSpecPodAffinityPodAntiAffinity(obj: VinylCacheSpecPodAffinityPodAntiAffinity | undefined): Record<string, any> | undefined;
+/**
+ * An empty preferred scheduling term matches all objects with implicit weight 0
+ * (i.e. it's a no-op). A null preferred scheduling term matches no objects (i.e. is also a no-op).
+ *
+ * @schema VinylCacheSpecPodAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecution
+ */
+export interface VinylCacheSpecPodAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecution {
+    /**
+     * A node selector term, associated with the corresponding weight.
+     *
+     * @schema VinylCacheSpecPodAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecution#preference
+     */
+    readonly preference: VinylCacheSpecPodAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreference;
+    /**
+     * Weight associated with matching the corresponding nodeSelectorTerm, in the range 1-100.
+     *
+     * @schema VinylCacheSpecPodAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecution#weight
+     */
+    readonly weight: number;
+}
+/**
+ * Converts an object of type 'VinylCacheSpecPodAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecution' to JSON representation.
+ */
+export declare function toJson_VinylCacheSpecPodAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecution(obj: VinylCacheSpecPodAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecution | undefined): Record<string, any> | undefined;
+/**
+ * If the affinity requirements specified by this field are not met at
+ * scheduling time, the pod will not be scheduled onto the node.
+ * If the affinity requirements specified by this field cease to be met
+ * at some point during pod execution (e.g. due to an update), the system
+ * may or may not try to eventually evict the pod from its node.
+ *
+ * @schema VinylCacheSpecPodAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecution
+ */
+export interface VinylCacheSpecPodAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecution {
+    /**
+     * Required. A list of node selector terms. The terms are ORed.
+     *
+     * @schema VinylCacheSpecPodAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecution#nodeSelectorTerms
+     */
+    readonly nodeSelectorTerms: VinylCacheSpecPodAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTerms[];
+}
+/**
+ * Converts an object of type 'VinylCacheSpecPodAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecution' to JSON representation.
+ */
+export declare function toJson_VinylCacheSpecPodAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecution(obj: VinylCacheSpecPodAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecution | undefined): Record<string, any> | undefined;
+/**
+ * The weights of all of the matched WeightedPodAffinityTerm fields are added per-node to find the most preferred node(s)
+ *
+ * @schema VinylCacheSpecPodAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecution
+ */
+export interface VinylCacheSpecPodAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecution {
+    /**
+     * Required. A pod affinity term, associated with the corresponding weight.
+     *
+     * @schema VinylCacheSpecPodAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecution#podAffinityTerm
+     */
+    readonly podAffinityTerm: VinylCacheSpecPodAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm;
+    /**
+     * weight associated with matching the corresponding podAffinityTerm,
+     * in the range 1-100.
+     *
+     * @schema VinylCacheSpecPodAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecution#weight
+     */
+    readonly weight: number;
+}
+/**
+ * Converts an object of type 'VinylCacheSpecPodAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecution' to JSON representation.
+ */
+export declare function toJson_VinylCacheSpecPodAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecution(obj: VinylCacheSpecPodAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecution | undefined): Record<string, any> | undefined;
+/**
+ * Defines a set of pods (namely those matching the labelSelector
+ * relative to the given namespace(s)) that this pod should be
+ * co-located (affinity) or not co-located (anti-affinity) with,
+ * where co-located is defined as running on a node whose value of
+ * the label with key <topologyKey> matches that of any node on which
+ * a pod of the set of pods is running
+ *
+ * @schema VinylCacheSpecPodAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecution
+ */
+export interface VinylCacheSpecPodAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecution {
+    /**
+     * A label query over a set of resources, in this case pods.
+     * If it's null, this PodAffinityTerm matches with no Pods.
+     *
+     * @schema VinylCacheSpecPodAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecution#labelSelector
+     */
+    readonly labelSelector?: VinylCacheSpecPodAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelector;
+    /**
+     * MatchLabelKeys is a set of pod label keys to select which pods will
+     * be taken into consideration. The keys are used to lookup values from the
+     * incoming pod labels, those key-value labels are merged with `labelSelector` as `key in (value)`
+     * to select the group of existing pods which pods will be taken into consideration
+     * for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming
+     * pod labels will be ignored. The default value is empty.
+     * The same key is forbidden to exist in both matchLabelKeys and labelSelector.
+     * Also, matchLabelKeys cannot be set when labelSelector isn't set.
+     *
+     * @schema VinylCacheSpecPodAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecution#matchLabelKeys
+     */
+    readonly matchLabelKeys?: string[];
+    /**
+     * MismatchLabelKeys is a set of pod label keys to select which pods will
+     * be taken into consideration. The keys are used to lookup values from the
+     * incoming pod labels, those key-value labels are merged with `labelSelector` as `key notin (value)`
+     * to select the group of existing pods which pods will be taken into consideration
+     * for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming
+     * pod labels will be ignored. The default value is empty.
+     * The same key is forbidden to exist in both mismatchLabelKeys and labelSelector.
+     * Also, mismatchLabelKeys cannot be set when labelSelector isn't set.
+     *
+     * @schema VinylCacheSpecPodAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecution#mismatchLabelKeys
+     */
+    readonly mismatchLabelKeys?: string[];
+    /**
+     * A label query over the set of namespaces that the term applies to.
+     * The term is applied to the union of the namespaces selected by this field
+     * and the ones listed in the namespaces field.
+     * null selector and null or empty namespaces list means "this pod's namespace".
+     * An empty selector ({}) matches all namespaces.
+     *
+     * @schema VinylCacheSpecPodAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecution#namespaceSelector
+     */
+    readonly namespaceSelector?: VinylCacheSpecPodAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelector;
+    /**
+     * namespaces specifies a static list of namespace names that the term applies to.
+     * The term is applied to the union of the namespaces listed in this field
+     * and the ones selected by namespaceSelector.
+     * null or empty namespaces list and null namespaceSelector means "this pod's namespace".
+     *
+     * @schema VinylCacheSpecPodAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecution#namespaces
+     */
+    readonly namespaces?: string[];
+    /**
+     * This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching
+     * the labelSelector in the specified namespaces, where co-located is defined as running on a node
+     * whose value of the label with key topologyKey matches that of any node on which any of the
+     * selected pods is running.
+     * Empty topologyKey is not allowed.
+     *
+     * @schema VinylCacheSpecPodAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecution#topologyKey
+     */
+    readonly topologyKey: string;
+}
+/**
+ * Converts an object of type 'VinylCacheSpecPodAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecution' to JSON representation.
+ */
+export declare function toJson_VinylCacheSpecPodAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecution(obj: VinylCacheSpecPodAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecution | undefined): Record<string, any> | undefined;
+/**
+ * The weights of all of the matched WeightedPodAffinityTerm fields are added per-node to find the most preferred node(s)
+ *
+ * @schema VinylCacheSpecPodAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecution
+ */
+export interface VinylCacheSpecPodAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecution {
+    /**
+     * Required. A pod affinity term, associated with the corresponding weight.
+     *
+     * @schema VinylCacheSpecPodAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecution#podAffinityTerm
+     */
+    readonly podAffinityTerm: VinylCacheSpecPodAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm;
+    /**
+     * weight associated with matching the corresponding podAffinityTerm,
+     * in the range 1-100.
+     *
+     * @schema VinylCacheSpecPodAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecution#weight
+     */
+    readonly weight: number;
+}
+/**
+ * Converts an object of type 'VinylCacheSpecPodAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecution' to JSON representation.
+ */
+export declare function toJson_VinylCacheSpecPodAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecution(obj: VinylCacheSpecPodAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecution | undefined): Record<string, any> | undefined;
+/**
+ * Defines a set of pods (namely those matching the labelSelector
+ * relative to the given namespace(s)) that this pod should be
+ * co-located (affinity) or not co-located (anti-affinity) with,
+ * where co-located is defined as running on a node whose value of
+ * the label with key <topologyKey> matches that of any node on which
+ * a pod of the set of pods is running
+ *
+ * @schema VinylCacheSpecPodAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecution
+ */
+export interface VinylCacheSpecPodAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecution {
+    /**
+     * A label query over a set of resources, in this case pods.
+     * If it's null, this PodAffinityTerm matches with no Pods.
+     *
+     * @schema VinylCacheSpecPodAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecution#labelSelector
+     */
+    readonly labelSelector?: VinylCacheSpecPodAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelector;
+    /**
+     * MatchLabelKeys is a set of pod label keys to select which pods will
+     * be taken into consideration. The keys are used to lookup values from the
+     * incoming pod labels, those key-value labels are merged with `labelSelector` as `key in (value)`
+     * to select the group of existing pods which pods will be taken into consideration
+     * for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming
+     * pod labels will be ignored. The default value is empty.
+     * The same key is forbidden to exist in both matchLabelKeys and labelSelector.
+     * Also, matchLabelKeys cannot be set when labelSelector isn't set.
+     *
+     * @schema VinylCacheSpecPodAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecution#matchLabelKeys
+     */
+    readonly matchLabelKeys?: string[];
+    /**
+     * MismatchLabelKeys is a set of pod label keys to select which pods will
+     * be taken into consideration. The keys are used to lookup values from the
+     * incoming pod labels, those key-value labels are merged with `labelSelector` as `key notin (value)`
+     * to select the group of existing pods which pods will be taken into consideration
+     * for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming
+     * pod labels will be ignored. The default value is empty.
+     * The same key is forbidden to exist in both mismatchLabelKeys and labelSelector.
+     * Also, mismatchLabelKeys cannot be set when labelSelector isn't set.
+     *
+     * @schema VinylCacheSpecPodAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecution#mismatchLabelKeys
+     */
+    readonly mismatchLabelKeys?: string[];
+    /**
+     * A label query over the set of namespaces that the term applies to.
+     * The term is applied to the union of the namespaces selected by this field
+     * and the ones listed in the namespaces field.
+     * null selector and null or empty namespaces list means "this pod's namespace".
+     * An empty selector ({}) matches all namespaces.
+     *
+     * @schema VinylCacheSpecPodAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecution#namespaceSelector
+     */
+    readonly namespaceSelector?: VinylCacheSpecPodAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelector;
+    /**
+     * namespaces specifies a static list of namespace names that the term applies to.
+     * The term is applied to the union of the namespaces listed in this field
+     * and the ones selected by namespaceSelector.
+     * null or empty namespaces list and null namespaceSelector means "this pod's namespace".
+     *
+     * @schema VinylCacheSpecPodAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecution#namespaces
+     */
+    readonly namespaces?: string[];
+    /**
+     * This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching
+     * the labelSelector in the specified namespaces, where co-located is defined as running on a node
+     * whose value of the label with key topologyKey matches that of any node on which any of the
+     * selected pods is running.
+     * Empty topologyKey is not allowed.
+     *
+     * @schema VinylCacheSpecPodAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecution#topologyKey
+     */
+    readonly topologyKey: string;
+}
+/**
+ * Converts an object of type 'VinylCacheSpecPodAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecution' to JSON representation.
+ */
+export declare function toJson_VinylCacheSpecPodAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecution(obj: VinylCacheSpecPodAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecution | undefined): Record<string, any> | undefined;
+/**
+ * A node selector term, associated with the corresponding weight.
+ *
+ * @schema VinylCacheSpecPodAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreference
+ */
+export interface VinylCacheSpecPodAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreference {
+    /**
+     * A list of node selector requirements by node's labels.
+     *
+     * @schema VinylCacheSpecPodAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreference#matchExpressions
+     */
+    readonly matchExpressions?: VinylCacheSpecPodAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchExpressions[];
+    /**
+     * A list of node selector requirements by node's fields.
+     *
+     * @schema VinylCacheSpecPodAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreference#matchFields
+     */
+    readonly matchFields?: VinylCacheSpecPodAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchFields[];
+}
+/**
+ * Converts an object of type 'VinylCacheSpecPodAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreference' to JSON representation.
+ */
+export declare function toJson_VinylCacheSpecPodAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreference(obj: VinylCacheSpecPodAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreference | undefined): Record<string, any> | undefined;
+/**
+ * A null or empty node selector term matches no objects. The requirements of
+ * them are ANDed.
+ * The TopologySelectorTerm type implements a subset of the NodeSelectorTerm.
+ *
+ * @schema VinylCacheSpecPodAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTerms
+ */
+export interface VinylCacheSpecPodAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTerms {
+    /**
+     * A list of node selector requirements by node's labels.
+     *
+     * @schema VinylCacheSpecPodAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTerms#matchExpressions
+     */
+    readonly matchExpressions?: VinylCacheSpecPodAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchExpressions[];
+    /**
+     * A list of node selector requirements by node's fields.
+     *
+     * @schema VinylCacheSpecPodAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTerms#matchFields
+     */
+    readonly matchFields?: VinylCacheSpecPodAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchFields[];
+}
+/**
+ * Converts an object of type 'VinylCacheSpecPodAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTerms' to JSON representation.
+ */
+export declare function toJson_VinylCacheSpecPodAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTerms(obj: VinylCacheSpecPodAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTerms | undefined): Record<string, any> | undefined;
+/**
+ * Required. A pod affinity term, associated with the corresponding weight.
+ *
+ * @schema VinylCacheSpecPodAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm
+ */
+export interface VinylCacheSpecPodAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm {
+    /**
+     * A label query over a set of resources, in this case pods.
+     * If it's null, this PodAffinityTerm matches with no Pods.
+     *
+     * @schema VinylCacheSpecPodAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm#labelSelector
+     */
+    readonly labelSelector?: VinylCacheSpecPodAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelector;
+    /**
+     * MatchLabelKeys is a set of pod label keys to select which pods will
+     * be taken into consideration. The keys are used to lookup values from the
+     * incoming pod labels, those key-value labels are merged with `labelSelector` as `key in (value)`
+     * to select the group of existing pods which pods will be taken into consideration
+     * for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming
+     * pod labels will be ignored. The default value is empty.
+     * The same key is forbidden to exist in both matchLabelKeys and labelSelector.
+     * Also, matchLabelKeys cannot be set when labelSelector isn't set.
+     *
+     * @schema VinylCacheSpecPodAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm#matchLabelKeys
+     */
+    readonly matchLabelKeys?: string[];
+    /**
+     * MismatchLabelKeys is a set of pod label keys to select which pods will
+     * be taken into consideration. The keys are used to lookup values from the
+     * incoming pod labels, those key-value labels are merged with `labelSelector` as `key notin (value)`
+     * to select the group of existing pods which pods will be taken into consideration
+     * for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming
+     * pod labels will be ignored. The default value is empty.
+     * The same key is forbidden to exist in both mismatchLabelKeys and labelSelector.
+     * Also, mismatchLabelKeys cannot be set when labelSelector isn't set.
+     *
+     * @schema VinylCacheSpecPodAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm#mismatchLabelKeys
+     */
+    readonly mismatchLabelKeys?: string[];
+    /**
+     * A label query over the set of namespaces that the term applies to.
+     * The term is applied to the union of the namespaces selected by this field
+     * and the ones listed in the namespaces field.
+     * null selector and null or empty namespaces list means "this pod's namespace".
+     * An empty selector ({}) matches all namespaces.
+     *
+     * @schema VinylCacheSpecPodAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm#namespaceSelector
+     */
+    readonly namespaceSelector?: VinylCacheSpecPodAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelector;
+    /**
+     * namespaces specifies a static list of namespace names that the term applies to.
+     * The term is applied to the union of the namespaces listed in this field
+     * and the ones selected by namespaceSelector.
+     * null or empty namespaces list and null namespaceSelector means "this pod's namespace".
+     *
+     * @schema VinylCacheSpecPodAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm#namespaces
+     */
+    readonly namespaces?: string[];
+    /**
+     * This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching
+     * the labelSelector in the specified namespaces, where co-located is defined as running on a node
+     * whose value of the label with key topologyKey matches that of any node on which any of the
+     * selected pods is running.
+     * Empty topologyKey is not allowed.
+     *
+     * @schema VinylCacheSpecPodAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm#topologyKey
+     */
+    readonly topologyKey: string;
+}
+/**
+ * Converts an object of type 'VinylCacheSpecPodAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm' to JSON representation.
+ */
+export declare function toJson_VinylCacheSpecPodAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm(obj: VinylCacheSpecPodAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm | undefined): Record<string, any> | undefined;
+/**
+ * A label query over a set of resources, in this case pods.
+ * If it's null, this PodAffinityTerm matches with no Pods.
+ *
+ * @schema VinylCacheSpecPodAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelector
+ */
+export interface VinylCacheSpecPodAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelector {
+    /**
+     * matchExpressions is a list of label selector requirements. The requirements are ANDed.
+     *
+     * @schema VinylCacheSpecPodAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelector#matchExpressions
+     */
+    readonly matchExpressions?: VinylCacheSpecPodAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressions[];
+    /**
+     * matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels
+     * map is equivalent to an element of matchExpressions, whose key field is "key", the
+     * operator is "In", and the values array contains only "value". The requirements are ANDed.
+     *
+     * @schema VinylCacheSpecPodAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelector#matchLabels
+     */
+    readonly matchLabels?: {
+        [key: string]: string;
+    };
+}
+/**
+ * Converts an object of type 'VinylCacheSpecPodAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelector' to JSON representation.
+ */
+export declare function toJson_VinylCacheSpecPodAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelector(obj: VinylCacheSpecPodAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelector | undefined): Record<string, any> | undefined;
+/**
+ * A label query over the set of namespaces that the term applies to.
+ * The term is applied to the union of the namespaces selected by this field
+ * and the ones listed in the namespaces field.
+ * null selector and null or empty namespaces list means "this pod's namespace".
+ * An empty selector ({}) matches all namespaces.
+ *
+ * @schema VinylCacheSpecPodAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelector
+ */
+export interface VinylCacheSpecPodAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelector {
+    /**
+     * matchExpressions is a list of label selector requirements. The requirements are ANDed.
+     *
+     * @schema VinylCacheSpecPodAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelector#matchExpressions
+     */
+    readonly matchExpressions?: VinylCacheSpecPodAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelectorMatchExpressions[];
+    /**
+     * matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels
+     * map is equivalent to an element of matchExpressions, whose key field is "key", the
+     * operator is "In", and the values array contains only "value". The requirements are ANDed.
+     *
+     * @schema VinylCacheSpecPodAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelector#matchLabels
+     */
+    readonly matchLabels?: {
+        [key: string]: string;
+    };
+}
+/**
+ * Converts an object of type 'VinylCacheSpecPodAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelector' to JSON representation.
+ */
+export declare function toJson_VinylCacheSpecPodAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelector(obj: VinylCacheSpecPodAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelector | undefined): Record<string, any> | undefined;
+/**
+ * Required. A pod affinity term, associated with the corresponding weight.
+ *
+ * @schema VinylCacheSpecPodAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm
+ */
+export interface VinylCacheSpecPodAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm {
+    /**
+     * A label query over a set of resources, in this case pods.
+     * If it's null, this PodAffinityTerm matches with no Pods.
+     *
+     * @schema VinylCacheSpecPodAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm#labelSelector
+     */
+    readonly labelSelector?: VinylCacheSpecPodAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelector;
+    /**
+     * MatchLabelKeys is a set of pod label keys to select which pods will
+     * be taken into consideration. The keys are used to lookup values from the
+     * incoming pod labels, those key-value labels are merged with `labelSelector` as `key in (value)`
+     * to select the group of existing pods which pods will be taken into consideration
+     * for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming
+     * pod labels will be ignored. The default value is empty.
+     * The same key is forbidden to exist in both matchLabelKeys and labelSelector.
+     * Also, matchLabelKeys cannot be set when labelSelector isn't set.
+     *
+     * @schema VinylCacheSpecPodAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm#matchLabelKeys
+     */
+    readonly matchLabelKeys?: string[];
+    /**
+     * MismatchLabelKeys is a set of pod label keys to select which pods will
+     * be taken into consideration. The keys are used to lookup values from the
+     * incoming pod labels, those key-value labels are merged with `labelSelector` as `key notin (value)`
+     * to select the group of existing pods which pods will be taken into consideration
+     * for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming
+     * pod labels will be ignored. The default value is empty.
+     * The same key is forbidden to exist in both mismatchLabelKeys and labelSelector.
+     * Also, mismatchLabelKeys cannot be set when labelSelector isn't set.
+     *
+     * @schema VinylCacheSpecPodAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm#mismatchLabelKeys
+     */
+    readonly mismatchLabelKeys?: string[];
+    /**
+     * A label query over the set of namespaces that the term applies to.
+     * The term is applied to the union of the namespaces selected by this field
+     * and the ones listed in the namespaces field.
+     * null selector and null or empty namespaces list means "this pod's namespace".
+     * An empty selector ({}) matches all namespaces.
+     *
+     * @schema VinylCacheSpecPodAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm#namespaceSelector
+     */
+    readonly namespaceSelector?: VinylCacheSpecPodAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelector;
+    /**
+     * namespaces specifies a static list of namespace names that the term applies to.
+     * The term is applied to the union of the namespaces listed in this field
+     * and the ones selected by namespaceSelector.
+     * null or empty namespaces list and null namespaceSelector means "this pod's namespace".
+     *
+     * @schema VinylCacheSpecPodAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm#namespaces
+     */
+    readonly namespaces?: string[];
+    /**
+     * This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching
+     * the labelSelector in the specified namespaces, where co-located is defined as running on a node
+     * whose value of the label with key topologyKey matches that of any node on which any of the
+     * selected pods is running.
+     * Empty topologyKey is not allowed.
+     *
+     * @schema VinylCacheSpecPodAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm#topologyKey
+     */
+    readonly topologyKey: string;
+}
+/**
+ * Converts an object of type 'VinylCacheSpecPodAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm' to JSON representation.
+ */
+export declare function toJson_VinylCacheSpecPodAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm(obj: VinylCacheSpecPodAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTerm | undefined): Record<string, any> | undefined;
+/**
+ * A label query over a set of resources, in this case pods.
+ * If it's null, this PodAffinityTerm matches with no Pods.
+ *
+ * @schema VinylCacheSpecPodAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelector
+ */
+export interface VinylCacheSpecPodAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelector {
+    /**
+     * matchExpressions is a list of label selector requirements. The requirements are ANDed.
+     *
+     * @schema VinylCacheSpecPodAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelector#matchExpressions
+     */
+    readonly matchExpressions?: VinylCacheSpecPodAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressions[];
+    /**
+     * matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels
+     * map is equivalent to an element of matchExpressions, whose key field is "key", the
+     * operator is "In", and the values array contains only "value". The requirements are ANDed.
+     *
+     * @schema VinylCacheSpecPodAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelector#matchLabels
+     */
+    readonly matchLabels?: {
+        [key: string]: string;
+    };
+}
+/**
+ * Converts an object of type 'VinylCacheSpecPodAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelector' to JSON representation.
+ */
+export declare function toJson_VinylCacheSpecPodAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelector(obj: VinylCacheSpecPodAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelector | undefined): Record<string, any> | undefined;
+/**
+ * A label query over the set of namespaces that the term applies to.
+ * The term is applied to the union of the namespaces selected by this field
+ * and the ones listed in the namespaces field.
+ * null selector and null or empty namespaces list means "this pod's namespace".
+ * An empty selector ({}) matches all namespaces.
+ *
+ * @schema VinylCacheSpecPodAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelector
+ */
+export interface VinylCacheSpecPodAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelector {
+    /**
+     * matchExpressions is a list of label selector requirements. The requirements are ANDed.
+     *
+     * @schema VinylCacheSpecPodAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelector#matchExpressions
+     */
+    readonly matchExpressions?: VinylCacheSpecPodAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelectorMatchExpressions[];
+    /**
+     * matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels
+     * map is equivalent to an element of matchExpressions, whose key field is "key", the
+     * operator is "In", and the values array contains only "value". The requirements are ANDed.
+     *
+     * @schema VinylCacheSpecPodAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelector#matchLabels
+     */
+    readonly matchLabels?: {
+        [key: string]: string;
+    };
+}
+/**
+ * Converts an object of type 'VinylCacheSpecPodAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelector' to JSON representation.
+ */
+export declare function toJson_VinylCacheSpecPodAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelector(obj: VinylCacheSpecPodAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelector | undefined): Record<string, any> | undefined;
+/**
+ * A node selector requirement is a selector that contains values, a key, and an operator
+ * that relates the key and values.
+ *
+ * @schema VinylCacheSpecPodAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchExpressions
+ */
+export interface VinylCacheSpecPodAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchExpressions {
+    /**
+     * The label key that the selector applies to.
+     *
+     * @schema VinylCacheSpecPodAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchExpressions#key
+     */
+    readonly key: string;
+    /**
+     * Represents a key's relationship to a set of values.
+     * Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.
+     *
+     * @schema VinylCacheSpecPodAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchExpressions#operator
+     */
+    readonly operator: string;
+    /**
+     * An array of string values. If the operator is In or NotIn,
+     * the values array must be non-empty. If the operator is Exists or DoesNotExist,
+     * the values array must be empty. If the operator is Gt or Lt, the values
+     * array must have a single element, which will be interpreted as an integer.
+     * This array is replaced during a strategic merge patch.
+     *
+     * @schema VinylCacheSpecPodAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchExpressions#values
+     */
+    readonly values?: string[];
+}
+/**
+ * Converts an object of type 'VinylCacheSpecPodAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchExpressions' to JSON representation.
+ */
+export declare function toJson_VinylCacheSpecPodAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchExpressions(obj: VinylCacheSpecPodAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchExpressions | undefined): Record<string, any> | undefined;
+/**
+ * A node selector requirement is a selector that contains values, a key, and an operator
+ * that relates the key and values.
+ *
+ * @schema VinylCacheSpecPodAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchFields
+ */
+export interface VinylCacheSpecPodAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchFields {
+    /**
+     * The label key that the selector applies to.
+     *
+     * @schema VinylCacheSpecPodAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchFields#key
+     */
+    readonly key: string;
+    /**
+     * Represents a key's relationship to a set of values.
+     * Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.
+     *
+     * @schema VinylCacheSpecPodAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchFields#operator
+     */
+    readonly operator: string;
+    /**
+     * An array of string values. If the operator is In or NotIn,
+     * the values array must be non-empty. If the operator is Exists or DoesNotExist,
+     * the values array must be empty. If the operator is Gt or Lt, the values
+     * array must have a single element, which will be interpreted as an integer.
+     * This array is replaced during a strategic merge patch.
+     *
+     * @schema VinylCacheSpecPodAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchFields#values
+     */
+    readonly values?: string[];
+}
+/**
+ * Converts an object of type 'VinylCacheSpecPodAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchFields' to JSON representation.
+ */
+export declare function toJson_VinylCacheSpecPodAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchFields(obj: VinylCacheSpecPodAffinityNodeAffinityPreferredDuringSchedulingIgnoredDuringExecutionPreferenceMatchFields | undefined): Record<string, any> | undefined;
+/**
+ * A node selector requirement is a selector that contains values, a key, and an operator
+ * that relates the key and values.
+ *
+ * @schema VinylCacheSpecPodAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchExpressions
+ */
+export interface VinylCacheSpecPodAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchExpressions {
+    /**
+     * The label key that the selector applies to.
+     *
+     * @schema VinylCacheSpecPodAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchExpressions#key
+     */
+    readonly key: string;
+    /**
+     * Represents a key's relationship to a set of values.
+     * Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.
+     *
+     * @schema VinylCacheSpecPodAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchExpressions#operator
+     */
+    readonly operator: string;
+    /**
+     * An array of string values. If the operator is In or NotIn,
+     * the values array must be non-empty. If the operator is Exists or DoesNotExist,
+     * the values array must be empty. If the operator is Gt or Lt, the values
+     * array must have a single element, which will be interpreted as an integer.
+     * This array is replaced during a strategic merge patch.
+     *
+     * @schema VinylCacheSpecPodAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchExpressions#values
+     */
+    readonly values?: string[];
+}
+/**
+ * Converts an object of type 'VinylCacheSpecPodAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchExpressions' to JSON representation.
+ */
+export declare function toJson_VinylCacheSpecPodAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchExpressions(obj: VinylCacheSpecPodAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchExpressions | undefined): Record<string, any> | undefined;
+/**
+ * A node selector requirement is a selector that contains values, a key, and an operator
+ * that relates the key and values.
+ *
+ * @schema VinylCacheSpecPodAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchFields
+ */
+export interface VinylCacheSpecPodAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchFields {
+    /**
+     * The label key that the selector applies to.
+     *
+     * @schema VinylCacheSpecPodAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchFields#key
+     */
+    readonly key: string;
+    /**
+     * Represents a key's relationship to a set of values.
+     * Valid operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.
+     *
+     * @schema VinylCacheSpecPodAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchFields#operator
+     */
+    readonly operator: string;
+    /**
+     * An array of string values. If the operator is In or NotIn,
+     * the values array must be non-empty. If the operator is Exists or DoesNotExist,
+     * the values array must be empty. If the operator is Gt or Lt, the values
+     * array must have a single element, which will be interpreted as an integer.
+     * This array is replaced during a strategic merge patch.
+     *
+     * @schema VinylCacheSpecPodAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchFields#values
+     */
+    readonly values?: string[];
+}
+/**
+ * Converts an object of type 'VinylCacheSpecPodAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchFields' to JSON representation.
+ */
+export declare function toJson_VinylCacheSpecPodAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchFields(obj: VinylCacheSpecPodAffinityNodeAffinityRequiredDuringSchedulingIgnoredDuringExecutionNodeSelectorTermsMatchFields | undefined): Record<string, any> | undefined;
+/**
+ * A label query over a set of resources, in this case pods.
+ * If it's null, this PodAffinityTerm matches with no Pods.
+ *
+ * @schema VinylCacheSpecPodAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelector
+ */
+export interface VinylCacheSpecPodAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelector {
+    /**
+     * matchExpressions is a list of label selector requirements. The requirements are ANDed.
+     *
+     * @schema VinylCacheSpecPodAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelector#matchExpressions
+     */
+    readonly matchExpressions?: VinylCacheSpecPodAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressions[];
+    /**
+     * matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels
+     * map is equivalent to an element of matchExpressions, whose key field is "key", the
+     * operator is "In", and the values array contains only "value". The requirements are ANDed.
+     *
+     * @schema VinylCacheSpecPodAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelector#matchLabels
+     */
+    readonly matchLabels?: {
+        [key: string]: string;
+    };
+}
+/**
+ * Converts an object of type 'VinylCacheSpecPodAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelector' to JSON representation.
+ */
+export declare function toJson_VinylCacheSpecPodAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelector(obj: VinylCacheSpecPodAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelector | undefined): Record<string, any> | undefined;
+/**
+ * A label query over the set of namespaces that the term applies to.
+ * The term is applied to the union of the namespaces selected by this field
+ * and the ones listed in the namespaces field.
+ * null selector and null or empty namespaces list means "this pod's namespace".
+ * An empty selector ({}) matches all namespaces.
+ *
+ * @schema VinylCacheSpecPodAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelector
+ */
+export interface VinylCacheSpecPodAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelector {
+    /**
+     * matchExpressions is a list of label selector requirements. The requirements are ANDed.
+     *
+     * @schema VinylCacheSpecPodAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelector#matchExpressions
+     */
+    readonly matchExpressions?: VinylCacheSpecPodAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelectorMatchExpressions[];
+    /**
+     * matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels
+     * map is equivalent to an element of matchExpressions, whose key field is "key", the
+     * operator is "In", and the values array contains only "value". The requirements are ANDed.
+     *
+     * @schema VinylCacheSpecPodAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelector#matchLabels
+     */
+    readonly matchLabels?: {
+        [key: string]: string;
+    };
+}
+/**
+ * Converts an object of type 'VinylCacheSpecPodAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelector' to JSON representation.
+ */
+export declare function toJson_VinylCacheSpecPodAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelector(obj: VinylCacheSpecPodAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelector | undefined): Record<string, any> | undefined;
+/**
+ * A label selector requirement is a selector that contains values, a key, and an operator that
+ * relates the key and values.
+ *
+ * @schema VinylCacheSpecPodAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressions
+ */
+export interface VinylCacheSpecPodAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressions {
+    /**
+     * key is the label key that the selector applies to.
+     *
+     * @schema VinylCacheSpecPodAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressions#key
+     */
+    readonly key: string;
+    /**
+     * operator represents a key's relationship to a set of values.
+     * Valid operators are In, NotIn, Exists and DoesNotExist.
+     *
+     * @schema VinylCacheSpecPodAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressions#operator
+     */
+    readonly operator: string;
+    /**
+     * values is an array of string values. If the operator is In or NotIn,
+     * the values array must be non-empty. If the operator is Exists or DoesNotExist,
+     * the values array must be empty. This array is replaced during a strategic
+     * merge patch.
+     *
+     * @schema VinylCacheSpecPodAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressions#values
+     */
+    readonly values?: string[];
+}
+/**
+ * Converts an object of type 'VinylCacheSpecPodAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressions' to JSON representation.
+ */
+export declare function toJson_VinylCacheSpecPodAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressions(obj: VinylCacheSpecPodAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressions | undefined): Record<string, any> | undefined;
+/**
+ * A label selector requirement is a selector that contains values, a key, and an operator that
+ * relates the key and values.
+ *
+ * @schema VinylCacheSpecPodAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelectorMatchExpressions
+ */
+export interface VinylCacheSpecPodAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelectorMatchExpressions {
+    /**
+     * key is the label key that the selector applies to.
+     *
+     * @schema VinylCacheSpecPodAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelectorMatchExpressions#key
+     */
+    readonly key: string;
+    /**
+     * operator represents a key's relationship to a set of values.
+     * Valid operators are In, NotIn, Exists and DoesNotExist.
+     *
+     * @schema VinylCacheSpecPodAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelectorMatchExpressions#operator
+     */
+    readonly operator: string;
+    /**
+     * values is an array of string values. If the operator is In or NotIn,
+     * the values array must be non-empty. If the operator is Exists or DoesNotExist,
+     * the values array must be empty. This array is replaced during a strategic
+     * merge patch.
+     *
+     * @schema VinylCacheSpecPodAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelectorMatchExpressions#values
+     */
+    readonly values?: string[];
+}
+/**
+ * Converts an object of type 'VinylCacheSpecPodAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelectorMatchExpressions' to JSON representation.
+ */
+export declare function toJson_VinylCacheSpecPodAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelectorMatchExpressions(obj: VinylCacheSpecPodAffinityPodAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelectorMatchExpressions | undefined): Record<string, any> | undefined;
+/**
+ * A label query over a set of resources, in this case pods.
+ * If it's null, this PodAffinityTerm matches with no Pods.
+ *
+ * @schema VinylCacheSpecPodAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelector
+ */
+export interface VinylCacheSpecPodAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelector {
+    /**
+     * matchExpressions is a list of label selector requirements. The requirements are ANDed.
+     *
+     * @schema VinylCacheSpecPodAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelector#matchExpressions
+     */
+    readonly matchExpressions?: VinylCacheSpecPodAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressions[];
+    /**
+     * matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels
+     * map is equivalent to an element of matchExpressions, whose key field is "key", the
+     * operator is "In", and the values array contains only "value". The requirements are ANDed.
+     *
+     * @schema VinylCacheSpecPodAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelector#matchLabels
+     */
+    readonly matchLabels?: {
+        [key: string]: string;
+    };
+}
+/**
+ * Converts an object of type 'VinylCacheSpecPodAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelector' to JSON representation.
+ */
+export declare function toJson_VinylCacheSpecPodAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelector(obj: VinylCacheSpecPodAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelector | undefined): Record<string, any> | undefined;
+/**
+ * A label query over the set of namespaces that the term applies to.
+ * The term is applied to the union of the namespaces selected by this field
+ * and the ones listed in the namespaces field.
+ * null selector and null or empty namespaces list means "this pod's namespace".
+ * An empty selector ({}) matches all namespaces.
+ *
+ * @schema VinylCacheSpecPodAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelector
+ */
+export interface VinylCacheSpecPodAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelector {
+    /**
+     * matchExpressions is a list of label selector requirements. The requirements are ANDed.
+     *
+     * @schema VinylCacheSpecPodAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelector#matchExpressions
+     */
+    readonly matchExpressions?: VinylCacheSpecPodAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelectorMatchExpressions[];
+    /**
+     * matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels
+     * map is equivalent to an element of matchExpressions, whose key field is "key", the
+     * operator is "In", and the values array contains only "value". The requirements are ANDed.
+     *
+     * @schema VinylCacheSpecPodAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelector#matchLabels
+     */
+    readonly matchLabels?: {
+        [key: string]: string;
+    };
+}
+/**
+ * Converts an object of type 'VinylCacheSpecPodAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelector' to JSON representation.
+ */
+export declare function toJson_VinylCacheSpecPodAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelector(obj: VinylCacheSpecPodAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelector | undefined): Record<string, any> | undefined;
+/**
+ * A label selector requirement is a selector that contains values, a key, and an operator that
+ * relates the key and values.
+ *
+ * @schema VinylCacheSpecPodAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressions
+ */
+export interface VinylCacheSpecPodAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressions {
+    /**
+     * key is the label key that the selector applies to.
+     *
+     * @schema VinylCacheSpecPodAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressions#key
+     */
+    readonly key: string;
+    /**
+     * operator represents a key's relationship to a set of values.
+     * Valid operators are In, NotIn, Exists and DoesNotExist.
+     *
+     * @schema VinylCacheSpecPodAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressions#operator
+     */
+    readonly operator: string;
+    /**
+     * values is an array of string values. If the operator is In or NotIn,
+     * the values array must be non-empty. If the operator is Exists or DoesNotExist,
+     * the values array must be empty. This array is replaced during a strategic
+     * merge patch.
+     *
+     * @schema VinylCacheSpecPodAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressions#values
+     */
+    readonly values?: string[];
+}
+/**
+ * Converts an object of type 'VinylCacheSpecPodAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressions' to JSON representation.
+ */
+export declare function toJson_VinylCacheSpecPodAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressions(obj: VinylCacheSpecPodAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionLabelSelectorMatchExpressions | undefined): Record<string, any> | undefined;
+/**
+ * A label selector requirement is a selector that contains values, a key, and an operator that
+ * relates the key and values.
+ *
+ * @schema VinylCacheSpecPodAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelectorMatchExpressions
+ */
+export interface VinylCacheSpecPodAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelectorMatchExpressions {
+    /**
+     * key is the label key that the selector applies to.
+     *
+     * @schema VinylCacheSpecPodAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelectorMatchExpressions#key
+     */
+    readonly key: string;
+    /**
+     * operator represents a key's relationship to a set of values.
+     * Valid operators are In, NotIn, Exists and DoesNotExist.
+     *
+     * @schema VinylCacheSpecPodAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelectorMatchExpressions#operator
+     */
+    readonly operator: string;
+    /**
+     * values is an array of string values. If the operator is In or NotIn,
+     * the values array must be non-empty. If the operator is Exists or DoesNotExist,
+     * the values array must be empty. This array is replaced during a strategic
+     * merge patch.
+     *
+     * @schema VinylCacheSpecPodAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelectorMatchExpressions#values
+     */
+    readonly values?: string[];
+}
+/**
+ * Converts an object of type 'VinylCacheSpecPodAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelectorMatchExpressions' to JSON representation.
+ */
+export declare function toJson_VinylCacheSpecPodAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelectorMatchExpressions(obj: VinylCacheSpecPodAffinityPodAntiAffinityRequiredDuringSchedulingIgnoredDuringExecutionNamespaceSelectorMatchExpressions | undefined): Record<string, any> | undefined;
+/**
+ * A label selector requirement is a selector that contains values, a key, and an operator that
+ * relates the key and values.
+ *
+ * @schema VinylCacheSpecPodAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressions
+ */
+export interface VinylCacheSpecPodAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressions {
+    /**
+     * key is the label key that the selector applies to.
+     *
+     * @schema VinylCacheSpecPodAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressions#key
+     */
+    readonly key: string;
+    /**
+     * operator represents a key's relationship to a set of values.
+     * Valid operators are In, NotIn, Exists and DoesNotExist.
+     *
+     * @schema VinylCacheSpecPodAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressions#operator
+     */
+    readonly operator: string;
+    /**
+     * values is an array of string values. If the operator is In or NotIn,
+     * the values array must be non-empty. If the operator is Exists or DoesNotExist,
+     * the values array must be empty. This array is replaced during a strategic
+     * merge patch.
+     *
+     * @schema VinylCacheSpecPodAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressions#values
+     */
+    readonly values?: string[];
+}
+/**
+ * Converts an object of type 'VinylCacheSpecPodAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressions' to JSON representation.
+ */
+export declare function toJson_VinylCacheSpecPodAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressions(obj: VinylCacheSpecPodAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressions | undefined): Record<string, any> | undefined;
+/**
+ * A label selector requirement is a selector that contains values, a key, and an operator that
+ * relates the key and values.
+ *
+ * @schema VinylCacheSpecPodAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelectorMatchExpressions
+ */
+export interface VinylCacheSpecPodAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelectorMatchExpressions {
+    /**
+     * key is the label key that the selector applies to.
+     *
+     * @schema VinylCacheSpecPodAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelectorMatchExpressions#key
+     */
+    readonly key: string;
+    /**
+     * operator represents a key's relationship to a set of values.
+     * Valid operators are In, NotIn, Exists and DoesNotExist.
+     *
+     * @schema VinylCacheSpecPodAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelectorMatchExpressions#operator
+     */
+    readonly operator: string;
+    /**
+     * values is an array of string values. If the operator is In or NotIn,
+     * the values array must be non-empty. If the operator is Exists or DoesNotExist,
+     * the values array must be empty. This array is replaced during a strategic
+     * merge patch.
+     *
+     * @schema VinylCacheSpecPodAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelectorMatchExpressions#values
+     */
+    readonly values?: string[];
+}
+/**
+ * Converts an object of type 'VinylCacheSpecPodAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelectorMatchExpressions' to JSON representation.
+ */
+export declare function toJson_VinylCacheSpecPodAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelectorMatchExpressions(obj: VinylCacheSpecPodAffinityPodAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelectorMatchExpressions | undefined): Record<string, any> | undefined;
+/**
+ * A label selector requirement is a selector that contains values, a key, and an operator that
+ * relates the key and values.
+ *
+ * @schema VinylCacheSpecPodAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressions
+ */
+export interface VinylCacheSpecPodAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressions {
+    /**
+     * key is the label key that the selector applies to.
+     *
+     * @schema VinylCacheSpecPodAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressions#key
+     */
+    readonly key: string;
+    /**
+     * operator represents a key's relationship to a set of values.
+     * Valid operators are In, NotIn, Exists and DoesNotExist.
+     *
+     * @schema VinylCacheSpecPodAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressions#operator
+     */
+    readonly operator: string;
+    /**
+     * values is an array of string values. If the operator is In or NotIn,
+     * the values array must be non-empty. If the operator is Exists or DoesNotExist,
+     * the values array must be empty. This array is replaced during a strategic
+     * merge patch.
+     *
+     * @schema VinylCacheSpecPodAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressions#values
+     */
+    readonly values?: string[];
+}
+/**
+ * Converts an object of type 'VinylCacheSpecPodAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressions' to JSON representation.
+ */
+export declare function toJson_VinylCacheSpecPodAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressions(obj: VinylCacheSpecPodAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermLabelSelectorMatchExpressions | undefined): Record<string, any> | undefined;
+/**
+ * A label selector requirement is a selector that contains values, a key, and an operator that
+ * relates the key and values.
+ *
+ * @schema VinylCacheSpecPodAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelectorMatchExpressions
+ */
+export interface VinylCacheSpecPodAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelectorMatchExpressions {
+    /**
+     * key is the label key that the selector applies to.
+     *
+     * @schema VinylCacheSpecPodAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelectorMatchExpressions#key
+     */
+    readonly key: string;
+    /**
+     * operator represents a key's relationship to a set of values.
+     * Valid operators are In, NotIn, Exists and DoesNotExist.
+     *
+     * @schema VinylCacheSpecPodAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelectorMatchExpressions#operator
+     */
+    readonly operator: string;
+    /**
+     * values is an array of string values. If the operator is In or NotIn,
+     * the values array must be non-empty. If the operator is Exists or DoesNotExist,
+     * the values array must be empty. This array is replaced during a strategic
+     * merge patch.
+     *
+     * @schema VinylCacheSpecPodAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelectorMatchExpressions#values
+     */
+    readonly values?: string[];
+}
+/**
+ * Converts an object of type 'VinylCacheSpecPodAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelectorMatchExpressions' to JSON representation.
+ */
+export declare function toJson_VinylCacheSpecPodAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelectorMatchExpressions(obj: VinylCacheSpecPodAffinityPodAntiAffinityPreferredDuringSchedulingIgnoredDuringExecutionPodAffinityTermNamespaceSelectorMatchExpressions | undefined): Record<string, any> | undefined;