com.marcnuri.yakc.api.authorizationopenshiftio.v1.AuthorizationOpenshiftIoV1Api 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.authorizationopenshiftio.v1;
import com.marcnuri.yakc.api.Api;
import com.marcnuri.yakc.api.KubernetesCall;
import com.marcnuri.yakc.api.KubernetesListCall;
import com.marcnuri.yakc.model.com.github.openshift.api.authorization.v1.ClusterRole;
import com.marcnuri.yakc.model.com.github.openshift.api.authorization.v1.ClusterRoleBinding;
import com.marcnuri.yakc.model.com.github.openshift.api.authorization.v1.ClusterRoleBindingList;
import com.marcnuri.yakc.model.com.github.openshift.api.authorization.v1.ClusterRoleList;
import com.marcnuri.yakc.model.com.github.openshift.api.authorization.v1.LocalResourceAccessReview;
import com.marcnuri.yakc.model.com.github.openshift.api.authorization.v1.LocalSubjectAccessReview;
import com.marcnuri.yakc.model.com.github.openshift.api.authorization.v1.ResourceAccessReview;
import com.marcnuri.yakc.model.com.github.openshift.api.authorization.v1.Role;
import com.marcnuri.yakc.model.com.github.openshift.api.authorization.v1.RoleBinding;
import com.marcnuri.yakc.model.com.github.openshift.api.authorization.v1.RoleBindingList;
import com.marcnuri.yakc.model.com.github.openshift.api.authorization.v1.RoleList;
import com.marcnuri.yakc.model.com.github.openshift.api.authorization.v1.SelfSubjectRulesReview;
import com.marcnuri.yakc.model.com.github.openshift.api.authorization.v1.SubjectAccessReview;
import com.marcnuri.yakc.model.com.github.openshift.api.authorization.v1.SubjectRulesReview;
import com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList;
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.authorization.v1.RoleBindingRestriction;
import com.marcnuri.yakc.model.io.openshift.authorization.v1.RoleBindingRestrictionList;
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 AuthorizationOpenshiftIoV1Api extends Api {
/**
* get available resources
*/
@HTTP(
method = "GET",
path = "/apis/authorization.openshift.io/v1/"
)
@Headers({
"Accept: */*"
})
KubernetesCall getAPIResources();
/**
* list objects of kind ClusterRoleBinding
*/
@HTTP(
method = "GET",
path = "/apis/authorization.openshift.io/v1/clusterrolebindings"
)
@Headers({
"Accept: */*"
})
KubernetesListCall listClusterRoleBinding();
/**
* list objects of kind ClusterRoleBinding
*/
@HTTP(
method = "GET",
path = "/apis/authorization.openshift.io/v1/clusterrolebindings"
)
@Headers({
"Accept: */*"
})
KubernetesListCall listClusterRoleBinding(
@QueryMap ListClusterRoleBinding queryParameters);
final class ListClusterRoleBinding extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ListClusterRoleBinding 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 ListClusterRoleBinding 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 ListClusterRoleBinding continues(String continues) {
put("continue", continues);
return this;
}
/**
* A selector to restrict the list of returned objects by their fields. Defaults to everything.
*/
public ListClusterRoleBinding fieldSelector(String fieldSelector) {
put("fieldSelector", fieldSelector);
return this;
}
/**
* A selector to restrict the list of returned objects by their labels. Defaults to everything.
*/
public ListClusterRoleBinding 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 ListClusterRoleBinding 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 ListClusterRoleBinding 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 ListClusterRoleBinding 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 ListClusterRoleBinding watch(Boolean watch) {
put("watch", watch);
return this;
}
}
/**
* create a ClusterRoleBinding
*/
@HTTP(
method = "POST",
path = "/apis/authorization.openshift.io/v1/clusterrolebindings",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall createClusterRoleBinding(
@Body ClusterRoleBinding body);
/**
* create a ClusterRoleBinding
*/
@HTTP(
method = "POST",
path = "/apis/authorization.openshift.io/v1/clusterrolebindings",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall createClusterRoleBinding(
@Body ClusterRoleBinding body,
@QueryMap CreateClusterRoleBinding queryParameters);
final class CreateClusterRoleBinding extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public CreateClusterRoleBinding 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 CreateClusterRoleBinding 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 CreateClusterRoleBinding fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* delete a ClusterRoleBinding
*
* @param name name of the ClusterRoleBinding
*/
@HTTP(
method = "DELETE",
path = "/apis/authorization.openshift.io/v1/clusterrolebindings/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteClusterRoleBinding(
@Path("name") String name,
@Body DeleteOptions body);
/**
* delete a ClusterRoleBinding
*
* @param name name of the ClusterRoleBinding
*/
@HTTP(
method = "DELETE",
path = "/apis/authorization.openshift.io/v1/clusterrolebindings/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteClusterRoleBinding(
@Path("name") String name);
/**
* delete a ClusterRoleBinding
*
* @param name name of the ClusterRoleBinding
*/
@HTTP(
method = "DELETE",
path = "/apis/authorization.openshift.io/v1/clusterrolebindings/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteClusterRoleBinding(
@Path("name") String name,
@Body DeleteOptions body,
@QueryMap DeleteClusterRoleBinding queryParameters);
/**
* delete a ClusterRoleBinding
*
* @param name name of the ClusterRoleBinding
*/
@HTTP(
method = "DELETE",
path = "/apis/authorization.openshift.io/v1/clusterrolebindings/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteClusterRoleBinding(
@Path("name") String name,
@QueryMap DeleteClusterRoleBinding queryParameters);
final class DeleteClusterRoleBinding extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public DeleteClusterRoleBinding 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 DeleteClusterRoleBinding 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 DeleteClusterRoleBinding 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 DeleteClusterRoleBinding 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 DeleteClusterRoleBinding propagationPolicy(String propagationPolicy) {
put("propagationPolicy", propagationPolicy);
return this;
}
}
/**
* read the specified ClusterRoleBinding
*
* @param name name of the ClusterRoleBinding
*/
@HTTP(
method = "GET",
path = "/apis/authorization.openshift.io/v1/clusterrolebindings/{name}"
)
@Headers({
"Accept: */*"
})
KubernetesCall readClusterRoleBinding(
@Path("name") String name);
/**
* read the specified ClusterRoleBinding
*
* @param name name of the ClusterRoleBinding
*/
@HTTP(
method = "GET",
path = "/apis/authorization.openshift.io/v1/clusterrolebindings/{name}"
)
@Headers({
"Accept: */*"
})
KubernetesCall readClusterRoleBinding(
@Path("name") String name,
@QueryMap ReadClusterRoleBinding queryParameters);
final class ReadClusterRoleBinding extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReadClusterRoleBinding pretty(String pretty) {
put("pretty", pretty);
return this;
}
}
/**
* partially update the specified ClusterRoleBinding
*
* @param name name of the ClusterRoleBinding
*/
@HTTP(
method = "PATCH",
path = "/apis/authorization.openshift.io/v1/clusterrolebindings/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchClusterRoleBinding(
@Path("name") String name,
@Body ClusterRoleBinding body);
/**
* partially update the specified ClusterRoleBinding
*
* @param name name of the ClusterRoleBinding
*/
@HTTP(
method = "PATCH",
path = "/apis/authorization.openshift.io/v1/clusterrolebindings/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchClusterRoleBinding(
@Path("name") String name,
@Body ClusterRoleBinding body,
@QueryMap PatchClusterRoleBinding queryParameters);
final class PatchClusterRoleBinding extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public PatchClusterRoleBinding 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 PatchClusterRoleBinding 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. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).
*/
public PatchClusterRoleBinding fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
/**
* Force is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.
*/
public PatchClusterRoleBinding force(Boolean force) {
put("force", force);
return this;
}
}
/**
* replace the specified ClusterRoleBinding
*
* @param name name of the ClusterRoleBinding
*/
@HTTP(
method = "PUT",
path = "/apis/authorization.openshift.io/v1/clusterrolebindings/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replaceClusterRoleBinding(
@Path("name") String name,
@Body ClusterRoleBinding body);
/**
* replace the specified ClusterRoleBinding
*
* @param name name of the ClusterRoleBinding
*/
@HTTP(
method = "PUT",
path = "/apis/authorization.openshift.io/v1/clusterrolebindings/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replaceClusterRoleBinding(
@Path("name") String name,
@Body ClusterRoleBinding body,
@QueryMap ReplaceClusterRoleBinding queryParameters);
final class ReplaceClusterRoleBinding extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReplaceClusterRoleBinding 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 ReplaceClusterRoleBinding 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 ReplaceClusterRoleBinding fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* list objects of kind ClusterRole
*/
@HTTP(
method = "GET",
path = "/apis/authorization.openshift.io/v1/clusterroles"
)
@Headers({
"Accept: */*"
})
KubernetesListCall listClusterRole();
/**
* list objects of kind ClusterRole
*/
@HTTP(
method = "GET",
path = "/apis/authorization.openshift.io/v1/clusterroles"
)
@Headers({
"Accept: */*"
})
KubernetesListCall listClusterRole(
@QueryMap ListClusterRole queryParameters);
final class ListClusterRole extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ListClusterRole 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 ListClusterRole 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 ListClusterRole continues(String continues) {
put("continue", continues);
return this;
}
/**
* A selector to restrict the list of returned objects by their fields. Defaults to everything.
*/
public ListClusterRole fieldSelector(String fieldSelector) {
put("fieldSelector", fieldSelector);
return this;
}
/**
* A selector to restrict the list of returned objects by their labels. Defaults to everything.
*/
public ListClusterRole 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 ListClusterRole 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 ListClusterRole 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 ListClusterRole 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 ListClusterRole watch(Boolean watch) {
put("watch", watch);
return this;
}
}
/**
* create a ClusterRole
*/
@HTTP(
method = "POST",
path = "/apis/authorization.openshift.io/v1/clusterroles",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall createClusterRole(
@Body ClusterRole body);
/**
* create a ClusterRole
*/
@HTTP(
method = "POST",
path = "/apis/authorization.openshift.io/v1/clusterroles",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall createClusterRole(
@Body ClusterRole body,
@QueryMap CreateClusterRole queryParameters);
final class CreateClusterRole extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public CreateClusterRole 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 CreateClusterRole 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 CreateClusterRole fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* delete a ClusterRole
*
* @param name name of the ClusterRole
*/
@HTTP(
method = "DELETE",
path = "/apis/authorization.openshift.io/v1/clusterroles/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteClusterRole(
@Path("name") String name,
@Body DeleteOptions body);
/**
* delete a ClusterRole
*
* @param name name of the ClusterRole
*/
@HTTP(
method = "DELETE",
path = "/apis/authorization.openshift.io/v1/clusterroles/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteClusterRole(
@Path("name") String name);
/**
* delete a ClusterRole
*
* @param name name of the ClusterRole
*/
@HTTP(
method = "DELETE",
path = "/apis/authorization.openshift.io/v1/clusterroles/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteClusterRole(
@Path("name") String name,
@Body DeleteOptions body,
@QueryMap DeleteClusterRole queryParameters);
/**
* delete a ClusterRole
*
* @param name name of the ClusterRole
*/
@HTTP(
method = "DELETE",
path = "/apis/authorization.openshift.io/v1/clusterroles/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteClusterRole(
@Path("name") String name,
@QueryMap DeleteClusterRole queryParameters);
final class DeleteClusterRole extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public DeleteClusterRole 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 DeleteClusterRole 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 DeleteClusterRole 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 DeleteClusterRole 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 DeleteClusterRole propagationPolicy(String propagationPolicy) {
put("propagationPolicy", propagationPolicy);
return this;
}
}
/**
* read the specified ClusterRole
*
* @param name name of the ClusterRole
*/
@HTTP(
method = "GET",
path = "/apis/authorization.openshift.io/v1/clusterroles/{name}"
)
@Headers({
"Accept: */*"
})
KubernetesCall readClusterRole(
@Path("name") String name);
/**
* read the specified ClusterRole
*
* @param name name of the ClusterRole
*/
@HTTP(
method = "GET",
path = "/apis/authorization.openshift.io/v1/clusterroles/{name}"
)
@Headers({
"Accept: */*"
})
KubernetesCall readClusterRole(
@Path("name") String name,
@QueryMap ReadClusterRole queryParameters);
final class ReadClusterRole extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReadClusterRole pretty(String pretty) {
put("pretty", pretty);
return this;
}
}
/**
* partially update the specified ClusterRole
*
* @param name name of the ClusterRole
*/
@HTTP(
method = "PATCH",
path = "/apis/authorization.openshift.io/v1/clusterroles/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchClusterRole(
@Path("name") String name,
@Body ClusterRole body);
/**
* partially update the specified ClusterRole
*
* @param name name of the ClusterRole
*/
@HTTP(
method = "PATCH",
path = "/apis/authorization.openshift.io/v1/clusterroles/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchClusterRole(
@Path("name") String name,
@Body ClusterRole body,
@QueryMap PatchClusterRole queryParameters);
final class PatchClusterRole extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public PatchClusterRole 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 PatchClusterRole 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. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).
*/
public PatchClusterRole fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
/**
* Force is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.
*/
public PatchClusterRole force(Boolean force) {
put("force", force);
return this;
}
}
/**
* replace the specified ClusterRole
*
* @param name name of the ClusterRole
*/
@HTTP(
method = "PUT",
path = "/apis/authorization.openshift.io/v1/clusterroles/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replaceClusterRole(
@Path("name") String name,
@Body ClusterRole body);
/**
* replace the specified ClusterRole
*
* @param name name of the ClusterRole
*/
@HTTP(
method = "PUT",
path = "/apis/authorization.openshift.io/v1/clusterroles/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replaceClusterRole(
@Path("name") String name,
@Body ClusterRole body,
@QueryMap ReplaceClusterRole queryParameters);
final class ReplaceClusterRole extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReplaceClusterRole 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 ReplaceClusterRole 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 ReplaceClusterRole fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* create a LocalResourceAccessReview
*
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "POST",
path = "/apis/authorization.openshift.io/v1/namespaces/{namespace}/localresourceaccessreviews",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall createNamespacedLocalResourceAccessReview(
@Path("namespace") String namespace,
@Body LocalResourceAccessReview body);
/**
* create a LocalResourceAccessReview
*
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "POST",
path = "/apis/authorization.openshift.io/v1/namespaces/{namespace}/localresourceaccessreviews",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall createNamespacedLocalResourceAccessReview(
@Path("namespace") String namespace,
@Body LocalResourceAccessReview body,
@QueryMap CreateNamespacedLocalResourceAccessReview queryParameters);
final class CreateNamespacedLocalResourceAccessReview extends HashMap {
/**
* 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 CreateNamespacedLocalResourceAccessReview 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 CreateNamespacedLocalResourceAccessReview fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
/**
* If 'true', then the output is pretty printed.
*/
public CreateNamespacedLocalResourceAccessReview pretty(String pretty) {
put("pretty", pretty);
return this;
}
}
/**
* create a LocalSubjectAccessReview
*
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "POST",
path = "/apis/authorization.openshift.io/v1/namespaces/{namespace}/localsubjectaccessreviews",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall createNamespacedLocalSubjectAccessReview(
@Path("namespace") String namespace,
@Body LocalSubjectAccessReview body);
/**
* create a LocalSubjectAccessReview
*
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "POST",
path = "/apis/authorization.openshift.io/v1/namespaces/{namespace}/localsubjectaccessreviews",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall createNamespacedLocalSubjectAccessReview(
@Path("namespace") String namespace,
@Body LocalSubjectAccessReview body,
@QueryMap CreateNamespacedLocalSubjectAccessReview queryParameters);
final class CreateNamespacedLocalSubjectAccessReview extends HashMap {
/**
* 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 CreateNamespacedLocalSubjectAccessReview 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 CreateNamespacedLocalSubjectAccessReview fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
/**
* If 'true', then the output is pretty printed.
*/
public CreateNamespacedLocalSubjectAccessReview pretty(String pretty) {
put("pretty", pretty);
return this;
}
}
/**
* delete collection of RoleBindingRestriction
*
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "DELETE",
path = "/apis/authorization.openshift.io/v1/namespaces/{namespace}/rolebindingrestrictions"
)
@Headers({
"Accept: */*"
})
KubernetesCall deleteCollectionNamespacedRoleBindingRestriction(
@Path("namespace") String namespace);
/**
* delete collection of RoleBindingRestriction
*
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "DELETE",
path = "/apis/authorization.openshift.io/v1/namespaces/{namespace}/rolebindingrestrictions"
)
@Headers({
"Accept: */*"
})
KubernetesCall deleteCollectionNamespacedRoleBindingRestriction(
@Path("namespace") String namespace,
@QueryMap DeleteCollectionNamespacedRoleBindingRestriction queryParameters);
final class DeleteCollectionNamespacedRoleBindingRestriction extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public DeleteCollectionNamespacedRoleBindingRestriction 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 DeleteCollectionNamespacedRoleBindingRestriction 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 DeleteCollectionNamespacedRoleBindingRestriction continues(String continues) {
put("continue", continues);
return this;
}
/**
* A selector to restrict the list of returned objects by their fields. Defaults to everything.
*/
public DeleteCollectionNamespacedRoleBindingRestriction fieldSelector(String fieldSelector) {
put("fieldSelector", fieldSelector);
return this;
}
/**
* A selector to restrict the list of returned objects by their labels. Defaults to everything.
*/
public DeleteCollectionNamespacedRoleBindingRestriction 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 DeleteCollectionNamespacedRoleBindingRestriction 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 DeleteCollectionNamespacedRoleBindingRestriction 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 DeleteCollectionNamespacedRoleBindingRestriction 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 DeleteCollectionNamespacedRoleBindingRestriction watch(Boolean watch) {
put("watch", watch);
return this;
}
}
/**
* list objects of kind RoleBindingRestriction
*
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "GET",
path = "/apis/authorization.openshift.io/v1/namespaces/{namespace}/rolebindingrestrictions"
)
@Headers({
"Accept: */*"
})
KubernetesListCall listNamespacedRoleBindingRestriction(
@Path("namespace") String namespace);
/**
* list objects of kind RoleBindingRestriction
*
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "GET",
path = "/apis/authorization.openshift.io/v1/namespaces/{namespace}/rolebindingrestrictions"
)
@Headers({
"Accept: */*"
})
KubernetesListCall listNamespacedRoleBindingRestriction(
@Path("namespace") String namespace,
@QueryMap ListNamespacedRoleBindingRestriction queryParameters);
final class ListNamespacedRoleBindingRestriction extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ListNamespacedRoleBindingRestriction 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 ListNamespacedRoleBindingRestriction 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 ListNamespacedRoleBindingRestriction continues(String continues) {
put("continue", continues);
return this;
}
/**
* A selector to restrict the list of returned objects by their fields. Defaults to everything.
*/
public ListNamespacedRoleBindingRestriction fieldSelector(String fieldSelector) {
put("fieldSelector", fieldSelector);
return this;
}
/**
* A selector to restrict the list of returned objects by their labels. Defaults to everything.
*/
public ListNamespacedRoleBindingRestriction 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 ListNamespacedRoleBindingRestriction 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 ListNamespacedRoleBindingRestriction 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 ListNamespacedRoleBindingRestriction 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 ListNamespacedRoleBindingRestriction watch(Boolean watch) {
put("watch", watch);
return this;
}
}
/**
* create a RoleBindingRestriction
*
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "POST",
path = "/apis/authorization.openshift.io/v1/namespaces/{namespace}/rolebindingrestrictions",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall createNamespacedRoleBindingRestriction(
@Path("namespace") String namespace,
@Body RoleBindingRestriction body);
/**
* create a RoleBindingRestriction
*
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "POST",
path = "/apis/authorization.openshift.io/v1/namespaces/{namespace}/rolebindingrestrictions",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall createNamespacedRoleBindingRestriction(
@Path("namespace") String namespace,
@Body RoleBindingRestriction body,
@QueryMap CreateNamespacedRoleBindingRestriction queryParameters);
final class CreateNamespacedRoleBindingRestriction extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public CreateNamespacedRoleBindingRestriction 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 CreateNamespacedRoleBindingRestriction 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 CreateNamespacedRoleBindingRestriction fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* delete a RoleBindingRestriction
*
* @param name name of the RoleBindingRestriction
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "DELETE",
path = "/apis/authorization.openshift.io/v1/namespaces/{namespace}/rolebindingrestrictions/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteNamespacedRoleBindingRestriction(
@Path("name") String name,
@Path("namespace") String namespace,
@Body DeleteOptions body);
/**
* delete a RoleBindingRestriction
*
* @param name name of the RoleBindingRestriction
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "DELETE",
path = "/apis/authorization.openshift.io/v1/namespaces/{namespace}/rolebindingrestrictions/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteNamespacedRoleBindingRestriction(
@Path("name") String name,
@Path("namespace") String namespace);
/**
* delete a RoleBindingRestriction
*
* @param name name of the RoleBindingRestriction
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "DELETE",
path = "/apis/authorization.openshift.io/v1/namespaces/{namespace}/rolebindingrestrictions/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteNamespacedRoleBindingRestriction(
@Path("name") String name,
@Path("namespace") String namespace,
@Body DeleteOptions body,
@QueryMap DeleteNamespacedRoleBindingRestriction queryParameters);
/**
* delete a RoleBindingRestriction
*
* @param name name of the RoleBindingRestriction
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "DELETE",
path = "/apis/authorization.openshift.io/v1/namespaces/{namespace}/rolebindingrestrictions/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteNamespacedRoleBindingRestriction(
@Path("name") String name,
@Path("namespace") String namespace,
@QueryMap DeleteNamespacedRoleBindingRestriction queryParameters);
final class DeleteNamespacedRoleBindingRestriction extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public DeleteNamespacedRoleBindingRestriction 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 DeleteNamespacedRoleBindingRestriction 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 DeleteNamespacedRoleBindingRestriction 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 DeleteNamespacedRoleBindingRestriction 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 DeleteNamespacedRoleBindingRestriction propagationPolicy(String propagationPolicy) {
put("propagationPolicy", propagationPolicy);
return this;
}
}
/**
* read the specified RoleBindingRestriction
*
* @param name name of the RoleBindingRestriction
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "GET",
path = "/apis/authorization.openshift.io/v1/namespaces/{namespace}/rolebindingrestrictions/{name}"
)
@Headers({
"Accept: */*"
})
KubernetesCall readNamespacedRoleBindingRestriction(
@Path("name") String name,
@Path("namespace") String namespace);
/**
* read the specified RoleBindingRestriction
*
* @param name name of the RoleBindingRestriction
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "GET",
path = "/apis/authorization.openshift.io/v1/namespaces/{namespace}/rolebindingrestrictions/{name}"
)
@Headers({
"Accept: */*"
})
KubernetesCall readNamespacedRoleBindingRestriction(
@Path("name") String name,
@Path("namespace") String namespace,
@QueryMap ReadNamespacedRoleBindingRestriction queryParameters);
final class ReadNamespacedRoleBindingRestriction extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReadNamespacedRoleBindingRestriction 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 ReadNamespacedRoleBindingRestriction resourceVersion(String resourceVersion) {
put("resourceVersion", resourceVersion);
return this;
}
}
/**
* partially update the specified RoleBindingRestriction
*
* @param name name of the RoleBindingRestriction
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "PATCH",
path = "/apis/authorization.openshift.io/v1/namespaces/{namespace}/rolebindingrestrictions/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchNamespacedRoleBindingRestriction(
@Path("name") String name,
@Path("namespace") String namespace,
@Body RoleBindingRestriction body);
/**
* partially update the specified RoleBindingRestriction
*
* @param name name of the RoleBindingRestriction
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "PATCH",
path = "/apis/authorization.openshift.io/v1/namespaces/{namespace}/rolebindingrestrictions/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchNamespacedRoleBindingRestriction(
@Path("name") String name,
@Path("namespace") String namespace,
@Body RoleBindingRestriction body,
@QueryMap PatchNamespacedRoleBindingRestriction queryParameters);
final class PatchNamespacedRoleBindingRestriction extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public PatchNamespacedRoleBindingRestriction 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 PatchNamespacedRoleBindingRestriction 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 PatchNamespacedRoleBindingRestriction fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* replace the specified RoleBindingRestriction
*
* @param name name of the RoleBindingRestriction
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "PUT",
path = "/apis/authorization.openshift.io/v1/namespaces/{namespace}/rolebindingrestrictions/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replaceNamespacedRoleBindingRestriction(
@Path("name") String name,
@Path("namespace") String namespace,
@Body RoleBindingRestriction body);
/**
* replace the specified RoleBindingRestriction
*
* @param name name of the RoleBindingRestriction
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "PUT",
path = "/apis/authorization.openshift.io/v1/namespaces/{namespace}/rolebindingrestrictions/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replaceNamespacedRoleBindingRestriction(
@Path("name") String name,
@Path("namespace") String namespace,
@Body RoleBindingRestriction body,
@QueryMap ReplaceNamespacedRoleBindingRestriction queryParameters);
final class ReplaceNamespacedRoleBindingRestriction extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReplaceNamespacedRoleBindingRestriction 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 ReplaceNamespacedRoleBindingRestriction 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 ReplaceNamespacedRoleBindingRestriction fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* list objects of kind RoleBinding
*
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "GET",
path = "/apis/authorization.openshift.io/v1/namespaces/{namespace}/rolebindings"
)
@Headers({
"Accept: */*"
})
KubernetesListCall listNamespacedRoleBinding(
@Path("namespace") String namespace);
/**
* list objects of kind RoleBinding
*
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "GET",
path = "/apis/authorization.openshift.io/v1/namespaces/{namespace}/rolebindings"
)
@Headers({
"Accept: */*"
})
KubernetesListCall listNamespacedRoleBinding(
@Path("namespace") String namespace,
@QueryMap ListNamespacedRoleBinding queryParameters);
final class ListNamespacedRoleBinding extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ListNamespacedRoleBinding 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 ListNamespacedRoleBinding 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 ListNamespacedRoleBinding continues(String continues) {
put("continue", continues);
return this;
}
/**
* A selector to restrict the list of returned objects by their fields. Defaults to everything.
*/
public ListNamespacedRoleBinding fieldSelector(String fieldSelector) {
put("fieldSelector", fieldSelector);
return this;
}
/**
* A selector to restrict the list of returned objects by their labels. Defaults to everything.
*/
public ListNamespacedRoleBinding 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 ListNamespacedRoleBinding 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 ListNamespacedRoleBinding 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 ListNamespacedRoleBinding 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 ListNamespacedRoleBinding watch(Boolean watch) {
put("watch", watch);
return this;
}
}
/**
* create a RoleBinding
*
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "POST",
path = "/apis/authorization.openshift.io/v1/namespaces/{namespace}/rolebindings",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall createNamespacedRoleBinding(
@Path("namespace") String namespace,
@Body RoleBinding body);
/**
* create a RoleBinding
*
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "POST",
path = "/apis/authorization.openshift.io/v1/namespaces/{namespace}/rolebindings",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall createNamespacedRoleBinding(
@Path("namespace") String namespace,
@Body RoleBinding body,
@QueryMap CreateNamespacedRoleBinding queryParameters);
final class CreateNamespacedRoleBinding extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public CreateNamespacedRoleBinding 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 CreateNamespacedRoleBinding 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 CreateNamespacedRoleBinding fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* delete a RoleBinding
*
* @param name name of the RoleBinding
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "DELETE",
path = "/apis/authorization.openshift.io/v1/namespaces/{namespace}/rolebindings/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteNamespacedRoleBinding(
@Path("name") String name,
@Path("namespace") String namespace,
@Body DeleteOptions body);
/**
* delete a RoleBinding
*
* @param name name of the RoleBinding
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "DELETE",
path = "/apis/authorization.openshift.io/v1/namespaces/{namespace}/rolebindings/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteNamespacedRoleBinding(
@Path("name") String name,
@Path("namespace") String namespace);
/**
* delete a RoleBinding
*
* @param name name of the RoleBinding
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "DELETE",
path = "/apis/authorization.openshift.io/v1/namespaces/{namespace}/rolebindings/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteNamespacedRoleBinding(
@Path("name") String name,
@Path("namespace") String namespace,
@Body DeleteOptions body,
@QueryMap DeleteNamespacedRoleBinding queryParameters);
/**
* delete a RoleBinding
*
* @param name name of the RoleBinding
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "DELETE",
path = "/apis/authorization.openshift.io/v1/namespaces/{namespace}/rolebindings/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteNamespacedRoleBinding(
@Path("name") String name,
@Path("namespace") String namespace,
@QueryMap DeleteNamespacedRoleBinding queryParameters);
final class DeleteNamespacedRoleBinding extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public DeleteNamespacedRoleBinding 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 DeleteNamespacedRoleBinding 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 DeleteNamespacedRoleBinding 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 DeleteNamespacedRoleBinding 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 DeleteNamespacedRoleBinding propagationPolicy(String propagationPolicy) {
put("propagationPolicy", propagationPolicy);
return this;
}
}
/**
* read the specified RoleBinding
*
* @param name name of the RoleBinding
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "GET",
path = "/apis/authorization.openshift.io/v1/namespaces/{namespace}/rolebindings/{name}"
)
@Headers({
"Accept: */*"
})
KubernetesCall readNamespacedRoleBinding(
@Path("name") String name,
@Path("namespace") String namespace);
/**
* read the specified RoleBinding
*
* @param name name of the RoleBinding
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "GET",
path = "/apis/authorization.openshift.io/v1/namespaces/{namespace}/rolebindings/{name}"
)
@Headers({
"Accept: */*"
})
KubernetesCall readNamespacedRoleBinding(
@Path("name") String name,
@Path("namespace") String namespace,
@QueryMap ReadNamespacedRoleBinding queryParameters);
final class ReadNamespacedRoleBinding extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReadNamespacedRoleBinding pretty(String pretty) {
put("pretty", pretty);
return this;
}
}
/**
* partially update the specified RoleBinding
*
* @param name name of the RoleBinding
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "PATCH",
path = "/apis/authorization.openshift.io/v1/namespaces/{namespace}/rolebindings/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchNamespacedRoleBinding(
@Path("name") String name,
@Path("namespace") String namespace,
@Body RoleBinding body);
/**
* partially update the specified RoleBinding
*
* @param name name of the RoleBinding
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "PATCH",
path = "/apis/authorization.openshift.io/v1/namespaces/{namespace}/rolebindings/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchNamespacedRoleBinding(
@Path("name") String name,
@Path("namespace") String namespace,
@Body RoleBinding body,
@QueryMap PatchNamespacedRoleBinding queryParameters);
final class PatchNamespacedRoleBinding extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public PatchNamespacedRoleBinding 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 PatchNamespacedRoleBinding 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. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).
*/
public PatchNamespacedRoleBinding fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
/**
* Force is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.
*/
public PatchNamespacedRoleBinding force(Boolean force) {
put("force", force);
return this;
}
}
/**
* replace the specified RoleBinding
*
* @param name name of the RoleBinding
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "PUT",
path = "/apis/authorization.openshift.io/v1/namespaces/{namespace}/rolebindings/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replaceNamespacedRoleBinding(
@Path("name") String name,
@Path("namespace") String namespace,
@Body RoleBinding body);
/**
* replace the specified RoleBinding
*
* @param name name of the RoleBinding
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "PUT",
path = "/apis/authorization.openshift.io/v1/namespaces/{namespace}/rolebindings/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replaceNamespacedRoleBinding(
@Path("name") String name,
@Path("namespace") String namespace,
@Body RoleBinding body,
@QueryMap ReplaceNamespacedRoleBinding queryParameters);
final class ReplaceNamespacedRoleBinding extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReplaceNamespacedRoleBinding 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 ReplaceNamespacedRoleBinding 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 ReplaceNamespacedRoleBinding fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* list objects of kind Role
*
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "GET",
path = "/apis/authorization.openshift.io/v1/namespaces/{namespace}/roles"
)
@Headers({
"Accept: */*"
})
KubernetesListCall listNamespacedRole(
@Path("namespace") String namespace);
/**
* list objects of kind Role
*
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "GET",
path = "/apis/authorization.openshift.io/v1/namespaces/{namespace}/roles"
)
@Headers({
"Accept: */*"
})
KubernetesListCall listNamespacedRole(
@Path("namespace") String namespace,
@QueryMap ListNamespacedRole queryParameters);
final class ListNamespacedRole extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ListNamespacedRole 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 ListNamespacedRole 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 ListNamespacedRole continues(String continues) {
put("continue", continues);
return this;
}
/**
* A selector to restrict the list of returned objects by their fields. Defaults to everything.
*/
public ListNamespacedRole fieldSelector(String fieldSelector) {
put("fieldSelector", fieldSelector);
return this;
}
/**
* A selector to restrict the list of returned objects by their labels. Defaults to everything.
*/
public ListNamespacedRole 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 ListNamespacedRole 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 ListNamespacedRole 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 ListNamespacedRole 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 ListNamespacedRole watch(Boolean watch) {
put("watch", watch);
return this;
}
}
/**
* create a Role
*
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "POST",
path = "/apis/authorization.openshift.io/v1/namespaces/{namespace}/roles",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall createNamespacedRole(
@Path("namespace") String namespace,
@Body Role body);
/**
* create a Role
*
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "POST",
path = "/apis/authorization.openshift.io/v1/namespaces/{namespace}/roles",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall createNamespacedRole(
@Path("namespace") String namespace,
@Body Role body,
@QueryMap CreateNamespacedRole queryParameters);
final class CreateNamespacedRole extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public CreateNamespacedRole 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 CreateNamespacedRole 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 CreateNamespacedRole fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* delete a Role
*
* @param name name of the Role
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "DELETE",
path = "/apis/authorization.openshift.io/v1/namespaces/{namespace}/roles/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteNamespacedRole(
@Path("name") String name,
@Path("namespace") String namespace,
@Body DeleteOptions body);
/**
* delete a Role
*
* @param name name of the Role
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "DELETE",
path = "/apis/authorization.openshift.io/v1/namespaces/{namespace}/roles/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteNamespacedRole(
@Path("name") String name,
@Path("namespace") String namespace);
/**
* delete a Role
*
* @param name name of the Role
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "DELETE",
path = "/apis/authorization.openshift.io/v1/namespaces/{namespace}/roles/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteNamespacedRole(
@Path("name") String name,
@Path("namespace") String namespace,
@Body DeleteOptions body,
@QueryMap DeleteNamespacedRole queryParameters);
/**
* delete a Role
*
* @param name name of the Role
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "DELETE",
path = "/apis/authorization.openshift.io/v1/namespaces/{namespace}/roles/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteNamespacedRole(
@Path("name") String name,
@Path("namespace") String namespace,
@QueryMap DeleteNamespacedRole queryParameters);
final class DeleteNamespacedRole extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public DeleteNamespacedRole 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 DeleteNamespacedRole 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 DeleteNamespacedRole 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 DeleteNamespacedRole 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 DeleteNamespacedRole propagationPolicy(String propagationPolicy) {
put("propagationPolicy", propagationPolicy);
return this;
}
}
/**
* read the specified Role
*
* @param name name of the Role
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "GET",
path = "/apis/authorization.openshift.io/v1/namespaces/{namespace}/roles/{name}"
)
@Headers({
"Accept: */*"
})
KubernetesCall readNamespacedRole(
@Path("name") String name,
@Path("namespace") String namespace);
/**
* read the specified Role
*
* @param name name of the Role
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "GET",
path = "/apis/authorization.openshift.io/v1/namespaces/{namespace}/roles/{name}"
)
@Headers({
"Accept: */*"
})
KubernetesCall readNamespacedRole(
@Path("name") String name,
@Path("namespace") String namespace,
@QueryMap ReadNamespacedRole queryParameters);
final class ReadNamespacedRole extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReadNamespacedRole pretty(String pretty) {
put("pretty", pretty);
return this;
}
}
/**
* partially update the specified Role
*
* @param name name of the Role
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "PATCH",
path = "/apis/authorization.openshift.io/v1/namespaces/{namespace}/roles/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchNamespacedRole(
@Path("name") String name,
@Path("namespace") String namespace,
@Body Role body);
/**
* partially update the specified Role
*
* @param name name of the Role
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "PATCH",
path = "/apis/authorization.openshift.io/v1/namespaces/{namespace}/roles/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchNamespacedRole(
@Path("name") String name,
@Path("namespace") String namespace,
@Body Role body,
@QueryMap PatchNamespacedRole queryParameters);
final class PatchNamespacedRole extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public PatchNamespacedRole 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 PatchNamespacedRole 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. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).
*/
public PatchNamespacedRole fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
/**
* Force is going to "force" Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.
*/
public PatchNamespacedRole force(Boolean force) {
put("force", force);
return this;
}
}
/**
* replace the specified Role
*
* @param name name of the Role
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "PUT",
path = "/apis/authorization.openshift.io/v1/namespaces/{namespace}/roles/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replaceNamespacedRole(
@Path("name") String name,
@Path("namespace") String namespace,
@Body Role body);
/**
* replace the specified Role
*
* @param name name of the Role
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "PUT",
path = "/apis/authorization.openshift.io/v1/namespaces/{namespace}/roles/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replaceNamespacedRole(
@Path("name") String name,
@Path("namespace") String namespace,
@Body Role body,
@QueryMap ReplaceNamespacedRole queryParameters);
final class ReplaceNamespacedRole extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReplaceNamespacedRole 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 ReplaceNamespacedRole 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 ReplaceNamespacedRole fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* create a SelfSubjectRulesReview
*
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "POST",
path = "/apis/authorization.openshift.io/v1/namespaces/{namespace}/selfsubjectrulesreviews",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall createNamespacedSelfSubjectRulesReview(
@Path("namespace") String namespace,
@Body SelfSubjectRulesReview body);
/**
* create a SelfSubjectRulesReview
*
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "POST",
path = "/apis/authorization.openshift.io/v1/namespaces/{namespace}/selfsubjectrulesreviews",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall createNamespacedSelfSubjectRulesReview(
@Path("namespace") String namespace,
@Body SelfSubjectRulesReview body,
@QueryMap CreateNamespacedSelfSubjectRulesReview queryParameters);
final class CreateNamespacedSelfSubjectRulesReview extends HashMap {
/**
* 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 CreateNamespacedSelfSubjectRulesReview 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 CreateNamespacedSelfSubjectRulesReview fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
/**
* If 'true', then the output is pretty printed.
*/
public CreateNamespacedSelfSubjectRulesReview pretty(String pretty) {
put("pretty", pretty);
return this;
}
}
/**
* create a SubjectRulesReview
*
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "POST",
path = "/apis/authorization.openshift.io/v1/namespaces/{namespace}/subjectrulesreviews",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall createNamespacedSubjectRulesReview(
@Path("namespace") String namespace,
@Body SubjectRulesReview body);
/**
* create a SubjectRulesReview
*
* @param namespace object name and auth scope, such as for teams and projects
*/
@HTTP(
method = "POST",
path = "/apis/authorization.openshift.io/v1/namespaces/{namespace}/subjectrulesreviews",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall createNamespacedSubjectRulesReview(
@Path("namespace") String namespace,
@Body SubjectRulesReview body,
@QueryMap CreateNamespacedSubjectRulesReview queryParameters);
final class CreateNamespacedSubjectRulesReview extends HashMap {
/**
* 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 CreateNamespacedSubjectRulesReview 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 CreateNamespacedSubjectRulesReview fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
/**
* If 'true', then the output is pretty printed.
*/
public CreateNamespacedSubjectRulesReview pretty(String pretty) {
put("pretty", pretty);
return this;
}
}
/**
* create a ResourceAccessReview
*/
@HTTP(
method = "POST",
path = "/apis/authorization.openshift.io/v1/resourceaccessreviews",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall createResourceAccessReview(
@Body ResourceAccessReview body);
/**
* create a ResourceAccessReview
*/
@HTTP(
method = "POST",
path = "/apis/authorization.openshift.io/v1/resourceaccessreviews",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall createResourceAccessReview(
@Body ResourceAccessReview body,
@QueryMap CreateResourceAccessReview queryParameters);
final class CreateResourceAccessReview extends HashMap {
/**
* 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 CreateResourceAccessReview 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 CreateResourceAccessReview fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
/**
* If 'true', then the output is pretty printed.
*/
public CreateResourceAccessReview pretty(String pretty) {
put("pretty", pretty);
return this;
}
}
/**
* list objects of kind RoleBindingRestriction
*/
@HTTP(
method = "GET",
path = "/apis/authorization.openshift.io/v1/rolebindingrestrictions"
)
@Headers({
"Accept: */*"
})
KubernetesListCall listRoleBindingRestrictionForAllNamespaces();
/**
* list objects of kind RoleBindingRestriction
*/
@HTTP(
method = "GET",
path = "/apis/authorization.openshift.io/v1/rolebindingrestrictions"
)
@Headers({
"Accept: */*"
})
KubernetesListCall listRoleBindingRestrictionForAllNamespaces(
@QueryMap ListRoleBindingRestrictionForAllNamespaces queryParameters);
final class ListRoleBindingRestrictionForAllNamespaces extends HashMap {
/**
* allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. If the feature gate WatchBookmarks is not enabled in apiserver, this field is ignored.
*/
public ListRoleBindingRestrictionForAllNamespaces 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 ListRoleBindingRestrictionForAllNamespaces continues(String continues) {
put("continue", continues);
return this;
}
/**
* A selector to restrict the list of returned objects by their fields. Defaults to everything.
*/
public ListRoleBindingRestrictionForAllNamespaces fieldSelector(String fieldSelector) {
put("fieldSelector", fieldSelector);
return this;
}
/**
* A selector to restrict the list of returned objects by their labels. Defaults to everything.
*/
public ListRoleBindingRestrictionForAllNamespaces 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 ListRoleBindingRestrictionForAllNamespaces limit(Number limit) {
put("limit", limit);
return this;
}
/**
* If 'true', then the output is pretty printed.
*/
public ListRoleBindingRestrictionForAllNamespaces pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* When specified with a watch call, shows changes that occur after that particular version of a resource. Defaults to changes from the beginning of history. When specified for list: - if unset, then the result is returned from remote storage based on quorum-read flag; - if it's 0, then we simply return what we currently have in cache, no guarantee; - if set to non zero, then the result is at least as fresh as given rv.
*/
public ListRoleBindingRestrictionForAllNamespaces 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 ListRoleBindingRestrictionForAllNamespaces 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 ListRoleBindingRestrictionForAllNamespaces watch(Boolean watch) {
put("watch", watch);
return this;
}
}
/**
* list objects of kind RoleBinding
*/
@HTTP(
method = "GET",
path = "/apis/authorization.openshift.io/v1/rolebindings"
)
@Headers({
"Accept: */*"
})
KubernetesListCall listRoleBindingForAllNamespaces();
/**
* list objects of kind RoleBinding
*/
@HTTP(
method = "GET",
path = "/apis/authorization.openshift.io/v1/rolebindings"
)
@Headers({
"Accept: */*"
})
KubernetesListCall listRoleBindingForAllNamespaces(
@QueryMap ListRoleBindingForAllNamespaces queryParameters);
final class ListRoleBindingForAllNamespaces extends HashMap {
/**
* allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. If the feature gate WatchBookmarks is not enabled in apiserver, this field is ignored.
*/
public ListRoleBindingForAllNamespaces 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 ListRoleBindingForAllNamespaces continues(String continues) {
put("continue", continues);
return this;
}
/**
* A selector to restrict the list of returned objects by their fields. Defaults to everything.
*/
public ListRoleBindingForAllNamespaces fieldSelector(String fieldSelector) {
put("fieldSelector", fieldSelector);
return this;
}
/**
* A selector to restrict the list of returned objects by their labels. Defaults to everything.
*/
public ListRoleBindingForAllNamespaces 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 ListRoleBindingForAllNamespaces limit(Number limit) {
put("limit", limit);
return this;
}
/**
* If 'true', then the output is pretty printed.
*/
public ListRoleBindingForAllNamespaces pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* When specified with a watch call, shows changes that occur after that particular version of a resource. Defaults to changes from the beginning of history. When specified for list: - if unset, then the result is returned from remote storage based on quorum-read flag; - if it's 0, then we simply return what we currently have in cache, no guarantee; - if set to non zero, then the result is at least as fresh as given rv.
*/
public ListRoleBindingForAllNamespaces 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 ListRoleBindingForAllNamespaces 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 ListRoleBindingForAllNamespaces watch(Boolean watch) {
put("watch", watch);
return this;
}
}
/**
* list objects of kind Role
*/
@HTTP(
method = "GET",
path = "/apis/authorization.openshift.io/v1/roles"
)
@Headers({
"Accept: */*"
})
KubernetesListCall listRoleForAllNamespaces();
/**
* list objects of kind Role
*/
@HTTP(
method = "GET",
path = "/apis/authorization.openshift.io/v1/roles"
)
@Headers({
"Accept: */*"
})
KubernetesListCall listRoleForAllNamespaces(
@QueryMap ListRoleForAllNamespaces queryParameters);
final class ListRoleForAllNamespaces extends HashMap {
/**
* allowWatchBookmarks requests watch events with type "BOOKMARK". Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server's discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored. If the feature gate WatchBookmarks is not enabled in apiserver, this field is ignored.
*/
public ListRoleForAllNamespaces 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 ListRoleForAllNamespaces continues(String continues) {
put("continue", continues);
return this;
}
/**
* A selector to restrict the list of returned objects by their fields. Defaults to everything.
*/
public ListRoleForAllNamespaces fieldSelector(String fieldSelector) {
put("fieldSelector", fieldSelector);
return this;
}
/**
* A selector to restrict the list of returned objects by their labels. Defaults to everything.
*/
public ListRoleForAllNamespaces 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 ListRoleForAllNamespaces limit(Number limit) {
put("limit", limit);
return this;
}
/**
* If 'true', then the output is pretty printed.
*/
public ListRoleForAllNamespaces pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* When specified with a watch call, shows changes that occur after that particular version of a resource. Defaults to changes from the beginning of history. When specified for list: - if unset, then the result is returned from remote storage based on quorum-read flag; - if it's 0, then we simply return what we currently have in cache, no guarantee; - if set to non zero, then the result is at least as fresh as given rv.
*/
public ListRoleForAllNamespaces 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 ListRoleForAllNamespaces 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 ListRoleForAllNamespaces watch(Boolean watch) {
put("watch", watch);
return this;
}
}
/**
* create a SubjectAccessReview
*/
@HTTP(
method = "POST",
path = "/apis/authorization.openshift.io/v1/subjectaccessreviews",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall createSubjectAccessReview(
@Body SubjectAccessReview body);
/**
* create a SubjectAccessReview
*/
@HTTP(
method = "POST",
path = "/apis/authorization.openshift.io/v1/subjectaccessreviews",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall createSubjectAccessReview(
@Body SubjectAccessReview body,
@QueryMap CreateSubjectAccessReview queryParameters);
final class CreateSubjectAccessReview extends HashMap {
/**
* 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 CreateSubjectAccessReview 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 CreateSubjectAccessReview fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
/**
* If 'true', then the output is pretty printed.
*/
public CreateSubjectAccessReview pretty(String pretty) {
put("pretty", pretty);
return this;
}
}
}