com.marcnuri.yakc.api.operatoropenshiftio.v1.OperatorOpenshiftIoV1Api Maven / Gradle / Ivy
Show all versions of openshift Show documentation
/*
* Copyright 2020 Marc Nuri
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.marcnuri.yakc.api.operatoropenshiftio.v1;
import com.marcnuri.yakc.api.Api;
import com.marcnuri.yakc.api.KubernetesCall;
import com.marcnuri.yakc.api.KubernetesListCall;
import com.marcnuri.yakc.model.io.k8s.api.autoscaling.v1.Scale;
import com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions;
import com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status;
import com.marcnuri.yakc.model.io.openshift.operator.v1.Authentication;
import com.marcnuri.yakc.model.io.openshift.operator.v1.AuthenticationList;
import com.marcnuri.yakc.model.io.openshift.operator.v1.CSISnapshotController;
import com.marcnuri.yakc.model.io.openshift.operator.v1.CSISnapshotControllerList;
import com.marcnuri.yakc.model.io.openshift.operator.v1.Console;
import com.marcnuri.yakc.model.io.openshift.operator.v1.ConsoleList;
import com.marcnuri.yakc.model.io.openshift.operator.v1.DNS;
import com.marcnuri.yakc.model.io.openshift.operator.v1.DNSList;
import com.marcnuri.yakc.model.io.openshift.operator.v1.Etcd;
import com.marcnuri.yakc.model.io.openshift.operator.v1.EtcdList;
import com.marcnuri.yakc.model.io.openshift.operator.v1.IngressController;
import com.marcnuri.yakc.model.io.openshift.operator.v1.IngressControllerList;
import com.marcnuri.yakc.model.io.openshift.operator.v1.KubeAPIServer;
import com.marcnuri.yakc.model.io.openshift.operator.v1.KubeAPIServerList;
import com.marcnuri.yakc.model.io.openshift.operator.v1.KubeControllerManager;
import com.marcnuri.yakc.model.io.openshift.operator.v1.KubeControllerManagerList;
import com.marcnuri.yakc.model.io.openshift.operator.v1.KubeScheduler;
import com.marcnuri.yakc.model.io.openshift.operator.v1.KubeSchedulerList;
import com.marcnuri.yakc.model.io.openshift.operator.v1.KubeStorageVersionMigrator;
import com.marcnuri.yakc.model.io.openshift.operator.v1.KubeStorageVersionMigratorList;
import com.marcnuri.yakc.model.io.openshift.operator.v1.Network;
import com.marcnuri.yakc.model.io.openshift.operator.v1.NetworkList;
import com.marcnuri.yakc.model.io.openshift.operator.v1.OpenShiftAPIServer;
import com.marcnuri.yakc.model.io.openshift.operator.v1.OpenShiftAPIServerList;
import com.marcnuri.yakc.model.io.openshift.operator.v1.OpenShiftControllerManager;
import com.marcnuri.yakc.model.io.openshift.operator.v1.OpenShiftControllerManagerList;
import com.marcnuri.yakc.model.io.openshift.operator.v1.ServiceCA;
import com.marcnuri.yakc.model.io.openshift.operator.v1.ServiceCAList;
import com.marcnuri.yakc.model.io.openshift.operator.v1.ServiceCatalogAPIServer;
import com.marcnuri.yakc.model.io.openshift.operator.v1.ServiceCatalogAPIServerList;
import com.marcnuri.yakc.model.io.openshift.operator.v1.ServiceCatalogControllerManager;
import com.marcnuri.yakc.model.io.openshift.operator.v1.ServiceCatalogControllerManagerList;
import java.util.HashMap;
import retrofit2.http.Body;
import retrofit2.http.HTTP;
import retrofit2.http.Headers;
import retrofit2.http.Path;
import retrofit2.http.QueryMap;
@SuppressWarnings({"squid:S1192", "unused"})
public interface OperatorOpenshiftIoV1Api extends Api {
/**
* delete collection of Authentication
*/
@HTTP(
method = "DELETE",
path = "/apis/operator.openshift.io/v1/authentications"
)
@Headers({
"Accept: */*"
})
KubernetesCall deleteCollectionAuthentication();
/**
* delete collection of Authentication
*/
@HTTP(
method = "DELETE",
path = "/apis/operator.openshift.io/v1/authentications"
)
@Headers({
"Accept: */*"
})
KubernetesCall deleteCollectionAuthentication(
@QueryMap DeleteCollectionAuthentication queryParameters);
final class DeleteCollectionAuthentication extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public DeleteCollectionAuthentication pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. If the feature gate WatchBookmarks is not enabled in apiserver, this field is ignored.
*/
public DeleteCollectionAuthentication allowWatchBookmarks(Boolean allowWatchBookmarks) {
put("allowWatchBookmarks", allowWatchBookmarks);
return this;
}
/**
* The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key".
This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.
*/
public DeleteCollectionAuthentication continues(String continues) {
put("continue", continues);
return this;
}
/**
* A selector to restrict the list of returned objects by their fields. Defaults to everything.
*/
public DeleteCollectionAuthentication fieldSelector(String fieldSelector) {
put("fieldSelector", fieldSelector);
return this;
}
/**
* A selector to restrict the list of returned objects by their labels. Defaults to everything.
*/
public DeleteCollectionAuthentication labelSelector(String labelSelector) {
put("labelSelector", labelSelector);
return this;
}
/**
* limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.
The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.
*/
public DeleteCollectionAuthentication limit(Number limit) {
put("limit", limit);
return this;
}
/**
* When specified with a watch call, shows changes that occur after that particular version of a resource. Defaults to changes from the beginning of history. When specified for list: - if unset, then the result is returned from remote storage based on quorum-read flag; - if it's 0, then we simply return what we currently have in cache, no guarantee; - if set to non zero, then the result is at least as fresh as given rv.
*/
public DeleteCollectionAuthentication resourceVersion(String resourceVersion) {
put("resourceVersion", resourceVersion);
return this;
}
/**
* Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.
*/
public DeleteCollectionAuthentication timeoutSeconds(Number timeoutSeconds) {
put("timeoutSeconds", timeoutSeconds);
return this;
}
/**
* Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.
*/
public DeleteCollectionAuthentication watch(Boolean watch) {
put("watch", watch);
return this;
}
}
/**
* list objects of kind Authentication
*/
@HTTP(
method = "GET",
path = "/apis/operator.openshift.io/v1/authentications"
)
@Headers({
"Accept: */*"
})
KubernetesListCall listAuthentication();
/**
* list objects of kind Authentication
*/
@HTTP(
method = "GET",
path = "/apis/operator.openshift.io/v1/authentications"
)
@Headers({
"Accept: */*"
})
KubernetesListCall listAuthentication(
@QueryMap ListAuthentication queryParameters);
final class ListAuthentication extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ListAuthentication pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. If the feature gate WatchBookmarks is not enabled in apiserver, this field is ignored.
*/
public ListAuthentication allowWatchBookmarks(Boolean allowWatchBookmarks) {
put("allowWatchBookmarks", allowWatchBookmarks);
return this;
}
/**
* The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key".
This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.
*/
public ListAuthentication continues(String continues) {
put("continue", continues);
return this;
}
/**
* A selector to restrict the list of returned objects by their fields. Defaults to everything.
*/
public ListAuthentication fieldSelector(String fieldSelector) {
put("fieldSelector", fieldSelector);
return this;
}
/**
* A selector to restrict the list of returned objects by their labels. Defaults to everything.
*/
public ListAuthentication labelSelector(String labelSelector) {
put("labelSelector", labelSelector);
return this;
}
/**
* limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.
The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.
*/
public ListAuthentication limit(Number limit) {
put("limit", limit);
return this;
}
/**
* When specified with a watch call, shows changes that occur after that particular version of a resource. Defaults to changes from the beginning of history. When specified for list: - if unset, then the result is returned from remote storage based on quorum-read flag; - if it's 0, then we simply return what we currently have in cache, no guarantee; - if set to non zero, then the result is at least as fresh as given rv.
*/
public ListAuthentication resourceVersion(String resourceVersion) {
put("resourceVersion", resourceVersion);
return this;
}
/**
* Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.
*/
public ListAuthentication timeoutSeconds(Number timeoutSeconds) {
put("timeoutSeconds", timeoutSeconds);
return this;
}
/**
* Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.
*/
public ListAuthentication watch(Boolean watch) {
put("watch", watch);
return this;
}
}
/**
* create an Authentication
*/
@HTTP(
method = "POST",
path = "/apis/operator.openshift.io/v1/authentications",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall createAuthentication(
@Body Authentication body);
/**
* create an Authentication
*/
@HTTP(
method = "POST",
path = "/apis/operator.openshift.io/v1/authentications",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall createAuthentication(
@Body Authentication body,
@QueryMap CreateAuthentication queryParameters);
final class CreateAuthentication extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public CreateAuthentication pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
*/
public CreateAuthentication dryRun(String dryRun) {
put("dryRun", dryRun);
return this;
}
/**
* fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.
*/
public CreateAuthentication fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* delete an Authentication
*
* @param name name of the Authentication
*/
@HTTP(
method = "DELETE",
path = "/apis/operator.openshift.io/v1/authentications/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteAuthentication(
@Path("name") String name,
@Body DeleteOptions body);
/**
* delete an Authentication
*
* @param name name of the Authentication
*/
@HTTP(
method = "DELETE",
path = "/apis/operator.openshift.io/v1/authentications/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteAuthentication(
@Path("name") String name);
/**
* delete an Authentication
*
* @param name name of the Authentication
*/
@HTTP(
method = "DELETE",
path = "/apis/operator.openshift.io/v1/authentications/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteAuthentication(
@Path("name") String name,
@Body DeleteOptions body,
@QueryMap DeleteAuthentication queryParameters);
/**
* delete an Authentication
*
* @param name name of the Authentication
*/
@HTTP(
method = "DELETE",
path = "/apis/operator.openshift.io/v1/authentications/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteAuthentication(
@Path("name") String name,
@QueryMap DeleteAuthentication queryParameters);
final class DeleteAuthentication extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public DeleteAuthentication pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
*/
public DeleteAuthentication dryRun(String dryRun) {
put("dryRun", dryRun);
return this;
}
/**
* The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.
*/
public DeleteAuthentication gracePeriodSeconds(Number gracePeriodSeconds) {
put("gracePeriodSeconds", gracePeriodSeconds);
return this;
}
/**
* Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.
*/
public DeleteAuthentication orphanDependents(Boolean orphanDependents) {
put("orphanDependents", orphanDependents);
return this;
}
/**
* Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.
*/
public DeleteAuthentication propagationPolicy(String propagationPolicy) {
put("propagationPolicy", propagationPolicy);
return this;
}
}
/**
* read the specified Authentication
*
* @param name name of the Authentication
*/
@HTTP(
method = "GET",
path = "/apis/operator.openshift.io/v1/authentications/{name}"
)
@Headers({
"Accept: */*"
})
KubernetesCall readAuthentication(
@Path("name") String name);
/**
* read the specified Authentication
*
* @param name name of the Authentication
*/
@HTTP(
method = "GET",
path = "/apis/operator.openshift.io/v1/authentications/{name}"
)
@Headers({
"Accept: */*"
})
KubernetesCall readAuthentication(
@Path("name") String name,
@QueryMap ReadAuthentication queryParameters);
final class ReadAuthentication extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReadAuthentication pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* When specified: - if unset, then the result is returned from remote storage based on quorum-read flag; - if it's 0, then we simply return what we currently have in cache, no guarantee; - if set to non zero, then the result is at least as fresh as given rv.
*/
public ReadAuthentication resourceVersion(String resourceVersion) {
put("resourceVersion", resourceVersion);
return this;
}
}
/**
* partially update the specified Authentication
*
* @param name name of the Authentication
*/
@HTTP(
method = "PATCH",
path = "/apis/operator.openshift.io/v1/authentications/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchAuthentication(
@Path("name") String name,
@Body Authentication body);
/**
* partially update the specified Authentication
*
* @param name name of the Authentication
*/
@HTTP(
method = "PATCH",
path = "/apis/operator.openshift.io/v1/authentications/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchAuthentication(
@Path("name") String name,
@Body Authentication body,
@QueryMap PatchAuthentication queryParameters);
final class PatchAuthentication extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public PatchAuthentication pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
*/
public PatchAuthentication dryRun(String dryRun) {
put("dryRun", dryRun);
return this;
}
/**
* fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.
*/
public PatchAuthentication fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* replace the specified Authentication
*
* @param name name of the Authentication
*/
@HTTP(
method = "PUT",
path = "/apis/operator.openshift.io/v1/authentications/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replaceAuthentication(
@Path("name") String name,
@Body Authentication body);
/**
* replace the specified Authentication
*
* @param name name of the Authentication
*/
@HTTP(
method = "PUT",
path = "/apis/operator.openshift.io/v1/authentications/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replaceAuthentication(
@Path("name") String name,
@Body Authentication body,
@QueryMap ReplaceAuthentication queryParameters);
final class ReplaceAuthentication extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReplaceAuthentication pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
*/
public ReplaceAuthentication dryRun(String dryRun) {
put("dryRun", dryRun);
return this;
}
/**
* fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.
*/
public ReplaceAuthentication fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* read status of the specified Authentication
*
* @param name name of the Authentication
*/
@HTTP(
method = "GET",
path = "/apis/operator.openshift.io/v1/authentications/{name}/status"
)
@Headers({
"Accept: */*"
})
KubernetesCall readAuthenticationStatus(
@Path("name") String name);
/**
* read status of the specified Authentication
*
* @param name name of the Authentication
*/
@HTTP(
method = "GET",
path = "/apis/operator.openshift.io/v1/authentications/{name}/status"
)
@Headers({
"Accept: */*"
})
KubernetesCall readAuthenticationStatus(
@Path("name") String name,
@QueryMap ReadAuthenticationStatus queryParameters);
final class ReadAuthenticationStatus extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReadAuthenticationStatus pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* When specified: - if unset, then the result is returned from remote storage based on quorum-read flag; - if it's 0, then we simply return what we currently have in cache, no guarantee; - if set to non zero, then the result is at least as fresh as given rv.
*/
public ReadAuthenticationStatus resourceVersion(String resourceVersion) {
put("resourceVersion", resourceVersion);
return this;
}
}
/**
* partially update status of the specified Authentication
*
* @param name name of the Authentication
*/
@HTTP(
method = "PATCH",
path = "/apis/operator.openshift.io/v1/authentications/{name}/status",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchAuthenticationStatus(
@Path("name") String name,
@Body Authentication body);
/**
* partially update status of the specified Authentication
*
* @param name name of the Authentication
*/
@HTTP(
method = "PATCH",
path = "/apis/operator.openshift.io/v1/authentications/{name}/status",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchAuthenticationStatus(
@Path("name") String name,
@Body Authentication body,
@QueryMap PatchAuthenticationStatus queryParameters);
final class PatchAuthenticationStatus extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public PatchAuthenticationStatus pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
*/
public PatchAuthenticationStatus dryRun(String dryRun) {
put("dryRun", dryRun);
return this;
}
/**
* fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.
*/
public PatchAuthenticationStatus fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* replace status of the specified Authentication
*
* @param name name of the Authentication
*/
@HTTP(
method = "PUT",
path = "/apis/operator.openshift.io/v1/authentications/{name}/status",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replaceAuthenticationStatus(
@Path("name") String name,
@Body Authentication body);
/**
* replace status of the specified Authentication
*
* @param name name of the Authentication
*/
@HTTP(
method = "PUT",
path = "/apis/operator.openshift.io/v1/authentications/{name}/status",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replaceAuthenticationStatus(
@Path("name") String name,
@Body Authentication body,
@QueryMap ReplaceAuthenticationStatus queryParameters);
final class ReplaceAuthenticationStatus extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReplaceAuthenticationStatus pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
*/
public ReplaceAuthenticationStatus dryRun(String dryRun) {
put("dryRun", dryRun);
return this;
}
/**
* fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.
*/
public ReplaceAuthenticationStatus fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* delete collection of Console
*/
@HTTP(
method = "DELETE",
path = "/apis/operator.openshift.io/v1/consoles"
)
@Headers({
"Accept: */*"
})
KubernetesCall deleteCollectionConsole();
/**
* delete collection of Console
*/
@HTTP(
method = "DELETE",
path = "/apis/operator.openshift.io/v1/consoles"
)
@Headers({
"Accept: */*"
})
KubernetesCall deleteCollectionConsole(
@QueryMap DeleteCollectionConsole queryParameters);
final class DeleteCollectionConsole extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public DeleteCollectionConsole pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. If the feature gate WatchBookmarks is not enabled in apiserver, this field is ignored.
*/
public DeleteCollectionConsole allowWatchBookmarks(Boolean allowWatchBookmarks) {
put("allowWatchBookmarks", allowWatchBookmarks);
return this;
}
/**
* The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key".
This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.
*/
public DeleteCollectionConsole continues(String continues) {
put("continue", continues);
return this;
}
/**
* A selector to restrict the list of returned objects by their fields. Defaults to everything.
*/
public DeleteCollectionConsole fieldSelector(String fieldSelector) {
put("fieldSelector", fieldSelector);
return this;
}
/**
* A selector to restrict the list of returned objects by their labels. Defaults to everything.
*/
public DeleteCollectionConsole labelSelector(String labelSelector) {
put("labelSelector", labelSelector);
return this;
}
/**
* limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.
The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.
*/
public DeleteCollectionConsole limit(Number limit) {
put("limit", limit);
return this;
}
/**
* When specified with a watch call, shows changes that occur after that particular version of a resource. Defaults to changes from the beginning of history. When specified for list: - if unset, then the result is returned from remote storage based on quorum-read flag; - if it's 0, then we simply return what we currently have in cache, no guarantee; - if set to non zero, then the result is at least as fresh as given rv.
*/
public DeleteCollectionConsole resourceVersion(String resourceVersion) {
put("resourceVersion", resourceVersion);
return this;
}
/**
* Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.
*/
public DeleteCollectionConsole timeoutSeconds(Number timeoutSeconds) {
put("timeoutSeconds", timeoutSeconds);
return this;
}
/**
* Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.
*/
public DeleteCollectionConsole watch(Boolean watch) {
put("watch", watch);
return this;
}
}
/**
* list objects of kind Console
*/
@HTTP(
method = "GET",
path = "/apis/operator.openshift.io/v1/consoles"
)
@Headers({
"Accept: */*"
})
KubernetesListCall listConsole();
/**
* list objects of kind Console
*/
@HTTP(
method = "GET",
path = "/apis/operator.openshift.io/v1/consoles"
)
@Headers({
"Accept: */*"
})
KubernetesListCall listConsole(
@QueryMap ListConsole queryParameters);
final class ListConsole extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ListConsole pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. If the feature gate WatchBookmarks is not enabled in apiserver, this field is ignored.
*/
public ListConsole allowWatchBookmarks(Boolean allowWatchBookmarks) {
put("allowWatchBookmarks", allowWatchBookmarks);
return this;
}
/**
* The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key".
This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.
*/
public ListConsole continues(String continues) {
put("continue", continues);
return this;
}
/**
* A selector to restrict the list of returned objects by their fields. Defaults to everything.
*/
public ListConsole fieldSelector(String fieldSelector) {
put("fieldSelector", fieldSelector);
return this;
}
/**
* A selector to restrict the list of returned objects by their labels. Defaults to everything.
*/
public ListConsole labelSelector(String labelSelector) {
put("labelSelector", labelSelector);
return this;
}
/**
* limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.
The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.
*/
public ListConsole limit(Number limit) {
put("limit", limit);
return this;
}
/**
* When specified with a watch call, shows changes that occur after that particular version of a resource. Defaults to changes from the beginning of history. When specified for list: - if unset, then the result is returned from remote storage based on quorum-read flag; - if it's 0, then we simply return what we currently have in cache, no guarantee; - if set to non zero, then the result is at least as fresh as given rv.
*/
public ListConsole resourceVersion(String resourceVersion) {
put("resourceVersion", resourceVersion);
return this;
}
/**
* Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.
*/
public ListConsole timeoutSeconds(Number timeoutSeconds) {
put("timeoutSeconds", timeoutSeconds);
return this;
}
/**
* Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.
*/
public ListConsole watch(Boolean watch) {
put("watch", watch);
return this;
}
}
/**
* create a Console
*/
@HTTP(
method = "POST",
path = "/apis/operator.openshift.io/v1/consoles",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall createConsole(
@Body Console body);
/**
* create a Console
*/
@HTTP(
method = "POST",
path = "/apis/operator.openshift.io/v1/consoles",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall createConsole(
@Body Console body,
@QueryMap CreateConsole queryParameters);
final class CreateConsole extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public CreateConsole pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
*/
public CreateConsole dryRun(String dryRun) {
put("dryRun", dryRun);
return this;
}
/**
* fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.
*/
public CreateConsole fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* delete a Console
*
* @param name name of the Console
*/
@HTTP(
method = "DELETE",
path = "/apis/operator.openshift.io/v1/consoles/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteConsole(
@Path("name") String name,
@Body DeleteOptions body);
/**
* delete a Console
*
* @param name name of the Console
*/
@HTTP(
method = "DELETE",
path = "/apis/operator.openshift.io/v1/consoles/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteConsole(
@Path("name") String name);
/**
* delete a Console
*
* @param name name of the Console
*/
@HTTP(
method = "DELETE",
path = "/apis/operator.openshift.io/v1/consoles/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteConsole(
@Path("name") String name,
@Body DeleteOptions body,
@QueryMap DeleteConsole queryParameters);
/**
* delete a Console
*
* @param name name of the Console
*/
@HTTP(
method = "DELETE",
path = "/apis/operator.openshift.io/v1/consoles/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteConsole(
@Path("name") String name,
@QueryMap DeleteConsole queryParameters);
final class DeleteConsole extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public DeleteConsole pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
*/
public DeleteConsole dryRun(String dryRun) {
put("dryRun", dryRun);
return this;
}
/**
* The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.
*/
public DeleteConsole gracePeriodSeconds(Number gracePeriodSeconds) {
put("gracePeriodSeconds", gracePeriodSeconds);
return this;
}
/**
* Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.
*/
public DeleteConsole orphanDependents(Boolean orphanDependents) {
put("orphanDependents", orphanDependents);
return this;
}
/**
* Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.
*/
public DeleteConsole propagationPolicy(String propagationPolicy) {
put("propagationPolicy", propagationPolicy);
return this;
}
}
/**
* read the specified Console
*
* @param name name of the Console
*/
@HTTP(
method = "GET",
path = "/apis/operator.openshift.io/v1/consoles/{name}"
)
@Headers({
"Accept: */*"
})
KubernetesCall readConsole(
@Path("name") String name);
/**
* read the specified Console
*
* @param name name of the Console
*/
@HTTP(
method = "GET",
path = "/apis/operator.openshift.io/v1/consoles/{name}"
)
@Headers({
"Accept: */*"
})
KubernetesCall readConsole(
@Path("name") String name,
@QueryMap ReadConsole queryParameters);
final class ReadConsole extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReadConsole pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* When specified: - if unset, then the result is returned from remote storage based on quorum-read flag; - if it's 0, then we simply return what we currently have in cache, no guarantee; - if set to non zero, then the result is at least as fresh as given rv.
*/
public ReadConsole resourceVersion(String resourceVersion) {
put("resourceVersion", resourceVersion);
return this;
}
}
/**
* partially update the specified Console
*
* @param name name of the Console
*/
@HTTP(
method = "PATCH",
path = "/apis/operator.openshift.io/v1/consoles/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchConsole(
@Path("name") String name,
@Body Console body);
/**
* partially update the specified Console
*
* @param name name of the Console
*/
@HTTP(
method = "PATCH",
path = "/apis/operator.openshift.io/v1/consoles/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchConsole(
@Path("name") String name,
@Body Console body,
@QueryMap PatchConsole queryParameters);
final class PatchConsole extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public PatchConsole pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
*/
public PatchConsole dryRun(String dryRun) {
put("dryRun", dryRun);
return this;
}
/**
* fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.
*/
public PatchConsole fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* replace the specified Console
*
* @param name name of the Console
*/
@HTTP(
method = "PUT",
path = "/apis/operator.openshift.io/v1/consoles/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replaceConsole(
@Path("name") String name,
@Body Console body);
/**
* replace the specified Console
*
* @param name name of the Console
*/
@HTTP(
method = "PUT",
path = "/apis/operator.openshift.io/v1/consoles/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replaceConsole(
@Path("name") String name,
@Body Console body,
@QueryMap ReplaceConsole queryParameters);
final class ReplaceConsole extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReplaceConsole pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
*/
public ReplaceConsole dryRun(String dryRun) {
put("dryRun", dryRun);
return this;
}
/**
* fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.
*/
public ReplaceConsole fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* read status of the specified Console
*
* @param name name of the Console
*/
@HTTP(
method = "GET",
path = "/apis/operator.openshift.io/v1/consoles/{name}/status"
)
@Headers({
"Accept: */*"
})
KubernetesCall readConsoleStatus(
@Path("name") String name);
/**
* read status of the specified Console
*
* @param name name of the Console
*/
@HTTP(
method = "GET",
path = "/apis/operator.openshift.io/v1/consoles/{name}/status"
)
@Headers({
"Accept: */*"
})
KubernetesCall readConsoleStatus(
@Path("name") String name,
@QueryMap ReadConsoleStatus queryParameters);
final class ReadConsoleStatus extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReadConsoleStatus pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* When specified: - if unset, then the result is returned from remote storage based on quorum-read flag; - if it's 0, then we simply return what we currently have in cache, no guarantee; - if set to non zero, then the result is at least as fresh as given rv.
*/
public ReadConsoleStatus resourceVersion(String resourceVersion) {
put("resourceVersion", resourceVersion);
return this;
}
}
/**
* partially update status of the specified Console
*
* @param name name of the Console
*/
@HTTP(
method = "PATCH",
path = "/apis/operator.openshift.io/v1/consoles/{name}/status",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchConsoleStatus(
@Path("name") String name,
@Body Console body);
/**
* partially update status of the specified Console
*
* @param name name of the Console
*/
@HTTP(
method = "PATCH",
path = "/apis/operator.openshift.io/v1/consoles/{name}/status",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchConsoleStatus(
@Path("name") String name,
@Body Console body,
@QueryMap PatchConsoleStatus queryParameters);
final class PatchConsoleStatus extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public PatchConsoleStatus pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
*/
public PatchConsoleStatus dryRun(String dryRun) {
put("dryRun", dryRun);
return this;
}
/**
* fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.
*/
public PatchConsoleStatus fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* replace status of the specified Console
*
* @param name name of the Console
*/
@HTTP(
method = "PUT",
path = "/apis/operator.openshift.io/v1/consoles/{name}/status",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replaceConsoleStatus(
@Path("name") String name,
@Body Console body);
/**
* replace status of the specified Console
*
* @param name name of the Console
*/
@HTTP(
method = "PUT",
path = "/apis/operator.openshift.io/v1/consoles/{name}/status",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replaceConsoleStatus(
@Path("name") String name,
@Body Console body,
@QueryMap ReplaceConsoleStatus queryParameters);
final class ReplaceConsoleStatus extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReplaceConsoleStatus pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
*/
public ReplaceConsoleStatus dryRun(String dryRun) {
put("dryRun", dryRun);
return this;
}
/**
* fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.
*/
public ReplaceConsoleStatus fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* delete collection of CSISnapshotController
*/
@HTTP(
method = "DELETE",
path = "/apis/operator.openshift.io/v1/csisnapshotcontrollers"
)
@Headers({
"Accept: */*"
})
KubernetesCall deleteCollectionCSISnapshotController();
/**
* delete collection of CSISnapshotController
*/
@HTTP(
method = "DELETE",
path = "/apis/operator.openshift.io/v1/csisnapshotcontrollers"
)
@Headers({
"Accept: */*"
})
KubernetesCall deleteCollectionCSISnapshotController(
@QueryMap DeleteCollectionCSISnapshotController queryParameters);
final class DeleteCollectionCSISnapshotController extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public DeleteCollectionCSISnapshotController pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. If the feature gate WatchBookmarks is not enabled in apiserver, this field is ignored.
*/
public DeleteCollectionCSISnapshotController allowWatchBookmarks(Boolean allowWatchBookmarks) {
put("allowWatchBookmarks", allowWatchBookmarks);
return this;
}
/**
* The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key".
This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.
*/
public DeleteCollectionCSISnapshotController continues(String continues) {
put("continue", continues);
return this;
}
/**
* A selector to restrict the list of returned objects by their fields. Defaults to everything.
*/
public DeleteCollectionCSISnapshotController fieldSelector(String fieldSelector) {
put("fieldSelector", fieldSelector);
return this;
}
/**
* A selector to restrict the list of returned objects by their labels. Defaults to everything.
*/
public DeleteCollectionCSISnapshotController labelSelector(String labelSelector) {
put("labelSelector", labelSelector);
return this;
}
/**
* limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.
The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.
*/
public DeleteCollectionCSISnapshotController limit(Number limit) {
put("limit", limit);
return this;
}
/**
* When specified with a watch call, shows changes that occur after that particular version of a resource. Defaults to changes from the beginning of history. When specified for list: - if unset, then the result is returned from remote storage based on quorum-read flag; - if it's 0, then we simply return what we currently have in cache, no guarantee; - if set to non zero, then the result is at least as fresh as given rv.
*/
public DeleteCollectionCSISnapshotController resourceVersion(String resourceVersion) {
put("resourceVersion", resourceVersion);
return this;
}
/**
* Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.
*/
public DeleteCollectionCSISnapshotController timeoutSeconds(Number timeoutSeconds) {
put("timeoutSeconds", timeoutSeconds);
return this;
}
/**
* Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.
*/
public DeleteCollectionCSISnapshotController watch(Boolean watch) {
put("watch", watch);
return this;
}
}
/**
* list objects of kind CSISnapshotController
*/
@HTTP(
method = "GET",
path = "/apis/operator.openshift.io/v1/csisnapshotcontrollers"
)
@Headers({
"Accept: */*"
})
KubernetesListCall listCSISnapshotController();
/**
* list objects of kind CSISnapshotController
*/
@HTTP(
method = "GET",
path = "/apis/operator.openshift.io/v1/csisnapshotcontrollers"
)
@Headers({
"Accept: */*"
})
KubernetesListCall listCSISnapshotController(
@QueryMap ListCSISnapshotController queryParameters);
final class ListCSISnapshotController extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ListCSISnapshotController pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. If the feature gate WatchBookmarks is not enabled in apiserver, this field is ignored.
*/
public ListCSISnapshotController allowWatchBookmarks(Boolean allowWatchBookmarks) {
put("allowWatchBookmarks", allowWatchBookmarks);
return this;
}
/**
* The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key".
This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.
*/
public ListCSISnapshotController continues(String continues) {
put("continue", continues);
return this;
}
/**
* A selector to restrict the list of returned objects by their fields. Defaults to everything.
*/
public ListCSISnapshotController fieldSelector(String fieldSelector) {
put("fieldSelector", fieldSelector);
return this;
}
/**
* A selector to restrict the list of returned objects by their labels. Defaults to everything.
*/
public ListCSISnapshotController labelSelector(String labelSelector) {
put("labelSelector", labelSelector);
return this;
}
/**
* limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.
The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.
*/
public ListCSISnapshotController limit(Number limit) {
put("limit", limit);
return this;
}
/**
* When specified with a watch call, shows changes that occur after that particular version of a resource. Defaults to changes from the beginning of history. When specified for list: - if unset, then the result is returned from remote storage based on quorum-read flag; - if it's 0, then we simply return what we currently have in cache, no guarantee; - if set to non zero, then the result is at least as fresh as given rv.
*/
public ListCSISnapshotController resourceVersion(String resourceVersion) {
put("resourceVersion", resourceVersion);
return this;
}
/**
* Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.
*/
public ListCSISnapshotController timeoutSeconds(Number timeoutSeconds) {
put("timeoutSeconds", timeoutSeconds);
return this;
}
/**
* Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.
*/
public ListCSISnapshotController watch(Boolean watch) {
put("watch", watch);
return this;
}
}
/**
* create a CSISnapshotController
*/
@HTTP(
method = "POST",
path = "/apis/operator.openshift.io/v1/csisnapshotcontrollers",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall createCSISnapshotController(
@Body CSISnapshotController body);
/**
* create a CSISnapshotController
*/
@HTTP(
method = "POST",
path = "/apis/operator.openshift.io/v1/csisnapshotcontrollers",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall createCSISnapshotController(
@Body CSISnapshotController body,
@QueryMap CreateCSISnapshotController queryParameters);
final class CreateCSISnapshotController extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public CreateCSISnapshotController pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
*/
public CreateCSISnapshotController dryRun(String dryRun) {
put("dryRun", dryRun);
return this;
}
/**
* fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.
*/
public CreateCSISnapshotController fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* delete a CSISnapshotController
*
* @param name name of the CSISnapshotController
*/
@HTTP(
method = "DELETE",
path = "/apis/operator.openshift.io/v1/csisnapshotcontrollers/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteCSISnapshotController(
@Path("name") String name,
@Body DeleteOptions body);
/**
* delete a CSISnapshotController
*
* @param name name of the CSISnapshotController
*/
@HTTP(
method = "DELETE",
path = "/apis/operator.openshift.io/v1/csisnapshotcontrollers/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteCSISnapshotController(
@Path("name") String name);
/**
* delete a CSISnapshotController
*
* @param name name of the CSISnapshotController
*/
@HTTP(
method = "DELETE",
path = "/apis/operator.openshift.io/v1/csisnapshotcontrollers/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteCSISnapshotController(
@Path("name") String name,
@Body DeleteOptions body,
@QueryMap DeleteCSISnapshotController queryParameters);
/**
* delete a CSISnapshotController
*
* @param name name of the CSISnapshotController
*/
@HTTP(
method = "DELETE",
path = "/apis/operator.openshift.io/v1/csisnapshotcontrollers/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteCSISnapshotController(
@Path("name") String name,
@QueryMap DeleteCSISnapshotController queryParameters);
final class DeleteCSISnapshotController extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public DeleteCSISnapshotController pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
*/
public DeleteCSISnapshotController dryRun(String dryRun) {
put("dryRun", dryRun);
return this;
}
/**
* The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.
*/
public DeleteCSISnapshotController gracePeriodSeconds(Number gracePeriodSeconds) {
put("gracePeriodSeconds", gracePeriodSeconds);
return this;
}
/**
* Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.
*/
public DeleteCSISnapshotController orphanDependents(Boolean orphanDependents) {
put("orphanDependents", orphanDependents);
return this;
}
/**
* Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.
*/
public DeleteCSISnapshotController propagationPolicy(String propagationPolicy) {
put("propagationPolicy", propagationPolicy);
return this;
}
}
/**
* read the specified CSISnapshotController
*
* @param name name of the CSISnapshotController
*/
@HTTP(
method = "GET",
path = "/apis/operator.openshift.io/v1/csisnapshotcontrollers/{name}"
)
@Headers({
"Accept: */*"
})
KubernetesCall readCSISnapshotController(
@Path("name") String name);
/**
* read the specified CSISnapshotController
*
* @param name name of the CSISnapshotController
*/
@HTTP(
method = "GET",
path = "/apis/operator.openshift.io/v1/csisnapshotcontrollers/{name}"
)
@Headers({
"Accept: */*"
})
KubernetesCall readCSISnapshotController(
@Path("name") String name,
@QueryMap ReadCSISnapshotController queryParameters);
final class ReadCSISnapshotController extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReadCSISnapshotController pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* When specified: - if unset, then the result is returned from remote storage based on quorum-read flag; - if it's 0, then we simply return what we currently have in cache, no guarantee; - if set to non zero, then the result is at least as fresh as given rv.
*/
public ReadCSISnapshotController resourceVersion(String resourceVersion) {
put("resourceVersion", resourceVersion);
return this;
}
}
/**
* partially update the specified CSISnapshotController
*
* @param name name of the CSISnapshotController
*/
@HTTP(
method = "PATCH",
path = "/apis/operator.openshift.io/v1/csisnapshotcontrollers/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchCSISnapshotController(
@Path("name") String name,
@Body CSISnapshotController body);
/**
* partially update the specified CSISnapshotController
*
* @param name name of the CSISnapshotController
*/
@HTTP(
method = "PATCH",
path = "/apis/operator.openshift.io/v1/csisnapshotcontrollers/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchCSISnapshotController(
@Path("name") String name,
@Body CSISnapshotController body,
@QueryMap PatchCSISnapshotController queryParameters);
final class PatchCSISnapshotController extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public PatchCSISnapshotController pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
*/
public PatchCSISnapshotController dryRun(String dryRun) {
put("dryRun", dryRun);
return this;
}
/**
* fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.
*/
public PatchCSISnapshotController fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* replace the specified CSISnapshotController
*
* @param name name of the CSISnapshotController
*/
@HTTP(
method = "PUT",
path = "/apis/operator.openshift.io/v1/csisnapshotcontrollers/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replaceCSISnapshotController(
@Path("name") String name,
@Body CSISnapshotController body);
/**
* replace the specified CSISnapshotController
*
* @param name name of the CSISnapshotController
*/
@HTTP(
method = "PUT",
path = "/apis/operator.openshift.io/v1/csisnapshotcontrollers/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replaceCSISnapshotController(
@Path("name") String name,
@Body CSISnapshotController body,
@QueryMap ReplaceCSISnapshotController queryParameters);
final class ReplaceCSISnapshotController extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReplaceCSISnapshotController pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
*/
public ReplaceCSISnapshotController dryRun(String dryRun) {
put("dryRun", dryRun);
return this;
}
/**
* fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.
*/
public ReplaceCSISnapshotController fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* read status of the specified CSISnapshotController
*
* @param name name of the CSISnapshotController
*/
@HTTP(
method = "GET",
path = "/apis/operator.openshift.io/v1/csisnapshotcontrollers/{name}/status"
)
@Headers({
"Accept: */*"
})
KubernetesCall readCSISnapshotControllerStatus(
@Path("name") String name);
/**
* read status of the specified CSISnapshotController
*
* @param name name of the CSISnapshotController
*/
@HTTP(
method = "GET",
path = "/apis/operator.openshift.io/v1/csisnapshotcontrollers/{name}/status"
)
@Headers({
"Accept: */*"
})
KubernetesCall readCSISnapshotControllerStatus(
@Path("name") String name,
@QueryMap ReadCSISnapshotControllerStatus queryParameters);
final class ReadCSISnapshotControllerStatus extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReadCSISnapshotControllerStatus pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* When specified: - if unset, then the result is returned from remote storage based on quorum-read flag; - if it's 0, then we simply return what we currently have in cache, no guarantee; - if set to non zero, then the result is at least as fresh as given rv.
*/
public ReadCSISnapshotControllerStatus resourceVersion(String resourceVersion) {
put("resourceVersion", resourceVersion);
return this;
}
}
/**
* partially update status of the specified CSISnapshotController
*
* @param name name of the CSISnapshotController
*/
@HTTP(
method = "PATCH",
path = "/apis/operator.openshift.io/v1/csisnapshotcontrollers/{name}/status",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchCSISnapshotControllerStatus(
@Path("name") String name,
@Body CSISnapshotController body);
/**
* partially update status of the specified CSISnapshotController
*
* @param name name of the CSISnapshotController
*/
@HTTP(
method = "PATCH",
path = "/apis/operator.openshift.io/v1/csisnapshotcontrollers/{name}/status",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchCSISnapshotControllerStatus(
@Path("name") String name,
@Body CSISnapshotController body,
@QueryMap PatchCSISnapshotControllerStatus queryParameters);
final class PatchCSISnapshotControllerStatus extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public PatchCSISnapshotControllerStatus pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
*/
public PatchCSISnapshotControllerStatus dryRun(String dryRun) {
put("dryRun", dryRun);
return this;
}
/**
* fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.
*/
public PatchCSISnapshotControllerStatus fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* replace status of the specified CSISnapshotController
*
* @param name name of the CSISnapshotController
*/
@HTTP(
method = "PUT",
path = "/apis/operator.openshift.io/v1/csisnapshotcontrollers/{name}/status",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replaceCSISnapshotControllerStatus(
@Path("name") String name,
@Body CSISnapshotController body);
/**
* replace status of the specified CSISnapshotController
*
* @param name name of the CSISnapshotController
*/
@HTTP(
method = "PUT",
path = "/apis/operator.openshift.io/v1/csisnapshotcontrollers/{name}/status",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replaceCSISnapshotControllerStatus(
@Path("name") String name,
@Body CSISnapshotController body,
@QueryMap ReplaceCSISnapshotControllerStatus queryParameters);
final class ReplaceCSISnapshotControllerStatus extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReplaceCSISnapshotControllerStatus pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
*/
public ReplaceCSISnapshotControllerStatus dryRun(String dryRun) {
put("dryRun", dryRun);
return this;
}
/**
* fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.
*/
public ReplaceCSISnapshotControllerStatus fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* delete collection of DNS
*/
@HTTP(
method = "DELETE",
path = "/apis/operator.openshift.io/v1/dnses"
)
@Headers({
"Accept: */*"
})
KubernetesCall deleteCollectionDNS();
/**
* delete collection of DNS
*/
@HTTP(
method = "DELETE",
path = "/apis/operator.openshift.io/v1/dnses"
)
@Headers({
"Accept: */*"
})
KubernetesCall deleteCollectionDNS(
@QueryMap DeleteCollectionDNS queryParameters);
final class DeleteCollectionDNS extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public DeleteCollectionDNS pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. If the feature gate WatchBookmarks is not enabled in apiserver, this field is ignored.
*/
public DeleteCollectionDNS allowWatchBookmarks(Boolean allowWatchBookmarks) {
put("allowWatchBookmarks", allowWatchBookmarks);
return this;
}
/**
* The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key".
This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.
*/
public DeleteCollectionDNS continues(String continues) {
put("continue", continues);
return this;
}
/**
* A selector to restrict the list of returned objects by their fields. Defaults to everything.
*/
public DeleteCollectionDNS fieldSelector(String fieldSelector) {
put("fieldSelector", fieldSelector);
return this;
}
/**
* A selector to restrict the list of returned objects by their labels. Defaults to everything.
*/
public DeleteCollectionDNS labelSelector(String labelSelector) {
put("labelSelector", labelSelector);
return this;
}
/**
* limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.
The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.
*/
public DeleteCollectionDNS limit(Number limit) {
put("limit", limit);
return this;
}
/**
* When specified with a watch call, shows changes that occur after that particular version of a resource. Defaults to changes from the beginning of history. When specified for list: - if unset, then the result is returned from remote storage based on quorum-read flag; - if it's 0, then we simply return what we currently have in cache, no guarantee; - if set to non zero, then the result is at least as fresh as given rv.
*/
public DeleteCollectionDNS resourceVersion(String resourceVersion) {
put("resourceVersion", resourceVersion);
return this;
}
/**
* Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.
*/
public DeleteCollectionDNS timeoutSeconds(Number timeoutSeconds) {
put("timeoutSeconds", timeoutSeconds);
return this;
}
/**
* Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.
*/
public DeleteCollectionDNS watch(Boolean watch) {
put("watch", watch);
return this;
}
}
/**
* list objects of kind DNS
*/
@HTTP(
method = "GET",
path = "/apis/operator.openshift.io/v1/dnses"
)
@Headers({
"Accept: */*"
})
KubernetesListCall listDNS();
/**
* list objects of kind DNS
*/
@HTTP(
method = "GET",
path = "/apis/operator.openshift.io/v1/dnses"
)
@Headers({
"Accept: */*"
})
KubernetesListCall listDNS(
@QueryMap ListDNS queryParameters);
final class ListDNS extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ListDNS pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. If the feature gate WatchBookmarks is not enabled in apiserver, this field is ignored.
*/
public ListDNS allowWatchBookmarks(Boolean allowWatchBookmarks) {
put("allowWatchBookmarks", allowWatchBookmarks);
return this;
}
/**
* The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key".
This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.
*/
public ListDNS continues(String continues) {
put("continue", continues);
return this;
}
/**
* A selector to restrict the list of returned objects by their fields. Defaults to everything.
*/
public ListDNS fieldSelector(String fieldSelector) {
put("fieldSelector", fieldSelector);
return this;
}
/**
* A selector to restrict the list of returned objects by their labels. Defaults to everything.
*/
public ListDNS labelSelector(String labelSelector) {
put("labelSelector", labelSelector);
return this;
}
/**
* limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.
The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.
*/
public ListDNS limit(Number limit) {
put("limit", limit);
return this;
}
/**
* When specified with a watch call, shows changes that occur after that particular version of a resource. Defaults to changes from the beginning of history. When specified for list: - if unset, then the result is returned from remote storage based on quorum-read flag; - if it's 0, then we simply return what we currently have in cache, no guarantee; - if set to non zero, then the result is at least as fresh as given rv.
*/
public ListDNS resourceVersion(String resourceVersion) {
put("resourceVersion", resourceVersion);
return this;
}
/**
* Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.
*/
public ListDNS timeoutSeconds(Number timeoutSeconds) {
put("timeoutSeconds", timeoutSeconds);
return this;
}
/**
* Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.
*/
public ListDNS watch(Boolean watch) {
put("watch", watch);
return this;
}
}
/**
* create a DNS
*/
@HTTP(
method = "POST",
path = "/apis/operator.openshift.io/v1/dnses",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall createDNS(
@Body DNS body);
/**
* create a DNS
*/
@HTTP(
method = "POST",
path = "/apis/operator.openshift.io/v1/dnses",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall createDNS(
@Body DNS body,
@QueryMap CreateDNS queryParameters);
final class CreateDNS extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public CreateDNS pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
*/
public CreateDNS dryRun(String dryRun) {
put("dryRun", dryRun);
return this;
}
/**
* fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.
*/
public CreateDNS fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* delete a DNS
*
* @param name name of the DNS
*/
@HTTP(
method = "DELETE",
path = "/apis/operator.openshift.io/v1/dnses/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteDNS(
@Path("name") String name,
@Body DeleteOptions body);
/**
* delete a DNS
*
* @param name name of the DNS
*/
@HTTP(
method = "DELETE",
path = "/apis/operator.openshift.io/v1/dnses/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteDNS(
@Path("name") String name);
/**
* delete a DNS
*
* @param name name of the DNS
*/
@HTTP(
method = "DELETE",
path = "/apis/operator.openshift.io/v1/dnses/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteDNS(
@Path("name") String name,
@Body DeleteOptions body,
@QueryMap DeleteDNS queryParameters);
/**
* delete a DNS
*
* @param name name of the DNS
*/
@HTTP(
method = "DELETE",
path = "/apis/operator.openshift.io/v1/dnses/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteDNS(
@Path("name") String name,
@QueryMap DeleteDNS queryParameters);
final class DeleteDNS extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public DeleteDNS pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
*/
public DeleteDNS dryRun(String dryRun) {
put("dryRun", dryRun);
return this;
}
/**
* The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.
*/
public DeleteDNS gracePeriodSeconds(Number gracePeriodSeconds) {
put("gracePeriodSeconds", gracePeriodSeconds);
return this;
}
/**
* Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.
*/
public DeleteDNS orphanDependents(Boolean orphanDependents) {
put("orphanDependents", orphanDependents);
return this;
}
/**
* Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.
*/
public DeleteDNS propagationPolicy(String propagationPolicy) {
put("propagationPolicy", propagationPolicy);
return this;
}
}
/**
* read the specified DNS
*
* @param name name of the DNS
*/
@HTTP(
method = "GET",
path = "/apis/operator.openshift.io/v1/dnses/{name}"
)
@Headers({
"Accept: */*"
})
KubernetesCall readDNS(
@Path("name") String name);
/**
* read the specified DNS
*
* @param name name of the DNS
*/
@HTTP(
method = "GET",
path = "/apis/operator.openshift.io/v1/dnses/{name}"
)
@Headers({
"Accept: */*"
})
KubernetesCall readDNS(
@Path("name") String name,
@QueryMap ReadDNS queryParameters);
final class ReadDNS extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReadDNS pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* When specified: - if unset, then the result is returned from remote storage based on quorum-read flag; - if it's 0, then we simply return what we currently have in cache, no guarantee; - if set to non zero, then the result is at least as fresh as given rv.
*/
public ReadDNS resourceVersion(String resourceVersion) {
put("resourceVersion", resourceVersion);
return this;
}
}
/**
* partially update the specified DNS
*
* @param name name of the DNS
*/
@HTTP(
method = "PATCH",
path = "/apis/operator.openshift.io/v1/dnses/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchDNS(
@Path("name") String name,
@Body DNS body);
/**
* partially update the specified DNS
*
* @param name name of the DNS
*/
@HTTP(
method = "PATCH",
path = "/apis/operator.openshift.io/v1/dnses/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchDNS(
@Path("name") String name,
@Body DNS body,
@QueryMap PatchDNS queryParameters);
final class PatchDNS extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public PatchDNS pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
*/
public PatchDNS dryRun(String dryRun) {
put("dryRun", dryRun);
return this;
}
/**
* fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.
*/
public PatchDNS fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* replace the specified DNS
*
* @param name name of the DNS
*/
@HTTP(
method = "PUT",
path = "/apis/operator.openshift.io/v1/dnses/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replaceDNS(
@Path("name") String name,
@Body DNS body);
/**
* replace the specified DNS
*
* @param name name of the DNS
*/
@HTTP(
method = "PUT",
path = "/apis/operator.openshift.io/v1/dnses/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replaceDNS(
@Path("name") String name,
@Body DNS body,
@QueryMap ReplaceDNS queryParameters);
final class ReplaceDNS extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReplaceDNS pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
*/
public ReplaceDNS dryRun(String dryRun) {
put("dryRun", dryRun);
return this;
}
/**
* fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.
*/
public ReplaceDNS fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* read status of the specified DNS
*
* @param name name of the DNS
*/
@HTTP(
method = "GET",
path = "/apis/operator.openshift.io/v1/dnses/{name}/status"
)
@Headers({
"Accept: */*"
})
KubernetesCall readDNSStatus(
@Path("name") String name);
/**
* read status of the specified DNS
*
* @param name name of the DNS
*/
@HTTP(
method = "GET",
path = "/apis/operator.openshift.io/v1/dnses/{name}/status"
)
@Headers({
"Accept: */*"
})
KubernetesCall readDNSStatus(
@Path("name") String name,
@QueryMap ReadDNSStatus queryParameters);
final class ReadDNSStatus extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReadDNSStatus pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* When specified: - if unset, then the result is returned from remote storage based on quorum-read flag; - if it's 0, then we simply return what we currently have in cache, no guarantee; - if set to non zero, then the result is at least as fresh as given rv.
*/
public ReadDNSStatus resourceVersion(String resourceVersion) {
put("resourceVersion", resourceVersion);
return this;
}
}
/**
* partially update status of the specified DNS
*
* @param name name of the DNS
*/
@HTTP(
method = "PATCH",
path = "/apis/operator.openshift.io/v1/dnses/{name}/status",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchDNSStatus(
@Path("name") String name,
@Body DNS body);
/**
* partially update status of the specified DNS
*
* @param name name of the DNS
*/
@HTTP(
method = "PATCH",
path = "/apis/operator.openshift.io/v1/dnses/{name}/status",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchDNSStatus(
@Path("name") String name,
@Body DNS body,
@QueryMap PatchDNSStatus queryParameters);
final class PatchDNSStatus extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public PatchDNSStatus pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
*/
public PatchDNSStatus dryRun(String dryRun) {
put("dryRun", dryRun);
return this;
}
/**
* fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.
*/
public PatchDNSStatus fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* replace status of the specified DNS
*
* @param name name of the DNS
*/
@HTTP(
method = "PUT",
path = "/apis/operator.openshift.io/v1/dnses/{name}/status",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replaceDNSStatus(
@Path("name") String name,
@Body DNS body);
/**
* replace status of the specified DNS
*
* @param name name of the DNS
*/
@HTTP(
method = "PUT",
path = "/apis/operator.openshift.io/v1/dnses/{name}/status",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replaceDNSStatus(
@Path("name") String name,
@Body DNS body,
@QueryMap ReplaceDNSStatus queryParameters);
final class ReplaceDNSStatus extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReplaceDNSStatus pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
*/
public ReplaceDNSStatus dryRun(String dryRun) {
put("dryRun", dryRun);
return this;
}
/**
* fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.
*/
public ReplaceDNSStatus fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* delete collection of Etcd
*/
@HTTP(
method = "DELETE",
path = "/apis/operator.openshift.io/v1/etcds"
)
@Headers({
"Accept: */*"
})
KubernetesCall deleteCollectionEtcd();
/**
* delete collection of Etcd
*/
@HTTP(
method = "DELETE",
path = "/apis/operator.openshift.io/v1/etcds"
)
@Headers({
"Accept: */*"
})
KubernetesCall deleteCollectionEtcd(
@QueryMap DeleteCollectionEtcd queryParameters);
final class DeleteCollectionEtcd extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public DeleteCollectionEtcd pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. If the feature gate WatchBookmarks is not enabled in apiserver, this field is ignored.
*/
public DeleteCollectionEtcd allowWatchBookmarks(Boolean allowWatchBookmarks) {
put("allowWatchBookmarks", allowWatchBookmarks);
return this;
}
/**
* The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key".
This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.
*/
public DeleteCollectionEtcd continues(String continues) {
put("continue", continues);
return this;
}
/**
* A selector to restrict the list of returned objects by their fields. Defaults to everything.
*/
public DeleteCollectionEtcd fieldSelector(String fieldSelector) {
put("fieldSelector", fieldSelector);
return this;
}
/**
* A selector to restrict the list of returned objects by their labels. Defaults to everything.
*/
public DeleteCollectionEtcd labelSelector(String labelSelector) {
put("labelSelector", labelSelector);
return this;
}
/**
* limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.
The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.
*/
public DeleteCollectionEtcd limit(Number limit) {
put("limit", limit);
return this;
}
/**
* When specified with a watch call, shows changes that occur after that particular version of a resource. Defaults to changes from the beginning of history. When specified for list: - if unset, then the result is returned from remote storage based on quorum-read flag; - if it's 0, then we simply return what we currently have in cache, no guarantee; - if set to non zero, then the result is at least as fresh as given rv.
*/
public DeleteCollectionEtcd resourceVersion(String resourceVersion) {
put("resourceVersion", resourceVersion);
return this;
}
/**
* Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.
*/
public DeleteCollectionEtcd timeoutSeconds(Number timeoutSeconds) {
put("timeoutSeconds", timeoutSeconds);
return this;
}
/**
* Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.
*/
public DeleteCollectionEtcd watch(Boolean watch) {
put("watch", watch);
return this;
}
}
/**
* list objects of kind Etcd
*/
@HTTP(
method = "GET",
path = "/apis/operator.openshift.io/v1/etcds"
)
@Headers({
"Accept: */*"
})
KubernetesListCall listEtcd();
/**
* list objects of kind Etcd
*/
@HTTP(
method = "GET",
path = "/apis/operator.openshift.io/v1/etcds"
)
@Headers({
"Accept: */*"
})
KubernetesListCall listEtcd(
@QueryMap ListEtcd queryParameters);
final class ListEtcd extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ListEtcd pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. If the feature gate WatchBookmarks is not enabled in apiserver, this field is ignored.
*/
public ListEtcd allowWatchBookmarks(Boolean allowWatchBookmarks) {
put("allowWatchBookmarks", allowWatchBookmarks);
return this;
}
/**
* The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key".
This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.
*/
public ListEtcd continues(String continues) {
put("continue", continues);
return this;
}
/**
* A selector to restrict the list of returned objects by their fields. Defaults to everything.
*/
public ListEtcd fieldSelector(String fieldSelector) {
put("fieldSelector", fieldSelector);
return this;
}
/**
* A selector to restrict the list of returned objects by their labels. Defaults to everything.
*/
public ListEtcd labelSelector(String labelSelector) {
put("labelSelector", labelSelector);
return this;
}
/**
* limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.
The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.
*/
public ListEtcd limit(Number limit) {
put("limit", limit);
return this;
}
/**
* When specified with a watch call, shows changes that occur after that particular version of a resource. Defaults to changes from the beginning of history. When specified for list: - if unset, then the result is returned from remote storage based on quorum-read flag; - if it's 0, then we simply return what we currently have in cache, no guarantee; - if set to non zero, then the result is at least as fresh as given rv.
*/
public ListEtcd resourceVersion(String resourceVersion) {
put("resourceVersion", resourceVersion);
return this;
}
/**
* Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.
*/
public ListEtcd timeoutSeconds(Number timeoutSeconds) {
put("timeoutSeconds", timeoutSeconds);
return this;
}
/**
* Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.
*/
public ListEtcd watch(Boolean watch) {
put("watch", watch);
return this;
}
}
/**
* create an Etcd
*/
@HTTP(
method = "POST",
path = "/apis/operator.openshift.io/v1/etcds",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall createEtcd(
@Body Etcd body);
/**
* create an Etcd
*/
@HTTP(
method = "POST",
path = "/apis/operator.openshift.io/v1/etcds",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall createEtcd(
@Body Etcd body,
@QueryMap CreateEtcd queryParameters);
final class CreateEtcd extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public CreateEtcd pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
*/
public CreateEtcd dryRun(String dryRun) {
put("dryRun", dryRun);
return this;
}
/**
* fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.
*/
public CreateEtcd fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* delete an Etcd
*
* @param name name of the Etcd
*/
@HTTP(
method = "DELETE",
path = "/apis/operator.openshift.io/v1/etcds/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteEtcd(
@Path("name") String name,
@Body DeleteOptions body);
/**
* delete an Etcd
*
* @param name name of the Etcd
*/
@HTTP(
method = "DELETE",
path = "/apis/operator.openshift.io/v1/etcds/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteEtcd(
@Path("name") String name);
/**
* delete an Etcd
*
* @param name name of the Etcd
*/
@HTTP(
method = "DELETE",
path = "/apis/operator.openshift.io/v1/etcds/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteEtcd(
@Path("name") String name,
@Body DeleteOptions body,
@QueryMap DeleteEtcd queryParameters);
/**
* delete an Etcd
*
* @param name name of the Etcd
*/
@HTTP(
method = "DELETE",
path = "/apis/operator.openshift.io/v1/etcds/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteEtcd(
@Path("name") String name,
@QueryMap DeleteEtcd queryParameters);
final class DeleteEtcd extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public DeleteEtcd pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
*/
public DeleteEtcd dryRun(String dryRun) {
put("dryRun", dryRun);
return this;
}
/**
* The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.
*/
public DeleteEtcd gracePeriodSeconds(Number gracePeriodSeconds) {
put("gracePeriodSeconds", gracePeriodSeconds);
return this;
}
/**
* Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.
*/
public DeleteEtcd orphanDependents(Boolean orphanDependents) {
put("orphanDependents", orphanDependents);
return this;
}
/**
* Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.
*/
public DeleteEtcd propagationPolicy(String propagationPolicy) {
put("propagationPolicy", propagationPolicy);
return this;
}
}
/**
* read the specified Etcd
*
* @param name name of the Etcd
*/
@HTTP(
method = "GET",
path = "/apis/operator.openshift.io/v1/etcds/{name}"
)
@Headers({
"Accept: */*"
})
KubernetesCall readEtcd(
@Path("name") String name);
/**
* read the specified Etcd
*
* @param name name of the Etcd
*/
@HTTP(
method = "GET",
path = "/apis/operator.openshift.io/v1/etcds/{name}"
)
@Headers({
"Accept: */*"
})
KubernetesCall readEtcd(
@Path("name") String name,
@QueryMap ReadEtcd queryParameters);
final class ReadEtcd extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReadEtcd pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* When specified: - if unset, then the result is returned from remote storage based on quorum-read flag; - if it's 0, then we simply return what we currently have in cache, no guarantee; - if set to non zero, then the result is at least as fresh as given rv.
*/
public ReadEtcd resourceVersion(String resourceVersion) {
put("resourceVersion", resourceVersion);
return this;
}
}
/**
* partially update the specified Etcd
*
* @param name name of the Etcd
*/
@HTTP(
method = "PATCH",
path = "/apis/operator.openshift.io/v1/etcds/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchEtcd(
@Path("name") String name,
@Body Etcd body);
/**
* partially update the specified Etcd
*
* @param name name of the Etcd
*/
@HTTP(
method = "PATCH",
path = "/apis/operator.openshift.io/v1/etcds/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchEtcd(
@Path("name") String name,
@Body Etcd body,
@QueryMap PatchEtcd queryParameters);
final class PatchEtcd extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public PatchEtcd pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
*/
public PatchEtcd dryRun(String dryRun) {
put("dryRun", dryRun);
return this;
}
/**
* fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.
*/
public PatchEtcd fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* replace the specified Etcd
*
* @param name name of the Etcd
*/
@HTTP(
method = "PUT",
path = "/apis/operator.openshift.io/v1/etcds/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replaceEtcd(
@Path("name") String name,
@Body Etcd body);
/**
* replace the specified Etcd
*
* @param name name of the Etcd
*/
@HTTP(
method = "PUT",
path = "/apis/operator.openshift.io/v1/etcds/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replaceEtcd(
@Path("name") String name,
@Body Etcd body,
@QueryMap ReplaceEtcd queryParameters);
final class ReplaceEtcd extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReplaceEtcd pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
*/
public ReplaceEtcd dryRun(String dryRun) {
put("dryRun", dryRun);
return this;
}
/**
* fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.
*/
public ReplaceEtcd fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* read status of the specified Etcd
*
* @param name name of the Etcd
*/
@HTTP(
method = "GET",
path = "/apis/operator.openshift.io/v1/etcds/{name}/status"
)
@Headers({
"Accept: */*"
})
KubernetesCall readEtcdStatus(
@Path("name") String name);
/**
* read status of the specified Etcd
*
* @param name name of the Etcd
*/
@HTTP(
method = "GET",
path = "/apis/operator.openshift.io/v1/etcds/{name}/status"
)
@Headers({
"Accept: */*"
})
KubernetesCall readEtcdStatus(
@Path("name") String name,
@QueryMap ReadEtcdStatus queryParameters);
final class ReadEtcdStatus extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReadEtcdStatus pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* When specified: - if unset, then the result is returned from remote storage based on quorum-read flag; - if it's 0, then we simply return what we currently have in cache, no guarantee; - if set to non zero, then the result is at least as fresh as given rv.
*/
public ReadEtcdStatus resourceVersion(String resourceVersion) {
put("resourceVersion", resourceVersion);
return this;
}
}
/**
* partially update status of the specified Etcd
*
* @param name name of the Etcd
*/
@HTTP(
method = "PATCH",
path = "/apis/operator.openshift.io/v1/etcds/{name}/status",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchEtcdStatus(
@Path("name") String name,
@Body Etcd body);
/**
* partially update status of the specified Etcd
*
* @param name name of the Etcd
*/
@HTTP(
method = "PATCH",
path = "/apis/operator.openshift.io/v1/etcds/{name}/status",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchEtcdStatus(
@Path("name") String name,
@Body Etcd body,
@QueryMap PatchEtcdStatus queryParameters);
final class PatchEtcdStatus extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public PatchEtcdStatus pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
*/
public PatchEtcdStatus dryRun(String dryRun) {
put("dryRun", dryRun);
return this;
}
/**
* fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.
*/
public PatchEtcdStatus fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* replace status of the specified Etcd
*
* @param name name of the Etcd
*/
@HTTP(
method = "PUT",
path = "/apis/operator.openshift.io/v1/etcds/{name}/status",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replaceEtcdStatus(
@Path("name") String name,
@Body Etcd body);
/**
* replace status of the specified Etcd
*
* @param name name of the Etcd
*/
@HTTP(
method = "PUT",
path = "/apis/operator.openshift.io/v1/etcds/{name}/status",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replaceEtcdStatus(
@Path("name") String name,
@Body Etcd body,
@QueryMap ReplaceEtcdStatus queryParameters);
final class ReplaceEtcdStatus extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReplaceEtcdStatus pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
*/
public ReplaceEtcdStatus dryRun(String dryRun) {
put("dryRun", dryRun);
return this;
}
/**
* fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.
*/
public ReplaceEtcdStatus fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* list objects of kind IngressController
*/
@HTTP(
method = "GET",
path = "/apis/operator.openshift.io/v1/ingresscontrollers"
)
@Headers({
"Accept: */*"
})
KubernetesListCall listIngressControllerForAllNamespaces();
/**
* list objects of kind IngressController
*/
@HTTP(
method = "GET",
path = "/apis/operator.openshift.io/v1/ingresscontrollers"
)
@Headers({
"Accept: */*"
})
KubernetesListCall listIngressControllerForAllNamespaces(
@QueryMap ListIngressControllerForAllNamespaces queryParameters);
final class ListIngressControllerForAllNamespaces extends HashMap {
/**
* allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. If the feature gate WatchBookmarks is not enabled in apiserver, this field is ignored.
*/
public ListIngressControllerForAllNamespaces allowWatchBookmarks(Boolean allowWatchBookmarks) {
put("allowWatchBookmarks", allowWatchBookmarks);
return this;
}
/**
* The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key".
This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.
*/
public ListIngressControllerForAllNamespaces continues(String continues) {
put("continue", continues);
return this;
}
/**
* A selector to restrict the list of returned objects by their fields. Defaults to everything.
*/
public ListIngressControllerForAllNamespaces fieldSelector(String fieldSelector) {
put("fieldSelector", fieldSelector);
return this;
}
/**
* A selector to restrict the list of returned objects by their labels. Defaults to everything.
*/
public ListIngressControllerForAllNamespaces labelSelector(String labelSelector) {
put("labelSelector", labelSelector);
return this;
}
/**
* limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.
The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.
*/
public ListIngressControllerForAllNamespaces limit(Number limit) {
put("limit", limit);
return this;
}
/**
* If 'true', then the output is pretty printed.
*/
public ListIngressControllerForAllNamespaces pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* When specified with a watch call, shows changes that occur after that particular version of a resource. Defaults to changes from the beginning of history. When specified for list: - if unset, then the result is returned from remote storage based on quorum-read flag; - if it's 0, then we simply return what we currently have in cache, no guarantee; - if set to non zero, then the result is at least as fresh as given rv.
*/
public ListIngressControllerForAllNamespaces resourceVersion(String resourceVersion) {
put("resourceVersion", resourceVersion);
return this;
}
/**
* Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.
*/
public ListIngressControllerForAllNamespaces timeoutSeconds(Number timeoutSeconds) {
put("timeoutSeconds", timeoutSeconds);
return this;
}
/**
* Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.
*/
public ListIngressControllerForAllNamespaces watch(Boolean watch) {
put("watch", watch);
return this;
}
}
/**
* delete collection of KubeAPIServer
*/
@HTTP(
method = "DELETE",
path = "/apis/operator.openshift.io/v1/kubeapiservers"
)
@Headers({
"Accept: */*"
})
KubernetesCall deleteCollectionKubeAPIServer();
/**
* delete collection of KubeAPIServer
*/
@HTTP(
method = "DELETE",
path = "/apis/operator.openshift.io/v1/kubeapiservers"
)
@Headers({
"Accept: */*"
})
KubernetesCall deleteCollectionKubeAPIServer(
@QueryMap DeleteCollectionKubeAPIServer queryParameters);
final class DeleteCollectionKubeAPIServer extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public DeleteCollectionKubeAPIServer pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. If the feature gate WatchBookmarks is not enabled in apiserver, this field is ignored.
*/
public DeleteCollectionKubeAPIServer allowWatchBookmarks(Boolean allowWatchBookmarks) {
put("allowWatchBookmarks", allowWatchBookmarks);
return this;
}
/**
* The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key".
This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.
*/
public DeleteCollectionKubeAPIServer continues(String continues) {
put("continue", continues);
return this;
}
/**
* A selector to restrict the list of returned objects by their fields. Defaults to everything.
*/
public DeleteCollectionKubeAPIServer fieldSelector(String fieldSelector) {
put("fieldSelector", fieldSelector);
return this;
}
/**
* A selector to restrict the list of returned objects by their labels. Defaults to everything.
*/
public DeleteCollectionKubeAPIServer labelSelector(String labelSelector) {
put("labelSelector", labelSelector);
return this;
}
/**
* limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.
The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.
*/
public DeleteCollectionKubeAPIServer limit(Number limit) {
put("limit", limit);
return this;
}
/**
* When specified with a watch call, shows changes that occur after that particular version of a resource. Defaults to changes from the beginning of history. When specified for list: - if unset, then the result is returned from remote storage based on quorum-read flag; - if it's 0, then we simply return what we currently have in cache, no guarantee; - if set to non zero, then the result is at least as fresh as given rv.
*/
public DeleteCollectionKubeAPIServer resourceVersion(String resourceVersion) {
put("resourceVersion", resourceVersion);
return this;
}
/**
* Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.
*/
public DeleteCollectionKubeAPIServer timeoutSeconds(Number timeoutSeconds) {
put("timeoutSeconds", timeoutSeconds);
return this;
}
/**
* Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.
*/
public DeleteCollectionKubeAPIServer watch(Boolean watch) {
put("watch", watch);
return this;
}
}
/**
* list objects of kind KubeAPIServer
*/
@HTTP(
method = "GET",
path = "/apis/operator.openshift.io/v1/kubeapiservers"
)
@Headers({
"Accept: */*"
})
KubernetesListCall listKubeAPIServer();
/**
* list objects of kind KubeAPIServer
*/
@HTTP(
method = "GET",
path = "/apis/operator.openshift.io/v1/kubeapiservers"
)
@Headers({
"Accept: */*"
})
KubernetesListCall listKubeAPIServer(
@QueryMap ListKubeAPIServer queryParameters);
final class ListKubeAPIServer extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ListKubeAPIServer pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. If the feature gate WatchBookmarks is not enabled in apiserver, this field is ignored.
*/
public ListKubeAPIServer allowWatchBookmarks(Boolean allowWatchBookmarks) {
put("allowWatchBookmarks", allowWatchBookmarks);
return this;
}
/**
* The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key".
This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.
*/
public ListKubeAPIServer continues(String continues) {
put("continue", continues);
return this;
}
/**
* A selector to restrict the list of returned objects by their fields. Defaults to everything.
*/
public ListKubeAPIServer fieldSelector(String fieldSelector) {
put("fieldSelector", fieldSelector);
return this;
}
/**
* A selector to restrict the list of returned objects by their labels. Defaults to everything.
*/
public ListKubeAPIServer labelSelector(String labelSelector) {
put("labelSelector", labelSelector);
return this;
}
/**
* limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.
The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.
*/
public ListKubeAPIServer limit(Number limit) {
put("limit", limit);
return this;
}
/**
* When specified with a watch call, shows changes that occur after that particular version of a resource. Defaults to changes from the beginning of history. When specified for list: - if unset, then the result is returned from remote storage based on quorum-read flag; - if it's 0, then we simply return what we currently have in cache, no guarantee; - if set to non zero, then the result is at least as fresh as given rv.
*/
public ListKubeAPIServer resourceVersion(String resourceVersion) {
put("resourceVersion", resourceVersion);
return this;
}
/**
* Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.
*/
public ListKubeAPIServer timeoutSeconds(Number timeoutSeconds) {
put("timeoutSeconds", timeoutSeconds);
return this;
}
/**
* Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.
*/
public ListKubeAPIServer watch(Boolean watch) {
put("watch", watch);
return this;
}
}
/**
* create a KubeAPIServer
*/
@HTTP(
method = "POST",
path = "/apis/operator.openshift.io/v1/kubeapiservers",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall createKubeAPIServer(
@Body KubeAPIServer body);
/**
* create a KubeAPIServer
*/
@HTTP(
method = "POST",
path = "/apis/operator.openshift.io/v1/kubeapiservers",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall createKubeAPIServer(
@Body KubeAPIServer body,
@QueryMap CreateKubeAPIServer queryParameters);
final class CreateKubeAPIServer extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public CreateKubeAPIServer pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
*/
public CreateKubeAPIServer dryRun(String dryRun) {
put("dryRun", dryRun);
return this;
}
/**
* fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.
*/
public CreateKubeAPIServer fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* delete a KubeAPIServer
*
* @param name name of the KubeAPIServer
*/
@HTTP(
method = "DELETE",
path = "/apis/operator.openshift.io/v1/kubeapiservers/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteKubeAPIServer(
@Path("name") String name,
@Body DeleteOptions body);
/**
* delete a KubeAPIServer
*
* @param name name of the KubeAPIServer
*/
@HTTP(
method = "DELETE",
path = "/apis/operator.openshift.io/v1/kubeapiservers/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteKubeAPIServer(
@Path("name") String name);
/**
* delete a KubeAPIServer
*
* @param name name of the KubeAPIServer
*/
@HTTP(
method = "DELETE",
path = "/apis/operator.openshift.io/v1/kubeapiservers/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteKubeAPIServer(
@Path("name") String name,
@Body DeleteOptions body,
@QueryMap DeleteKubeAPIServer queryParameters);
/**
* delete a KubeAPIServer
*
* @param name name of the KubeAPIServer
*/
@HTTP(
method = "DELETE",
path = "/apis/operator.openshift.io/v1/kubeapiservers/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteKubeAPIServer(
@Path("name") String name,
@QueryMap DeleteKubeAPIServer queryParameters);
final class DeleteKubeAPIServer extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public DeleteKubeAPIServer pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
*/
public DeleteKubeAPIServer dryRun(String dryRun) {
put("dryRun", dryRun);
return this;
}
/**
* The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.
*/
public DeleteKubeAPIServer gracePeriodSeconds(Number gracePeriodSeconds) {
put("gracePeriodSeconds", gracePeriodSeconds);
return this;
}
/**
* Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.
*/
public DeleteKubeAPIServer orphanDependents(Boolean orphanDependents) {
put("orphanDependents", orphanDependents);
return this;
}
/**
* Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.
*/
public DeleteKubeAPIServer propagationPolicy(String propagationPolicy) {
put("propagationPolicy", propagationPolicy);
return this;
}
}
/**
* read the specified KubeAPIServer
*
* @param name name of the KubeAPIServer
*/
@HTTP(
method = "GET",
path = "/apis/operator.openshift.io/v1/kubeapiservers/{name}"
)
@Headers({
"Accept: */*"
})
KubernetesCall readKubeAPIServer(
@Path("name") String name);
/**
* read the specified KubeAPIServer
*
* @param name name of the KubeAPIServer
*/
@HTTP(
method = "GET",
path = "/apis/operator.openshift.io/v1/kubeapiservers/{name}"
)
@Headers({
"Accept: */*"
})
KubernetesCall readKubeAPIServer(
@Path("name") String name,
@QueryMap ReadKubeAPIServer queryParameters);
final class ReadKubeAPIServer extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReadKubeAPIServer pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* When specified: - if unset, then the result is returned from remote storage based on quorum-read flag; - if it's 0, then we simply return what we currently have in cache, no guarantee; - if set to non zero, then the result is at least as fresh as given rv.
*/
public ReadKubeAPIServer resourceVersion(String resourceVersion) {
put("resourceVersion", resourceVersion);
return this;
}
}
/**
* partially update the specified KubeAPIServer
*
* @param name name of the KubeAPIServer
*/
@HTTP(
method = "PATCH",
path = "/apis/operator.openshift.io/v1/kubeapiservers/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchKubeAPIServer(
@Path("name") String name,
@Body KubeAPIServer body);
/**
* partially update the specified KubeAPIServer
*
* @param name name of the KubeAPIServer
*/
@HTTP(
method = "PATCH",
path = "/apis/operator.openshift.io/v1/kubeapiservers/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchKubeAPIServer(
@Path("name") String name,
@Body KubeAPIServer body,
@QueryMap PatchKubeAPIServer queryParameters);
final class PatchKubeAPIServer extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public PatchKubeAPIServer pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
*/
public PatchKubeAPIServer dryRun(String dryRun) {
put("dryRun", dryRun);
return this;
}
/**
* fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.
*/
public PatchKubeAPIServer fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* replace the specified KubeAPIServer
*
* @param name name of the KubeAPIServer
*/
@HTTP(
method = "PUT",
path = "/apis/operator.openshift.io/v1/kubeapiservers/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replaceKubeAPIServer(
@Path("name") String name,
@Body KubeAPIServer body);
/**
* replace the specified KubeAPIServer
*
* @param name name of the KubeAPIServer
*/
@HTTP(
method = "PUT",
path = "/apis/operator.openshift.io/v1/kubeapiservers/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replaceKubeAPIServer(
@Path("name") String name,
@Body KubeAPIServer body,
@QueryMap ReplaceKubeAPIServer queryParameters);
final class ReplaceKubeAPIServer extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReplaceKubeAPIServer pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
*/
public ReplaceKubeAPIServer dryRun(String dryRun) {
put("dryRun", dryRun);
return this;
}
/**
* fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.
*/
public ReplaceKubeAPIServer fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* read status of the specified KubeAPIServer
*
* @param name name of the KubeAPIServer
*/
@HTTP(
method = "GET",
path = "/apis/operator.openshift.io/v1/kubeapiservers/{name}/status"
)
@Headers({
"Accept: */*"
})
KubernetesCall readKubeAPIServerStatus(
@Path("name") String name);
/**
* read status of the specified KubeAPIServer
*
* @param name name of the KubeAPIServer
*/
@HTTP(
method = "GET",
path = "/apis/operator.openshift.io/v1/kubeapiservers/{name}/status"
)
@Headers({
"Accept: */*"
})
KubernetesCall readKubeAPIServerStatus(
@Path("name") String name,
@QueryMap ReadKubeAPIServerStatus queryParameters);
final class ReadKubeAPIServerStatus extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReadKubeAPIServerStatus pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* When specified: - if unset, then the result is returned from remote storage based on quorum-read flag; - if it's 0, then we simply return what we currently have in cache, no guarantee; - if set to non zero, then the result is at least as fresh as given rv.
*/
public ReadKubeAPIServerStatus resourceVersion(String resourceVersion) {
put("resourceVersion", resourceVersion);
return this;
}
}
/**
* partially update status of the specified KubeAPIServer
*
* @param name name of the KubeAPIServer
*/
@HTTP(
method = "PATCH",
path = "/apis/operator.openshift.io/v1/kubeapiservers/{name}/status",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchKubeAPIServerStatus(
@Path("name") String name,
@Body KubeAPIServer body);
/**
* partially update status of the specified KubeAPIServer
*
* @param name name of the KubeAPIServer
*/
@HTTP(
method = "PATCH",
path = "/apis/operator.openshift.io/v1/kubeapiservers/{name}/status",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchKubeAPIServerStatus(
@Path("name") String name,
@Body KubeAPIServer body,
@QueryMap PatchKubeAPIServerStatus queryParameters);
final class PatchKubeAPIServerStatus extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public PatchKubeAPIServerStatus pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
*/
public PatchKubeAPIServerStatus dryRun(String dryRun) {
put("dryRun", dryRun);
return this;
}
/**
* fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.
*/
public PatchKubeAPIServerStatus fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* replace status of the specified KubeAPIServer
*
* @param name name of the KubeAPIServer
*/
@HTTP(
method = "PUT",
path = "/apis/operator.openshift.io/v1/kubeapiservers/{name}/status",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replaceKubeAPIServerStatus(
@Path("name") String name,
@Body KubeAPIServer body);
/**
* replace status of the specified KubeAPIServer
*
* @param name name of the KubeAPIServer
*/
@HTTP(
method = "PUT",
path = "/apis/operator.openshift.io/v1/kubeapiservers/{name}/status",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replaceKubeAPIServerStatus(
@Path("name") String name,
@Body KubeAPIServer body,
@QueryMap ReplaceKubeAPIServerStatus queryParameters);
final class ReplaceKubeAPIServerStatus extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReplaceKubeAPIServerStatus pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
*/
public ReplaceKubeAPIServerStatus dryRun(String dryRun) {
put("dryRun", dryRun);
return this;
}
/**
* fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.
*/
public ReplaceKubeAPIServerStatus fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* delete collection of KubeControllerManager
*/
@HTTP(
method = "DELETE",
path = "/apis/operator.openshift.io/v1/kubecontrollermanagers"
)
@Headers({
"Accept: */*"
})
KubernetesCall deleteCollectionKubeControllerManager();
/**
* delete collection of KubeControllerManager
*/
@HTTP(
method = "DELETE",
path = "/apis/operator.openshift.io/v1/kubecontrollermanagers"
)
@Headers({
"Accept: */*"
})
KubernetesCall deleteCollectionKubeControllerManager(
@QueryMap DeleteCollectionKubeControllerManager queryParameters);
final class DeleteCollectionKubeControllerManager extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public DeleteCollectionKubeControllerManager pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. If the feature gate WatchBookmarks is not enabled in apiserver, this field is ignored.
*/
public DeleteCollectionKubeControllerManager allowWatchBookmarks(Boolean allowWatchBookmarks) {
put("allowWatchBookmarks", allowWatchBookmarks);
return this;
}
/**
* The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key".
This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.
*/
public DeleteCollectionKubeControllerManager continues(String continues) {
put("continue", continues);
return this;
}
/**
* A selector to restrict the list of returned objects by their fields. Defaults to everything.
*/
public DeleteCollectionKubeControllerManager fieldSelector(String fieldSelector) {
put("fieldSelector", fieldSelector);
return this;
}
/**
* A selector to restrict the list of returned objects by their labels. Defaults to everything.
*/
public DeleteCollectionKubeControllerManager labelSelector(String labelSelector) {
put("labelSelector", labelSelector);
return this;
}
/**
* limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.
The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.
*/
public DeleteCollectionKubeControllerManager limit(Number limit) {
put("limit", limit);
return this;
}
/**
* When specified with a watch call, shows changes that occur after that particular version of a resource. Defaults to changes from the beginning of history. When specified for list: - if unset, then the result is returned from remote storage based on quorum-read flag; - if it's 0, then we simply return what we currently have in cache, no guarantee; - if set to non zero, then the result is at least as fresh as given rv.
*/
public DeleteCollectionKubeControllerManager resourceVersion(String resourceVersion) {
put("resourceVersion", resourceVersion);
return this;
}
/**
* Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.
*/
public DeleteCollectionKubeControllerManager timeoutSeconds(Number timeoutSeconds) {
put("timeoutSeconds", timeoutSeconds);
return this;
}
/**
* Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.
*/
public DeleteCollectionKubeControllerManager watch(Boolean watch) {
put("watch", watch);
return this;
}
}
/**
* list objects of kind KubeControllerManager
*/
@HTTP(
method = "GET",
path = "/apis/operator.openshift.io/v1/kubecontrollermanagers"
)
@Headers({
"Accept: */*"
})
KubernetesListCall listKubeControllerManager();
/**
* list objects of kind KubeControllerManager
*/
@HTTP(
method = "GET",
path = "/apis/operator.openshift.io/v1/kubecontrollermanagers"
)
@Headers({
"Accept: */*"
})
KubernetesListCall listKubeControllerManager(
@QueryMap ListKubeControllerManager queryParameters);
final class ListKubeControllerManager extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ListKubeControllerManager pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. If the feature gate WatchBookmarks is not enabled in apiserver, this field is ignored.
*/
public ListKubeControllerManager allowWatchBookmarks(Boolean allowWatchBookmarks) {
put("allowWatchBookmarks", allowWatchBookmarks);
return this;
}
/**
* The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key".
This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.
*/
public ListKubeControllerManager continues(String continues) {
put("continue", continues);
return this;
}
/**
* A selector to restrict the list of returned objects by their fields. Defaults to everything.
*/
public ListKubeControllerManager fieldSelector(String fieldSelector) {
put("fieldSelector", fieldSelector);
return this;
}
/**
* A selector to restrict the list of returned objects by their labels. Defaults to everything.
*/
public ListKubeControllerManager labelSelector(String labelSelector) {
put("labelSelector", labelSelector);
return this;
}
/**
* limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.
The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.
*/
public ListKubeControllerManager limit(Number limit) {
put("limit", limit);
return this;
}
/**
* When specified with a watch call, shows changes that occur after that particular version of a resource. Defaults to changes from the beginning of history. When specified for list: - if unset, then the result is returned from remote storage based on quorum-read flag; - if it's 0, then we simply return what we currently have in cache, no guarantee; - if set to non zero, then the result is at least as fresh as given rv.
*/
public ListKubeControllerManager resourceVersion(String resourceVersion) {
put("resourceVersion", resourceVersion);
return this;
}
/**
* Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.
*/
public ListKubeControllerManager timeoutSeconds(Number timeoutSeconds) {
put("timeoutSeconds", timeoutSeconds);
return this;
}
/**
* Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.
*/
public ListKubeControllerManager watch(Boolean watch) {
put("watch", watch);
return this;
}
}
/**
* create a KubeControllerManager
*/
@HTTP(
method = "POST",
path = "/apis/operator.openshift.io/v1/kubecontrollermanagers",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall createKubeControllerManager(
@Body KubeControllerManager body);
/**
* create a KubeControllerManager
*/
@HTTP(
method = "POST",
path = "/apis/operator.openshift.io/v1/kubecontrollermanagers",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall createKubeControllerManager(
@Body KubeControllerManager body,
@QueryMap CreateKubeControllerManager queryParameters);
final class CreateKubeControllerManager extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public CreateKubeControllerManager pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
*/
public CreateKubeControllerManager dryRun(String dryRun) {
put("dryRun", dryRun);
return this;
}
/**
* fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.
*/
public CreateKubeControllerManager fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* delete a KubeControllerManager
*
* @param name name of the KubeControllerManager
*/
@HTTP(
method = "DELETE",
path = "/apis/operator.openshift.io/v1/kubecontrollermanagers/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteKubeControllerManager(
@Path("name") String name,
@Body DeleteOptions body);
/**
* delete a KubeControllerManager
*
* @param name name of the KubeControllerManager
*/
@HTTP(
method = "DELETE",
path = "/apis/operator.openshift.io/v1/kubecontrollermanagers/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteKubeControllerManager(
@Path("name") String name);
/**
* delete a KubeControllerManager
*
* @param name name of the KubeControllerManager
*/
@HTTP(
method = "DELETE",
path = "/apis/operator.openshift.io/v1/kubecontrollermanagers/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteKubeControllerManager(
@Path("name") String name,
@Body DeleteOptions body,
@QueryMap DeleteKubeControllerManager queryParameters);
/**
* delete a KubeControllerManager
*
* @param name name of the KubeControllerManager
*/
@HTTP(
method = "DELETE",
path = "/apis/operator.openshift.io/v1/kubecontrollermanagers/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteKubeControllerManager(
@Path("name") String name,
@QueryMap DeleteKubeControllerManager queryParameters);
final class DeleteKubeControllerManager extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public DeleteKubeControllerManager pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
*/
public DeleteKubeControllerManager dryRun(String dryRun) {
put("dryRun", dryRun);
return this;
}
/**
* The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.
*/
public DeleteKubeControllerManager gracePeriodSeconds(Number gracePeriodSeconds) {
put("gracePeriodSeconds", gracePeriodSeconds);
return this;
}
/**
* Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the "orphan" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.
*/
public DeleteKubeControllerManager orphanDependents(Boolean orphanDependents) {
put("orphanDependents", orphanDependents);
return this;
}
/**
* Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.
*/
public DeleteKubeControllerManager propagationPolicy(String propagationPolicy) {
put("propagationPolicy", propagationPolicy);
return this;
}
}
/**
* read the specified KubeControllerManager
*
* @param name name of the KubeControllerManager
*/
@HTTP(
method = "GET",
path = "/apis/operator.openshift.io/v1/kubecontrollermanagers/{name}"
)
@Headers({
"Accept: */*"
})
KubernetesCall readKubeControllerManager(
@Path("name") String name);
/**
* read the specified KubeControllerManager
*
* @param name name of the KubeControllerManager
*/
@HTTP(
method = "GET",
path = "/apis/operator.openshift.io/v1/kubecontrollermanagers/{name}"
)
@Headers({
"Accept: */*"
})
KubernetesCall readKubeControllerManager(
@Path("name") String name,
@QueryMap ReadKubeControllerManager queryParameters);
final class ReadKubeControllerManager extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReadKubeControllerManager pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* When specified: - if unset, then the result is returned from remote storage based on quorum-read flag; - if it's 0, then we simply return what we currently have in cache, no guarantee; - if set to non zero, then the result is at least as fresh as given rv.
*/
public ReadKubeControllerManager resourceVersion(String resourceVersion) {
put("resourceVersion", resourceVersion);
return this;
}
}
/**
* partially update the specified KubeControllerManager
*
* @param name name of the KubeControllerManager
*/
@HTTP(
method = "PATCH",
path = "/apis/operator.openshift.io/v1/kubecontrollermanagers/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchKubeControllerManager(
@Path("name") String name,
@Body KubeControllerManager body);
/**
* partially update the specified KubeControllerManager
*
* @param name name of the KubeControllerManager
*/
@HTTP(
method = "PATCH",
path = "/apis/operator.openshift.io/v1/kubecontrollermanagers/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchKubeControllerManager(
@Path("name") String name,
@Body KubeControllerManager body,
@QueryMap PatchKubeControllerManager queryParameters);
final class PatchKubeControllerManager extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public PatchKubeControllerManager pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
*/
public PatchKubeControllerManager dryRun(String dryRun) {
put("dryRun", dryRun);
return this;
}
/**
* fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.
*/
public PatchKubeControllerManager fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* replace the specified KubeControllerManager
*
* @param name name of the KubeControllerManager
*/
@HTTP(
method = "PUT",
path = "/apis/operator.openshift.io/v1/kubecontrollermanagers/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replaceKubeControllerManager(
@Path("name") String name,
@Body KubeControllerManager body);
/**
* replace the specified KubeControllerManager
*
* @param name name of the KubeControllerManager
*/
@HTTP(
method = "PUT",
path = "/apis/operator.openshift.io/v1/kubecontrollermanagers/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replaceKubeControllerManager(
@Path("name") String name,
@Body KubeControllerManager body,
@QueryMap ReplaceKubeControllerManager queryParameters);
final class ReplaceKubeControllerManager extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReplaceKubeControllerManager pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
*/
public ReplaceKubeControllerManager dryRun(String dryRun) {
put("dryRun", dryRun);
return this;
}
/**
* fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.
*/
public ReplaceKubeControllerManager fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* read status of the specified KubeControllerManager
*
* @param name name of the KubeControllerManager
*/
@HTTP(
method = "GET",
path = "/apis/operator.openshift.io/v1/kubecontrollermanagers/{name}/status"
)
@Headers({
"Accept: */*"
})
KubernetesCall readKubeControllerManagerStatus(
@Path("name") String name);
/**
* read status of the specified KubeControllerManager
*
* @param name name of the KubeControllerManager
*/
@HTTP(
method = "GET",
path = "/apis/operator.openshift.io/v1/kubecontrollermanagers/{name}/status"
)
@Headers({
"Accept: */*"
})
KubernetesCall readKubeControllerManagerStatus(
@Path("name") String name,
@QueryMap ReadKubeControllerManagerStatus queryParameters);
final class ReadKubeControllerManagerStatus extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReadKubeControllerManagerStatus pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* When specified: - if unset, then the result is returned from remote storage based on quorum-read flag; - if it's 0, then we simply return what we currently have in cache, no guarantee; - if set to non zero, then the result is at least as fresh as given rv.
*/
public ReadKubeControllerManagerStatus resourceVersion(String resourceVersion) {
put("resourceVersion", resourceVersion);
return this;
}
}
/**
* partially update status of the specified KubeControllerManager
*
* @param name name of the KubeControllerManager
*/
@HTTP(
method = "PATCH",
path = "/apis/operator.openshift.io/v1/kubecontrollermanagers/{name}/status",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchKubeControllerManagerStatus(
@Path("name") String name,
@Body KubeControllerManager body);
/**
* partially update status of the specified KubeControllerManager
*
* @param name name of the KubeControllerManager
*/
@HTTP(
method = "PATCH",
path = "/apis/operator.openshift.io/v1/kubecontrollermanagers/{name}/status",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchKubeControllerManagerStatus(
@Path("name") String name,
@Body KubeControllerManager body,
@QueryMap PatchKubeControllerManagerStatus queryParameters);
final class PatchKubeControllerManagerStatus extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public PatchKubeControllerManagerStatus pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
*/
public PatchKubeControllerManagerStatus dryRun(String dryRun) {
put("dryRun", dryRun);
return this;
}
/**
* fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.
*/
public PatchKubeControllerManagerStatus fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* replace status of the specified KubeControllerManager
*
* @param name name of the KubeControllerManager
*/
@HTTP(
method = "PUT",
path = "/apis/operator.openshift.io/v1/kubecontrollermanagers/{name}/status",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replaceKubeControllerManagerStatus(
@Path("name") String name,
@Body KubeControllerManager body);
/**
* replace status of the specified KubeControllerManager
*
* @param name name of the KubeControllerManager
*/
@HTTP(
method = "PUT",
path = "/apis/operator.openshift.io/v1/kubecontrollermanagers/{name}/status",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replaceKubeControllerManagerStatus(
@Path("name") String name,
@Body KubeControllerManager body,
@QueryMap ReplaceKubeControllerManagerStatus queryParameters);
final class ReplaceKubeControllerManagerStatus extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReplaceKubeControllerManagerStatus pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
*/
public ReplaceKubeControllerManagerStatus dryRun(String dryRun) {
put("dryRun", dryRun);
return this;
}
/**
* fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.
*/
public ReplaceKubeControllerManagerStatus fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* delete collection of KubeScheduler
*/
@HTTP(
method = "DELETE",
path = "/apis/operator.openshift.io/v1/kubeschedulers"
)
@Headers({
"Accept: */*"
})
KubernetesCall deleteCollectionKubeScheduler();
/**
* delete collection of KubeScheduler
*/
@HTTP(
method = "DELETE",
path = "/apis/operator.openshift.io/v1/kubeschedulers"
)
@Headers({
"Accept: */*"
})
KubernetesCall deleteCollectionKubeScheduler(
@QueryMap DeleteCollectionKubeScheduler queryParameters);
final class DeleteCollectionKubeScheduler extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public DeleteCollectionKubeScheduler pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. If the feature gate WatchBookmarks is not enabled in apiserver, this field is ignored.
*/
public DeleteCollectionKubeScheduler allowWatchBookmarks(Boolean allowWatchBookmarks) {
put("allowWatchBookmarks", allowWatchBookmarks);
return this;
}
/**
* The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key".
This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.
*/
public DeleteCollectionKubeScheduler continues(String continues) {
put("continue", continues);
return this;
}
/**
* A selector to restrict the list of returned objects by their fields. Defaults to everything.
*/
public DeleteCollectionKubeScheduler fieldSelector(String fieldSelector) {
put("fieldSelector", fieldSelector);
return this;
}
/**
* A selector to restrict the list of returned objects by their labels. Defaults to everything.
*/
public DeleteCollectionKubeScheduler labelSelector(String labelSelector) {
put("labelSelector", labelSelector);
return this;
}
/**
* limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.
The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.
*/
public DeleteCollectionKubeScheduler limit(Number limit) {
put("limit", limit);
return this;
}
/**
* When specified with a watch call, shows changes that occur after that particular version of a resource. Defaults to changes from the beginning of history. When specified for list: - if unset, then the result is returned from remote storage based on quorum-read flag; - if it's 0, then we simply return what we currently have in cache, no guarantee; - if set to non zero, then the result is at least as fresh as given rv.
*/
public DeleteCollectionKubeScheduler resourceVersion(String resourceVersion) {
put("resourceVersion", resourceVersion);
return this;
}
/**
* Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.
*/
public DeleteCollectionKubeScheduler timeoutSeconds(Number timeoutSeconds) {
put("timeoutSeconds", timeoutSeconds);
return this;
}
/**
* Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.
*/
public DeleteCollectionKubeScheduler watch(Boolean watch) {
put("watch", watch);
return this;
}
}
/**
* list objects of kind KubeScheduler
*/
@HTTP(
method = "GET",
path = "/apis/operator.openshift.io/v1/kubeschedulers"
)
@Headers({
"Accept: */*"
})
KubernetesListCall listKubeScheduler();
/**
* list objects of kind KubeScheduler
*/
@HTTP(
method = "GET",
path = "/apis/operator.openshift.io/v1/kubeschedulers"
)
@Headers({
"Accept: */*"
})
KubernetesListCall listKubeScheduler(
@QueryMap ListKubeScheduler queryParameters);
final class ListKubeScheduler extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ListKubeScheduler pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. If the feature gate WatchBookmarks is not enabled in apiserver, this field is ignored.
*/
public ListKubeScheduler allowWatchBookmarks(Boolean allowWatchBookmarks) {
put("allowWatchBookmarks", allowWatchBookmarks);
return this;
}
/**
* The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the "next key".