com.marcnuri.yakc.api.configopenshiftio.v1.ConfigOpenshiftIoV1Api 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.configopenshiftio.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.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.config.v1.APIServer;
import com.marcnuri.yakc.model.io.openshift.config.v1.APIServerList;
import com.marcnuri.yakc.model.io.openshift.config.v1.Authentication;
import com.marcnuri.yakc.model.io.openshift.config.v1.AuthenticationList;
import com.marcnuri.yakc.model.io.openshift.config.v1.Build;
import com.marcnuri.yakc.model.io.openshift.config.v1.BuildList;
import com.marcnuri.yakc.model.io.openshift.config.v1.ClusterOperator;
import com.marcnuri.yakc.model.io.openshift.config.v1.ClusterOperatorList;
import com.marcnuri.yakc.model.io.openshift.config.v1.ClusterVersion;
import com.marcnuri.yakc.model.io.openshift.config.v1.ClusterVersionList;
import com.marcnuri.yakc.model.io.openshift.config.v1.Console;
import com.marcnuri.yakc.model.io.openshift.config.v1.ConsoleList;
import com.marcnuri.yakc.model.io.openshift.config.v1.DNS;
import com.marcnuri.yakc.model.io.openshift.config.v1.DNSList;
import com.marcnuri.yakc.model.io.openshift.config.v1.FeatureGate;
import com.marcnuri.yakc.model.io.openshift.config.v1.FeatureGateList;
import com.marcnuri.yakc.model.io.openshift.config.v1.Image;
import com.marcnuri.yakc.model.io.openshift.config.v1.ImageList;
import com.marcnuri.yakc.model.io.openshift.config.v1.Infrastructure;
import com.marcnuri.yakc.model.io.openshift.config.v1.InfrastructureList;
import com.marcnuri.yakc.model.io.openshift.config.v1.Ingress;
import com.marcnuri.yakc.model.io.openshift.config.v1.IngressList;
import com.marcnuri.yakc.model.io.openshift.config.v1.Network;
import com.marcnuri.yakc.model.io.openshift.config.v1.NetworkList;
import com.marcnuri.yakc.model.io.openshift.config.v1.OAuth;
import com.marcnuri.yakc.model.io.openshift.config.v1.OAuthList;
import com.marcnuri.yakc.model.io.openshift.config.v1.OperatorHub;
import com.marcnuri.yakc.model.io.openshift.config.v1.OperatorHubList;
import com.marcnuri.yakc.model.io.openshift.config.v1.Project;
import com.marcnuri.yakc.model.io.openshift.config.v1.ProjectList;
import com.marcnuri.yakc.model.io.openshift.config.v1.Proxy;
import com.marcnuri.yakc.model.io.openshift.config.v1.ProxyList;
import com.marcnuri.yakc.model.io.openshift.config.v1.Scheduler;
import com.marcnuri.yakc.model.io.openshift.config.v1.SchedulerList;
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 ConfigOpenshiftIoV1Api extends Api {
/**
* delete collection of APIServer
*/
@HTTP(
method = "DELETE",
path = "/apis/config.openshift.io/v1/apiservers"
)
@Headers({
"Accept: */*"
})
KubernetesCall deleteCollectionAPIServer();
/**
* delete collection of APIServer
*/
@HTTP(
method = "DELETE",
path = "/apis/config.openshift.io/v1/apiservers"
)
@Headers({
"Accept: */*"
})
KubernetesCall deleteCollectionAPIServer(
@QueryMap DeleteCollectionAPIServer queryParameters);
final class DeleteCollectionAPIServer extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public DeleteCollectionAPIServer 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 DeleteCollectionAPIServer 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 DeleteCollectionAPIServer continues(String continues) {
put("continue", continues);
return this;
}
/**
* A selector to restrict the list of returned objects by their fields. Defaults to everything.
*/
public DeleteCollectionAPIServer fieldSelector(String fieldSelector) {
put("fieldSelector", fieldSelector);
return this;
}
/**
* A selector to restrict the list of returned objects by their labels. Defaults to everything.
*/
public DeleteCollectionAPIServer 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 DeleteCollectionAPIServer 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 DeleteCollectionAPIServer 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 DeleteCollectionAPIServer 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 DeleteCollectionAPIServer watch(Boolean watch) {
put("watch", watch);
return this;
}
}
/**
* list objects of kind APIServer
*/
@HTTP(
method = "GET",
path = "/apis/config.openshift.io/v1/apiservers"
)
@Headers({
"Accept: */*"
})
KubernetesListCall listAPIServer();
/**
* list objects of kind APIServer
*/
@HTTP(
method = "GET",
path = "/apis/config.openshift.io/v1/apiservers"
)
@Headers({
"Accept: */*"
})
KubernetesListCall listAPIServer(
@QueryMap ListAPIServer queryParameters);
final class ListAPIServer extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ListAPIServer 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 ListAPIServer 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 ListAPIServer continues(String continues) {
put("continue", continues);
return this;
}
/**
* A selector to restrict the list of returned objects by their fields. Defaults to everything.
*/
public ListAPIServer fieldSelector(String fieldSelector) {
put("fieldSelector", fieldSelector);
return this;
}
/**
* A selector to restrict the list of returned objects by their labels. Defaults to everything.
*/
public ListAPIServer 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 ListAPIServer 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 ListAPIServer 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 ListAPIServer 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 ListAPIServer watch(Boolean watch) {
put("watch", watch);
return this;
}
}
/**
* create an APIServer
*/
@HTTP(
method = "POST",
path = "/apis/config.openshift.io/v1/apiservers",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall createAPIServer(
@Body APIServer body);
/**
* create an APIServer
*/
@HTTP(
method = "POST",
path = "/apis/config.openshift.io/v1/apiservers",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall createAPIServer(
@Body APIServer body,
@QueryMap CreateAPIServer queryParameters);
final class CreateAPIServer extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public CreateAPIServer 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 CreateAPIServer 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 CreateAPIServer fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* delete an APIServer
*
* @param name name of the APIServer
*/
@HTTP(
method = "DELETE",
path = "/apis/config.openshift.io/v1/apiservers/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteAPIServer(
@Path("name") String name,
@Body DeleteOptions body);
/**
* delete an APIServer
*
* @param name name of the APIServer
*/
@HTTP(
method = "DELETE",
path = "/apis/config.openshift.io/v1/apiservers/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteAPIServer(
@Path("name") String name);
/**
* delete an APIServer
*
* @param name name of the APIServer
*/
@HTTP(
method = "DELETE",
path = "/apis/config.openshift.io/v1/apiservers/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteAPIServer(
@Path("name") String name,
@Body DeleteOptions body,
@QueryMap DeleteAPIServer queryParameters);
/**
* delete an APIServer
*
* @param name name of the APIServer
*/
@HTTP(
method = "DELETE",
path = "/apis/config.openshift.io/v1/apiservers/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteAPIServer(
@Path("name") String name,
@QueryMap DeleteAPIServer queryParameters);
final class DeleteAPIServer extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public DeleteAPIServer 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 DeleteAPIServer 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 DeleteAPIServer 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 DeleteAPIServer 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 DeleteAPIServer propagationPolicy(String propagationPolicy) {
put("propagationPolicy", propagationPolicy);
return this;
}
}
/**
* read the specified APIServer
*
* @param name name of the APIServer
*/
@HTTP(
method = "GET",
path = "/apis/config.openshift.io/v1/apiservers/{name}"
)
@Headers({
"Accept: */*"
})
KubernetesCall readAPIServer(
@Path("name") String name);
/**
* read the specified APIServer
*
* @param name name of the APIServer
*/
@HTTP(
method = "GET",
path = "/apis/config.openshift.io/v1/apiservers/{name}"
)
@Headers({
"Accept: */*"
})
KubernetesCall readAPIServer(
@Path("name") String name,
@QueryMap ReadAPIServer queryParameters);
final class ReadAPIServer extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReadAPIServer 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 ReadAPIServer resourceVersion(String resourceVersion) {
put("resourceVersion", resourceVersion);
return this;
}
}
/**
* partially update the specified APIServer
*
* @param name name of the APIServer
*/
@HTTP(
method = "PATCH",
path = "/apis/config.openshift.io/v1/apiservers/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchAPIServer(
@Path("name") String name,
@Body APIServer body);
/**
* partially update the specified APIServer
*
* @param name name of the APIServer
*/
@HTTP(
method = "PATCH",
path = "/apis/config.openshift.io/v1/apiservers/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchAPIServer(
@Path("name") String name,
@Body APIServer body,
@QueryMap PatchAPIServer queryParameters);
final class PatchAPIServer extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public PatchAPIServer 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 PatchAPIServer 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 PatchAPIServer fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* replace the specified APIServer
*
* @param name name of the APIServer
*/
@HTTP(
method = "PUT",
path = "/apis/config.openshift.io/v1/apiservers/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replaceAPIServer(
@Path("name") String name,
@Body APIServer body);
/**
* replace the specified APIServer
*
* @param name name of the APIServer
*/
@HTTP(
method = "PUT",
path = "/apis/config.openshift.io/v1/apiservers/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replaceAPIServer(
@Path("name") String name,
@Body APIServer body,
@QueryMap ReplaceAPIServer queryParameters);
final class ReplaceAPIServer extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReplaceAPIServer 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 ReplaceAPIServer 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 ReplaceAPIServer fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* read status of the specified APIServer
*
* @param name name of the APIServer
*/
@HTTP(
method = "GET",
path = "/apis/config.openshift.io/v1/apiservers/{name}/status"
)
@Headers({
"Accept: */*"
})
KubernetesCall readAPIServerStatus(
@Path("name") String name);
/**
* read status of the specified APIServer
*
* @param name name of the APIServer
*/
@HTTP(
method = "GET",
path = "/apis/config.openshift.io/v1/apiservers/{name}/status"
)
@Headers({
"Accept: */*"
})
KubernetesCall readAPIServerStatus(
@Path("name") String name,
@QueryMap ReadAPIServerStatus queryParameters);
final class ReadAPIServerStatus extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReadAPIServerStatus 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 ReadAPIServerStatus resourceVersion(String resourceVersion) {
put("resourceVersion", resourceVersion);
return this;
}
}
/**
* partially update status of the specified APIServer
*
* @param name name of the APIServer
*/
@HTTP(
method = "PATCH",
path = "/apis/config.openshift.io/v1/apiservers/{name}/status",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchAPIServerStatus(
@Path("name") String name,
@Body APIServer body);
/**
* partially update status of the specified APIServer
*
* @param name name of the APIServer
*/
@HTTP(
method = "PATCH",
path = "/apis/config.openshift.io/v1/apiservers/{name}/status",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchAPIServerStatus(
@Path("name") String name,
@Body APIServer body,
@QueryMap PatchAPIServerStatus queryParameters);
final class PatchAPIServerStatus extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public PatchAPIServerStatus 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 PatchAPIServerStatus 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 PatchAPIServerStatus fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* replace status of the specified APIServer
*
* @param name name of the APIServer
*/
@HTTP(
method = "PUT",
path = "/apis/config.openshift.io/v1/apiservers/{name}/status",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replaceAPIServerStatus(
@Path("name") String name,
@Body APIServer body);
/**
* replace status of the specified APIServer
*
* @param name name of the APIServer
*/
@HTTP(
method = "PUT",
path = "/apis/config.openshift.io/v1/apiservers/{name}/status",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replaceAPIServerStatus(
@Path("name") String name,
@Body APIServer body,
@QueryMap ReplaceAPIServerStatus queryParameters);
final class ReplaceAPIServerStatus extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReplaceAPIServerStatus 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 ReplaceAPIServerStatus 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 ReplaceAPIServerStatus fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* delete collection of Authentication
*/
@HTTP(
method = "DELETE",
path = "/apis/config.openshift.io/v1/authentications"
)
@Headers({
"Accept: */*"
})
KubernetesCall deleteCollectionAuthentication();
/**
* delete collection of Authentication
*/
@HTTP(
method = "DELETE",
path = "/apis/config.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/config.openshift.io/v1/authentications"
)
@Headers({
"Accept: */*"
})
KubernetesListCall listAuthentication();
/**
* list objects of kind Authentication
*/
@HTTP(
method = "GET",
path = "/apis/config.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/config.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/config.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/config.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/config.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/config.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/config.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/config.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/config.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/config.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/config.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/config.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/config.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/config.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/config.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/config.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/config.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/config.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/config.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 Build
*/
@HTTP(
method = "DELETE",
path = "/apis/config.openshift.io/v1/builds"
)
@Headers({
"Accept: */*"
})
KubernetesCall deleteCollectionBuild();
/**
* delete collection of Build
*/
@HTTP(
method = "DELETE",
path = "/apis/config.openshift.io/v1/builds"
)
@Headers({
"Accept: */*"
})
KubernetesCall deleteCollectionBuild(
@QueryMap DeleteCollectionBuild queryParameters);
final class DeleteCollectionBuild extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public DeleteCollectionBuild 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 DeleteCollectionBuild 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 DeleteCollectionBuild continues(String continues) {
put("continue", continues);
return this;
}
/**
* A selector to restrict the list of returned objects by their fields. Defaults to everything.
*/
public DeleteCollectionBuild fieldSelector(String fieldSelector) {
put("fieldSelector", fieldSelector);
return this;
}
/**
* A selector to restrict the list of returned objects by their labels. Defaults to everything.
*/
public DeleteCollectionBuild 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 DeleteCollectionBuild 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 DeleteCollectionBuild 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 DeleteCollectionBuild 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 DeleteCollectionBuild watch(Boolean watch) {
put("watch", watch);
return this;
}
}
/**
* list objects of kind Build
*/
@HTTP(
method = "GET",
path = "/apis/config.openshift.io/v1/builds"
)
@Headers({
"Accept: */*"
})
KubernetesListCall listBuild();
/**
* list objects of kind Build
*/
@HTTP(
method = "GET",
path = "/apis/config.openshift.io/v1/builds"
)
@Headers({
"Accept: */*"
})
KubernetesListCall listBuild(
@QueryMap ListBuild queryParameters);
final class ListBuild extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ListBuild 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 ListBuild 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 ListBuild continues(String continues) {
put("continue", continues);
return this;
}
/**
* A selector to restrict the list of returned objects by their fields. Defaults to everything.
*/
public ListBuild fieldSelector(String fieldSelector) {
put("fieldSelector", fieldSelector);
return this;
}
/**
* A selector to restrict the list of returned objects by their labels. Defaults to everything.
*/
public ListBuild 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 ListBuild 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 ListBuild 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 ListBuild 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 ListBuild watch(Boolean watch) {
put("watch", watch);
return this;
}
}
/**
* create a Build
*/
@HTTP(
method = "POST",
path = "/apis/config.openshift.io/v1/builds",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall createBuild(
@Body Build body);
/**
* create a Build
*/
@HTTP(
method = "POST",
path = "/apis/config.openshift.io/v1/builds",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall createBuild(
@Body Build body,
@QueryMap CreateBuild queryParameters);
final class CreateBuild extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public CreateBuild 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 CreateBuild 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 CreateBuild fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* delete a Build
*
* @param name name of the Build
*/
@HTTP(
method = "DELETE",
path = "/apis/config.openshift.io/v1/builds/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteBuild(
@Path("name") String name,
@Body DeleteOptions body);
/**
* delete a Build
*
* @param name name of the Build
*/
@HTTP(
method = "DELETE",
path = "/apis/config.openshift.io/v1/builds/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteBuild(
@Path("name") String name);
/**
* delete a Build
*
* @param name name of the Build
*/
@HTTP(
method = "DELETE",
path = "/apis/config.openshift.io/v1/builds/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteBuild(
@Path("name") String name,
@Body DeleteOptions body,
@QueryMap DeleteBuild queryParameters);
/**
* delete a Build
*
* @param name name of the Build
*/
@HTTP(
method = "DELETE",
path = "/apis/config.openshift.io/v1/builds/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteBuild(
@Path("name") String name,
@QueryMap DeleteBuild queryParameters);
final class DeleteBuild extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public DeleteBuild 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 DeleteBuild 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 DeleteBuild 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 DeleteBuild 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 DeleteBuild propagationPolicy(String propagationPolicy) {
put("propagationPolicy", propagationPolicy);
return this;
}
}
/**
* read the specified Build
*
* @param name name of the Build
*/
@HTTP(
method = "GET",
path = "/apis/config.openshift.io/v1/builds/{name}"
)
@Headers({
"Accept: */*"
})
KubernetesCall readBuild(
@Path("name") String name);
/**
* read the specified Build
*
* @param name name of the Build
*/
@HTTP(
method = "GET",
path = "/apis/config.openshift.io/v1/builds/{name}"
)
@Headers({
"Accept: */*"
})
KubernetesCall readBuild(
@Path("name") String name,
@QueryMap ReadBuild queryParameters);
final class ReadBuild extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReadBuild 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 ReadBuild resourceVersion(String resourceVersion) {
put("resourceVersion", resourceVersion);
return this;
}
}
/**
* partially update the specified Build
*
* @param name name of the Build
*/
@HTTP(
method = "PATCH",
path = "/apis/config.openshift.io/v1/builds/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchBuild(
@Path("name") String name,
@Body Build body);
/**
* partially update the specified Build
*
* @param name name of the Build
*/
@HTTP(
method = "PATCH",
path = "/apis/config.openshift.io/v1/builds/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchBuild(
@Path("name") String name,
@Body Build body,
@QueryMap PatchBuild queryParameters);
final class PatchBuild extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public PatchBuild 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 PatchBuild 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 PatchBuild fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* replace the specified Build
*
* @param name name of the Build
*/
@HTTP(
method = "PUT",
path = "/apis/config.openshift.io/v1/builds/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replaceBuild(
@Path("name") String name,
@Body Build body);
/**
* replace the specified Build
*
* @param name name of the Build
*/
@HTTP(
method = "PUT",
path = "/apis/config.openshift.io/v1/builds/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replaceBuild(
@Path("name") String name,
@Body Build body,
@QueryMap ReplaceBuild queryParameters);
final class ReplaceBuild extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReplaceBuild 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 ReplaceBuild 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 ReplaceBuild fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* read status of the specified Build
*
* @param name name of the Build
*/
@HTTP(
method = "GET",
path = "/apis/config.openshift.io/v1/builds/{name}/status"
)
@Headers({
"Accept: */*"
})
KubernetesCall readBuildStatus(
@Path("name") String name);
/**
* read status of the specified Build
*
* @param name name of the Build
*/
@HTTP(
method = "GET",
path = "/apis/config.openshift.io/v1/builds/{name}/status"
)
@Headers({
"Accept: */*"
})
KubernetesCall readBuildStatus(
@Path("name") String name,
@QueryMap ReadBuildStatus queryParameters);
final class ReadBuildStatus extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReadBuildStatus 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 ReadBuildStatus resourceVersion(String resourceVersion) {
put("resourceVersion", resourceVersion);
return this;
}
}
/**
* partially update status of the specified Build
*
* @param name name of the Build
*/
@HTTP(
method = "PATCH",
path = "/apis/config.openshift.io/v1/builds/{name}/status",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchBuildStatus(
@Path("name") String name,
@Body Build body);
/**
* partially update status of the specified Build
*
* @param name name of the Build
*/
@HTTP(
method = "PATCH",
path = "/apis/config.openshift.io/v1/builds/{name}/status",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchBuildStatus(
@Path("name") String name,
@Body Build body,
@QueryMap PatchBuildStatus queryParameters);
final class PatchBuildStatus extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public PatchBuildStatus 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 PatchBuildStatus 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 PatchBuildStatus fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* replace status of the specified Build
*
* @param name name of the Build
*/
@HTTP(
method = "PUT",
path = "/apis/config.openshift.io/v1/builds/{name}/status",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replaceBuildStatus(
@Path("name") String name,
@Body Build body);
/**
* replace status of the specified Build
*
* @param name name of the Build
*/
@HTTP(
method = "PUT",
path = "/apis/config.openshift.io/v1/builds/{name}/status",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replaceBuildStatus(
@Path("name") String name,
@Body Build body,
@QueryMap ReplaceBuildStatus queryParameters);
final class ReplaceBuildStatus extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReplaceBuildStatus 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 ReplaceBuildStatus 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 ReplaceBuildStatus fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* delete collection of ClusterOperator
*/
@HTTP(
method = "DELETE",
path = "/apis/config.openshift.io/v1/clusteroperators"
)
@Headers({
"Accept: */*"
})
KubernetesCall deleteCollectionClusterOperator();
/**
* delete collection of ClusterOperator
*/
@HTTP(
method = "DELETE",
path = "/apis/config.openshift.io/v1/clusteroperators"
)
@Headers({
"Accept: */*"
})
KubernetesCall deleteCollectionClusterOperator(
@QueryMap DeleteCollectionClusterOperator queryParameters);
final class DeleteCollectionClusterOperator extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public DeleteCollectionClusterOperator 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 DeleteCollectionClusterOperator 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 DeleteCollectionClusterOperator continues(String continues) {
put("continue", continues);
return this;
}
/**
* A selector to restrict the list of returned objects by their fields. Defaults to everything.
*/
public DeleteCollectionClusterOperator fieldSelector(String fieldSelector) {
put("fieldSelector", fieldSelector);
return this;
}
/**
* A selector to restrict the list of returned objects by their labels. Defaults to everything.
*/
public DeleteCollectionClusterOperator 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 DeleteCollectionClusterOperator 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 DeleteCollectionClusterOperator 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 DeleteCollectionClusterOperator 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 DeleteCollectionClusterOperator watch(Boolean watch) {
put("watch", watch);
return this;
}
}
/**
* list objects of kind ClusterOperator
*/
@HTTP(
method = "GET",
path = "/apis/config.openshift.io/v1/clusteroperators"
)
@Headers({
"Accept: */*"
})
KubernetesListCall listClusterOperator();
/**
* list objects of kind ClusterOperator
*/
@HTTP(
method = "GET",
path = "/apis/config.openshift.io/v1/clusteroperators"
)
@Headers({
"Accept: */*"
})
KubernetesListCall listClusterOperator(
@QueryMap ListClusterOperator queryParameters);
final class ListClusterOperator extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ListClusterOperator 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 ListClusterOperator 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 ListClusterOperator continues(String continues) {
put("continue", continues);
return this;
}
/**
* A selector to restrict the list of returned objects by their fields. Defaults to everything.
*/
public ListClusterOperator fieldSelector(String fieldSelector) {
put("fieldSelector", fieldSelector);
return this;
}
/**
* A selector to restrict the list of returned objects by their labels. Defaults to everything.
*/
public ListClusterOperator 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 ListClusterOperator 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 ListClusterOperator 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 ListClusterOperator 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 ListClusterOperator watch(Boolean watch) {
put("watch", watch);
return this;
}
}
/**
* create a ClusterOperator
*/
@HTTP(
method = "POST",
path = "/apis/config.openshift.io/v1/clusteroperators",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall createClusterOperator(
@Body ClusterOperator body);
/**
* create a ClusterOperator
*/
@HTTP(
method = "POST",
path = "/apis/config.openshift.io/v1/clusteroperators",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall createClusterOperator(
@Body ClusterOperator body,
@QueryMap CreateClusterOperator queryParameters);
final class CreateClusterOperator extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public CreateClusterOperator 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 CreateClusterOperator 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 CreateClusterOperator fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* delete a ClusterOperator
*
* @param name name of the ClusterOperator
*/
@HTTP(
method = "DELETE",
path = "/apis/config.openshift.io/v1/clusteroperators/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteClusterOperator(
@Path("name") String name,
@Body DeleteOptions body);
/**
* delete a ClusterOperator
*
* @param name name of the ClusterOperator
*/
@HTTP(
method = "DELETE",
path = "/apis/config.openshift.io/v1/clusteroperators/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteClusterOperator(
@Path("name") String name);
/**
* delete a ClusterOperator
*
* @param name name of the ClusterOperator
*/
@HTTP(
method = "DELETE",
path = "/apis/config.openshift.io/v1/clusteroperators/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteClusterOperator(
@Path("name") String name,
@Body DeleteOptions body,
@QueryMap DeleteClusterOperator queryParameters);
/**
* delete a ClusterOperator
*
* @param name name of the ClusterOperator
*/
@HTTP(
method = "DELETE",
path = "/apis/config.openshift.io/v1/clusteroperators/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteClusterOperator(
@Path("name") String name,
@QueryMap DeleteClusterOperator queryParameters);
final class DeleteClusterOperator extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public DeleteClusterOperator 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 DeleteClusterOperator 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 DeleteClusterOperator 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 DeleteClusterOperator 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 DeleteClusterOperator propagationPolicy(String propagationPolicy) {
put("propagationPolicy", propagationPolicy);
return this;
}
}
/**
* read the specified ClusterOperator
*
* @param name name of the ClusterOperator
*/
@HTTP(
method = "GET",
path = "/apis/config.openshift.io/v1/clusteroperators/{name}"
)
@Headers({
"Accept: */*"
})
KubernetesCall readClusterOperator(
@Path("name") String name);
/**
* read the specified ClusterOperator
*
* @param name name of the ClusterOperator
*/
@HTTP(
method = "GET",
path = "/apis/config.openshift.io/v1/clusteroperators/{name}"
)
@Headers({
"Accept: */*"
})
KubernetesCall readClusterOperator(
@Path("name") String name,
@QueryMap ReadClusterOperator queryParameters);
final class ReadClusterOperator extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReadClusterOperator 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 ReadClusterOperator resourceVersion(String resourceVersion) {
put("resourceVersion", resourceVersion);
return this;
}
}
/**
* partially update the specified ClusterOperator
*
* @param name name of the ClusterOperator
*/
@HTTP(
method = "PATCH",
path = "/apis/config.openshift.io/v1/clusteroperators/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchClusterOperator(
@Path("name") String name,
@Body ClusterOperator body);
/**
* partially update the specified ClusterOperator
*
* @param name name of the ClusterOperator
*/
@HTTP(
method = "PATCH",
path = "/apis/config.openshift.io/v1/clusteroperators/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchClusterOperator(
@Path("name") String name,
@Body ClusterOperator body,
@QueryMap PatchClusterOperator queryParameters);
final class PatchClusterOperator extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public PatchClusterOperator 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 PatchClusterOperator 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 PatchClusterOperator fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* replace the specified ClusterOperator
*
* @param name name of the ClusterOperator
*/
@HTTP(
method = "PUT",
path = "/apis/config.openshift.io/v1/clusteroperators/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replaceClusterOperator(
@Path("name") String name,
@Body ClusterOperator body);
/**
* replace the specified ClusterOperator
*
* @param name name of the ClusterOperator
*/
@HTTP(
method = "PUT",
path = "/apis/config.openshift.io/v1/clusteroperators/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replaceClusterOperator(
@Path("name") String name,
@Body ClusterOperator body,
@QueryMap ReplaceClusterOperator queryParameters);
final class ReplaceClusterOperator extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReplaceClusterOperator 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 ReplaceClusterOperator 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 ReplaceClusterOperator fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* read status of the specified ClusterOperator
*
* @param name name of the ClusterOperator
*/
@HTTP(
method = "GET",
path = "/apis/config.openshift.io/v1/clusteroperators/{name}/status"
)
@Headers({
"Accept: */*"
})
KubernetesCall readClusterOperatorStatus(
@Path("name") String name);
/**
* read status of the specified ClusterOperator
*
* @param name name of the ClusterOperator
*/
@HTTP(
method = "GET",
path = "/apis/config.openshift.io/v1/clusteroperators/{name}/status"
)
@Headers({
"Accept: */*"
})
KubernetesCall readClusterOperatorStatus(
@Path("name") String name,
@QueryMap ReadClusterOperatorStatus queryParameters);
final class ReadClusterOperatorStatus extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReadClusterOperatorStatus 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 ReadClusterOperatorStatus resourceVersion(String resourceVersion) {
put("resourceVersion", resourceVersion);
return this;
}
}
/**
* partially update status of the specified ClusterOperator
*
* @param name name of the ClusterOperator
*/
@HTTP(
method = "PATCH",
path = "/apis/config.openshift.io/v1/clusteroperators/{name}/status",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchClusterOperatorStatus(
@Path("name") String name,
@Body ClusterOperator body);
/**
* partially update status of the specified ClusterOperator
*
* @param name name of the ClusterOperator
*/
@HTTP(
method = "PATCH",
path = "/apis/config.openshift.io/v1/clusteroperators/{name}/status",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchClusterOperatorStatus(
@Path("name") String name,
@Body ClusterOperator body,
@QueryMap PatchClusterOperatorStatus queryParameters);
final class PatchClusterOperatorStatus extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public PatchClusterOperatorStatus 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 PatchClusterOperatorStatus 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 PatchClusterOperatorStatus fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* replace status of the specified ClusterOperator
*
* @param name name of the ClusterOperator
*/
@HTTP(
method = "PUT",
path = "/apis/config.openshift.io/v1/clusteroperators/{name}/status",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replaceClusterOperatorStatus(
@Path("name") String name,
@Body ClusterOperator body);
/**
* replace status of the specified ClusterOperator
*
* @param name name of the ClusterOperator
*/
@HTTP(
method = "PUT",
path = "/apis/config.openshift.io/v1/clusteroperators/{name}/status",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replaceClusterOperatorStatus(
@Path("name") String name,
@Body ClusterOperator body,
@QueryMap ReplaceClusterOperatorStatus queryParameters);
final class ReplaceClusterOperatorStatus extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReplaceClusterOperatorStatus 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 ReplaceClusterOperatorStatus 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 ReplaceClusterOperatorStatus fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* delete collection of ClusterVersion
*/
@HTTP(
method = "DELETE",
path = "/apis/config.openshift.io/v1/clusterversions"
)
@Headers({
"Accept: */*"
})
KubernetesCall deleteCollectionClusterVersion();
/**
* delete collection of ClusterVersion
*/
@HTTP(
method = "DELETE",
path = "/apis/config.openshift.io/v1/clusterversions"
)
@Headers({
"Accept: */*"
})
KubernetesCall deleteCollectionClusterVersion(
@QueryMap DeleteCollectionClusterVersion queryParameters);
final class DeleteCollectionClusterVersion extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public DeleteCollectionClusterVersion 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 DeleteCollectionClusterVersion 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 DeleteCollectionClusterVersion continues(String continues) {
put("continue", continues);
return this;
}
/**
* A selector to restrict the list of returned objects by their fields. Defaults to everything.
*/
public DeleteCollectionClusterVersion fieldSelector(String fieldSelector) {
put("fieldSelector", fieldSelector);
return this;
}
/**
* A selector to restrict the list of returned objects by their labels. Defaults to everything.
*/
public DeleteCollectionClusterVersion 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 DeleteCollectionClusterVersion 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 DeleteCollectionClusterVersion 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 DeleteCollectionClusterVersion 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 DeleteCollectionClusterVersion watch(Boolean watch) {
put("watch", watch);
return this;
}
}
/**
* list objects of kind ClusterVersion
*/
@HTTP(
method = "GET",
path = "/apis/config.openshift.io/v1/clusterversions"
)
@Headers({
"Accept: */*"
})
KubernetesListCall listClusterVersion();
/**
* list objects of kind ClusterVersion
*/
@HTTP(
method = "GET",
path = "/apis/config.openshift.io/v1/clusterversions"
)
@Headers({
"Accept: */*"
})
KubernetesListCall listClusterVersion(
@QueryMap ListClusterVersion queryParameters);
final class ListClusterVersion extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ListClusterVersion 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 ListClusterVersion 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 ListClusterVersion continues(String continues) {
put("continue", continues);
return this;
}
/**
* A selector to restrict the list of returned objects by their fields. Defaults to everything.
*/
public ListClusterVersion fieldSelector(String fieldSelector) {
put("fieldSelector", fieldSelector);
return this;
}
/**
* A selector to restrict the list of returned objects by their labels. Defaults to everything.
*/
public ListClusterVersion 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 ListClusterVersion 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 ListClusterVersion 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 ListClusterVersion 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 ListClusterVersion watch(Boolean watch) {
put("watch", watch);
return this;
}
}
/**
* create a ClusterVersion
*/
@HTTP(
method = "POST",
path = "/apis/config.openshift.io/v1/clusterversions",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall createClusterVersion(
@Body ClusterVersion body);
/**
* create a ClusterVersion
*/
@HTTP(
method = "POST",
path = "/apis/config.openshift.io/v1/clusterversions",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall createClusterVersion(
@Body ClusterVersion body,
@QueryMap CreateClusterVersion queryParameters);
final class CreateClusterVersion extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public CreateClusterVersion 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 CreateClusterVersion 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 CreateClusterVersion fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* delete a ClusterVersion
*
* @param name name of the ClusterVersion
*/
@HTTP(
method = "DELETE",
path = "/apis/config.openshift.io/v1/clusterversions/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteClusterVersion(
@Path("name") String name,
@Body DeleteOptions body);
/**
* delete a ClusterVersion
*
* @param name name of the ClusterVersion
*/
@HTTP(
method = "DELETE",
path = "/apis/config.openshift.io/v1/clusterversions/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteClusterVersion(
@Path("name") String name);
/**
* delete a ClusterVersion
*
* @param name name of the ClusterVersion
*/
@HTTP(
method = "DELETE",
path = "/apis/config.openshift.io/v1/clusterversions/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteClusterVersion(
@Path("name") String name,
@Body DeleteOptions body,
@QueryMap DeleteClusterVersion queryParameters);
/**
* delete a ClusterVersion
*
* @param name name of the ClusterVersion
*/
@HTTP(
method = "DELETE",
path = "/apis/config.openshift.io/v1/clusterversions/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteClusterVersion(
@Path("name") String name,
@QueryMap DeleteClusterVersion queryParameters);
final class DeleteClusterVersion extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public DeleteClusterVersion 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 DeleteClusterVersion 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 DeleteClusterVersion 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 DeleteClusterVersion 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 DeleteClusterVersion propagationPolicy(String propagationPolicy) {
put("propagationPolicy", propagationPolicy);
return this;
}
}
/**
* read the specified ClusterVersion
*
* @param name name of the ClusterVersion
*/
@HTTP(
method = "GET",
path = "/apis/config.openshift.io/v1/clusterversions/{name}"
)
@Headers({
"Accept: */*"
})
KubernetesCall readClusterVersion(
@Path("name") String name);
/**
* read the specified ClusterVersion
*
* @param name name of the ClusterVersion
*/
@HTTP(
method = "GET",
path = "/apis/config.openshift.io/v1/clusterversions/{name}"
)
@Headers({
"Accept: */*"
})
KubernetesCall readClusterVersion(
@Path("name") String name,
@QueryMap ReadClusterVersion queryParameters);
final class ReadClusterVersion extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReadClusterVersion 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 ReadClusterVersion resourceVersion(String resourceVersion) {
put("resourceVersion", resourceVersion);
return this;
}
}
/**
* partially update the specified ClusterVersion
*
* @param name name of the ClusterVersion
*/
@HTTP(
method = "PATCH",
path = "/apis/config.openshift.io/v1/clusterversions/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchClusterVersion(
@Path("name") String name,
@Body ClusterVersion body);
/**
* partially update the specified ClusterVersion
*
* @param name name of the ClusterVersion
*/
@HTTP(
method = "PATCH",
path = "/apis/config.openshift.io/v1/clusterversions/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchClusterVersion(
@Path("name") String name,
@Body ClusterVersion body,
@QueryMap PatchClusterVersion queryParameters);
final class PatchClusterVersion extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public PatchClusterVersion 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 PatchClusterVersion 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 PatchClusterVersion fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* replace the specified ClusterVersion
*
* @param name name of the ClusterVersion
*/
@HTTP(
method = "PUT",
path = "/apis/config.openshift.io/v1/clusterversions/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replaceClusterVersion(
@Path("name") String name,
@Body ClusterVersion body);
/**
* replace the specified ClusterVersion
*
* @param name name of the ClusterVersion
*/
@HTTP(
method = "PUT",
path = "/apis/config.openshift.io/v1/clusterversions/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replaceClusterVersion(
@Path("name") String name,
@Body ClusterVersion body,
@QueryMap ReplaceClusterVersion queryParameters);
final class ReplaceClusterVersion extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReplaceClusterVersion 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 ReplaceClusterVersion 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 ReplaceClusterVersion fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* read status of the specified ClusterVersion
*
* @param name name of the ClusterVersion
*/
@HTTP(
method = "GET",
path = "/apis/config.openshift.io/v1/clusterversions/{name}/status"
)
@Headers({
"Accept: */*"
})
KubernetesCall readClusterVersionStatus(
@Path("name") String name);
/**
* read status of the specified ClusterVersion
*
* @param name name of the ClusterVersion
*/
@HTTP(
method = "GET",
path = "/apis/config.openshift.io/v1/clusterversions/{name}/status"
)
@Headers({
"Accept: */*"
})
KubernetesCall readClusterVersionStatus(
@Path("name") String name,
@QueryMap ReadClusterVersionStatus queryParameters);
final class ReadClusterVersionStatus extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReadClusterVersionStatus 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 ReadClusterVersionStatus resourceVersion(String resourceVersion) {
put("resourceVersion", resourceVersion);
return this;
}
}
/**
* partially update status of the specified ClusterVersion
*
* @param name name of the ClusterVersion
*/
@HTTP(
method = "PATCH",
path = "/apis/config.openshift.io/v1/clusterversions/{name}/status",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchClusterVersionStatus(
@Path("name") String name,
@Body ClusterVersion body);
/**
* partially update status of the specified ClusterVersion
*
* @param name name of the ClusterVersion
*/
@HTTP(
method = "PATCH",
path = "/apis/config.openshift.io/v1/clusterversions/{name}/status",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchClusterVersionStatus(
@Path("name") String name,
@Body ClusterVersion body,
@QueryMap PatchClusterVersionStatus queryParameters);
final class PatchClusterVersionStatus extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public PatchClusterVersionStatus 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 PatchClusterVersionStatus 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 PatchClusterVersionStatus fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* replace status of the specified ClusterVersion
*
* @param name name of the ClusterVersion
*/
@HTTP(
method = "PUT",
path = "/apis/config.openshift.io/v1/clusterversions/{name}/status",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replaceClusterVersionStatus(
@Path("name") String name,
@Body ClusterVersion body);
/**
* replace status of the specified ClusterVersion
*
* @param name name of the ClusterVersion
*/
@HTTP(
method = "PUT",
path = "/apis/config.openshift.io/v1/clusterversions/{name}/status",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replaceClusterVersionStatus(
@Path("name") String name,
@Body ClusterVersion body,
@QueryMap ReplaceClusterVersionStatus queryParameters);
final class ReplaceClusterVersionStatus extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReplaceClusterVersionStatus 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 ReplaceClusterVersionStatus 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 ReplaceClusterVersionStatus fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* delete collection of Console
*/
@HTTP(
method = "DELETE",
path = "/apis/config.openshift.io/v1/consoles"
)
@Headers({
"Accept: */*"
})
KubernetesCall deleteCollectionConsole();
/**
* delete collection of Console
*/
@HTTP(
method = "DELETE",
path = "/apis/config.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/config.openshift.io/v1/consoles"
)
@Headers({
"Accept: */*"
})
KubernetesListCall listConsole();
/**
* list objects of kind Console
*/
@HTTP(
method = "GET",
path = "/apis/config.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/config.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/config.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/config.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/config.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/config.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/config.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/config.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/config.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/config.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/config.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/config.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/config.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/config.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/config.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/config.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/config.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/config.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/config.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 DNS
*/
@HTTP(
method = "DELETE",
path = "/apis/config.openshift.io/v1/dnses"
)
@Headers({
"Accept: */*"
})
KubernetesCall deleteCollectionDNS();
/**
* delete collection of DNS
*/
@HTTP(
method = "DELETE",
path = "/apis/config.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/config.openshift.io/v1/dnses"
)
@Headers({
"Accept: */*"
})
KubernetesListCall listDNS();
/**
* list objects of kind DNS
*/
@HTTP(
method = "GET",
path = "/apis/config.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/config.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/config.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/config.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/config.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/config.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/config.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/config.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/config.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/config.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/config.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/config.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/config.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/config.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/config.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/config.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/config.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/config.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/config.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 FeatureGate
*/
@HTTP(
method = "DELETE",
path = "/apis/config.openshift.io/v1/featuregates"
)
@Headers({
"Accept: */*"
})
KubernetesCall deleteCollectionFeatureGate();
/**
* delete collection of FeatureGate
*/
@HTTP(
method = "DELETE",
path = "/apis/config.openshift.io/v1/featuregates"
)
@Headers({
"Accept: */*"
})
KubernetesCall deleteCollectionFeatureGate(
@QueryMap DeleteCollectionFeatureGate queryParameters);
final class DeleteCollectionFeatureGate extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public DeleteCollectionFeatureGate 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 DeleteCollectionFeatureGate 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 DeleteCollectionFeatureGate continues(String continues) {
put("continue", continues);
return this;
}
/**
* A selector to restrict the list of returned objects by their fields. Defaults to everything.
*/
public DeleteCollectionFeatureGate fieldSelector(String fieldSelector) {
put("fieldSelector", fieldSelector);
return this;
}
/**
* A selector to restrict the list of returned objects by their labels. Defaults to everything.
*/
public DeleteCollectionFeatureGate 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 DeleteCollectionFeatureGate 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 DeleteCollectionFeatureGate 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 DeleteCollectionFeatureGate 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 DeleteCollectionFeatureGate watch(Boolean watch) {
put("watch", watch);
return this;
}
}
/**
* list objects of kind FeatureGate
*/
@HTTP(
method = "GET",
path = "/apis/config.openshift.io/v1/featuregates"
)
@Headers({
"Accept: */*"
})
KubernetesListCall listFeatureGate();
/**
* list objects of kind FeatureGate
*/
@HTTP(
method = "GET",
path = "/apis/config.openshift.io/v1/featuregates"
)
@Headers({
"Accept: */*"
})
KubernetesListCall listFeatureGate(
@QueryMap ListFeatureGate queryParameters);
final class ListFeatureGate extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ListFeatureGate 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 ListFeatureGate 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 ListFeatureGate continues(String continues) {
put("continue", continues);
return this;
}
/**
* A selector to restrict the list of returned objects by their fields. Defaults to everything.
*/
public ListFeatureGate fieldSelector(String fieldSelector) {
put("fieldSelector", fieldSelector);
return this;
}
/**
* A selector to restrict the list of returned objects by their labels. Defaults to everything.
*/
public ListFeatureGate 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 ListFeatureGate 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 ListFeatureGate 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 ListFeatureGate 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 ListFeatureGate watch(Boolean watch) {
put("watch", watch);
return this;
}
}
/**
* create a FeatureGate
*/
@HTTP(
method = "POST",
path = "/apis/config.openshift.io/v1/featuregates",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall createFeatureGate(
@Body FeatureGate body);
/**
* create a FeatureGate
*/
@HTTP(
method = "POST",
path = "/apis/config.openshift.io/v1/featuregates",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall createFeatureGate(
@Body FeatureGate body,
@QueryMap CreateFeatureGate queryParameters);
final class CreateFeatureGate extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public CreateFeatureGate 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 CreateFeatureGate 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 CreateFeatureGate fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* delete a FeatureGate
*
* @param name name of the FeatureGate
*/
@HTTP(
method = "DELETE",
path = "/apis/config.openshift.io/v1/featuregates/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteFeatureGate(
@Path("name") String name,
@Body DeleteOptions body);
/**
* delete a FeatureGate
*
* @param name name of the FeatureGate
*/
@HTTP(
method = "DELETE",
path = "/apis/config.openshift.io/v1/featuregates/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall