All Downloads are FREE. Search and download functionalities are using the official Maven repository.

io.strimzi.api.kafka.model.connect.AbstractKafkaConnectSpecFluent Maven / Gradle / Ivy

The newest version!
package io.strimzi.api.kafka.model.connect;

import io.fabric8.kubernetes.api.builder.VisitableBuilder;
import io.strimzi.api.kafka.model.common.RackBuilder;
import io.strimzi.api.kafka.model.common.metrics.JmxPrometheusExporterMetricsFluent;
import java.lang.String;
import io.strimzi.api.kafka.model.common.Probe;
import io.fabric8.kubernetes.api.model.ResourceRequirements;
import io.strimzi.api.kafka.model.common.tracing.OpenTelemetryTracing;
import io.strimzi.api.kafka.model.common.tracing.OpenTelemetryTracingFluent;
import io.strimzi.api.kafka.model.common.Logging;
import io.strimzi.api.kafka.model.common.RackFluent;
import io.strimzi.api.kafka.model.common.jmx.KafkaJmxOptionsFluent;
import io.strimzi.api.kafka.model.common.ProbeFluent;
import io.strimzi.api.kafka.model.common.tracing.JaegerTracingFluent;
import io.strimzi.api.kafka.model.common.jmx.KafkaJmxOptionsBuilder;
import io.strimzi.api.kafka.model.common.metrics.JmxPrometheusExporterMetricsBuilder;
import io.strimzi.api.kafka.model.common.JvmOptions;
import io.strimzi.api.kafka.model.common.InlineLoggingFluent;
import java.lang.Object;
import io.strimzi.api.kafka.model.common.tracing.Tracing;
import io.strimzi.api.kafka.model.common.tracing.OpenTelemetryTracingBuilder;
import io.strimzi.api.kafka.model.common.JvmOptionsFluent;
import io.strimzi.api.kafka.model.common.tracing.JaegerTracingBuilder;
import io.strimzi.api.kafka.model.common.InlineLoggingBuilder;
import java.lang.SuppressWarnings;
import io.fabric8.kubernetes.api.builder.Nested;
import io.strimzi.api.kafka.model.common.JvmOptionsBuilder;
import io.strimzi.api.kafka.model.common.InlineLogging;
import io.strimzi.api.kafka.model.common.metrics.MetricsConfig;
import io.strimzi.api.kafka.model.common.ExternalLoggingBuilder;
import io.strimzi.api.kafka.model.common.Rack;
import io.strimzi.api.kafka.model.common.ProbeBuilder;
import io.strimzi.api.kafka.model.common.metrics.JmxPrometheusExporterMetrics;
import io.strimzi.api.kafka.model.common.ExternalLoggingFluent;
import io.strimzi.api.kafka.model.common.tracing.JaegerTracing;
import io.strimzi.api.kafka.model.common.SpecFluent;
import io.strimzi.api.kafka.model.common.ExternalLogging;
import io.strimzi.api.kafka.model.common.jmx.KafkaJmxOptions;

/**
 * Generated
 */
@SuppressWarnings("unchecked")
public class AbstractKafkaConnectSpecFluent> extends SpecFluent{
  public AbstractKafkaConnectSpecFluent() {
  }
  
  public AbstractKafkaConnectSpecFluent(AbstractKafkaConnectSpec instance) {
    this.copyInstance(instance);
  }
  private VisitableBuilder logging;
  private int replicas;
  private String version;
  private String image;
  private ResourceRequirements resources;
  private ProbeBuilder livenessProbe;
  private ProbeBuilder readinessProbe;
  private KafkaJmxOptionsBuilder jmxOptions;
  private JvmOptionsBuilder jvmOptions;
  private VisitableBuilder metricsConfig;
  private VisitableBuilder tracing;
  private KafkaConnectTemplateBuilder template;
  private ExternalConfigurationBuilder externalConfiguration;
  private String clientRackInitImage;
  private RackBuilder rack;
  
  protected void copyInstance(AbstractKafkaConnectSpec instance) {
    if (instance != null) {
          this.withLogging(instance.getLogging());
          this.withReplicas(instance.getReplicas());
          this.withVersion(instance.getVersion());
          this.withImage(instance.getImage());
          this.withResources(instance.getResources());
          this.withLivenessProbe(instance.getLivenessProbe());
          this.withReadinessProbe(instance.getReadinessProbe());
          this.withJmxOptions(instance.getJmxOptions());
          this.withJvmOptions(instance.getJvmOptions());
          this.withMetricsConfig(instance.getMetricsConfig());
          this.withTracing(instance.getTracing());
          this.withTemplate(instance.getTemplate());
          this.withExternalConfiguration(instance.getExternalConfiguration());
          this.withClientRackInitImage(instance.getClientRackInitImage());
          this.withRack(instance.getRack());
        }
  }
  
  public Logging buildLogging() {
    return this.logging != null ? this.logging.build() : null;
  }
  
  public A withLogging(Logging logging) {
    if (logging == null) {
        this.logging = null;
        this._visitables.remove("logging");
        return (A) this;
    } else {
        VisitableBuilder builder = builder(logging);;
        this._visitables.get("logging").clear();
        this._visitables.get("logging").add(builder);
        this.logging = builder;
        return (A) this;
    }
  }
  
  public boolean hasLogging() {
    return this.logging != null;
  }
  
  public InlineLoggingNested withNewInlineLogging() {
    return new InlineLoggingNested(null);
  }
  
  public InlineLoggingNested withNewInlineLoggingLike(InlineLogging item) {
    return new InlineLoggingNested(item);
  }
  
  public ExternalLoggingNested withNewExternalLogging() {
    return new ExternalLoggingNested(null);
  }
  
  public ExternalLoggingNested withNewExternalLoggingLike(ExternalLogging item) {
    return new ExternalLoggingNested(item);
  }
  
  public int getReplicas() {
    return this.replicas;
  }
  
  public A withReplicas(int replicas) {
    this.replicas = replicas;
    return (A) this;
  }
  
  public boolean hasReplicas() {
    return true;
  }
  
  public String getVersion() {
    return this.version;
  }
  
  public A withVersion(String version) {
    this.version = version;
    return (A) this;
  }
  
  public boolean hasVersion() {
    return this.version != null;
  }
  
  public String getImage() {
    return this.image;
  }
  
  public A withImage(String image) {
    this.image = image;
    return (A) this;
  }
  
  public boolean hasImage() {
    return this.image != null;
  }
  
  public ResourceRequirements getResources() {
    return this.resources;
  }
  
  public A withResources(ResourceRequirements resources) {
    this.resources = resources;
    return (A) this;
  }
  
  public boolean hasResources() {
    return this.resources != null;
  }
  
  public Probe buildLivenessProbe() {
    return this.livenessProbe != null ? this.livenessProbe.build() : null;
  }
  
  public A withLivenessProbe(Probe livenessProbe) {
    this._visitables.remove("livenessProbe");
    if (livenessProbe != null) {
        this.livenessProbe = new ProbeBuilder(livenessProbe);
        this._visitables.get("livenessProbe").add(this.livenessProbe);
    } else {
        this.livenessProbe = null;
        this._visitables.get("livenessProbe").remove(this.livenessProbe);
    }
    return (A) this;
  }
  
  public boolean hasLivenessProbe() {
    return this.livenessProbe != null;
  }
  
  public A withNewLivenessProbe(int initialDelaySeconds,int timeoutSeconds) {
    return (A)withLivenessProbe(new Probe(initialDelaySeconds, timeoutSeconds));
  }
  
  public LivenessProbeNested withNewLivenessProbe() {
    return new LivenessProbeNested(null);
  }
  
  public LivenessProbeNested withNewLivenessProbeLike(Probe item) {
    return new LivenessProbeNested(item);
  }
  
  public LivenessProbeNested editLivenessProbe() {
    return withNewLivenessProbeLike(java.util.Optional.ofNullable(buildLivenessProbe()).orElse(null));
  }
  
  public LivenessProbeNested editOrNewLivenessProbe() {
    return withNewLivenessProbeLike(java.util.Optional.ofNullable(buildLivenessProbe()).orElse(new ProbeBuilder().build()));
  }
  
  public LivenessProbeNested editOrNewLivenessProbeLike(Probe item) {
    return withNewLivenessProbeLike(java.util.Optional.ofNullable(buildLivenessProbe()).orElse(item));
  }
  
  public Probe buildReadinessProbe() {
    return this.readinessProbe != null ? this.readinessProbe.build() : null;
  }
  
  public A withReadinessProbe(Probe readinessProbe) {
    this._visitables.remove("readinessProbe");
    if (readinessProbe != null) {
        this.readinessProbe = new ProbeBuilder(readinessProbe);
        this._visitables.get("readinessProbe").add(this.readinessProbe);
    } else {
        this.readinessProbe = null;
        this._visitables.get("readinessProbe").remove(this.readinessProbe);
    }
    return (A) this;
  }
  
  public boolean hasReadinessProbe() {
    return this.readinessProbe != null;
  }
  
  public A withNewReadinessProbe(int initialDelaySeconds,int timeoutSeconds) {
    return (A)withReadinessProbe(new Probe(initialDelaySeconds, timeoutSeconds));
  }
  
  public ReadinessProbeNested withNewReadinessProbe() {
    return new ReadinessProbeNested(null);
  }
  
  public ReadinessProbeNested withNewReadinessProbeLike(Probe item) {
    return new ReadinessProbeNested(item);
  }
  
  public ReadinessProbeNested editReadinessProbe() {
    return withNewReadinessProbeLike(java.util.Optional.ofNullable(buildReadinessProbe()).orElse(null));
  }
  
  public ReadinessProbeNested editOrNewReadinessProbe() {
    return withNewReadinessProbeLike(java.util.Optional.ofNullable(buildReadinessProbe()).orElse(new ProbeBuilder().build()));
  }
  
  public ReadinessProbeNested editOrNewReadinessProbeLike(Probe item) {
    return withNewReadinessProbeLike(java.util.Optional.ofNullable(buildReadinessProbe()).orElse(item));
  }
  
  public KafkaJmxOptions buildJmxOptions() {
    return this.jmxOptions != null ? this.jmxOptions.build() : null;
  }
  
  public A withJmxOptions(KafkaJmxOptions jmxOptions) {
    this._visitables.remove("jmxOptions");
    if (jmxOptions != null) {
        this.jmxOptions = new KafkaJmxOptionsBuilder(jmxOptions);
        this._visitables.get("jmxOptions").add(this.jmxOptions);
    } else {
        this.jmxOptions = null;
        this._visitables.get("jmxOptions").remove(this.jmxOptions);
    }
    return (A) this;
  }
  
  public boolean hasJmxOptions() {
    return this.jmxOptions != null;
  }
  
  public JmxOptionsNested withNewJmxOptions() {
    return new JmxOptionsNested(null);
  }
  
  public JmxOptionsNested withNewJmxOptionsLike(KafkaJmxOptions item) {
    return new JmxOptionsNested(item);
  }
  
  public JmxOptionsNested editJmxOptions() {
    return withNewJmxOptionsLike(java.util.Optional.ofNullable(buildJmxOptions()).orElse(null));
  }
  
  public JmxOptionsNested editOrNewJmxOptions() {
    return withNewJmxOptionsLike(java.util.Optional.ofNullable(buildJmxOptions()).orElse(new KafkaJmxOptionsBuilder().build()));
  }
  
  public JmxOptionsNested editOrNewJmxOptionsLike(KafkaJmxOptions item) {
    return withNewJmxOptionsLike(java.util.Optional.ofNullable(buildJmxOptions()).orElse(item));
  }
  
  public JvmOptions buildJvmOptions() {
    return this.jvmOptions != null ? this.jvmOptions.build() : null;
  }
  
  public A withJvmOptions(JvmOptions jvmOptions) {
    this._visitables.remove("jvmOptions");
    if (jvmOptions != null) {
        this.jvmOptions = new JvmOptionsBuilder(jvmOptions);
        this._visitables.get("jvmOptions").add(this.jvmOptions);
    } else {
        this.jvmOptions = null;
        this._visitables.get("jvmOptions").remove(this.jvmOptions);
    }
    return (A) this;
  }
  
  public boolean hasJvmOptions() {
    return this.jvmOptions != null;
  }
  
  public JvmOptionsNested withNewJvmOptions() {
    return new JvmOptionsNested(null);
  }
  
  public JvmOptionsNested withNewJvmOptionsLike(JvmOptions item) {
    return new JvmOptionsNested(item);
  }
  
  public JvmOptionsNested editJvmOptions() {
    return withNewJvmOptionsLike(java.util.Optional.ofNullable(buildJvmOptions()).orElse(null));
  }
  
  public JvmOptionsNested editOrNewJvmOptions() {
    return withNewJvmOptionsLike(java.util.Optional.ofNullable(buildJvmOptions()).orElse(new JvmOptionsBuilder().build()));
  }
  
  public JvmOptionsNested editOrNewJvmOptionsLike(JvmOptions item) {
    return withNewJvmOptionsLike(java.util.Optional.ofNullable(buildJvmOptions()).orElse(item));
  }
  
  public MetricsConfig buildMetricsConfig() {
    return this.metricsConfig != null ? this.metricsConfig.build() : null;
  }
  
  public A withMetricsConfig(MetricsConfig metricsConfig) {
    if (metricsConfig == null) {
        this.metricsConfig = null;
        this._visitables.remove("metricsConfig");
        return (A) this;
    } else {
        VisitableBuilder builder = builder(metricsConfig);;
        this._visitables.get("metricsConfig").clear();
        this._visitables.get("metricsConfig").add(builder);
        this.metricsConfig = builder;
        return (A) this;
    }
  }
  
  public boolean hasMetricsConfig() {
    return this.metricsConfig != null;
  }
  
  public JmxPrometheusExporterMetricsConfigNested withNewJmxPrometheusExporterMetricsConfig() {
    return new JmxPrometheusExporterMetricsConfigNested(null);
  }
  
  public JmxPrometheusExporterMetricsConfigNested withNewJmxPrometheusExporterMetricsConfigLike(JmxPrometheusExporterMetrics item) {
    return new JmxPrometheusExporterMetricsConfigNested(item);
  }
  
  public Tracing buildTracing() {
    return this.tracing != null ? this.tracing.build() : null;
  }
  
  public A withTracing(Tracing tracing) {
    if (tracing == null) {
        this.tracing = null;
        this._visitables.remove("tracing");
        return (A) this;
    } else {
        VisitableBuilder builder = builder(tracing);;
        this._visitables.get("tracing").clear();
        this._visitables.get("tracing").add(builder);
        this.tracing = builder;
        return (A) this;
    }
  }
  
  public boolean hasTracing() {
    return this.tracing != null;
  }
  
  public JaegerTracingNested withNewJaegerTracing() {
    return new JaegerTracingNested(null);
  }
  
  public JaegerTracingNested withNewJaegerTracingLike(JaegerTracing item) {
    return new JaegerTracingNested(item);
  }
  
  public OpenTelemetryTracingNested withNewOpenTelemetryTracing() {
    return new OpenTelemetryTracingNested(null);
  }
  
  public OpenTelemetryTracingNested withNewOpenTelemetryTracingLike(OpenTelemetryTracing item) {
    return new OpenTelemetryTracingNested(item);
  }
  
  public KafkaConnectTemplate buildTemplate() {
    return this.template != null ? this.template.build() : null;
  }
  
  public A withTemplate(KafkaConnectTemplate template) {
    this._visitables.remove("template");
    if (template != null) {
        this.template = new KafkaConnectTemplateBuilder(template);
        this._visitables.get("template").add(this.template);
    } else {
        this.template = null;
        this._visitables.get("template").remove(this.template);
    }
    return (A) this;
  }
  
  public boolean hasTemplate() {
    return this.template != null;
  }
  
  public TemplateNested withNewTemplate() {
    return new TemplateNested(null);
  }
  
  public TemplateNested withNewTemplateLike(KafkaConnectTemplate item) {
    return new TemplateNested(item);
  }
  
  public TemplateNested editTemplate() {
    return withNewTemplateLike(java.util.Optional.ofNullable(buildTemplate()).orElse(null));
  }
  
  public TemplateNested editOrNewTemplate() {
    return withNewTemplateLike(java.util.Optional.ofNullable(buildTemplate()).orElse(new KafkaConnectTemplateBuilder().build()));
  }
  
  public TemplateNested editOrNewTemplateLike(KafkaConnectTemplate item) {
    return withNewTemplateLike(java.util.Optional.ofNullable(buildTemplate()).orElse(item));
  }
  
  public ExternalConfiguration buildExternalConfiguration() {
    return this.externalConfiguration != null ? this.externalConfiguration.build() : null;
  }
  
  public A withExternalConfiguration(ExternalConfiguration externalConfiguration) {
    this._visitables.remove("externalConfiguration");
    if (externalConfiguration != null) {
        this.externalConfiguration = new ExternalConfigurationBuilder(externalConfiguration);
        this._visitables.get("externalConfiguration").add(this.externalConfiguration);
    } else {
        this.externalConfiguration = null;
        this._visitables.get("externalConfiguration").remove(this.externalConfiguration);
    }
    return (A) this;
  }
  
  public boolean hasExternalConfiguration() {
    return this.externalConfiguration != null;
  }
  
  public ExternalConfigurationNested withNewExternalConfiguration() {
    return new ExternalConfigurationNested(null);
  }
  
  public ExternalConfigurationNested withNewExternalConfigurationLike(ExternalConfiguration item) {
    return new ExternalConfigurationNested(item);
  }
  
  public ExternalConfigurationNested editExternalConfiguration() {
    return withNewExternalConfigurationLike(java.util.Optional.ofNullable(buildExternalConfiguration()).orElse(null));
  }
  
  public ExternalConfigurationNested editOrNewExternalConfiguration() {
    return withNewExternalConfigurationLike(java.util.Optional.ofNullable(buildExternalConfiguration()).orElse(new ExternalConfigurationBuilder().build()));
  }
  
  public ExternalConfigurationNested editOrNewExternalConfigurationLike(ExternalConfiguration item) {
    return withNewExternalConfigurationLike(java.util.Optional.ofNullable(buildExternalConfiguration()).orElse(item));
  }
  
  public String getClientRackInitImage() {
    return this.clientRackInitImage;
  }
  
  public A withClientRackInitImage(String clientRackInitImage) {
    this.clientRackInitImage = clientRackInitImage;
    return (A) this;
  }
  
  public boolean hasClientRackInitImage() {
    return this.clientRackInitImage != null;
  }
  
  public Rack buildRack() {
    return this.rack != null ? this.rack.build() : null;
  }
  
  public A withRack(Rack rack) {
    this._visitables.remove("rack");
    if (rack != null) {
        this.rack = new RackBuilder(rack);
        this._visitables.get("rack").add(this.rack);
    } else {
        this.rack = null;
        this._visitables.get("rack").remove(this.rack);
    }
    return (A) this;
  }
  
  public boolean hasRack() {
    return this.rack != null;
  }
  
  public A withNewRack(String topologyKey) {
    return (A)withRack(new Rack(topologyKey));
  }
  
  public RackNested withNewRack() {
    return new RackNested(null);
  }
  
  public RackNested withNewRackLike(Rack item) {
    return new RackNested(item);
  }
  
  public RackNested editRack() {
    return withNewRackLike(java.util.Optional.ofNullable(buildRack()).orElse(null));
  }
  
  public RackNested editOrNewRack() {
    return withNewRackLike(java.util.Optional.ofNullable(buildRack()).orElse(new RackBuilder().build()));
  }
  
  public RackNested editOrNewRackLike(Rack item) {
    return withNewRackLike(java.util.Optional.ofNullable(buildRack()).orElse(item));
  }
  
  public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;
    if (!super.equals(o)) return false;
    AbstractKafkaConnectSpecFluent that = (AbstractKafkaConnectSpecFluent) o;
    if (!java.util.Objects.equals(logging, that.logging)) return false;
    if (replicas != that.replicas) return false;
    if (!java.util.Objects.equals(version, that.version)) return false;
    if (!java.util.Objects.equals(image, that.image)) return false;
    if (!java.util.Objects.equals(resources, that.resources)) return false;
    if (!java.util.Objects.equals(livenessProbe, that.livenessProbe)) return false;
    if (!java.util.Objects.equals(readinessProbe, that.readinessProbe)) return false;
    if (!java.util.Objects.equals(jmxOptions, that.jmxOptions)) return false;
    if (!java.util.Objects.equals(jvmOptions, that.jvmOptions)) return false;
    if (!java.util.Objects.equals(metricsConfig, that.metricsConfig)) return false;
    if (!java.util.Objects.equals(tracing, that.tracing)) return false;
    if (!java.util.Objects.equals(template, that.template)) return false;
    if (!java.util.Objects.equals(externalConfiguration, that.externalConfiguration)) return false;
    if (!java.util.Objects.equals(clientRackInitImage, that.clientRackInitImage)) return false;
    if (!java.util.Objects.equals(rack, that.rack)) return false;
    return true;
  }
  
  public int hashCode() {
    return java.util.Objects.hash(logging,  replicas,  version,  image,  resources,  livenessProbe,  readinessProbe,  jmxOptions,  jvmOptions,  metricsConfig,  tracing,  template,  externalConfiguration,  clientRackInitImage,  rack,  super.hashCode());
  }
  
  public String toString() {
    StringBuilder sb = new StringBuilder();
    sb.append("{");
    if (logging != null) { sb.append("logging:"); sb.append(logging + ","); }
    sb.append("replicas:"); sb.append(replicas + ",");
    if (version != null) { sb.append("version:"); sb.append(version + ","); }
    if (image != null) { sb.append("image:"); sb.append(image + ","); }
    if (resources != null) { sb.append("resources:"); sb.append(resources + ","); }
    if (livenessProbe != null) { sb.append("livenessProbe:"); sb.append(livenessProbe + ","); }
    if (readinessProbe != null) { sb.append("readinessProbe:"); sb.append(readinessProbe + ","); }
    if (jmxOptions != null) { sb.append("jmxOptions:"); sb.append(jmxOptions + ","); }
    if (jvmOptions != null) { sb.append("jvmOptions:"); sb.append(jvmOptions + ","); }
    if (metricsConfig != null) { sb.append("metricsConfig:"); sb.append(metricsConfig + ","); }
    if (tracing != null) { sb.append("tracing:"); sb.append(tracing + ","); }
    if (template != null) { sb.append("template:"); sb.append(template + ","); }
    if (externalConfiguration != null) { sb.append("externalConfiguration:"); sb.append(externalConfiguration + ","); }
    if (clientRackInitImage != null) { sb.append("clientRackInitImage:"); sb.append(clientRackInitImage + ","); }
    if (rack != null) { sb.append("rack:"); sb.append(rack); }
    sb.append("}");
    return sb.toString();
  }
  
  protected static VisitableBuilder builder(Object item) {
    switch (item.getClass().getName()) {
    case "io.strimzi.api.kafka.model.common."+"InlineLogging": return (VisitableBuilder)new InlineLoggingBuilder((InlineLogging) item);
    case "io.strimzi.api.kafka.model.common."+"ExternalLogging": return (VisitableBuilder)new ExternalLoggingBuilder((ExternalLogging) item);
    case "io.strimzi.api.kafka.model.common.metrics."+"JmxPrometheusExporterMetrics": return (VisitableBuilder)new JmxPrometheusExporterMetricsBuilder((JmxPrometheusExporterMetrics) item);
    case "io.strimzi.api.kafka.model.common.tracing."+"JaegerTracing": return (VisitableBuilder)new JaegerTracingBuilder((JaegerTracing) item);
    case "io.strimzi.api.kafka.model.common.tracing."+"OpenTelemetryTracing": return (VisitableBuilder)new OpenTelemetryTracingBuilder((OpenTelemetryTracing) item);
    }
     return (VisitableBuilder)builderOf(item);
  }
  public class InlineLoggingNested extends InlineLoggingFluent> implements Nested{
    InlineLoggingNested(InlineLogging item) {
      this.builder = new InlineLoggingBuilder(this, item);
    }
    InlineLoggingBuilder builder;
    
    public N and() {
      return (N) AbstractKafkaConnectSpecFluent.this.withLogging(builder.build());
    }
    
    public N endInlineLogging() {
      return and();
    }
    
  
  }
  public class ExternalLoggingNested extends ExternalLoggingFluent> implements Nested{
    ExternalLoggingNested(ExternalLogging item) {
      this.builder = new ExternalLoggingBuilder(this, item);
    }
    ExternalLoggingBuilder builder;
    
    public N and() {
      return (N) AbstractKafkaConnectSpecFluent.this.withLogging(builder.build());
    }
    
    public N endExternalLogging() {
      return and();
    }
    
  
  }
  public class LivenessProbeNested extends ProbeFluent> implements Nested{
    LivenessProbeNested(Probe item) {
      this.builder = new ProbeBuilder(this, item);
    }
    ProbeBuilder builder;
    
    public N and() {
      return (N) AbstractKafkaConnectSpecFluent.this.withLivenessProbe(builder.build());
    }
    
    public N endLivenessProbe() {
      return and();
    }
    
  
  }
  public class ReadinessProbeNested extends ProbeFluent> implements Nested{
    ReadinessProbeNested(Probe item) {
      this.builder = new ProbeBuilder(this, item);
    }
    ProbeBuilder builder;
    
    public N and() {
      return (N) AbstractKafkaConnectSpecFluent.this.withReadinessProbe(builder.build());
    }
    
    public N endReadinessProbe() {
      return and();
    }
    
  
  }
  public class JmxOptionsNested extends KafkaJmxOptionsFluent> implements Nested{
    JmxOptionsNested(KafkaJmxOptions item) {
      this.builder = new KafkaJmxOptionsBuilder(this, item);
    }
    KafkaJmxOptionsBuilder builder;
    
    public N and() {
      return (N) AbstractKafkaConnectSpecFluent.this.withJmxOptions(builder.build());
    }
    
    public N endJmxOptions() {
      return and();
    }
    
  
  }
  public class JvmOptionsNested extends JvmOptionsFluent> implements Nested{
    JvmOptionsNested(JvmOptions item) {
      this.builder = new JvmOptionsBuilder(this, item);
    }
    JvmOptionsBuilder builder;
    
    public N and() {
      return (N) AbstractKafkaConnectSpecFluent.this.withJvmOptions(builder.build());
    }
    
    public N endJvmOptions() {
      return and();
    }
    
  
  }
  public class JmxPrometheusExporterMetricsConfigNested extends JmxPrometheusExporterMetricsFluent> implements Nested{
    JmxPrometheusExporterMetricsConfigNested(JmxPrometheusExporterMetrics item) {
      this.builder = new JmxPrometheusExporterMetricsBuilder(this, item);
    }
    JmxPrometheusExporterMetricsBuilder builder;
    
    public N and() {
      return (N) AbstractKafkaConnectSpecFluent.this.withMetricsConfig(builder.build());
    }
    
    public N endJmxPrometheusExporterMetricsConfig() {
      return and();
    }
    
  
  }
  public class JaegerTracingNested extends JaegerTracingFluent> implements Nested{
    JaegerTracingNested(JaegerTracing item) {
      this.builder = new JaegerTracingBuilder(this, item);
    }
    JaegerTracingBuilder builder;
    
    public N and() {
      return (N) AbstractKafkaConnectSpecFluent.this.withTracing(builder.build());
    }
    
    public N endJaegerTracing() {
      return and();
    }
    
  
  }
  public class OpenTelemetryTracingNested extends OpenTelemetryTracingFluent> implements Nested{
    OpenTelemetryTracingNested(OpenTelemetryTracing item) {
      this.builder = new OpenTelemetryTracingBuilder(this, item);
    }
    OpenTelemetryTracingBuilder builder;
    
    public N and() {
      return (N) AbstractKafkaConnectSpecFluent.this.withTracing(builder.build());
    }
    
    public N endOpenTelemetryTracing() {
      return and();
    }
    
  
  }
  public class TemplateNested extends KafkaConnectTemplateFluent> implements Nested{
    TemplateNested(KafkaConnectTemplate item) {
      this.builder = new KafkaConnectTemplateBuilder(this, item);
    }
    KafkaConnectTemplateBuilder builder;
    
    public N and() {
      return (N) AbstractKafkaConnectSpecFluent.this.withTemplate(builder.build());
    }
    
    public N endTemplate() {
      return and();
    }
    
  
  }
  public class ExternalConfigurationNested extends ExternalConfigurationFluent> implements Nested{
    ExternalConfigurationNested(ExternalConfiguration item) {
      this.builder = new ExternalConfigurationBuilder(this, item);
    }
    ExternalConfigurationBuilder builder;
    
    public N and() {
      return (N) AbstractKafkaConnectSpecFluent.this.withExternalConfiguration(builder.build());
    }
    
    public N endExternalConfiguration() {
      return and();
    }
    
  
  }
  public class RackNested extends RackFluent> implements Nested{
    RackNested(Rack item) {
      this.builder = new RackBuilder(this, item);
    }
    RackBuilder builder;
    
    public N and() {
      return (N) AbstractKafkaConnectSpecFluent.this.withRack(builder.build());
    }
    
    public N endRack() {
      return and();
    }
    
  
  }

}




© 2015 - 2024 Weber Informatics LLC | Privacy Policy