com.marcnuri.yakc.api.flowcontrolapiserver.v1alpha1.FlowcontrolApiserverV1alpha1Api Maven / Gradle / Ivy
Show all versions of kubernetes-api 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.flowcontrolapiserver.v1alpha1;
import com.marcnuri.yakc.api.Api;
import com.marcnuri.yakc.api.KubernetesCall;
import com.marcnuri.yakc.api.KubernetesListCall;
import com.marcnuri.yakc.model.io.k8s.api.flowcontrol.v1alpha1.FlowSchema;
import com.marcnuri.yakc.model.io.k8s.api.flowcontrol.v1alpha1.FlowSchemaList;
import com.marcnuri.yakc.model.io.k8s.api.flowcontrol.v1alpha1.PriorityLevelConfiguration;
import com.marcnuri.yakc.model.io.k8s.api.flowcontrol.v1alpha1.PriorityLevelConfigurationList;
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.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent;
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 FlowcontrolApiserverV1alpha1Api extends Api {
/**
* get available resources
*/
@HTTP(
method = "GET",
path = "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/"
)
@Headers({
"Accept: */*"
})
KubernetesCall getAPIResources();
/**
* delete collection of FlowSchema
*/
@HTTP(
method = "DELETE",
path = "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/flowschemas",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteCollectionFlowSchema(
@Body DeleteOptions body);
/**
* delete collection of FlowSchema
*/
@HTTP(
method = "DELETE",
path = "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/flowschemas",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteCollectionFlowSchema();
/**
* delete collection of FlowSchema
*/
@HTTP(
method = "DELETE",
path = "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/flowschemas",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteCollectionFlowSchema(
@Body DeleteOptions body,
@QueryMap DeleteCollectionFlowSchema queryParameters);
/**
* delete collection of FlowSchema
*/
@HTTP(
method = "DELETE",
path = "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/flowschemas",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteCollectionFlowSchema(
@QueryMap DeleteCollectionFlowSchema queryParameters);
final class DeleteCollectionFlowSchema extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public DeleteCollectionFlowSchema 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 DeleteCollectionFlowSchema 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 DeleteCollectionFlowSchema continues(String continues) {
put("continue", continues);
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 DeleteCollectionFlowSchema dryRun(String dryRun) {
put("dryRun", dryRun);
return this;
}
/**
* A selector to restrict the list of returned objects by their fields. Defaults to everything.
*/
public DeleteCollectionFlowSchema fieldSelector(String fieldSelector) {
put("fieldSelector", fieldSelector);
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 DeleteCollectionFlowSchema gracePeriodSeconds(Integer gracePeriodSeconds) {
put("gracePeriodSeconds", gracePeriodSeconds);
return this;
}
/**
* A selector to restrict the list of returned objects by their labels. Defaults to everything.
*/
public DeleteCollectionFlowSchema 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 DeleteCollectionFlowSchema limit(Integer limit) {
put("limit", limit);
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 DeleteCollectionFlowSchema 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 DeleteCollectionFlowSchema propagationPolicy(String propagationPolicy) {
put("propagationPolicy", propagationPolicy);
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 DeleteCollectionFlowSchema 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 DeleteCollectionFlowSchema timeoutSeconds(Integer 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 DeleteCollectionFlowSchema watch(Boolean watch) {
put("watch", watch);
return this;
}
}
/**
* list or watch objects of kind FlowSchema
*/
@HTTP(
method = "GET",
path = "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/flowschemas"
)
@Headers({
"Accept: */*"
})
KubernetesListCall listFlowSchema();
/**
* list or watch objects of kind FlowSchema
*/
@HTTP(
method = "GET",
path = "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/flowschemas"
)
@Headers({
"Accept: */*"
})
KubernetesListCall listFlowSchema(
@QueryMap ListFlowSchema queryParameters);
final class ListFlowSchema extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ListFlowSchema 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 ListFlowSchema 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 ListFlowSchema continues(String continues) {
put("continue", continues);
return this;
}
/**
* A selector to restrict the list of returned objects by their fields. Defaults to everything.
*/
public ListFlowSchema fieldSelector(String fieldSelector) {
put("fieldSelector", fieldSelector);
return this;
}
/**
* A selector to restrict the list of returned objects by their labels. Defaults to everything.
*/
public ListFlowSchema 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 ListFlowSchema limit(Integer 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 ListFlowSchema 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 ListFlowSchema timeoutSeconds(Integer 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 ListFlowSchema watch(Boolean watch) {
put("watch", watch);
return this;
}
}
/**
* create a FlowSchema
*/
@HTTP(
method = "POST",
path = "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/flowschemas",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall createFlowSchema(
@Body FlowSchema body);
/**
* create a FlowSchema
*/
@HTTP(
method = "POST",
path = "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/flowschemas",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall createFlowSchema(
@Body FlowSchema body,
@QueryMap CreateFlowSchema queryParameters);
final class CreateFlowSchema extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public CreateFlowSchema 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 CreateFlowSchema 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 CreateFlowSchema fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* delete a FlowSchema
*
* @param name name of the FlowSchema
*/
@HTTP(
method = "DELETE",
path = "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/flowschemas/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteFlowSchema(
@Path("name") String name,
@Body DeleteOptions body);
/**
* delete a FlowSchema
*
* @param name name of the FlowSchema
*/
@HTTP(
method = "DELETE",
path = "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/flowschemas/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteFlowSchema(
@Path("name") String name);
/**
* delete a FlowSchema
*
* @param name name of the FlowSchema
*/
@HTTP(
method = "DELETE",
path = "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/flowschemas/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteFlowSchema(
@Path("name") String name,
@Body DeleteOptions body,
@QueryMap DeleteFlowSchema queryParameters);
/**
* delete a FlowSchema
*
* @param name name of the FlowSchema
*/
@HTTP(
method = "DELETE",
path = "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/flowschemas/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteFlowSchema(
@Path("name") String name,
@QueryMap DeleteFlowSchema queryParameters);
final class DeleteFlowSchema extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public DeleteFlowSchema 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 DeleteFlowSchema 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 DeleteFlowSchema gracePeriodSeconds(Integer 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 DeleteFlowSchema 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 DeleteFlowSchema propagationPolicy(String propagationPolicy) {
put("propagationPolicy", propagationPolicy);
return this;
}
}
/**
* read the specified FlowSchema
*
* @param name name of the FlowSchema
*/
@HTTP(
method = "GET",
path = "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/flowschemas/{name}"
)
@Headers({
"Accept: */*"
})
KubernetesCall readFlowSchema(
@Path("name") String name);
/**
* read the specified FlowSchema
*
* @param name name of the FlowSchema
*/
@HTTP(
method = "GET",
path = "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/flowschemas/{name}"
)
@Headers({
"Accept: */*"
})
KubernetesCall readFlowSchema(
@Path("name") String name,
@QueryMap ReadFlowSchema queryParameters);
final class ReadFlowSchema extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReadFlowSchema pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* Should the export be exact. Exact export maintains cluster-specific fields like 'Namespace'. Deprecated. Planned for removal in 1.18.
*/
public ReadFlowSchema exact(Boolean exact) {
put("exact", exact);
return this;
}
/**
* Should this value be exported. Export strips fields that a user can not specify. Deprecated. Planned for removal in 1.18.
*/
public ReadFlowSchema export(Boolean export) {
put("export", export);
return this;
}
}
/**
* partially update the specified FlowSchema
*
* @param name name of the FlowSchema
*/
@HTTP(
method = "PATCH",
path = "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/flowschemas/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchFlowSchema(
@Path("name") String name,
@Body FlowSchema body);
/**
* partially update the specified FlowSchema
*
* @param name name of the FlowSchema
*/
@HTTP(
method = "PATCH",
path = "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/flowschemas/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchFlowSchema(
@Path("name") String name,
@Body FlowSchema body,
@QueryMap PatchFlowSchema queryParameters);
final class PatchFlowSchema extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public PatchFlowSchema 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 PatchFlowSchema 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 PatchFlowSchema 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 PatchFlowSchema force(Boolean force) {
put("force", force);
return this;
}
}
/**
* replace the specified FlowSchema
*
* @param name name of the FlowSchema
*/
@HTTP(
method = "PUT",
path = "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/flowschemas/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replaceFlowSchema(
@Path("name") String name,
@Body FlowSchema body);
/**
* replace the specified FlowSchema
*
* @param name name of the FlowSchema
*/
@HTTP(
method = "PUT",
path = "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/flowschemas/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replaceFlowSchema(
@Path("name") String name,
@Body FlowSchema body,
@QueryMap ReplaceFlowSchema queryParameters);
final class ReplaceFlowSchema extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReplaceFlowSchema 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 ReplaceFlowSchema 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 ReplaceFlowSchema fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* read status of the specified FlowSchema
*
* @param name name of the FlowSchema
*/
@HTTP(
method = "GET",
path = "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/flowschemas/{name}/status"
)
@Headers({
"Accept: */*"
})
KubernetesCall readFlowSchemaStatus(
@Path("name") String name);
/**
* read status of the specified FlowSchema
*
* @param name name of the FlowSchema
*/
@HTTP(
method = "GET",
path = "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/flowschemas/{name}/status"
)
@Headers({
"Accept: */*"
})
KubernetesCall readFlowSchemaStatus(
@Path("name") String name,
@QueryMap ReadFlowSchemaStatus queryParameters);
final class ReadFlowSchemaStatus extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReadFlowSchemaStatus pretty(String pretty) {
put("pretty", pretty);
return this;
}
}
/**
* partially update status of the specified FlowSchema
*
* @param name name of the FlowSchema
*/
@HTTP(
method = "PATCH",
path = "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/flowschemas/{name}/status",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchFlowSchemaStatus(
@Path("name") String name,
@Body FlowSchema body);
/**
* partially update status of the specified FlowSchema
*
* @param name name of the FlowSchema
*/
@HTTP(
method = "PATCH",
path = "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/flowschemas/{name}/status",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchFlowSchemaStatus(
@Path("name") String name,
@Body FlowSchema body,
@QueryMap PatchFlowSchemaStatus queryParameters);
final class PatchFlowSchemaStatus extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public PatchFlowSchemaStatus 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 PatchFlowSchemaStatus 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 PatchFlowSchemaStatus 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 PatchFlowSchemaStatus force(Boolean force) {
put("force", force);
return this;
}
}
/**
* replace status of the specified FlowSchema
*
* @param name name of the FlowSchema
*/
@HTTP(
method = "PUT",
path = "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/flowschemas/{name}/status",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replaceFlowSchemaStatus(
@Path("name") String name,
@Body FlowSchema body);
/**
* replace status of the specified FlowSchema
*
* @param name name of the FlowSchema
*/
@HTTP(
method = "PUT",
path = "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/flowschemas/{name}/status",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replaceFlowSchemaStatus(
@Path("name") String name,
@Body FlowSchema body,
@QueryMap ReplaceFlowSchemaStatus queryParameters);
final class ReplaceFlowSchemaStatus extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReplaceFlowSchemaStatus 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 ReplaceFlowSchemaStatus 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 ReplaceFlowSchemaStatus fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* delete collection of PriorityLevelConfiguration
*/
@HTTP(
method = "DELETE",
path = "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/prioritylevelconfigurations",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteCollectionPriorityLevelConfiguration(
@Body DeleteOptions body);
/**
* delete collection of PriorityLevelConfiguration
*/
@HTTP(
method = "DELETE",
path = "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/prioritylevelconfigurations",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteCollectionPriorityLevelConfiguration();
/**
* delete collection of PriorityLevelConfiguration
*/
@HTTP(
method = "DELETE",
path = "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/prioritylevelconfigurations",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteCollectionPriorityLevelConfiguration(
@Body DeleteOptions body,
@QueryMap DeleteCollectionPriorityLevelConfiguration queryParameters);
/**
* delete collection of PriorityLevelConfiguration
*/
@HTTP(
method = "DELETE",
path = "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/prioritylevelconfigurations",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deleteCollectionPriorityLevelConfiguration(
@QueryMap DeleteCollectionPriorityLevelConfiguration queryParameters);
final class DeleteCollectionPriorityLevelConfiguration extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public DeleteCollectionPriorityLevelConfiguration 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 DeleteCollectionPriorityLevelConfiguration 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 DeleteCollectionPriorityLevelConfiguration continues(String continues) {
put("continue", continues);
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 DeleteCollectionPriorityLevelConfiguration dryRun(String dryRun) {
put("dryRun", dryRun);
return this;
}
/**
* A selector to restrict the list of returned objects by their fields. Defaults to everything.
*/
public DeleteCollectionPriorityLevelConfiguration fieldSelector(String fieldSelector) {
put("fieldSelector", fieldSelector);
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 DeleteCollectionPriorityLevelConfiguration gracePeriodSeconds(Integer gracePeriodSeconds) {
put("gracePeriodSeconds", gracePeriodSeconds);
return this;
}
/**
* A selector to restrict the list of returned objects by their labels. Defaults to everything.
*/
public DeleteCollectionPriorityLevelConfiguration 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 DeleteCollectionPriorityLevelConfiguration limit(Integer limit) {
put("limit", limit);
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 DeleteCollectionPriorityLevelConfiguration 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 DeleteCollectionPriorityLevelConfiguration propagationPolicy(String propagationPolicy) {
put("propagationPolicy", propagationPolicy);
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 DeleteCollectionPriorityLevelConfiguration 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 DeleteCollectionPriorityLevelConfiguration timeoutSeconds(Integer 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 DeleteCollectionPriorityLevelConfiguration watch(Boolean watch) {
put("watch", watch);
return this;
}
}
/**
* list or watch objects of kind PriorityLevelConfiguration
*/
@HTTP(
method = "GET",
path = "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/prioritylevelconfigurations"
)
@Headers({
"Accept: */*"
})
KubernetesListCall listPriorityLevelConfiguration();
/**
* list or watch objects of kind PriorityLevelConfiguration
*/
@HTTP(
method = "GET",
path = "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/prioritylevelconfigurations"
)
@Headers({
"Accept: */*"
})
KubernetesListCall listPriorityLevelConfiguration(
@QueryMap ListPriorityLevelConfiguration queryParameters);
final class ListPriorityLevelConfiguration extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ListPriorityLevelConfiguration 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 ListPriorityLevelConfiguration 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 ListPriorityLevelConfiguration continues(String continues) {
put("continue", continues);
return this;
}
/**
* A selector to restrict the list of returned objects by their fields. Defaults to everything.
*/
public ListPriorityLevelConfiguration fieldSelector(String fieldSelector) {
put("fieldSelector", fieldSelector);
return this;
}
/**
* A selector to restrict the list of returned objects by their labels. Defaults to everything.
*/
public ListPriorityLevelConfiguration 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 ListPriorityLevelConfiguration limit(Integer 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 ListPriorityLevelConfiguration 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 ListPriorityLevelConfiguration timeoutSeconds(Integer 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 ListPriorityLevelConfiguration watch(Boolean watch) {
put("watch", watch);
return this;
}
}
/**
* create a PriorityLevelConfiguration
*/
@HTTP(
method = "POST",
path = "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/prioritylevelconfigurations",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall createPriorityLevelConfiguration(
@Body PriorityLevelConfiguration body);
/**
* create a PriorityLevelConfiguration
*/
@HTTP(
method = "POST",
path = "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/prioritylevelconfigurations",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall createPriorityLevelConfiguration(
@Body PriorityLevelConfiguration body,
@QueryMap CreatePriorityLevelConfiguration queryParameters);
final class CreatePriorityLevelConfiguration extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public CreatePriorityLevelConfiguration 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 CreatePriorityLevelConfiguration 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 CreatePriorityLevelConfiguration fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* delete a PriorityLevelConfiguration
*
* @param name name of the PriorityLevelConfiguration
*/
@HTTP(
method = "DELETE",
path = "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/prioritylevelconfigurations/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deletePriorityLevelConfiguration(
@Path("name") String name,
@Body DeleteOptions body);
/**
* delete a PriorityLevelConfiguration
*
* @param name name of the PriorityLevelConfiguration
*/
@HTTP(
method = "DELETE",
path = "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/prioritylevelconfigurations/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deletePriorityLevelConfiguration(
@Path("name") String name);
/**
* delete a PriorityLevelConfiguration
*
* @param name name of the PriorityLevelConfiguration
*/
@HTTP(
method = "DELETE",
path = "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/prioritylevelconfigurations/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deletePriorityLevelConfiguration(
@Path("name") String name,
@Body DeleteOptions body,
@QueryMap DeletePriorityLevelConfiguration queryParameters);
/**
* delete a PriorityLevelConfiguration
*
* @param name name of the PriorityLevelConfiguration
*/
@HTTP(
method = "DELETE",
path = "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/prioritylevelconfigurations/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall deletePriorityLevelConfiguration(
@Path("name") String name,
@QueryMap DeletePriorityLevelConfiguration queryParameters);
final class DeletePriorityLevelConfiguration extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public DeletePriorityLevelConfiguration 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 DeletePriorityLevelConfiguration 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 DeletePriorityLevelConfiguration gracePeriodSeconds(Integer 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 DeletePriorityLevelConfiguration 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 DeletePriorityLevelConfiguration propagationPolicy(String propagationPolicy) {
put("propagationPolicy", propagationPolicy);
return this;
}
}
/**
* read the specified PriorityLevelConfiguration
*
* @param name name of the PriorityLevelConfiguration
*/
@HTTP(
method = "GET",
path = "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/prioritylevelconfigurations/{name}"
)
@Headers({
"Accept: */*"
})
KubernetesCall readPriorityLevelConfiguration(
@Path("name") String name);
/**
* read the specified PriorityLevelConfiguration
*
* @param name name of the PriorityLevelConfiguration
*/
@HTTP(
method = "GET",
path = "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/prioritylevelconfigurations/{name}"
)
@Headers({
"Accept: */*"
})
KubernetesCall readPriorityLevelConfiguration(
@Path("name") String name,
@QueryMap ReadPriorityLevelConfiguration queryParameters);
final class ReadPriorityLevelConfiguration extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReadPriorityLevelConfiguration pretty(String pretty) {
put("pretty", pretty);
return this;
}
/**
* Should the export be exact. Exact export maintains cluster-specific fields like 'Namespace'. Deprecated. Planned for removal in 1.18.
*/
public ReadPriorityLevelConfiguration exact(Boolean exact) {
put("exact", exact);
return this;
}
/**
* Should this value be exported. Export strips fields that a user can not specify. Deprecated. Planned for removal in 1.18.
*/
public ReadPriorityLevelConfiguration export(Boolean export) {
put("export", export);
return this;
}
}
/**
* partially update the specified PriorityLevelConfiguration
*
* @param name name of the PriorityLevelConfiguration
*/
@HTTP(
method = "PATCH",
path = "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/prioritylevelconfigurations/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchPriorityLevelConfiguration(
@Path("name") String name,
@Body PriorityLevelConfiguration body);
/**
* partially update the specified PriorityLevelConfiguration
*
* @param name name of the PriorityLevelConfiguration
*/
@HTTP(
method = "PATCH",
path = "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/prioritylevelconfigurations/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchPriorityLevelConfiguration(
@Path("name") String name,
@Body PriorityLevelConfiguration body,
@QueryMap PatchPriorityLevelConfiguration queryParameters);
final class PatchPriorityLevelConfiguration extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public PatchPriorityLevelConfiguration 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 PatchPriorityLevelConfiguration 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 PatchPriorityLevelConfiguration 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 PatchPriorityLevelConfiguration force(Boolean force) {
put("force", force);
return this;
}
}
/**
* replace the specified PriorityLevelConfiguration
*
* @param name name of the PriorityLevelConfiguration
*/
@HTTP(
method = "PUT",
path = "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/prioritylevelconfigurations/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replacePriorityLevelConfiguration(
@Path("name") String name,
@Body PriorityLevelConfiguration body);
/**
* replace the specified PriorityLevelConfiguration
*
* @param name name of the PriorityLevelConfiguration
*/
@HTTP(
method = "PUT",
path = "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/prioritylevelconfigurations/{name}",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replacePriorityLevelConfiguration(
@Path("name") String name,
@Body PriorityLevelConfiguration body,
@QueryMap ReplacePriorityLevelConfiguration queryParameters);
final class ReplacePriorityLevelConfiguration extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReplacePriorityLevelConfiguration 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 ReplacePriorityLevelConfiguration 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 ReplacePriorityLevelConfiguration fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* read status of the specified PriorityLevelConfiguration
*
* @param name name of the PriorityLevelConfiguration
*/
@HTTP(
method = "GET",
path = "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/prioritylevelconfigurations/{name}/status"
)
@Headers({
"Accept: */*"
})
KubernetesCall readPriorityLevelConfigurationStatus(
@Path("name") String name);
/**
* read status of the specified PriorityLevelConfiguration
*
* @param name name of the PriorityLevelConfiguration
*/
@HTTP(
method = "GET",
path = "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/prioritylevelconfigurations/{name}/status"
)
@Headers({
"Accept: */*"
})
KubernetesCall readPriorityLevelConfigurationStatus(
@Path("name") String name,
@QueryMap ReadPriorityLevelConfigurationStatus queryParameters);
final class ReadPriorityLevelConfigurationStatus extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReadPriorityLevelConfigurationStatus pretty(String pretty) {
put("pretty", pretty);
return this;
}
}
/**
* partially update status of the specified PriorityLevelConfiguration
*
* @param name name of the PriorityLevelConfiguration
*/
@HTTP(
method = "PATCH",
path = "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/prioritylevelconfigurations/{name}/status",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchPriorityLevelConfigurationStatus(
@Path("name") String name,
@Body PriorityLevelConfiguration body);
/**
* partially update status of the specified PriorityLevelConfiguration
*
* @param name name of the PriorityLevelConfiguration
*/
@HTTP(
method = "PATCH",
path = "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/prioritylevelconfigurations/{name}/status",
hasBody = true
)
@Headers({
"Content-Type: application/merge-patch+json",
"Accept: */*"
})
KubernetesCall patchPriorityLevelConfigurationStatus(
@Path("name") String name,
@Body PriorityLevelConfiguration body,
@QueryMap PatchPriorityLevelConfigurationStatus queryParameters);
final class PatchPriorityLevelConfigurationStatus extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public PatchPriorityLevelConfigurationStatus 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 PatchPriorityLevelConfigurationStatus 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 PatchPriorityLevelConfigurationStatus 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 PatchPriorityLevelConfigurationStatus force(Boolean force) {
put("force", force);
return this;
}
}
/**
* replace status of the specified PriorityLevelConfiguration
*
* @param name name of the PriorityLevelConfiguration
*/
@HTTP(
method = "PUT",
path = "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/prioritylevelconfigurations/{name}/status",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replacePriorityLevelConfigurationStatus(
@Path("name") String name,
@Body PriorityLevelConfiguration body);
/**
* replace status of the specified PriorityLevelConfiguration
*
* @param name name of the PriorityLevelConfiguration
*/
@HTTP(
method = "PUT",
path = "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/prioritylevelconfigurations/{name}/status",
hasBody = true
)
@Headers({
"Content-Type: application/json",
"Accept: */*"
})
KubernetesCall replacePriorityLevelConfigurationStatus(
@Path("name") String name,
@Body PriorityLevelConfiguration body,
@QueryMap ReplacePriorityLevelConfigurationStatus queryParameters);
final class ReplacePriorityLevelConfigurationStatus extends HashMap {
/**
* If 'true', then the output is pretty printed.
*/
public ReplacePriorityLevelConfigurationStatus 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 ReplacePriorityLevelConfigurationStatus 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 ReplacePriorityLevelConfigurationStatus fieldManager(String fieldManager) {
put("fieldManager", fieldManager);
return this;
}
}
/**
* watch individual changes to a list of FlowSchema. deprecated: use the 'watch' parameter with a list operation instead.
*/
@HTTP(
method = "GET",
path = "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/watch/flowschemas"
)
@Headers({
"Accept: */*"
})
KubernetesCall watchFlowSchemaList();
/**
* watch individual changes to a list of FlowSchema. deprecated: use the 'watch' parameter with a list operation instead.
*/
@HTTP(
method = "GET",
path = "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/watch/flowschemas"
)
@Headers({
"Accept: */*"
})
KubernetesCall watchFlowSchemaList(
@QueryMap WatchFlowSchemaList queryParameters);
final class WatchFlowSchemaList 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 WatchFlowSchemaList 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 WatchFlowSchemaList continues(String continues) {
put("continue", continues);
return this;
}
/**
* A selector to restrict the list of returned objects by their fields. Defaults to everything.
*/
public WatchFlowSchemaList fieldSelector(String fieldSelector) {
put("fieldSelector", fieldSelector);
return this;
}
/**
* A selector to restrict the list of returned objects by their labels. Defaults to everything.
*/
public WatchFlowSchemaList 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 WatchFlowSchemaList limit(Integer limit) {
put("limit", limit);
return this;
}
/**
* If 'true', then the output is pretty printed.
*/
public WatchFlowSchemaList 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 WatchFlowSchemaList 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 WatchFlowSchemaList timeoutSeconds(Integer 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 WatchFlowSchemaList watch(Boolean watch) {
put("watch", watch);
return this;
}
}
/**
* watch changes to an object of kind FlowSchema. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.
*
* @param name name of the FlowSchema
*/
@HTTP(
method = "GET",
path = "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/watch/flowschemas/{name}"
)
@Headers({
"Accept: */*"
})
KubernetesCall watchFlowSchema(
@Path("name") String name);
/**
* watch changes to an object of kind FlowSchema. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.
*
* @param name name of the FlowSchema
*/
@HTTP(
method = "GET",
path = "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/watch/flowschemas/{name}"
)
@Headers({
"Accept: */*"
})
KubernetesCall watchFlowSchema(
@Path("name") String name,
@QueryMap WatchFlowSchema queryParameters);
final class WatchFlowSchema 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 WatchFlowSchema 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 WatchFlowSchema continues(String continues) {
put("continue", continues);
return this;
}
/**
* A selector to restrict the list of returned objects by their fields. Defaults to everything.
*/
public WatchFlowSchema fieldSelector(String fieldSelector) {
put("fieldSelector", fieldSelector);
return this;
}
/**
* A selector to restrict the list of returned objects by their labels. Defaults to everything.
*/
public WatchFlowSchema 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 WatchFlowSchema limit(Integer limit) {
put("limit", limit);
return this;
}
/**
* If 'true', then the output is pretty printed.
*/
public WatchFlowSchema 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 WatchFlowSchema 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 WatchFlowSchema timeoutSeconds(Integer 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 WatchFlowSchema watch(Boolean watch) {
put("watch", watch);
return this;
}
}
/**
* watch individual changes to a list of PriorityLevelConfiguration. deprecated: use the 'watch' parameter with a list operation instead.
*/
@HTTP(
method = "GET",
path = "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/watch/prioritylevelconfigurations"
)
@Headers({
"Accept: */*"
})
KubernetesCall watchPriorityLevelConfigurationList();
/**
* watch individual changes to a list of PriorityLevelConfiguration. deprecated: use the 'watch' parameter with a list operation instead.
*/
@HTTP(
method = "GET",
path = "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/watch/prioritylevelconfigurations"
)
@Headers({
"Accept: */*"
})
KubernetesCall watchPriorityLevelConfigurationList(
@QueryMap WatchPriorityLevelConfigurationList queryParameters);
final class WatchPriorityLevelConfigurationList 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 WatchPriorityLevelConfigurationList 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 WatchPriorityLevelConfigurationList continues(String continues) {
put("continue", continues);
return this;
}
/**
* A selector to restrict the list of returned objects by their fields. Defaults to everything.
*/
public WatchPriorityLevelConfigurationList fieldSelector(String fieldSelector) {
put("fieldSelector", fieldSelector);
return this;
}
/**
* A selector to restrict the list of returned objects by their labels. Defaults to everything.
*/
public WatchPriorityLevelConfigurationList 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 WatchPriorityLevelConfigurationList limit(Integer limit) {
put("limit", limit);
return this;
}
/**
* If 'true', then the output is pretty printed.
*/
public WatchPriorityLevelConfigurationList 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 WatchPriorityLevelConfigurationList 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 WatchPriorityLevelConfigurationList timeoutSeconds(Integer 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 WatchPriorityLevelConfigurationList watch(Boolean watch) {
put("watch", watch);
return this;
}
}
/**
* watch changes to an object of kind PriorityLevelConfiguration. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.
*
* @param name name of the PriorityLevelConfiguration
*/
@HTTP(
method = "GET",
path = "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/watch/prioritylevelconfigurations/{name}"
)
@Headers({
"Accept: */*"
})
KubernetesCall watchPriorityLevelConfiguration(
@Path("name") String name);
/**
* watch changes to an object of kind PriorityLevelConfiguration. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.
*
* @param name name of the PriorityLevelConfiguration
*/
@HTTP(
method = "GET",
path = "/apis/flowcontrol.apiserver.k8s.io/v1alpha1/watch/prioritylevelconfigurations/{name}"
)
@Headers({
"Accept: */*"
})
KubernetesCall watchPriorityLevelConfiguration(
@Path("name") String name,
@QueryMap WatchPriorityLevelConfiguration queryParameters);
final class WatchPriorityLevelConfiguration 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 WatchPriorityLevelConfiguration 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 WatchPriorityLevelConfiguration continues(String continues) {
put("continue", continues);
return this;
}
/**
* A selector to restrict the list of returned objects by their fields. Defaults to everything.
*/
public WatchPriorityLevelConfiguration fieldSelector(String fieldSelector) {
put("fieldSelector", fieldSelector);
return this;
}
/**
* A selector to restrict the list of returned objects by their labels. Defaults to everything.
*/
public WatchPriorityLevelConfiguration 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 WatchPriorityLevelConfiguration limit(Integer limit) {
put("limit", limit);
return this;
}
/**
* If 'true', then the output is pretty printed.
*/
public WatchPriorityLevelConfiguration 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 WatchPriorityLevelConfiguration 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 WatchPriorityLevelConfiguration timeoutSeconds(Integer 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 WatchPriorityLevelConfiguration watch(Boolean watch) {
put("watch", watch);
return this;
}
}
}