Interface CoreV1Api

  • All Superinterfaces:
    com.marcnuri.yakc.api.Api
    All Known Subinterfaces:
    ExtendedCoreV1Api

    public interface CoreV1Api
    extends com.marcnuri.yakc.api.Api
    • Method Detail

      • getAPIResources

        @HTTP(method="GET",
              path="/api/v1/")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.APIResourceList> getAPIResources()
        get available resources
      • listComponentStatus

        @HTTP(method="GET",
              path="/api/v1/componentstatuses")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesListCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.ComponentStatusList,​com.marcnuri.yakc.model.io.k8s.api.core.v1.ComponentStatus> listComponentStatus()
        list objects of kind ComponentStatus
      • listComponentStatus

        @HTTP(method="GET",
              path="/api/v1/componentstatuses")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesListCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.ComponentStatusList,​com.marcnuri.yakc.model.io.k8s.api.core.v1.ComponentStatus> listComponentStatus​(@QueryMap
                                                                                                                                                                                                      CoreV1Api.ListComponentStatus queryParameters)
        list objects of kind ComponentStatus
      • readComponentStatus

        @HTTP(method="GET",
              path="/api/v1/componentstatuses/{name}")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.ComponentStatus> readComponentStatus​(@Path("name")
                                                                                                                             java.lang.String name)
        read the specified ComponentStatus
        Parameters:
        name - name of the ComponentStatus
      • readComponentStatus

        @HTTP(method="GET",
              path="/api/v1/componentstatuses/{name}")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.ComponentStatus> readComponentStatus​(@Path("name")
                                                                                                                             java.lang.String name,
                                                                                                                             @QueryMap
                                                                                                                             CoreV1Api.ReadComponentStatus queryParameters)
        read the specified ComponentStatus
        Parameters:
        name - name of the ComponentStatus
      • listConfigMapForAllNamespaces

        @HTTP(method="GET",
              path="/api/v1/configmaps")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesListCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.ConfigMapList,​com.marcnuri.yakc.model.io.k8s.api.core.v1.ConfigMap> listConfigMapForAllNamespaces()
        list or watch objects of kind ConfigMap
      • listConfigMapForAllNamespaces

        @HTTP(method="GET",
              path="/api/v1/configmaps")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesListCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.ConfigMapList,​com.marcnuri.yakc.model.io.k8s.api.core.v1.ConfigMap> listConfigMapForAllNamespaces​(@QueryMap
                                                                                                                                                                                                    CoreV1Api.ListConfigMapForAllNamespaces queryParameters)
        list or watch objects of kind ConfigMap
      • listEndpointsForAllNamespaces

        @HTTP(method="GET",
              path="/api/v1/endpoints")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesListCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.EndpointsList,​com.marcnuri.yakc.model.io.k8s.api.core.v1.Endpoints> listEndpointsForAllNamespaces()
        list or watch objects of kind Endpoints
      • listEndpointsForAllNamespaces

        @HTTP(method="GET",
              path="/api/v1/endpoints")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesListCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.EndpointsList,​com.marcnuri.yakc.model.io.k8s.api.core.v1.Endpoints> listEndpointsForAllNamespaces​(@QueryMap
                                                                                                                                                                                                    CoreV1Api.ListEndpointsForAllNamespaces queryParameters)
        list or watch objects of kind Endpoints
      • listEventForAllNamespaces

        @HTTP(method="GET",
              path="/api/v1/events")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesListCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.EventList,​com.marcnuri.yakc.model.io.k8s.api.core.v1.Event> listEventForAllNamespaces()
        list or watch objects of kind Event
      • listEventForAllNamespaces

        @HTTP(method="GET",
              path="/api/v1/events")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesListCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.EventList,​com.marcnuri.yakc.model.io.k8s.api.core.v1.Event> listEventForAllNamespaces​(@QueryMap
                                                                                                                                                                                        CoreV1Api.ListEventForAllNamespaces queryParameters)
        list or watch objects of kind Event
      • listLimitRangeForAllNamespaces

        @HTTP(method="GET",
              path="/api/v1/limitranges")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesListCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.LimitRangeList,​com.marcnuri.yakc.model.io.k8s.api.core.v1.LimitRange> listLimitRangeForAllNamespaces()
        list or watch objects of kind LimitRange
      • listLimitRangeForAllNamespaces

        @HTTP(method="GET",
              path="/api/v1/limitranges")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesListCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.LimitRangeList,​com.marcnuri.yakc.model.io.k8s.api.core.v1.LimitRange> listLimitRangeForAllNamespaces​(@QueryMap
                                                                                                                                                                                                       CoreV1Api.ListLimitRangeForAllNamespaces queryParameters)
        list or watch objects of kind LimitRange
      • listNamespace

        @HTTP(method="GET",
              path="/api/v1/namespaces")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesListCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.NamespaceList,​com.marcnuri.yakc.model.io.k8s.api.core.v1.Namespace> listNamespace()
        list or watch objects of kind Namespace
      • listNamespace

        @HTTP(method="GET",
              path="/api/v1/namespaces")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesListCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.NamespaceList,​com.marcnuri.yakc.model.io.k8s.api.core.v1.Namespace> listNamespace​(@QueryMap
                                                                                                                                                                                    CoreV1Api.ListNamespace queryParameters)
        list or watch objects of kind Namespace
      • createNamespace

        @HTTP(method="POST",
              path="/api/v1/namespaces",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Namespace> createNamespace​(@Body
                                                                                                                   com.marcnuri.yakc.model.io.k8s.api.core.v1.Namespace body)
        create a Namespace
      • createNamespace

        @HTTP(method="POST",
              path="/api/v1/namespaces",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Namespace> createNamespace​(@Body
                                                                                                                   com.marcnuri.yakc.model.io.k8s.api.core.v1.Namespace body,
                                                                                                                   @QueryMap
                                                                                                                   CoreV1Api.CreateNamespace queryParameters)
        create a Namespace
      • createNamespacedBinding

        @HTTP(method="POST",
              path="/api/v1/namespaces/{namespace}/bindings",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Binding> createNamespacedBinding​(@Path("namespace")
                                                                                                                         java.lang.String namespace,
                                                                                                                         @Body
                                                                                                                         com.marcnuri.yakc.model.io.k8s.api.core.v1.Binding body)
        create a Binding
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • createNamespacedBinding

        @HTTP(method="POST",
              path="/api/v1/namespaces/{namespace}/bindings",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Binding> createNamespacedBinding​(@Path("namespace")
                                                                                                                         java.lang.String namespace,
                                                                                                                         @Body
                                                                                                                         com.marcnuri.yakc.model.io.k8s.api.core.v1.Binding body,
                                                                                                                         @QueryMap
                                                                                                                         CoreV1Api.CreateNamespacedBinding queryParameters)
        create a Binding
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • deleteCollectionNamespacedConfigMap

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/configmaps",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteCollectionNamespacedConfigMap​(@Path("namespace")
                                                                                                                                                      java.lang.String namespace,
                                                                                                                                                      @Body
                                                                                                                                                      com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions body)
        delete collection of ConfigMap
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • deleteCollectionNamespacedConfigMap

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/configmaps",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteCollectionNamespacedConfigMap​(@Path("namespace")
                                                                                                                                                      java.lang.String namespace)
        delete collection of ConfigMap
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • deleteCollectionNamespacedConfigMap

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/configmaps",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteCollectionNamespacedConfigMap​(@Path("namespace")
                                                                                                                                                      java.lang.String namespace,
                                                                                                                                                      @Body
                                                                                                                                                      com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions body,
                                                                                                                                                      @QueryMap
                                                                                                                                                      CoreV1Api.DeleteCollectionNamespacedConfigMap queryParameters)
        delete collection of ConfigMap
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • deleteCollectionNamespacedConfigMap

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/configmaps",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteCollectionNamespacedConfigMap​(@Path("namespace")
                                                                                                                                                      java.lang.String namespace,
                                                                                                                                                      @QueryMap
                                                                                                                                                      CoreV1Api.DeleteCollectionNamespacedConfigMap queryParameters)
        delete collection of ConfigMap
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • listNamespacedConfigMap

        @HTTP(method="GET",
              path="/api/v1/namespaces/{namespace}/configmaps")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesListCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.ConfigMapList,​com.marcnuri.yakc.model.io.k8s.api.core.v1.ConfigMap> listNamespacedConfigMap​(@Path("namespace")
                                                                                                                                                                                              java.lang.String namespace)
        list or watch objects of kind ConfigMap
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • listNamespacedConfigMap

        @HTTP(method="GET",
              path="/api/v1/namespaces/{namespace}/configmaps")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesListCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.ConfigMapList,​com.marcnuri.yakc.model.io.k8s.api.core.v1.ConfigMap> listNamespacedConfigMap​(@Path("namespace")
                                                                                                                                                                                              java.lang.String namespace,
                                                                                                                                                                                              @QueryMap
                                                                                                                                                                                              CoreV1Api.ListNamespacedConfigMap queryParameters)
        list or watch objects of kind ConfigMap
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • createNamespacedConfigMap

        @HTTP(method="POST",
              path="/api/v1/namespaces/{namespace}/configmaps",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.ConfigMap> createNamespacedConfigMap​(@Path("namespace")
                                                                                                                             java.lang.String namespace,
                                                                                                                             @Body
                                                                                                                             com.marcnuri.yakc.model.io.k8s.api.core.v1.ConfigMap body)
        create a ConfigMap
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • createNamespacedConfigMap

        @HTTP(method="POST",
              path="/api/v1/namespaces/{namespace}/configmaps",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.ConfigMap> createNamespacedConfigMap​(@Path("namespace")
                                                                                                                             java.lang.String namespace,
                                                                                                                             @Body
                                                                                                                             com.marcnuri.yakc.model.io.k8s.api.core.v1.ConfigMap body,
                                                                                                                             @QueryMap
                                                                                                                             CoreV1Api.CreateNamespacedConfigMap queryParameters)
        create a ConfigMap
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • deleteNamespacedConfigMap

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/configmaps/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteNamespacedConfigMap​(@Path("name")
                                                                                                                                            java.lang.String name,
                                                                                                                                            @Path("namespace")
                                                                                                                                            java.lang.String namespace,
                                                                                                                                            @Body
                                                                                                                                            com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions body)
        delete a ConfigMap
        Parameters:
        name - name of the ConfigMap
        namespace - object name and auth scope, such as for teams and projects
      • deleteNamespacedConfigMap

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/configmaps/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteNamespacedConfigMap​(@Path("name")
                                                                                                                                            java.lang.String name,
                                                                                                                                            @Path("namespace")
                                                                                                                                            java.lang.String namespace)
        delete a ConfigMap
        Parameters:
        name - name of the ConfigMap
        namespace - object name and auth scope, such as for teams and projects
      • deleteNamespacedConfigMap

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/configmaps/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteNamespacedConfigMap​(@Path("name")
                                                                                                                                            java.lang.String name,
                                                                                                                                            @Path("namespace")
                                                                                                                                            java.lang.String namespace,
                                                                                                                                            @Body
                                                                                                                                            com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions body,
                                                                                                                                            @QueryMap
                                                                                                                                            CoreV1Api.DeleteNamespacedConfigMap queryParameters)
        delete a ConfigMap
        Parameters:
        name - name of the ConfigMap
        namespace - object name and auth scope, such as for teams and projects
      • deleteNamespacedConfigMap

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/configmaps/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteNamespacedConfigMap​(@Path("name")
                                                                                                                                            java.lang.String name,
                                                                                                                                            @Path("namespace")
                                                                                                                                            java.lang.String namespace,
                                                                                                                                            @QueryMap
                                                                                                                                            CoreV1Api.DeleteNamespacedConfigMap queryParameters)
        delete a ConfigMap
        Parameters:
        name - name of the ConfigMap
        namespace - object name and auth scope, such as for teams and projects
      • readNamespacedConfigMap

        @HTTP(method="GET",
              path="/api/v1/namespaces/{namespace}/configmaps/{name}")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.ConfigMap> readNamespacedConfigMap​(@Path("name")
                                                                                                                           java.lang.String name,
                                                                                                                           @Path("namespace")
                                                                                                                           java.lang.String namespace)
        read the specified ConfigMap
        Parameters:
        name - name of the ConfigMap
        namespace - object name and auth scope, such as for teams and projects
      • readNamespacedConfigMap

        @HTTP(method="GET",
              path="/api/v1/namespaces/{namespace}/configmaps/{name}")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.ConfigMap> readNamespacedConfigMap​(@Path("name")
                                                                                                                           java.lang.String name,
                                                                                                                           @Path("namespace")
                                                                                                                           java.lang.String namespace,
                                                                                                                           @QueryMap
                                                                                                                           CoreV1Api.ReadNamespacedConfigMap queryParameters)
        read the specified ConfigMap
        Parameters:
        name - name of the ConfigMap
        namespace - object name and auth scope, such as for teams and projects
      • patchNamespacedConfigMap

        @HTTP(method="PATCH",
              path="/api/v1/namespaces/{namespace}/configmaps/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/merge-patch+json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.ConfigMap> patchNamespacedConfigMap​(@Path("name")
                                                                                                                            java.lang.String name,
                                                                                                                            @Path("namespace")
                                                                                                                            java.lang.String namespace,
                                                                                                                            @Body
                                                                                                                            com.marcnuri.yakc.model.io.k8s.api.core.v1.ConfigMap body)
        partially update the specified ConfigMap
        Parameters:
        name - name of the ConfigMap
        namespace - object name and auth scope, such as for teams and projects
      • patchNamespacedConfigMap

        @HTTP(method="PATCH",
              path="/api/v1/namespaces/{namespace}/configmaps/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/merge-patch+json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.ConfigMap> patchNamespacedConfigMap​(@Path("name")
                                                                                                                            java.lang.String name,
                                                                                                                            @Path("namespace")
                                                                                                                            java.lang.String namespace,
                                                                                                                            @Body
                                                                                                                            com.marcnuri.yakc.model.io.k8s.api.core.v1.ConfigMap body,
                                                                                                                            @QueryMap
                                                                                                                            CoreV1Api.PatchNamespacedConfigMap queryParameters)
        partially update the specified ConfigMap
        Parameters:
        name - name of the ConfigMap
        namespace - object name and auth scope, such as for teams and projects
      • replaceNamespacedConfigMap

        @HTTP(method="PUT",
              path="/api/v1/namespaces/{namespace}/configmaps/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.ConfigMap> replaceNamespacedConfigMap​(@Path("name")
                                                                                                                              java.lang.String name,
                                                                                                                              @Path("namespace")
                                                                                                                              java.lang.String namespace,
                                                                                                                              @Body
                                                                                                                              com.marcnuri.yakc.model.io.k8s.api.core.v1.ConfigMap body)
        replace the specified ConfigMap
        Parameters:
        name - name of the ConfigMap
        namespace - object name and auth scope, such as for teams and projects
      • replaceNamespacedConfigMap

        @HTTP(method="PUT",
              path="/api/v1/namespaces/{namespace}/configmaps/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.ConfigMap> replaceNamespacedConfigMap​(@Path("name")
                                                                                                                              java.lang.String name,
                                                                                                                              @Path("namespace")
                                                                                                                              java.lang.String namespace,
                                                                                                                              @Body
                                                                                                                              com.marcnuri.yakc.model.io.k8s.api.core.v1.ConfigMap body,
                                                                                                                              @QueryMap
                                                                                                                              CoreV1Api.ReplaceNamespacedConfigMap queryParameters)
        replace the specified ConfigMap
        Parameters:
        name - name of the ConfigMap
        namespace - object name and auth scope, such as for teams and projects
      • deleteCollectionNamespacedEndpoints

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/endpoints",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteCollectionNamespacedEndpoints​(@Path("namespace")
                                                                                                                                                      java.lang.String namespace,
                                                                                                                                                      @Body
                                                                                                                                                      com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions body)
        delete collection of Endpoints
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • deleteCollectionNamespacedEndpoints

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/endpoints",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteCollectionNamespacedEndpoints​(@Path("namespace")
                                                                                                                                                      java.lang.String namespace)
        delete collection of Endpoints
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • deleteCollectionNamespacedEndpoints

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/endpoints",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteCollectionNamespacedEndpoints​(@Path("namespace")
                                                                                                                                                      java.lang.String namespace,
                                                                                                                                                      @Body
                                                                                                                                                      com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions body,
                                                                                                                                                      @QueryMap
                                                                                                                                                      CoreV1Api.DeleteCollectionNamespacedEndpoints queryParameters)
        delete collection of Endpoints
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • deleteCollectionNamespacedEndpoints

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/endpoints",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteCollectionNamespacedEndpoints​(@Path("namespace")
                                                                                                                                                      java.lang.String namespace,
                                                                                                                                                      @QueryMap
                                                                                                                                                      CoreV1Api.DeleteCollectionNamespacedEndpoints queryParameters)
        delete collection of Endpoints
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • listNamespacedEndpoints

        @HTTP(method="GET",
              path="/api/v1/namespaces/{namespace}/endpoints")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesListCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.EndpointsList,​com.marcnuri.yakc.model.io.k8s.api.core.v1.Endpoints> listNamespacedEndpoints​(@Path("namespace")
                                                                                                                                                                                              java.lang.String namespace)
        list or watch objects of kind Endpoints
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • listNamespacedEndpoints

        @HTTP(method="GET",
              path="/api/v1/namespaces/{namespace}/endpoints")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesListCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.EndpointsList,​com.marcnuri.yakc.model.io.k8s.api.core.v1.Endpoints> listNamespacedEndpoints​(@Path("namespace")
                                                                                                                                                                                              java.lang.String namespace,
                                                                                                                                                                                              @QueryMap
                                                                                                                                                                                              CoreV1Api.ListNamespacedEndpoints queryParameters)
        list or watch objects of kind Endpoints
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • createNamespacedEndpoints

        @HTTP(method="POST",
              path="/api/v1/namespaces/{namespace}/endpoints",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Endpoints> createNamespacedEndpoints​(@Path("namespace")
                                                                                                                             java.lang.String namespace,
                                                                                                                             @Body
                                                                                                                             com.marcnuri.yakc.model.io.k8s.api.core.v1.Endpoints body)
        create Endpoints
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • createNamespacedEndpoints

        @HTTP(method="POST",
              path="/api/v1/namespaces/{namespace}/endpoints",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Endpoints> createNamespacedEndpoints​(@Path("namespace")
                                                                                                                             java.lang.String namespace,
                                                                                                                             @Body
                                                                                                                             com.marcnuri.yakc.model.io.k8s.api.core.v1.Endpoints body,
                                                                                                                             @QueryMap
                                                                                                                             CoreV1Api.CreateNamespacedEndpoints queryParameters)
        create Endpoints
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • deleteNamespacedEndpoints

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/endpoints/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteNamespacedEndpoints​(@Path("name")
                                                                                                                                            java.lang.String name,
                                                                                                                                            @Path("namespace")
                                                                                                                                            java.lang.String namespace,
                                                                                                                                            @Body
                                                                                                                                            com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions body)
        delete Endpoints
        Parameters:
        name - name of the Endpoints
        namespace - object name and auth scope, such as for teams and projects
      • deleteNamespacedEndpoints

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/endpoints/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteNamespacedEndpoints​(@Path("name")
                                                                                                                                            java.lang.String name,
                                                                                                                                            @Path("namespace")
                                                                                                                                            java.lang.String namespace)
        delete Endpoints
        Parameters:
        name - name of the Endpoints
        namespace - object name and auth scope, such as for teams and projects
      • deleteNamespacedEndpoints

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/endpoints/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteNamespacedEndpoints​(@Path("name")
                                                                                                                                            java.lang.String name,
                                                                                                                                            @Path("namespace")
                                                                                                                                            java.lang.String namespace,
                                                                                                                                            @Body
                                                                                                                                            com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions body,
                                                                                                                                            @QueryMap
                                                                                                                                            CoreV1Api.DeleteNamespacedEndpoints queryParameters)
        delete Endpoints
        Parameters:
        name - name of the Endpoints
        namespace - object name and auth scope, such as for teams and projects
      • deleteNamespacedEndpoints

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/endpoints/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteNamespacedEndpoints​(@Path("name")
                                                                                                                                            java.lang.String name,
                                                                                                                                            @Path("namespace")
                                                                                                                                            java.lang.String namespace,
                                                                                                                                            @QueryMap
                                                                                                                                            CoreV1Api.DeleteNamespacedEndpoints queryParameters)
        delete Endpoints
        Parameters:
        name - name of the Endpoints
        namespace - object name and auth scope, such as for teams and projects
      • readNamespacedEndpoints

        @HTTP(method="GET",
              path="/api/v1/namespaces/{namespace}/endpoints/{name}")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Endpoints> readNamespacedEndpoints​(@Path("name")
                                                                                                                           java.lang.String name,
                                                                                                                           @Path("namespace")
                                                                                                                           java.lang.String namespace)
        read the specified Endpoints
        Parameters:
        name - name of the Endpoints
        namespace - object name and auth scope, such as for teams and projects
      • readNamespacedEndpoints

        @HTTP(method="GET",
              path="/api/v1/namespaces/{namespace}/endpoints/{name}")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Endpoints> readNamespacedEndpoints​(@Path("name")
                                                                                                                           java.lang.String name,
                                                                                                                           @Path("namespace")
                                                                                                                           java.lang.String namespace,
                                                                                                                           @QueryMap
                                                                                                                           CoreV1Api.ReadNamespacedEndpoints queryParameters)
        read the specified Endpoints
        Parameters:
        name - name of the Endpoints
        namespace - object name and auth scope, such as for teams and projects
      • patchNamespacedEndpoints

        @HTTP(method="PATCH",
              path="/api/v1/namespaces/{namespace}/endpoints/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/merge-patch+json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Endpoints> patchNamespacedEndpoints​(@Path("name")
                                                                                                                            java.lang.String name,
                                                                                                                            @Path("namespace")
                                                                                                                            java.lang.String namespace,
                                                                                                                            @Body
                                                                                                                            com.marcnuri.yakc.model.io.k8s.api.core.v1.Endpoints body)
        partially update the specified Endpoints
        Parameters:
        name - name of the Endpoints
        namespace - object name and auth scope, such as for teams and projects
      • patchNamespacedEndpoints

        @HTTP(method="PATCH",
              path="/api/v1/namespaces/{namespace}/endpoints/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/merge-patch+json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Endpoints> patchNamespacedEndpoints​(@Path("name")
                                                                                                                            java.lang.String name,
                                                                                                                            @Path("namespace")
                                                                                                                            java.lang.String namespace,
                                                                                                                            @Body
                                                                                                                            com.marcnuri.yakc.model.io.k8s.api.core.v1.Endpoints body,
                                                                                                                            @QueryMap
                                                                                                                            CoreV1Api.PatchNamespacedEndpoints queryParameters)
        partially update the specified Endpoints
        Parameters:
        name - name of the Endpoints
        namespace - object name and auth scope, such as for teams and projects
      • replaceNamespacedEndpoints

        @HTTP(method="PUT",
              path="/api/v1/namespaces/{namespace}/endpoints/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Endpoints> replaceNamespacedEndpoints​(@Path("name")
                                                                                                                              java.lang.String name,
                                                                                                                              @Path("namespace")
                                                                                                                              java.lang.String namespace,
                                                                                                                              @Body
                                                                                                                              com.marcnuri.yakc.model.io.k8s.api.core.v1.Endpoints body)
        replace the specified Endpoints
        Parameters:
        name - name of the Endpoints
        namespace - object name and auth scope, such as for teams and projects
      • replaceNamespacedEndpoints

        @HTTP(method="PUT",
              path="/api/v1/namespaces/{namespace}/endpoints/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Endpoints> replaceNamespacedEndpoints​(@Path("name")
                                                                                                                              java.lang.String name,
                                                                                                                              @Path("namespace")
                                                                                                                              java.lang.String namespace,
                                                                                                                              @Body
                                                                                                                              com.marcnuri.yakc.model.io.k8s.api.core.v1.Endpoints body,
                                                                                                                              @QueryMap
                                                                                                                              CoreV1Api.ReplaceNamespacedEndpoints queryParameters)
        replace the specified Endpoints
        Parameters:
        name - name of the Endpoints
        namespace - object name and auth scope, such as for teams and projects
      • deleteCollectionNamespacedEvent

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/events",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteCollectionNamespacedEvent​(@Path("namespace")
                                                                                                                                                  java.lang.String namespace,
                                                                                                                                                  @Body
                                                                                                                                                  com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions body)
        delete collection of Event
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • deleteCollectionNamespacedEvent

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/events",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteCollectionNamespacedEvent​(@Path("namespace")
                                                                                                                                                  java.lang.String namespace)
        delete collection of Event
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • deleteCollectionNamespacedEvent

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/events",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteCollectionNamespacedEvent​(@Path("namespace")
                                                                                                                                                  java.lang.String namespace,
                                                                                                                                                  @Body
                                                                                                                                                  com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions body,
                                                                                                                                                  @QueryMap
                                                                                                                                                  CoreV1Api.DeleteCollectionNamespacedEvent queryParameters)
        delete collection of Event
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • deleteCollectionNamespacedEvent

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/events",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteCollectionNamespacedEvent​(@Path("namespace")
                                                                                                                                                  java.lang.String namespace,
                                                                                                                                                  @QueryMap
                                                                                                                                                  CoreV1Api.DeleteCollectionNamespacedEvent queryParameters)
        delete collection of Event
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • listNamespacedEvent

        @HTTP(method="GET",
              path="/api/v1/namespaces/{namespace}/events")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesListCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.EventList,​com.marcnuri.yakc.model.io.k8s.api.core.v1.Event> listNamespacedEvent​(@Path("namespace")
                                                                                                                                                                                  java.lang.String namespace)
        list or watch objects of kind Event
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • listNamespacedEvent

        @HTTP(method="GET",
              path="/api/v1/namespaces/{namespace}/events")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesListCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.EventList,​com.marcnuri.yakc.model.io.k8s.api.core.v1.Event> listNamespacedEvent​(@Path("namespace")
                                                                                                                                                                                  java.lang.String namespace,
                                                                                                                                                                                  @QueryMap
                                                                                                                                                                                  CoreV1Api.ListNamespacedEvent queryParameters)
        list or watch objects of kind Event
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • createNamespacedEvent

        @HTTP(method="POST",
              path="/api/v1/namespaces/{namespace}/events",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Event> createNamespacedEvent​(@Path("namespace")
                                                                                                                     java.lang.String namespace,
                                                                                                                     @Body
                                                                                                                     com.marcnuri.yakc.model.io.k8s.api.core.v1.Event body)
        create an Event
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • createNamespacedEvent

        @HTTP(method="POST",
              path="/api/v1/namespaces/{namespace}/events",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Event> createNamespacedEvent​(@Path("namespace")
                                                                                                                     java.lang.String namespace,
                                                                                                                     @Body
                                                                                                                     com.marcnuri.yakc.model.io.k8s.api.core.v1.Event body,
                                                                                                                     @QueryMap
                                                                                                                     CoreV1Api.CreateNamespacedEvent queryParameters)
        create an Event
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • deleteNamespacedEvent

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/events/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteNamespacedEvent​(@Path("name")
                                                                                                                                        java.lang.String name,
                                                                                                                                        @Path("namespace")
                                                                                                                                        java.lang.String namespace,
                                                                                                                                        @Body
                                                                                                                                        com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions body)
        delete an Event
        Parameters:
        name - name of the Event
        namespace - object name and auth scope, such as for teams and projects
      • deleteNamespacedEvent

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/events/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteNamespacedEvent​(@Path("name")
                                                                                                                                        java.lang.String name,
                                                                                                                                        @Path("namespace")
                                                                                                                                        java.lang.String namespace)
        delete an Event
        Parameters:
        name - name of the Event
        namespace - object name and auth scope, such as for teams and projects
      • deleteNamespacedEvent

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/events/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteNamespacedEvent​(@Path("name")
                                                                                                                                        java.lang.String name,
                                                                                                                                        @Path("namespace")
                                                                                                                                        java.lang.String namespace,
                                                                                                                                        @Body
                                                                                                                                        com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions body,
                                                                                                                                        @QueryMap
                                                                                                                                        CoreV1Api.DeleteNamespacedEvent queryParameters)
        delete an Event
        Parameters:
        name - name of the Event
        namespace - object name and auth scope, such as for teams and projects
      • deleteNamespacedEvent

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/events/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteNamespacedEvent​(@Path("name")
                                                                                                                                        java.lang.String name,
                                                                                                                                        @Path("namespace")
                                                                                                                                        java.lang.String namespace,
                                                                                                                                        @QueryMap
                                                                                                                                        CoreV1Api.DeleteNamespacedEvent queryParameters)
        delete an Event
        Parameters:
        name - name of the Event
        namespace - object name and auth scope, such as for teams and projects
      • readNamespacedEvent

        @HTTP(method="GET",
              path="/api/v1/namespaces/{namespace}/events/{name}")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Event> readNamespacedEvent​(@Path("name")
                                                                                                                   java.lang.String name,
                                                                                                                   @Path("namespace")
                                                                                                                   java.lang.String namespace)
        read the specified Event
        Parameters:
        name - name of the Event
        namespace - object name and auth scope, such as for teams and projects
      • readNamespacedEvent

        @HTTP(method="GET",
              path="/api/v1/namespaces/{namespace}/events/{name}")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Event> readNamespacedEvent​(@Path("name")
                                                                                                                   java.lang.String name,
                                                                                                                   @Path("namespace")
                                                                                                                   java.lang.String namespace,
                                                                                                                   @QueryMap
                                                                                                                   CoreV1Api.ReadNamespacedEvent queryParameters)
        read the specified Event
        Parameters:
        name - name of the Event
        namespace - object name and auth scope, such as for teams and projects
      • patchNamespacedEvent

        @HTTP(method="PATCH",
              path="/api/v1/namespaces/{namespace}/events/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/merge-patch+json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Event> patchNamespacedEvent​(@Path("name")
                                                                                                                    java.lang.String name,
                                                                                                                    @Path("namespace")
                                                                                                                    java.lang.String namespace,
                                                                                                                    @Body
                                                                                                                    com.marcnuri.yakc.model.io.k8s.api.core.v1.Event body)
        partially update the specified Event
        Parameters:
        name - name of the Event
        namespace - object name and auth scope, such as for teams and projects
      • patchNamespacedEvent

        @HTTP(method="PATCH",
              path="/api/v1/namespaces/{namespace}/events/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/merge-patch+json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Event> patchNamespacedEvent​(@Path("name")
                                                                                                                    java.lang.String name,
                                                                                                                    @Path("namespace")
                                                                                                                    java.lang.String namespace,
                                                                                                                    @Body
                                                                                                                    com.marcnuri.yakc.model.io.k8s.api.core.v1.Event body,
                                                                                                                    @QueryMap
                                                                                                                    CoreV1Api.PatchNamespacedEvent queryParameters)
        partially update the specified Event
        Parameters:
        name - name of the Event
        namespace - object name and auth scope, such as for teams and projects
      • replaceNamespacedEvent

        @HTTP(method="PUT",
              path="/api/v1/namespaces/{namespace}/events/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Event> replaceNamespacedEvent​(@Path("name")
                                                                                                                      java.lang.String name,
                                                                                                                      @Path("namespace")
                                                                                                                      java.lang.String namespace,
                                                                                                                      @Body
                                                                                                                      com.marcnuri.yakc.model.io.k8s.api.core.v1.Event body)
        replace the specified Event
        Parameters:
        name - name of the Event
        namespace - object name and auth scope, such as for teams and projects
      • replaceNamespacedEvent

        @HTTP(method="PUT",
              path="/api/v1/namespaces/{namespace}/events/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Event> replaceNamespacedEvent​(@Path("name")
                                                                                                                      java.lang.String name,
                                                                                                                      @Path("namespace")
                                                                                                                      java.lang.String namespace,
                                                                                                                      @Body
                                                                                                                      com.marcnuri.yakc.model.io.k8s.api.core.v1.Event body,
                                                                                                                      @QueryMap
                                                                                                                      CoreV1Api.ReplaceNamespacedEvent queryParameters)
        replace the specified Event
        Parameters:
        name - name of the Event
        namespace - object name and auth scope, such as for teams and projects
      • deleteCollectionNamespacedLimitRange

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/limitranges",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteCollectionNamespacedLimitRange​(@Path("namespace")
                                                                                                                                                       java.lang.String namespace,
                                                                                                                                                       @Body
                                                                                                                                                       com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions body)
        delete collection of LimitRange
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • deleteCollectionNamespacedLimitRange

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/limitranges",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteCollectionNamespacedLimitRange​(@Path("namespace")
                                                                                                                                                       java.lang.String namespace)
        delete collection of LimitRange
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • deleteCollectionNamespacedLimitRange

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/limitranges",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteCollectionNamespacedLimitRange​(@Path("namespace")
                                                                                                                                                       java.lang.String namespace,
                                                                                                                                                       @Body
                                                                                                                                                       com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions body,
                                                                                                                                                       @QueryMap
                                                                                                                                                       CoreV1Api.DeleteCollectionNamespacedLimitRange queryParameters)
        delete collection of LimitRange
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • deleteCollectionNamespacedLimitRange

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/limitranges",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteCollectionNamespacedLimitRange​(@Path("namespace")
                                                                                                                                                       java.lang.String namespace,
                                                                                                                                                       @QueryMap
                                                                                                                                                       CoreV1Api.DeleteCollectionNamespacedLimitRange queryParameters)
        delete collection of LimitRange
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • listNamespacedLimitRange

        @HTTP(method="GET",
              path="/api/v1/namespaces/{namespace}/limitranges")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesListCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.LimitRangeList,​com.marcnuri.yakc.model.io.k8s.api.core.v1.LimitRange> listNamespacedLimitRange​(@Path("namespace")
                                                                                                                                                                                                 java.lang.String namespace)
        list or watch objects of kind LimitRange
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • listNamespacedLimitRange

        @HTTP(method="GET",
              path="/api/v1/namespaces/{namespace}/limitranges")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesListCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.LimitRangeList,​com.marcnuri.yakc.model.io.k8s.api.core.v1.LimitRange> listNamespacedLimitRange​(@Path("namespace")
                                                                                                                                                                                                 java.lang.String namespace,
                                                                                                                                                                                                 @QueryMap
                                                                                                                                                                                                 CoreV1Api.ListNamespacedLimitRange queryParameters)
        list or watch objects of kind LimitRange
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • createNamespacedLimitRange

        @HTTP(method="POST",
              path="/api/v1/namespaces/{namespace}/limitranges",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.LimitRange> createNamespacedLimitRange​(@Path("namespace")
                                                                                                                               java.lang.String namespace,
                                                                                                                               @Body
                                                                                                                               com.marcnuri.yakc.model.io.k8s.api.core.v1.LimitRange body)
        create a LimitRange
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • createNamespacedLimitRange

        @HTTP(method="POST",
              path="/api/v1/namespaces/{namespace}/limitranges",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.LimitRange> createNamespacedLimitRange​(@Path("namespace")
                                                                                                                               java.lang.String namespace,
                                                                                                                               @Body
                                                                                                                               com.marcnuri.yakc.model.io.k8s.api.core.v1.LimitRange body,
                                                                                                                               @QueryMap
                                                                                                                               CoreV1Api.CreateNamespacedLimitRange queryParameters)
        create a LimitRange
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • deleteNamespacedLimitRange

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/limitranges/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteNamespacedLimitRange​(@Path("name")
                                                                                                                                             java.lang.String name,
                                                                                                                                             @Path("namespace")
                                                                                                                                             java.lang.String namespace,
                                                                                                                                             @Body
                                                                                                                                             com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions body)
        delete a LimitRange
        Parameters:
        name - name of the LimitRange
        namespace - object name and auth scope, such as for teams and projects
      • deleteNamespacedLimitRange

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/limitranges/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteNamespacedLimitRange​(@Path("name")
                                                                                                                                             java.lang.String name,
                                                                                                                                             @Path("namespace")
                                                                                                                                             java.lang.String namespace)
        delete a LimitRange
        Parameters:
        name - name of the LimitRange
        namespace - object name and auth scope, such as for teams and projects
      • deleteNamespacedLimitRange

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/limitranges/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteNamespacedLimitRange​(@Path("name")
                                                                                                                                             java.lang.String name,
                                                                                                                                             @Path("namespace")
                                                                                                                                             java.lang.String namespace,
                                                                                                                                             @Body
                                                                                                                                             com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions body,
                                                                                                                                             @QueryMap
                                                                                                                                             CoreV1Api.DeleteNamespacedLimitRange queryParameters)
        delete a LimitRange
        Parameters:
        name - name of the LimitRange
        namespace - object name and auth scope, such as for teams and projects
      • deleteNamespacedLimitRange

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/limitranges/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteNamespacedLimitRange​(@Path("name")
                                                                                                                                             java.lang.String name,
                                                                                                                                             @Path("namespace")
                                                                                                                                             java.lang.String namespace,
                                                                                                                                             @QueryMap
                                                                                                                                             CoreV1Api.DeleteNamespacedLimitRange queryParameters)
        delete a LimitRange
        Parameters:
        name - name of the LimitRange
        namespace - object name and auth scope, such as for teams and projects
      • readNamespacedLimitRange

        @HTTP(method="GET",
              path="/api/v1/namespaces/{namespace}/limitranges/{name}")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.LimitRange> readNamespacedLimitRange​(@Path("name")
                                                                                                                             java.lang.String name,
                                                                                                                             @Path("namespace")
                                                                                                                             java.lang.String namespace)
        read the specified LimitRange
        Parameters:
        name - name of the LimitRange
        namespace - object name and auth scope, such as for teams and projects
      • readNamespacedLimitRange

        @HTTP(method="GET",
              path="/api/v1/namespaces/{namespace}/limitranges/{name}")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.LimitRange> readNamespacedLimitRange​(@Path("name")
                                                                                                                             java.lang.String name,
                                                                                                                             @Path("namespace")
                                                                                                                             java.lang.String namespace,
                                                                                                                             @QueryMap
                                                                                                                             CoreV1Api.ReadNamespacedLimitRange queryParameters)
        read the specified LimitRange
        Parameters:
        name - name of the LimitRange
        namespace - object name and auth scope, such as for teams and projects
      • patchNamespacedLimitRange

        @HTTP(method="PATCH",
              path="/api/v1/namespaces/{namespace}/limitranges/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/merge-patch+json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.LimitRange> patchNamespacedLimitRange​(@Path("name")
                                                                                                                              java.lang.String name,
                                                                                                                              @Path("namespace")
                                                                                                                              java.lang.String namespace,
                                                                                                                              @Body
                                                                                                                              com.marcnuri.yakc.model.io.k8s.api.core.v1.LimitRange body)
        partially update the specified LimitRange
        Parameters:
        name - name of the LimitRange
        namespace - object name and auth scope, such as for teams and projects
      • patchNamespacedLimitRange

        @HTTP(method="PATCH",
              path="/api/v1/namespaces/{namespace}/limitranges/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/merge-patch+json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.LimitRange> patchNamespacedLimitRange​(@Path("name")
                                                                                                                              java.lang.String name,
                                                                                                                              @Path("namespace")
                                                                                                                              java.lang.String namespace,
                                                                                                                              @Body
                                                                                                                              com.marcnuri.yakc.model.io.k8s.api.core.v1.LimitRange body,
                                                                                                                              @QueryMap
                                                                                                                              CoreV1Api.PatchNamespacedLimitRange queryParameters)
        partially update the specified LimitRange
        Parameters:
        name - name of the LimitRange
        namespace - object name and auth scope, such as for teams and projects
      • replaceNamespacedLimitRange

        @HTTP(method="PUT",
              path="/api/v1/namespaces/{namespace}/limitranges/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.LimitRange> replaceNamespacedLimitRange​(@Path("name")
                                                                                                                                java.lang.String name,
                                                                                                                                @Path("namespace")
                                                                                                                                java.lang.String namespace,
                                                                                                                                @Body
                                                                                                                                com.marcnuri.yakc.model.io.k8s.api.core.v1.LimitRange body)
        replace the specified LimitRange
        Parameters:
        name - name of the LimitRange
        namespace - object name and auth scope, such as for teams and projects
      • replaceNamespacedLimitRange

        @HTTP(method="PUT",
              path="/api/v1/namespaces/{namespace}/limitranges/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.LimitRange> replaceNamespacedLimitRange​(@Path("name")
                                                                                                                                java.lang.String name,
                                                                                                                                @Path("namespace")
                                                                                                                                java.lang.String namespace,
                                                                                                                                @Body
                                                                                                                                com.marcnuri.yakc.model.io.k8s.api.core.v1.LimitRange body,
                                                                                                                                @QueryMap
                                                                                                                                CoreV1Api.ReplaceNamespacedLimitRange queryParameters)
        replace the specified LimitRange
        Parameters:
        name - name of the LimitRange
        namespace - object name and auth scope, such as for teams and projects
      • deleteCollectionNamespacedPersistentVolumeClaim

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/persistentvolumeclaims",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteCollectionNamespacedPersistentVolumeClaim​(@Path("namespace")
                                                                                                                                                                  java.lang.String namespace,
                                                                                                                                                                  @Body
                                                                                                                                                                  com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions body)
        delete collection of PersistentVolumeClaim
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • deleteCollectionNamespacedPersistentVolumeClaim

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/persistentvolumeclaims",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteCollectionNamespacedPersistentVolumeClaim​(@Path("namespace")
                                                                                                                                                                  java.lang.String namespace)
        delete collection of PersistentVolumeClaim
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • deleteCollectionNamespacedPersistentVolumeClaim

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/persistentvolumeclaims",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteCollectionNamespacedPersistentVolumeClaim​(@Path("namespace")
                                                                                                                                                                  java.lang.String namespace,
                                                                                                                                                                  @Body
                                                                                                                                                                  com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions body,
                                                                                                                                                                  @QueryMap
                                                                                                                                                                  CoreV1Api.DeleteCollectionNamespacedPersistentVolumeClaim queryParameters)
        delete collection of PersistentVolumeClaim
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • deleteCollectionNamespacedPersistentVolumeClaim

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/persistentvolumeclaims",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteCollectionNamespacedPersistentVolumeClaim​(@Path("namespace")
                                                                                                                                                                  java.lang.String namespace,
                                                                                                                                                                  @QueryMap
                                                                                                                                                                  CoreV1Api.DeleteCollectionNamespacedPersistentVolumeClaim queryParameters)
        delete collection of PersistentVolumeClaim
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • listNamespacedPersistentVolumeClaim

        @HTTP(method="GET",
              path="/api/v1/namespaces/{namespace}/persistentvolumeclaims")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesListCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.PersistentVolumeClaimList,​com.marcnuri.yakc.model.io.k8s.api.core.v1.PersistentVolumeClaim> listNamespacedPersistentVolumeClaim​(@Path("namespace")
                                                                                                                                                                                                                                  java.lang.String namespace)
        list or watch objects of kind PersistentVolumeClaim
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • listNamespacedPersistentVolumeClaim

        @HTTP(method="GET",
              path="/api/v1/namespaces/{namespace}/persistentvolumeclaims")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesListCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.PersistentVolumeClaimList,​com.marcnuri.yakc.model.io.k8s.api.core.v1.PersistentVolumeClaim> listNamespacedPersistentVolumeClaim​(@Path("namespace")
                                                                                                                                                                                                                                  java.lang.String namespace,
                                                                                                                                                                                                                                  @QueryMap
                                                                                                                                                                                                                                  CoreV1Api.ListNamespacedPersistentVolumeClaim queryParameters)
        list or watch objects of kind PersistentVolumeClaim
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • createNamespacedPersistentVolumeClaim

        @HTTP(method="POST",
              path="/api/v1/namespaces/{namespace}/persistentvolumeclaims",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.PersistentVolumeClaim> createNamespacedPersistentVolumeClaim​(@Path("namespace")
                                                                                                                                                     java.lang.String namespace,
                                                                                                                                                     @Body
                                                                                                                                                     com.marcnuri.yakc.model.io.k8s.api.core.v1.PersistentVolumeClaim body)
        create a PersistentVolumeClaim
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • createNamespacedPersistentVolumeClaim

        @HTTP(method="POST",
              path="/api/v1/namespaces/{namespace}/persistentvolumeclaims",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.PersistentVolumeClaim> createNamespacedPersistentVolumeClaim​(@Path("namespace")
                                                                                                                                                     java.lang.String namespace,
                                                                                                                                                     @Body
                                                                                                                                                     com.marcnuri.yakc.model.io.k8s.api.core.v1.PersistentVolumeClaim body,
                                                                                                                                                     @QueryMap
                                                                                                                                                     CoreV1Api.CreateNamespacedPersistentVolumeClaim queryParameters)
        create a PersistentVolumeClaim
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • deleteNamespacedPersistentVolumeClaim

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/persistentvolumeclaims/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.PersistentVolumeClaim> deleteNamespacedPersistentVolumeClaim​(@Path("name")
                                                                                                                                                     java.lang.String name,
                                                                                                                                                     @Path("namespace")
                                                                                                                                                     java.lang.String namespace,
                                                                                                                                                     @Body
                                                                                                                                                     com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions body)
        delete a PersistentVolumeClaim
        Parameters:
        name - name of the PersistentVolumeClaim
        namespace - object name and auth scope, such as for teams and projects
      • deleteNamespacedPersistentVolumeClaim

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/persistentvolumeclaims/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.PersistentVolumeClaim> deleteNamespacedPersistentVolumeClaim​(@Path("name")
                                                                                                                                                     java.lang.String name,
                                                                                                                                                     @Path("namespace")
                                                                                                                                                     java.lang.String namespace)
        delete a PersistentVolumeClaim
        Parameters:
        name - name of the PersistentVolumeClaim
        namespace - object name and auth scope, such as for teams and projects
      • deleteNamespacedPersistentVolumeClaim

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/persistentvolumeclaims/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.PersistentVolumeClaim> deleteNamespacedPersistentVolumeClaim​(@Path("name")
                                                                                                                                                     java.lang.String name,
                                                                                                                                                     @Path("namespace")
                                                                                                                                                     java.lang.String namespace,
                                                                                                                                                     @Body
                                                                                                                                                     com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions body,
                                                                                                                                                     @QueryMap
                                                                                                                                                     CoreV1Api.DeleteNamespacedPersistentVolumeClaim queryParameters)
        delete a PersistentVolumeClaim
        Parameters:
        name - name of the PersistentVolumeClaim
        namespace - object name and auth scope, such as for teams and projects
      • deleteNamespacedPersistentVolumeClaim

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/persistentvolumeclaims/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.PersistentVolumeClaim> deleteNamespacedPersistentVolumeClaim​(@Path("name")
                                                                                                                                                     java.lang.String name,
                                                                                                                                                     @Path("namespace")
                                                                                                                                                     java.lang.String namespace,
                                                                                                                                                     @QueryMap
                                                                                                                                                     CoreV1Api.DeleteNamespacedPersistentVolumeClaim queryParameters)
        delete a PersistentVolumeClaim
        Parameters:
        name - name of the PersistentVolumeClaim
        namespace - object name and auth scope, such as for teams and projects
      • readNamespacedPersistentVolumeClaim

        @HTTP(method="GET",
              path="/api/v1/namespaces/{namespace}/persistentvolumeclaims/{name}")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.PersistentVolumeClaim> readNamespacedPersistentVolumeClaim​(@Path("name")
                                                                                                                                                   java.lang.String name,
                                                                                                                                                   @Path("namespace")
                                                                                                                                                   java.lang.String namespace)
        read the specified PersistentVolumeClaim
        Parameters:
        name - name of the PersistentVolumeClaim
        namespace - object name and auth scope, such as for teams and projects
      • readNamespacedPersistentVolumeClaim

        @HTTP(method="GET",
              path="/api/v1/namespaces/{namespace}/persistentvolumeclaims/{name}")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.PersistentVolumeClaim> readNamespacedPersistentVolumeClaim​(@Path("name")
                                                                                                                                                   java.lang.String name,
                                                                                                                                                   @Path("namespace")
                                                                                                                                                   java.lang.String namespace,
                                                                                                                                                   @QueryMap
                                                                                                                                                   CoreV1Api.ReadNamespacedPersistentVolumeClaim queryParameters)
        read the specified PersistentVolumeClaim
        Parameters:
        name - name of the PersistentVolumeClaim
        namespace - object name and auth scope, such as for teams and projects
      • patchNamespacedPersistentVolumeClaim

        @HTTP(method="PATCH",
              path="/api/v1/namespaces/{namespace}/persistentvolumeclaims/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/merge-patch+json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.PersistentVolumeClaim> patchNamespacedPersistentVolumeClaim​(@Path("name")
                                                                                                                                                    java.lang.String name,
                                                                                                                                                    @Path("namespace")
                                                                                                                                                    java.lang.String namespace,
                                                                                                                                                    @Body
                                                                                                                                                    com.marcnuri.yakc.model.io.k8s.api.core.v1.PersistentVolumeClaim body)
        partially update the specified PersistentVolumeClaim
        Parameters:
        name - name of the PersistentVolumeClaim
        namespace - object name and auth scope, such as for teams and projects
      • patchNamespacedPersistentVolumeClaim

        @HTTP(method="PATCH",
              path="/api/v1/namespaces/{namespace}/persistentvolumeclaims/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/merge-patch+json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.PersistentVolumeClaim> patchNamespacedPersistentVolumeClaim​(@Path("name")
                                                                                                                                                    java.lang.String name,
                                                                                                                                                    @Path("namespace")
                                                                                                                                                    java.lang.String namespace,
                                                                                                                                                    @Body
                                                                                                                                                    com.marcnuri.yakc.model.io.k8s.api.core.v1.PersistentVolumeClaim body,
                                                                                                                                                    @QueryMap
                                                                                                                                                    CoreV1Api.PatchNamespacedPersistentVolumeClaim queryParameters)
        partially update the specified PersistentVolumeClaim
        Parameters:
        name - name of the PersistentVolumeClaim
        namespace - object name and auth scope, such as for teams and projects
      • replaceNamespacedPersistentVolumeClaim

        @HTTP(method="PUT",
              path="/api/v1/namespaces/{namespace}/persistentvolumeclaims/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.PersistentVolumeClaim> replaceNamespacedPersistentVolumeClaim​(@Path("name")
                                                                                                                                                      java.lang.String name,
                                                                                                                                                      @Path("namespace")
                                                                                                                                                      java.lang.String namespace,
                                                                                                                                                      @Body
                                                                                                                                                      com.marcnuri.yakc.model.io.k8s.api.core.v1.PersistentVolumeClaim body)
        replace the specified PersistentVolumeClaim
        Parameters:
        name - name of the PersistentVolumeClaim
        namespace - object name and auth scope, such as for teams and projects
      • replaceNamespacedPersistentVolumeClaim

        @HTTP(method="PUT",
              path="/api/v1/namespaces/{namespace}/persistentvolumeclaims/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.PersistentVolumeClaim> replaceNamespacedPersistentVolumeClaim​(@Path("name")
                                                                                                                                                      java.lang.String name,
                                                                                                                                                      @Path("namespace")
                                                                                                                                                      java.lang.String namespace,
                                                                                                                                                      @Body
                                                                                                                                                      com.marcnuri.yakc.model.io.k8s.api.core.v1.PersistentVolumeClaim body,
                                                                                                                                                      @QueryMap
                                                                                                                                                      CoreV1Api.ReplaceNamespacedPersistentVolumeClaim queryParameters)
        replace the specified PersistentVolumeClaim
        Parameters:
        name - name of the PersistentVolumeClaim
        namespace - object name and auth scope, such as for teams and projects
      • readNamespacedPersistentVolumeClaimStatus

        @HTTP(method="GET",
              path="/api/v1/namespaces/{namespace}/persistentvolumeclaims/{name}/status")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.PersistentVolumeClaim> readNamespacedPersistentVolumeClaimStatus​(@Path("name")
                                                                                                                                                         java.lang.String name,
                                                                                                                                                         @Path("namespace")
                                                                                                                                                         java.lang.String namespace)
        read status of the specified PersistentVolumeClaim
        Parameters:
        name - name of the PersistentVolumeClaim
        namespace - object name and auth scope, such as for teams and projects
      • readNamespacedPersistentVolumeClaimStatus

        @HTTP(method="GET",
              path="/api/v1/namespaces/{namespace}/persistentvolumeclaims/{name}/status")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.PersistentVolumeClaim> readNamespacedPersistentVolumeClaimStatus​(@Path("name")
                                                                                                                                                         java.lang.String name,
                                                                                                                                                         @Path("namespace")
                                                                                                                                                         java.lang.String namespace,
                                                                                                                                                         @QueryMap
                                                                                                                                                         CoreV1Api.ReadNamespacedPersistentVolumeClaimStatus queryParameters)
        read status of the specified PersistentVolumeClaim
        Parameters:
        name - name of the PersistentVolumeClaim
        namespace - object name and auth scope, such as for teams and projects
      • patchNamespacedPersistentVolumeClaimStatus

        @HTTP(method="PATCH",
              path="/api/v1/namespaces/{namespace}/persistentvolumeclaims/{name}/status",
              hasBody=true)
        @Headers({"Content-Type: application/merge-patch+json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.PersistentVolumeClaim> patchNamespacedPersistentVolumeClaimStatus​(@Path("name")
                                                                                                                                                          java.lang.String name,
                                                                                                                                                          @Path("namespace")
                                                                                                                                                          java.lang.String namespace,
                                                                                                                                                          @Body
                                                                                                                                                          com.marcnuri.yakc.model.io.k8s.api.core.v1.PersistentVolumeClaim body)
        partially update status of the specified PersistentVolumeClaim
        Parameters:
        name - name of the PersistentVolumeClaim
        namespace - object name and auth scope, such as for teams and projects
      • patchNamespacedPersistentVolumeClaimStatus

        @HTTP(method="PATCH",
              path="/api/v1/namespaces/{namespace}/persistentvolumeclaims/{name}/status",
              hasBody=true)
        @Headers({"Content-Type: application/merge-patch+json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.PersistentVolumeClaim> patchNamespacedPersistentVolumeClaimStatus​(@Path("name")
                                                                                                                                                          java.lang.String name,
                                                                                                                                                          @Path("namespace")
                                                                                                                                                          java.lang.String namespace,
                                                                                                                                                          @Body
                                                                                                                                                          com.marcnuri.yakc.model.io.k8s.api.core.v1.PersistentVolumeClaim body,
                                                                                                                                                          @QueryMap
                                                                                                                                                          CoreV1Api.PatchNamespacedPersistentVolumeClaimStatus queryParameters)
        partially update status of the specified PersistentVolumeClaim
        Parameters:
        name - name of the PersistentVolumeClaim
        namespace - object name and auth scope, such as for teams and projects
      • replaceNamespacedPersistentVolumeClaimStatus

        @HTTP(method="PUT",
              path="/api/v1/namespaces/{namespace}/persistentvolumeclaims/{name}/status",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.PersistentVolumeClaim> replaceNamespacedPersistentVolumeClaimStatus​(@Path("name")
                                                                                                                                                            java.lang.String name,
                                                                                                                                                            @Path("namespace")
                                                                                                                                                            java.lang.String namespace,
                                                                                                                                                            @Body
                                                                                                                                                            com.marcnuri.yakc.model.io.k8s.api.core.v1.PersistentVolumeClaim body)
        replace status of the specified PersistentVolumeClaim
        Parameters:
        name - name of the PersistentVolumeClaim
        namespace - object name and auth scope, such as for teams and projects
      • replaceNamespacedPersistentVolumeClaimStatus

        @HTTP(method="PUT",
              path="/api/v1/namespaces/{namespace}/persistentvolumeclaims/{name}/status",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.PersistentVolumeClaim> replaceNamespacedPersistentVolumeClaimStatus​(@Path("name")
                                                                                                                                                            java.lang.String name,
                                                                                                                                                            @Path("namespace")
                                                                                                                                                            java.lang.String namespace,
                                                                                                                                                            @Body
                                                                                                                                                            com.marcnuri.yakc.model.io.k8s.api.core.v1.PersistentVolumeClaim body,
                                                                                                                                                            @QueryMap
                                                                                                                                                            CoreV1Api.ReplaceNamespacedPersistentVolumeClaimStatus queryParameters)
        replace status of the specified PersistentVolumeClaim
        Parameters:
        name - name of the PersistentVolumeClaim
        namespace - object name and auth scope, such as for teams and projects
      • deleteCollectionNamespacedPod

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/pods",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteCollectionNamespacedPod​(@Path("namespace")
                                                                                                                                                java.lang.String namespace,
                                                                                                                                                @Body
                                                                                                                                                com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions body)
        delete collection of Pod
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • deleteCollectionNamespacedPod

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/pods",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteCollectionNamespacedPod​(@Path("namespace")
                                                                                                                                                java.lang.String namespace)
        delete collection of Pod
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • deleteCollectionNamespacedPod

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/pods",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteCollectionNamespacedPod​(@Path("namespace")
                                                                                                                                                java.lang.String namespace,
                                                                                                                                                @Body
                                                                                                                                                com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions body,
                                                                                                                                                @QueryMap
                                                                                                                                                CoreV1Api.DeleteCollectionNamespacedPod queryParameters)
        delete collection of Pod
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • deleteCollectionNamespacedPod

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/pods",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteCollectionNamespacedPod​(@Path("namespace")
                                                                                                                                                java.lang.String namespace,
                                                                                                                                                @QueryMap
                                                                                                                                                CoreV1Api.DeleteCollectionNamespacedPod queryParameters)
        delete collection of Pod
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • listNamespacedPod

        @HTTP(method="GET",
              path="/api/v1/namespaces/{namespace}/pods")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesListCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.PodList,​com.marcnuri.yakc.model.io.k8s.api.core.v1.Pod> listNamespacedPod​(@Path("namespace")
                                                                                                                                                                            java.lang.String namespace)
        list or watch objects of kind Pod
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • listNamespacedPod

        @HTTP(method="GET",
              path="/api/v1/namespaces/{namespace}/pods")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesListCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.PodList,​com.marcnuri.yakc.model.io.k8s.api.core.v1.Pod> listNamespacedPod​(@Path("namespace")
                                                                                                                                                                            java.lang.String namespace,
                                                                                                                                                                            @QueryMap
                                                                                                                                                                            CoreV1Api.ListNamespacedPod queryParameters)
        list or watch objects of kind Pod
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • createNamespacedPod

        @HTTP(method="POST",
              path="/api/v1/namespaces/{namespace}/pods",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Pod> createNamespacedPod​(@Path("namespace")
                                                                                                                 java.lang.String namespace,
                                                                                                                 @Body
                                                                                                                 com.marcnuri.yakc.model.io.k8s.api.core.v1.Pod body)
        create a Pod
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • createNamespacedPod

        @HTTP(method="POST",
              path="/api/v1/namespaces/{namespace}/pods",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Pod> createNamespacedPod​(@Path("namespace")
                                                                                                                 java.lang.String namespace,
                                                                                                                 @Body
                                                                                                                 com.marcnuri.yakc.model.io.k8s.api.core.v1.Pod body,
                                                                                                                 @QueryMap
                                                                                                                 CoreV1Api.CreateNamespacedPod queryParameters)
        create a Pod
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • deleteNamespacedPod

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/pods/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Pod> deleteNamespacedPod​(@Path("name")
                                                                                                                 java.lang.String name,
                                                                                                                 @Path("namespace")
                                                                                                                 java.lang.String namespace,
                                                                                                                 @Body
                                                                                                                 com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions body)
        delete a Pod
        Parameters:
        name - name of the Pod
        namespace - object name and auth scope, such as for teams and projects
      • deleteNamespacedPod

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/pods/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Pod> deleteNamespacedPod​(@Path("name")
                                                                                                                 java.lang.String name,
                                                                                                                 @Path("namespace")
                                                                                                                 java.lang.String namespace)
        delete a Pod
        Parameters:
        name - name of the Pod
        namespace - object name and auth scope, such as for teams and projects
      • deleteNamespacedPod

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/pods/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Pod> deleteNamespacedPod​(@Path("name")
                                                                                                                 java.lang.String name,
                                                                                                                 @Path("namespace")
                                                                                                                 java.lang.String namespace,
                                                                                                                 @Body
                                                                                                                 com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions body,
                                                                                                                 @QueryMap
                                                                                                                 CoreV1Api.DeleteNamespacedPod queryParameters)
        delete a Pod
        Parameters:
        name - name of the Pod
        namespace - object name and auth scope, such as for teams and projects
      • deleteNamespacedPod

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/pods/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Pod> deleteNamespacedPod​(@Path("name")
                                                                                                                 java.lang.String name,
                                                                                                                 @Path("namespace")
                                                                                                                 java.lang.String namespace,
                                                                                                                 @QueryMap
                                                                                                                 CoreV1Api.DeleteNamespacedPod queryParameters)
        delete a Pod
        Parameters:
        name - name of the Pod
        namespace - object name and auth scope, such as for teams and projects
      • readNamespacedPod

        @HTTP(method="GET",
              path="/api/v1/namespaces/{namespace}/pods/{name}")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Pod> readNamespacedPod​(@Path("name")
                                                                                                               java.lang.String name,
                                                                                                               @Path("namespace")
                                                                                                               java.lang.String namespace)
        read the specified Pod
        Parameters:
        name - name of the Pod
        namespace - object name and auth scope, such as for teams and projects
      • readNamespacedPod

        @HTTP(method="GET",
              path="/api/v1/namespaces/{namespace}/pods/{name}")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Pod> readNamespacedPod​(@Path("name")
                                                                                                               java.lang.String name,
                                                                                                               @Path("namespace")
                                                                                                               java.lang.String namespace,
                                                                                                               @QueryMap
                                                                                                               CoreV1Api.ReadNamespacedPod queryParameters)
        read the specified Pod
        Parameters:
        name - name of the Pod
        namespace - object name and auth scope, such as for teams and projects
      • patchNamespacedPod

        @HTTP(method="PATCH",
              path="/api/v1/namespaces/{namespace}/pods/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/merge-patch+json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Pod> patchNamespacedPod​(@Path("name")
                                                                                                                java.lang.String name,
                                                                                                                @Path("namespace")
                                                                                                                java.lang.String namespace,
                                                                                                                @Body
                                                                                                                com.marcnuri.yakc.model.io.k8s.api.core.v1.Pod body)
        partially update the specified Pod
        Parameters:
        name - name of the Pod
        namespace - object name and auth scope, such as for teams and projects
      • patchNamespacedPod

        @HTTP(method="PATCH",
              path="/api/v1/namespaces/{namespace}/pods/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/merge-patch+json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Pod> patchNamespacedPod​(@Path("name")
                                                                                                                java.lang.String name,
                                                                                                                @Path("namespace")
                                                                                                                java.lang.String namespace,
                                                                                                                @Body
                                                                                                                com.marcnuri.yakc.model.io.k8s.api.core.v1.Pod body,
                                                                                                                @QueryMap
                                                                                                                CoreV1Api.PatchNamespacedPod queryParameters)
        partially update the specified Pod
        Parameters:
        name - name of the Pod
        namespace - object name and auth scope, such as for teams and projects
      • replaceNamespacedPod

        @HTTP(method="PUT",
              path="/api/v1/namespaces/{namespace}/pods/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Pod> replaceNamespacedPod​(@Path("name")
                                                                                                                  java.lang.String name,
                                                                                                                  @Path("namespace")
                                                                                                                  java.lang.String namespace,
                                                                                                                  @Body
                                                                                                                  com.marcnuri.yakc.model.io.k8s.api.core.v1.Pod body)
        replace the specified Pod
        Parameters:
        name - name of the Pod
        namespace - object name and auth scope, such as for teams and projects
      • replaceNamespacedPod

        @HTTP(method="PUT",
              path="/api/v1/namespaces/{namespace}/pods/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Pod> replaceNamespacedPod​(@Path("name")
                                                                                                                  java.lang.String name,
                                                                                                                  @Path("namespace")
                                                                                                                  java.lang.String namespace,
                                                                                                                  @Body
                                                                                                                  com.marcnuri.yakc.model.io.k8s.api.core.v1.Pod body,
                                                                                                                  @QueryMap
                                                                                                                  CoreV1Api.ReplaceNamespacedPod queryParameters)
        replace the specified Pod
        Parameters:
        name - name of the Pod
        namespace - object name and auth scope, such as for teams and projects
      • createNamespacedPodBinding

        @HTTP(method="POST",
              path="/api/v1/namespaces/{namespace}/pods/{name}/binding",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Binding> createNamespacedPodBinding​(@Path("name")
                                                                                                                            java.lang.String name,
                                                                                                                            @Path("namespace")
                                                                                                                            java.lang.String namespace,
                                                                                                                            @Body
                                                                                                                            com.marcnuri.yakc.model.io.k8s.api.core.v1.Binding body)
        create binding of a Pod
        Parameters:
        name - name of the Binding
        namespace - object name and auth scope, such as for teams and projects
      • createNamespacedPodBinding

        @HTTP(method="POST",
              path="/api/v1/namespaces/{namespace}/pods/{name}/binding",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Binding> createNamespacedPodBinding​(@Path("name")
                                                                                                                            java.lang.String name,
                                                                                                                            @Path("namespace")
                                                                                                                            java.lang.String namespace,
                                                                                                                            @Body
                                                                                                                            com.marcnuri.yakc.model.io.k8s.api.core.v1.Binding body,
                                                                                                                            @QueryMap
                                                                                                                            CoreV1Api.CreateNamespacedPodBinding queryParameters)
        create binding of a Pod
        Parameters:
        name - name of the Binding
        namespace - object name and auth scope, such as for teams and projects
      • readNamespacedPodEphemeralcontainers

        @HTTP(method="GET",
              path="/api/v1/namespaces/{namespace}/pods/{name}/ephemeralcontainers")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Pod> readNamespacedPodEphemeralcontainers​(@Path("name")
                                                                                                                                  java.lang.String name,
                                                                                                                                  @Path("namespace")
                                                                                                                                  java.lang.String namespace)
        read ephemeralcontainers of the specified Pod
        Parameters:
        name - name of the Pod
        namespace - object name and auth scope, such as for teams and projects
      • readNamespacedPodEphemeralcontainers

        @HTTP(method="GET",
              path="/api/v1/namespaces/{namespace}/pods/{name}/ephemeralcontainers")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Pod> readNamespacedPodEphemeralcontainers​(@Path("name")
                                                                                                                                  java.lang.String name,
                                                                                                                                  @Path("namespace")
                                                                                                                                  java.lang.String namespace,
                                                                                                                                  @QueryMap
                                                                                                                                  CoreV1Api.ReadNamespacedPodEphemeralcontainers queryParameters)
        read ephemeralcontainers of the specified Pod
        Parameters:
        name - name of the Pod
        namespace - object name and auth scope, such as for teams and projects
      • patchNamespacedPodEphemeralcontainers

        @HTTP(method="PATCH",
              path="/api/v1/namespaces/{namespace}/pods/{name}/ephemeralcontainers",
              hasBody=true)
        @Headers({"Content-Type: application/merge-patch+json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Pod> patchNamespacedPodEphemeralcontainers​(@Path("name")
                                                                                                                                   java.lang.String name,
                                                                                                                                   @Path("namespace")
                                                                                                                                   java.lang.String namespace,
                                                                                                                                   @Body
                                                                                                                                   com.marcnuri.yakc.model.io.k8s.api.core.v1.Pod body)
        partially update ephemeralcontainers of the specified Pod
        Parameters:
        name - name of the Pod
        namespace - object name and auth scope, such as for teams and projects
      • patchNamespacedPodEphemeralcontainers

        @HTTP(method="PATCH",
              path="/api/v1/namespaces/{namespace}/pods/{name}/ephemeralcontainers",
              hasBody=true)
        @Headers({"Content-Type: application/merge-patch+json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Pod> patchNamespacedPodEphemeralcontainers​(@Path("name")
                                                                                                                                   java.lang.String name,
                                                                                                                                   @Path("namespace")
                                                                                                                                   java.lang.String namespace,
                                                                                                                                   @Body
                                                                                                                                   com.marcnuri.yakc.model.io.k8s.api.core.v1.Pod body,
                                                                                                                                   @QueryMap
                                                                                                                                   CoreV1Api.PatchNamespacedPodEphemeralcontainers queryParameters)
        partially update ephemeralcontainers of the specified Pod
        Parameters:
        name - name of the Pod
        namespace - object name and auth scope, such as for teams and projects
      • replaceNamespacedPodEphemeralcontainers

        @HTTP(method="PUT",
              path="/api/v1/namespaces/{namespace}/pods/{name}/ephemeralcontainers",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Pod> replaceNamespacedPodEphemeralcontainers​(@Path("name")
                                                                                                                                     java.lang.String name,
                                                                                                                                     @Path("namespace")
                                                                                                                                     java.lang.String namespace,
                                                                                                                                     @Body
                                                                                                                                     com.marcnuri.yakc.model.io.k8s.api.core.v1.Pod body)
        replace ephemeralcontainers of the specified Pod
        Parameters:
        name - name of the Pod
        namespace - object name and auth scope, such as for teams and projects
      • replaceNamespacedPodEphemeralcontainers

        @HTTP(method="PUT",
              path="/api/v1/namespaces/{namespace}/pods/{name}/ephemeralcontainers",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Pod> replaceNamespacedPodEphemeralcontainers​(@Path("name")
                                                                                                                                     java.lang.String name,
                                                                                                                                     @Path("namespace")
                                                                                                                                     java.lang.String namespace,
                                                                                                                                     @Body
                                                                                                                                     com.marcnuri.yakc.model.io.k8s.api.core.v1.Pod body,
                                                                                                                                     @QueryMap
                                                                                                                                     CoreV1Api.ReplaceNamespacedPodEphemeralcontainers queryParameters)
        replace ephemeralcontainers of the specified Pod
        Parameters:
        name - name of the Pod
        namespace - object name and auth scope, such as for teams and projects
      • createNamespacedPodEviction

        @HTTP(method="POST",
              path="/api/v1/namespaces/{namespace}/pods/{name}/eviction",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.policy.v1.Eviction> createNamespacedPodEviction​(@Path("name")
                                                                                                                                java.lang.String name,
                                                                                                                                @Path("namespace")
                                                                                                                                java.lang.String namespace,
                                                                                                                                @Body
                                                                                                                                com.marcnuri.yakc.model.io.k8s.api.policy.v1.Eviction body)
        create eviction of a Pod
        Parameters:
        name - name of the Eviction
        namespace - object name and auth scope, such as for teams and projects
      • createNamespacedPodEviction

        @HTTP(method="POST",
              path="/api/v1/namespaces/{namespace}/pods/{name}/eviction",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.policy.v1.Eviction> createNamespacedPodEviction​(@Path("name")
                                                                                                                                java.lang.String name,
                                                                                                                                @Path("namespace")
                                                                                                                                java.lang.String namespace,
                                                                                                                                @Body
                                                                                                                                com.marcnuri.yakc.model.io.k8s.api.policy.v1.Eviction body,
                                                                                                                                @QueryMap
                                                                                                                                CoreV1Api.CreateNamespacedPodEviction queryParameters)
        create eviction of a Pod
        Parameters:
        name - name of the Eviction
        namespace - object name and auth scope, such as for teams and projects
      • readNamespacedPodLog

        @HTTP(method="GET",
              path="/api/v1/namespaces/{namespace}/pods/{name}/log")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<java.lang.String> readNamespacedPodLog​(@Path("name")
                                                                                    java.lang.String name,
                                                                                    @Path("namespace")
                                                                                    java.lang.String namespace)
        read log of the specified Pod
        Parameters:
        name - name of the Pod
        namespace - object name and auth scope, such as for teams and projects
      • readNamespacedPodLog

        @HTTP(method="GET",
              path="/api/v1/namespaces/{namespace}/pods/{name}/log")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<java.lang.String> readNamespacedPodLog​(@Path("name")
                                                                                    java.lang.String name,
                                                                                    @Path("namespace")
                                                                                    java.lang.String namespace,
                                                                                    @QueryMap
                                                                                    CoreV1Api.ReadNamespacedPodLog queryParameters)
        read log of the specified Pod
        Parameters:
        name - name of the Pod
        namespace - object name and auth scope, such as for teams and projects
      • readNamespacedPodStatus

        @HTTP(method="GET",
              path="/api/v1/namespaces/{namespace}/pods/{name}/status")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Pod> readNamespacedPodStatus​(@Path("name")
                                                                                                                     java.lang.String name,
                                                                                                                     @Path("namespace")
                                                                                                                     java.lang.String namespace)
        read status of the specified Pod
        Parameters:
        name - name of the Pod
        namespace - object name and auth scope, such as for teams and projects
      • readNamespacedPodStatus

        @HTTP(method="GET",
              path="/api/v1/namespaces/{namespace}/pods/{name}/status")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Pod> readNamespacedPodStatus​(@Path("name")
                                                                                                                     java.lang.String name,
                                                                                                                     @Path("namespace")
                                                                                                                     java.lang.String namespace,
                                                                                                                     @QueryMap
                                                                                                                     CoreV1Api.ReadNamespacedPodStatus queryParameters)
        read status of the specified Pod
        Parameters:
        name - name of the Pod
        namespace - object name and auth scope, such as for teams and projects
      • patchNamespacedPodStatus

        @HTTP(method="PATCH",
              path="/api/v1/namespaces/{namespace}/pods/{name}/status",
              hasBody=true)
        @Headers({"Content-Type: application/merge-patch+json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Pod> patchNamespacedPodStatus​(@Path("name")
                                                                                                                      java.lang.String name,
                                                                                                                      @Path("namespace")
                                                                                                                      java.lang.String namespace,
                                                                                                                      @Body
                                                                                                                      com.marcnuri.yakc.model.io.k8s.api.core.v1.Pod body)
        partially update status of the specified Pod
        Parameters:
        name - name of the Pod
        namespace - object name and auth scope, such as for teams and projects
      • patchNamespacedPodStatus

        @HTTP(method="PATCH",
              path="/api/v1/namespaces/{namespace}/pods/{name}/status",
              hasBody=true)
        @Headers({"Content-Type: application/merge-patch+json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Pod> patchNamespacedPodStatus​(@Path("name")
                                                                                                                      java.lang.String name,
                                                                                                                      @Path("namespace")
                                                                                                                      java.lang.String namespace,
                                                                                                                      @Body
                                                                                                                      com.marcnuri.yakc.model.io.k8s.api.core.v1.Pod body,
                                                                                                                      @QueryMap
                                                                                                                      CoreV1Api.PatchNamespacedPodStatus queryParameters)
        partially update status of the specified Pod
        Parameters:
        name - name of the Pod
        namespace - object name and auth scope, such as for teams and projects
      • replaceNamespacedPodStatus

        @HTTP(method="PUT",
              path="/api/v1/namespaces/{namespace}/pods/{name}/status",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Pod> replaceNamespacedPodStatus​(@Path("name")
                                                                                                                        java.lang.String name,
                                                                                                                        @Path("namespace")
                                                                                                                        java.lang.String namespace,
                                                                                                                        @Body
                                                                                                                        com.marcnuri.yakc.model.io.k8s.api.core.v1.Pod body)
        replace status of the specified Pod
        Parameters:
        name - name of the Pod
        namespace - object name and auth scope, such as for teams and projects
      • replaceNamespacedPodStatus

        @HTTP(method="PUT",
              path="/api/v1/namespaces/{namespace}/pods/{name}/status",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Pod> replaceNamespacedPodStatus​(@Path("name")
                                                                                                                        java.lang.String name,
                                                                                                                        @Path("namespace")
                                                                                                                        java.lang.String namespace,
                                                                                                                        @Body
                                                                                                                        com.marcnuri.yakc.model.io.k8s.api.core.v1.Pod body,
                                                                                                                        @QueryMap
                                                                                                                        CoreV1Api.ReplaceNamespacedPodStatus queryParameters)
        replace status of the specified Pod
        Parameters:
        name - name of the Pod
        namespace - object name and auth scope, such as for teams and projects
      • deleteCollectionNamespacedPodTemplate

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/podtemplates",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteCollectionNamespacedPodTemplate​(@Path("namespace")
                                                                                                                                                        java.lang.String namespace,
                                                                                                                                                        @Body
                                                                                                                                                        com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions body)
        delete collection of PodTemplate
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • deleteCollectionNamespacedPodTemplate

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/podtemplates",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteCollectionNamespacedPodTemplate​(@Path("namespace")
                                                                                                                                                        java.lang.String namespace)
        delete collection of PodTemplate
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • deleteCollectionNamespacedPodTemplate

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/podtemplates",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteCollectionNamespacedPodTemplate​(@Path("namespace")
                                                                                                                                                        java.lang.String namespace,
                                                                                                                                                        @Body
                                                                                                                                                        com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions body,
                                                                                                                                                        @QueryMap
                                                                                                                                                        CoreV1Api.DeleteCollectionNamespacedPodTemplate queryParameters)
        delete collection of PodTemplate
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • deleteCollectionNamespacedPodTemplate

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/podtemplates",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteCollectionNamespacedPodTemplate​(@Path("namespace")
                                                                                                                                                        java.lang.String namespace,
                                                                                                                                                        @QueryMap
                                                                                                                                                        CoreV1Api.DeleteCollectionNamespacedPodTemplate queryParameters)
        delete collection of PodTemplate
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • listNamespacedPodTemplate

        @HTTP(method="GET",
              path="/api/v1/namespaces/{namespace}/podtemplates")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesListCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.PodTemplateList,​com.marcnuri.yakc.model.io.k8s.api.core.v1.PodTemplate> listNamespacedPodTemplate​(@Path("namespace")
                                                                                                                                                                                                    java.lang.String namespace)
        list or watch objects of kind PodTemplate
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • listNamespacedPodTemplate

        @HTTP(method="GET",
              path="/api/v1/namespaces/{namespace}/podtemplates")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesListCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.PodTemplateList,​com.marcnuri.yakc.model.io.k8s.api.core.v1.PodTemplate> listNamespacedPodTemplate​(@Path("namespace")
                                                                                                                                                                                                    java.lang.String namespace,
                                                                                                                                                                                                    @QueryMap
                                                                                                                                                                                                    CoreV1Api.ListNamespacedPodTemplate queryParameters)
        list or watch objects of kind PodTemplate
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • createNamespacedPodTemplate

        @HTTP(method="POST",
              path="/api/v1/namespaces/{namespace}/podtemplates",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.PodTemplate> createNamespacedPodTemplate​(@Path("namespace")
                                                                                                                                 java.lang.String namespace,
                                                                                                                                 @Body
                                                                                                                                 com.marcnuri.yakc.model.io.k8s.api.core.v1.PodTemplate body)
        create a PodTemplate
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • createNamespacedPodTemplate

        @HTTP(method="POST",
              path="/api/v1/namespaces/{namespace}/podtemplates",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.PodTemplate> createNamespacedPodTemplate​(@Path("namespace")
                                                                                                                                 java.lang.String namespace,
                                                                                                                                 @Body
                                                                                                                                 com.marcnuri.yakc.model.io.k8s.api.core.v1.PodTemplate body,
                                                                                                                                 @QueryMap
                                                                                                                                 CoreV1Api.CreateNamespacedPodTemplate queryParameters)
        create a PodTemplate
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • deleteNamespacedPodTemplate

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/podtemplates/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.PodTemplate> deleteNamespacedPodTemplate​(@Path("name")
                                                                                                                                 java.lang.String name,
                                                                                                                                 @Path("namespace")
                                                                                                                                 java.lang.String namespace,
                                                                                                                                 @Body
                                                                                                                                 com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions body)
        delete a PodTemplate
        Parameters:
        name - name of the PodTemplate
        namespace - object name and auth scope, such as for teams and projects
      • deleteNamespacedPodTemplate

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/podtemplates/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.PodTemplate> deleteNamespacedPodTemplate​(@Path("name")
                                                                                                                                 java.lang.String name,
                                                                                                                                 @Path("namespace")
                                                                                                                                 java.lang.String namespace)
        delete a PodTemplate
        Parameters:
        name - name of the PodTemplate
        namespace - object name and auth scope, such as for teams and projects
      • deleteNamespacedPodTemplate

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/podtemplates/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.PodTemplate> deleteNamespacedPodTemplate​(@Path("name")
                                                                                                                                 java.lang.String name,
                                                                                                                                 @Path("namespace")
                                                                                                                                 java.lang.String namespace,
                                                                                                                                 @Body
                                                                                                                                 com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions body,
                                                                                                                                 @QueryMap
                                                                                                                                 CoreV1Api.DeleteNamespacedPodTemplate queryParameters)
        delete a PodTemplate
        Parameters:
        name - name of the PodTemplate
        namespace - object name and auth scope, such as for teams and projects
      • deleteNamespacedPodTemplate

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/podtemplates/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.PodTemplate> deleteNamespacedPodTemplate​(@Path("name")
                                                                                                                                 java.lang.String name,
                                                                                                                                 @Path("namespace")
                                                                                                                                 java.lang.String namespace,
                                                                                                                                 @QueryMap
                                                                                                                                 CoreV1Api.DeleteNamespacedPodTemplate queryParameters)
        delete a PodTemplate
        Parameters:
        name - name of the PodTemplate
        namespace - object name and auth scope, such as for teams and projects
      • readNamespacedPodTemplate

        @HTTP(method="GET",
              path="/api/v1/namespaces/{namespace}/podtemplates/{name}")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.PodTemplate> readNamespacedPodTemplate​(@Path("name")
                                                                                                                               java.lang.String name,
                                                                                                                               @Path("namespace")
                                                                                                                               java.lang.String namespace)
        read the specified PodTemplate
        Parameters:
        name - name of the PodTemplate
        namespace - object name and auth scope, such as for teams and projects
      • readNamespacedPodTemplate

        @HTTP(method="GET",
              path="/api/v1/namespaces/{namespace}/podtemplates/{name}")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.PodTemplate> readNamespacedPodTemplate​(@Path("name")
                                                                                                                               java.lang.String name,
                                                                                                                               @Path("namespace")
                                                                                                                               java.lang.String namespace,
                                                                                                                               @QueryMap
                                                                                                                               CoreV1Api.ReadNamespacedPodTemplate queryParameters)
        read the specified PodTemplate
        Parameters:
        name - name of the PodTemplate
        namespace - object name and auth scope, such as for teams and projects
      • patchNamespacedPodTemplate

        @HTTP(method="PATCH",
              path="/api/v1/namespaces/{namespace}/podtemplates/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/merge-patch+json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.PodTemplate> patchNamespacedPodTemplate​(@Path("name")
                                                                                                                                java.lang.String name,
                                                                                                                                @Path("namespace")
                                                                                                                                java.lang.String namespace,
                                                                                                                                @Body
                                                                                                                                com.marcnuri.yakc.model.io.k8s.api.core.v1.PodTemplate body)
        partially update the specified PodTemplate
        Parameters:
        name - name of the PodTemplate
        namespace - object name and auth scope, such as for teams and projects
      • patchNamespacedPodTemplate

        @HTTP(method="PATCH",
              path="/api/v1/namespaces/{namespace}/podtemplates/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/merge-patch+json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.PodTemplate> patchNamespacedPodTemplate​(@Path("name")
                                                                                                                                java.lang.String name,
                                                                                                                                @Path("namespace")
                                                                                                                                java.lang.String namespace,
                                                                                                                                @Body
                                                                                                                                com.marcnuri.yakc.model.io.k8s.api.core.v1.PodTemplate body,
                                                                                                                                @QueryMap
                                                                                                                                CoreV1Api.PatchNamespacedPodTemplate queryParameters)
        partially update the specified PodTemplate
        Parameters:
        name - name of the PodTemplate
        namespace - object name and auth scope, such as for teams and projects
      • replaceNamespacedPodTemplate

        @HTTP(method="PUT",
              path="/api/v1/namespaces/{namespace}/podtemplates/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.PodTemplate> replaceNamespacedPodTemplate​(@Path("name")
                                                                                                                                  java.lang.String name,
                                                                                                                                  @Path("namespace")
                                                                                                                                  java.lang.String namespace,
                                                                                                                                  @Body
                                                                                                                                  com.marcnuri.yakc.model.io.k8s.api.core.v1.PodTemplate body)
        replace the specified PodTemplate
        Parameters:
        name - name of the PodTemplate
        namespace - object name and auth scope, such as for teams and projects
      • replaceNamespacedPodTemplate

        @HTTP(method="PUT",
              path="/api/v1/namespaces/{namespace}/podtemplates/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.PodTemplate> replaceNamespacedPodTemplate​(@Path("name")
                                                                                                                                  java.lang.String name,
                                                                                                                                  @Path("namespace")
                                                                                                                                  java.lang.String namespace,
                                                                                                                                  @Body
                                                                                                                                  com.marcnuri.yakc.model.io.k8s.api.core.v1.PodTemplate body,
                                                                                                                                  @QueryMap
                                                                                                                                  CoreV1Api.ReplaceNamespacedPodTemplate queryParameters)
        replace the specified PodTemplate
        Parameters:
        name - name of the PodTemplate
        namespace - object name and auth scope, such as for teams and projects
      • deleteCollectionNamespacedReplicationController

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/replicationcontrollers",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteCollectionNamespacedReplicationController​(@Path("namespace")
                                                                                                                                                                  java.lang.String namespace,
                                                                                                                                                                  @Body
                                                                                                                                                                  com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions body)
        delete collection of ReplicationController
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • deleteCollectionNamespacedReplicationController

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/replicationcontrollers",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteCollectionNamespacedReplicationController​(@Path("namespace")
                                                                                                                                                                  java.lang.String namespace)
        delete collection of ReplicationController
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • deleteCollectionNamespacedReplicationController

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/replicationcontrollers",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteCollectionNamespacedReplicationController​(@Path("namespace")
                                                                                                                                                                  java.lang.String namespace,
                                                                                                                                                                  @Body
                                                                                                                                                                  com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions body,
                                                                                                                                                                  @QueryMap
                                                                                                                                                                  CoreV1Api.DeleteCollectionNamespacedReplicationController queryParameters)
        delete collection of ReplicationController
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • deleteCollectionNamespacedReplicationController

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/replicationcontrollers",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteCollectionNamespacedReplicationController​(@Path("namespace")
                                                                                                                                                                  java.lang.String namespace,
                                                                                                                                                                  @QueryMap
                                                                                                                                                                  CoreV1Api.DeleteCollectionNamespacedReplicationController queryParameters)
        delete collection of ReplicationController
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • listNamespacedReplicationController

        @HTTP(method="GET",
              path="/api/v1/namespaces/{namespace}/replicationcontrollers")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesListCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.ReplicationControllerList,​com.marcnuri.yakc.model.io.k8s.api.core.v1.ReplicationController> listNamespacedReplicationController​(@Path("namespace")
                                                                                                                                                                                                                                  java.lang.String namespace)
        list or watch objects of kind ReplicationController
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • listNamespacedReplicationController

        @HTTP(method="GET",
              path="/api/v1/namespaces/{namespace}/replicationcontrollers")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesListCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.ReplicationControllerList,​com.marcnuri.yakc.model.io.k8s.api.core.v1.ReplicationController> listNamespacedReplicationController​(@Path("namespace")
                                                                                                                                                                                                                                  java.lang.String namespace,
                                                                                                                                                                                                                                  @QueryMap
                                                                                                                                                                                                                                  CoreV1Api.ListNamespacedReplicationController queryParameters)
        list or watch objects of kind ReplicationController
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • createNamespacedReplicationController

        @HTTP(method="POST",
              path="/api/v1/namespaces/{namespace}/replicationcontrollers",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.ReplicationController> createNamespacedReplicationController​(@Path("namespace")
                                                                                                                                                     java.lang.String namespace,
                                                                                                                                                     @Body
                                                                                                                                                     com.marcnuri.yakc.model.io.k8s.api.core.v1.ReplicationController body)
        create a ReplicationController
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • createNamespacedReplicationController

        @HTTP(method="POST",
              path="/api/v1/namespaces/{namespace}/replicationcontrollers",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.ReplicationController> createNamespacedReplicationController​(@Path("namespace")
                                                                                                                                                     java.lang.String namespace,
                                                                                                                                                     @Body
                                                                                                                                                     com.marcnuri.yakc.model.io.k8s.api.core.v1.ReplicationController body,
                                                                                                                                                     @QueryMap
                                                                                                                                                     CoreV1Api.CreateNamespacedReplicationController queryParameters)
        create a ReplicationController
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • deleteNamespacedReplicationController

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/replicationcontrollers/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteNamespacedReplicationController​(@Path("name")
                                                                                                                                                        java.lang.String name,
                                                                                                                                                        @Path("namespace")
                                                                                                                                                        java.lang.String namespace,
                                                                                                                                                        @Body
                                                                                                                                                        com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions body)
        delete a ReplicationController
        Parameters:
        name - name of the ReplicationController
        namespace - object name and auth scope, such as for teams and projects
      • deleteNamespacedReplicationController

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/replicationcontrollers/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteNamespacedReplicationController​(@Path("name")
                                                                                                                                                        java.lang.String name,
                                                                                                                                                        @Path("namespace")
                                                                                                                                                        java.lang.String namespace)
        delete a ReplicationController
        Parameters:
        name - name of the ReplicationController
        namespace - object name and auth scope, such as for teams and projects
      • deleteNamespacedReplicationController

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/replicationcontrollers/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteNamespacedReplicationController​(@Path("name")
                                                                                                                                                        java.lang.String name,
                                                                                                                                                        @Path("namespace")
                                                                                                                                                        java.lang.String namespace,
                                                                                                                                                        @Body
                                                                                                                                                        com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions body,
                                                                                                                                                        @QueryMap
                                                                                                                                                        CoreV1Api.DeleteNamespacedReplicationController queryParameters)
        delete a ReplicationController
        Parameters:
        name - name of the ReplicationController
        namespace - object name and auth scope, such as for teams and projects
      • deleteNamespacedReplicationController

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/replicationcontrollers/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteNamespacedReplicationController​(@Path("name")
                                                                                                                                                        java.lang.String name,
                                                                                                                                                        @Path("namespace")
                                                                                                                                                        java.lang.String namespace,
                                                                                                                                                        @QueryMap
                                                                                                                                                        CoreV1Api.DeleteNamespacedReplicationController queryParameters)
        delete a ReplicationController
        Parameters:
        name - name of the ReplicationController
        namespace - object name and auth scope, such as for teams and projects
      • readNamespacedReplicationController

        @HTTP(method="GET",
              path="/api/v1/namespaces/{namespace}/replicationcontrollers/{name}")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.ReplicationController> readNamespacedReplicationController​(@Path("name")
                                                                                                                                                   java.lang.String name,
                                                                                                                                                   @Path("namespace")
                                                                                                                                                   java.lang.String namespace)
        read the specified ReplicationController
        Parameters:
        name - name of the ReplicationController
        namespace - object name and auth scope, such as for teams and projects
      • readNamespacedReplicationController

        @HTTP(method="GET",
              path="/api/v1/namespaces/{namespace}/replicationcontrollers/{name}")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.ReplicationController> readNamespacedReplicationController​(@Path("name")
                                                                                                                                                   java.lang.String name,
                                                                                                                                                   @Path("namespace")
                                                                                                                                                   java.lang.String namespace,
                                                                                                                                                   @QueryMap
                                                                                                                                                   CoreV1Api.ReadNamespacedReplicationController queryParameters)
        read the specified ReplicationController
        Parameters:
        name - name of the ReplicationController
        namespace - object name and auth scope, such as for teams and projects
      • patchNamespacedReplicationController

        @HTTP(method="PATCH",
              path="/api/v1/namespaces/{namespace}/replicationcontrollers/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/merge-patch+json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.ReplicationController> patchNamespacedReplicationController​(@Path("name")
                                                                                                                                                    java.lang.String name,
                                                                                                                                                    @Path("namespace")
                                                                                                                                                    java.lang.String namespace,
                                                                                                                                                    @Body
                                                                                                                                                    com.marcnuri.yakc.model.io.k8s.api.core.v1.ReplicationController body)
        partially update the specified ReplicationController
        Parameters:
        name - name of the ReplicationController
        namespace - object name and auth scope, such as for teams and projects
      • patchNamespacedReplicationController

        @HTTP(method="PATCH",
              path="/api/v1/namespaces/{namespace}/replicationcontrollers/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/merge-patch+json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.ReplicationController> patchNamespacedReplicationController​(@Path("name")
                                                                                                                                                    java.lang.String name,
                                                                                                                                                    @Path("namespace")
                                                                                                                                                    java.lang.String namespace,
                                                                                                                                                    @Body
                                                                                                                                                    com.marcnuri.yakc.model.io.k8s.api.core.v1.ReplicationController body,
                                                                                                                                                    @QueryMap
                                                                                                                                                    CoreV1Api.PatchNamespacedReplicationController queryParameters)
        partially update the specified ReplicationController
        Parameters:
        name - name of the ReplicationController
        namespace - object name and auth scope, such as for teams and projects
      • replaceNamespacedReplicationController

        @HTTP(method="PUT",
              path="/api/v1/namespaces/{namespace}/replicationcontrollers/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.ReplicationController> replaceNamespacedReplicationController​(@Path("name")
                                                                                                                                                      java.lang.String name,
                                                                                                                                                      @Path("namespace")
                                                                                                                                                      java.lang.String namespace,
                                                                                                                                                      @Body
                                                                                                                                                      com.marcnuri.yakc.model.io.k8s.api.core.v1.ReplicationController body)
        replace the specified ReplicationController
        Parameters:
        name - name of the ReplicationController
        namespace - object name and auth scope, such as for teams and projects
      • replaceNamespacedReplicationController

        @HTTP(method="PUT",
              path="/api/v1/namespaces/{namespace}/replicationcontrollers/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.ReplicationController> replaceNamespacedReplicationController​(@Path("name")
                                                                                                                                                      java.lang.String name,
                                                                                                                                                      @Path("namespace")
                                                                                                                                                      java.lang.String namespace,
                                                                                                                                                      @Body
                                                                                                                                                      com.marcnuri.yakc.model.io.k8s.api.core.v1.ReplicationController body,
                                                                                                                                                      @QueryMap
                                                                                                                                                      CoreV1Api.ReplaceNamespacedReplicationController queryParameters)
        replace the specified ReplicationController
        Parameters:
        name - name of the ReplicationController
        namespace - object name and auth scope, such as for teams and projects
      • readNamespacedReplicationControllerScale

        @HTTP(method="GET",
              path="/api/v1/namespaces/{namespace}/replicationcontrollers/{name}/scale")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.autoscaling.v1.Scale> readNamespacedReplicationControllerScale​(@Path("name")
                                                                                                                                               java.lang.String name,
                                                                                                                                               @Path("namespace")
                                                                                                                                               java.lang.String namespace)
        read scale of the specified ReplicationController
        Parameters:
        name - name of the Scale
        namespace - object name and auth scope, such as for teams and projects
      • readNamespacedReplicationControllerScale

        @HTTP(method="GET",
              path="/api/v1/namespaces/{namespace}/replicationcontrollers/{name}/scale")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.autoscaling.v1.Scale> readNamespacedReplicationControllerScale​(@Path("name")
                                                                                                                                               java.lang.String name,
                                                                                                                                               @Path("namespace")
                                                                                                                                               java.lang.String namespace,
                                                                                                                                               @QueryMap
                                                                                                                                               CoreV1Api.ReadNamespacedReplicationControllerScale queryParameters)
        read scale of the specified ReplicationController
        Parameters:
        name - name of the Scale
        namespace - object name and auth scope, such as for teams and projects
      • patchNamespacedReplicationControllerScale

        @HTTP(method="PATCH",
              path="/api/v1/namespaces/{namespace}/replicationcontrollers/{name}/scale",
              hasBody=true)
        @Headers({"Content-Type: application/merge-patch+json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.autoscaling.v1.Scale> patchNamespacedReplicationControllerScale​(@Path("name")
                                                                                                                                                java.lang.String name,
                                                                                                                                                @Path("namespace")
                                                                                                                                                java.lang.String namespace,
                                                                                                                                                @Body
                                                                                                                                                com.marcnuri.yakc.model.io.k8s.api.autoscaling.v1.Scale body)
        partially update scale of the specified ReplicationController
        Parameters:
        name - name of the Scale
        namespace - object name and auth scope, such as for teams and projects
      • patchNamespacedReplicationControllerScale

        @HTTP(method="PATCH",
              path="/api/v1/namespaces/{namespace}/replicationcontrollers/{name}/scale",
              hasBody=true)
        @Headers({"Content-Type: application/merge-patch+json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.autoscaling.v1.Scale> patchNamespacedReplicationControllerScale​(@Path("name")
                                                                                                                                                java.lang.String name,
                                                                                                                                                @Path("namespace")
                                                                                                                                                java.lang.String namespace,
                                                                                                                                                @Body
                                                                                                                                                com.marcnuri.yakc.model.io.k8s.api.autoscaling.v1.Scale body,
                                                                                                                                                @QueryMap
                                                                                                                                                CoreV1Api.PatchNamespacedReplicationControllerScale queryParameters)
        partially update scale of the specified ReplicationController
        Parameters:
        name - name of the Scale
        namespace - object name and auth scope, such as for teams and projects
      • replaceNamespacedReplicationControllerScale

        @HTTP(method="PUT",
              path="/api/v1/namespaces/{namespace}/replicationcontrollers/{name}/scale",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.autoscaling.v1.Scale> replaceNamespacedReplicationControllerScale​(@Path("name")
                                                                                                                                                  java.lang.String name,
                                                                                                                                                  @Path("namespace")
                                                                                                                                                  java.lang.String namespace,
                                                                                                                                                  @Body
                                                                                                                                                  com.marcnuri.yakc.model.io.k8s.api.autoscaling.v1.Scale body)
        replace scale of the specified ReplicationController
        Parameters:
        name - name of the Scale
        namespace - object name and auth scope, such as for teams and projects
      • replaceNamespacedReplicationControllerScale

        @HTTP(method="PUT",
              path="/api/v1/namespaces/{namespace}/replicationcontrollers/{name}/scale",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.autoscaling.v1.Scale> replaceNamespacedReplicationControllerScale​(@Path("name")
                                                                                                                                                  java.lang.String name,
                                                                                                                                                  @Path("namespace")
                                                                                                                                                  java.lang.String namespace,
                                                                                                                                                  @Body
                                                                                                                                                  com.marcnuri.yakc.model.io.k8s.api.autoscaling.v1.Scale body,
                                                                                                                                                  @QueryMap
                                                                                                                                                  CoreV1Api.ReplaceNamespacedReplicationControllerScale queryParameters)
        replace scale of the specified ReplicationController
        Parameters:
        name - name of the Scale
        namespace - object name and auth scope, such as for teams and projects
      • readNamespacedReplicationControllerStatus

        @HTTP(method="GET",
              path="/api/v1/namespaces/{namespace}/replicationcontrollers/{name}/status")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.ReplicationController> readNamespacedReplicationControllerStatus​(@Path("name")
                                                                                                                                                         java.lang.String name,
                                                                                                                                                         @Path("namespace")
                                                                                                                                                         java.lang.String namespace)
        read status of the specified ReplicationController
        Parameters:
        name - name of the ReplicationController
        namespace - object name and auth scope, such as for teams and projects
      • readNamespacedReplicationControllerStatus

        @HTTP(method="GET",
              path="/api/v1/namespaces/{namespace}/replicationcontrollers/{name}/status")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.ReplicationController> readNamespacedReplicationControllerStatus​(@Path("name")
                                                                                                                                                         java.lang.String name,
                                                                                                                                                         @Path("namespace")
                                                                                                                                                         java.lang.String namespace,
                                                                                                                                                         @QueryMap
                                                                                                                                                         CoreV1Api.ReadNamespacedReplicationControllerStatus queryParameters)
        read status of the specified ReplicationController
        Parameters:
        name - name of the ReplicationController
        namespace - object name and auth scope, such as for teams and projects
      • patchNamespacedReplicationControllerStatus

        @HTTP(method="PATCH",
              path="/api/v1/namespaces/{namespace}/replicationcontrollers/{name}/status",
              hasBody=true)
        @Headers({"Content-Type: application/merge-patch+json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.ReplicationController> patchNamespacedReplicationControllerStatus​(@Path("name")
                                                                                                                                                          java.lang.String name,
                                                                                                                                                          @Path("namespace")
                                                                                                                                                          java.lang.String namespace,
                                                                                                                                                          @Body
                                                                                                                                                          com.marcnuri.yakc.model.io.k8s.api.core.v1.ReplicationController body)
        partially update status of the specified ReplicationController
        Parameters:
        name - name of the ReplicationController
        namespace - object name and auth scope, such as for teams and projects
      • patchNamespacedReplicationControllerStatus

        @HTTP(method="PATCH",
              path="/api/v1/namespaces/{namespace}/replicationcontrollers/{name}/status",
              hasBody=true)
        @Headers({"Content-Type: application/merge-patch+json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.ReplicationController> patchNamespacedReplicationControllerStatus​(@Path("name")
                                                                                                                                                          java.lang.String name,
                                                                                                                                                          @Path("namespace")
                                                                                                                                                          java.lang.String namespace,
                                                                                                                                                          @Body
                                                                                                                                                          com.marcnuri.yakc.model.io.k8s.api.core.v1.ReplicationController body,
                                                                                                                                                          @QueryMap
                                                                                                                                                          CoreV1Api.PatchNamespacedReplicationControllerStatus queryParameters)
        partially update status of the specified ReplicationController
        Parameters:
        name - name of the ReplicationController
        namespace - object name and auth scope, such as for teams and projects
      • replaceNamespacedReplicationControllerStatus

        @HTTP(method="PUT",
              path="/api/v1/namespaces/{namespace}/replicationcontrollers/{name}/status",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.ReplicationController> replaceNamespacedReplicationControllerStatus​(@Path("name")
                                                                                                                                                            java.lang.String name,
                                                                                                                                                            @Path("namespace")
                                                                                                                                                            java.lang.String namespace,
                                                                                                                                                            @Body
                                                                                                                                                            com.marcnuri.yakc.model.io.k8s.api.core.v1.ReplicationController body)
        replace status of the specified ReplicationController
        Parameters:
        name - name of the ReplicationController
        namespace - object name and auth scope, such as for teams and projects
      • replaceNamespacedReplicationControllerStatus

        @HTTP(method="PUT",
              path="/api/v1/namespaces/{namespace}/replicationcontrollers/{name}/status",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.ReplicationController> replaceNamespacedReplicationControllerStatus​(@Path("name")
                                                                                                                                                            java.lang.String name,
                                                                                                                                                            @Path("namespace")
                                                                                                                                                            java.lang.String namespace,
                                                                                                                                                            @Body
                                                                                                                                                            com.marcnuri.yakc.model.io.k8s.api.core.v1.ReplicationController body,
                                                                                                                                                            @QueryMap
                                                                                                                                                            CoreV1Api.ReplaceNamespacedReplicationControllerStatus queryParameters)
        replace status of the specified ReplicationController
        Parameters:
        name - name of the ReplicationController
        namespace - object name and auth scope, such as for teams and projects
      • deleteCollectionNamespacedResourceQuota

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/resourcequotas",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteCollectionNamespacedResourceQuota​(@Path("namespace")
                                                                                                                                                          java.lang.String namespace,
                                                                                                                                                          @Body
                                                                                                                                                          com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions body)
        delete collection of ResourceQuota
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • deleteCollectionNamespacedResourceQuota

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/resourcequotas",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteCollectionNamespacedResourceQuota​(@Path("namespace")
                                                                                                                                                          java.lang.String namespace)
        delete collection of ResourceQuota
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • deleteCollectionNamespacedResourceQuota

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/resourcequotas",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteCollectionNamespacedResourceQuota​(@Path("namespace")
                                                                                                                                                          java.lang.String namespace,
                                                                                                                                                          @Body
                                                                                                                                                          com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions body,
                                                                                                                                                          @QueryMap
                                                                                                                                                          CoreV1Api.DeleteCollectionNamespacedResourceQuota queryParameters)
        delete collection of ResourceQuota
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • deleteCollectionNamespacedResourceQuota

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/resourcequotas",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteCollectionNamespacedResourceQuota​(@Path("namespace")
                                                                                                                                                          java.lang.String namespace,
                                                                                                                                                          @QueryMap
                                                                                                                                                          CoreV1Api.DeleteCollectionNamespacedResourceQuota queryParameters)
        delete collection of ResourceQuota
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • listNamespacedResourceQuota

        @HTTP(method="GET",
              path="/api/v1/namespaces/{namespace}/resourcequotas")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesListCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.ResourceQuotaList,​com.marcnuri.yakc.model.io.k8s.api.core.v1.ResourceQuota> listNamespacedResourceQuota​(@Path("namespace")
                                                                                                                                                                                                          java.lang.String namespace)
        list or watch objects of kind ResourceQuota
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • listNamespacedResourceQuota

        @HTTP(method="GET",
              path="/api/v1/namespaces/{namespace}/resourcequotas")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesListCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.ResourceQuotaList,​com.marcnuri.yakc.model.io.k8s.api.core.v1.ResourceQuota> listNamespacedResourceQuota​(@Path("namespace")
                                                                                                                                                                                                          java.lang.String namespace,
                                                                                                                                                                                                          @QueryMap
                                                                                                                                                                                                          CoreV1Api.ListNamespacedResourceQuota queryParameters)
        list or watch objects of kind ResourceQuota
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • createNamespacedResourceQuota

        @HTTP(method="POST",
              path="/api/v1/namespaces/{namespace}/resourcequotas",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.ResourceQuota> createNamespacedResourceQuota​(@Path("namespace")
                                                                                                                                     java.lang.String namespace,
                                                                                                                                     @Body
                                                                                                                                     com.marcnuri.yakc.model.io.k8s.api.core.v1.ResourceQuota body)
        create a ResourceQuota
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • createNamespacedResourceQuota

        @HTTP(method="POST",
              path="/api/v1/namespaces/{namespace}/resourcequotas",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.ResourceQuota> createNamespacedResourceQuota​(@Path("namespace")
                                                                                                                                     java.lang.String namespace,
                                                                                                                                     @Body
                                                                                                                                     com.marcnuri.yakc.model.io.k8s.api.core.v1.ResourceQuota body,
                                                                                                                                     @QueryMap
                                                                                                                                     CoreV1Api.CreateNamespacedResourceQuota queryParameters)
        create a ResourceQuota
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • deleteNamespacedResourceQuota

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/resourcequotas/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.ResourceQuota> deleteNamespacedResourceQuota​(@Path("name")
                                                                                                                                     java.lang.String name,
                                                                                                                                     @Path("namespace")
                                                                                                                                     java.lang.String namespace,
                                                                                                                                     @Body
                                                                                                                                     com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions body)
        delete a ResourceQuota
        Parameters:
        name - name of the ResourceQuota
        namespace - object name and auth scope, such as for teams and projects
      • deleteNamespacedResourceQuota

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/resourcequotas/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.ResourceQuota> deleteNamespacedResourceQuota​(@Path("name")
                                                                                                                                     java.lang.String name,
                                                                                                                                     @Path("namespace")
                                                                                                                                     java.lang.String namespace)
        delete a ResourceQuota
        Parameters:
        name - name of the ResourceQuota
        namespace - object name and auth scope, such as for teams and projects
      • deleteNamespacedResourceQuota

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/resourcequotas/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.ResourceQuota> deleteNamespacedResourceQuota​(@Path("name")
                                                                                                                                     java.lang.String name,
                                                                                                                                     @Path("namespace")
                                                                                                                                     java.lang.String namespace,
                                                                                                                                     @Body
                                                                                                                                     com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions body,
                                                                                                                                     @QueryMap
                                                                                                                                     CoreV1Api.DeleteNamespacedResourceQuota queryParameters)
        delete a ResourceQuota
        Parameters:
        name - name of the ResourceQuota
        namespace - object name and auth scope, such as for teams and projects
      • deleteNamespacedResourceQuota

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/resourcequotas/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.ResourceQuota> deleteNamespacedResourceQuota​(@Path("name")
                                                                                                                                     java.lang.String name,
                                                                                                                                     @Path("namespace")
                                                                                                                                     java.lang.String namespace,
                                                                                                                                     @QueryMap
                                                                                                                                     CoreV1Api.DeleteNamespacedResourceQuota queryParameters)
        delete a ResourceQuota
        Parameters:
        name - name of the ResourceQuota
        namespace - object name and auth scope, such as for teams and projects
      • readNamespacedResourceQuota

        @HTTP(method="GET",
              path="/api/v1/namespaces/{namespace}/resourcequotas/{name}")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.ResourceQuota> readNamespacedResourceQuota​(@Path("name")
                                                                                                                                   java.lang.String name,
                                                                                                                                   @Path("namespace")
                                                                                                                                   java.lang.String namespace)
        read the specified ResourceQuota
        Parameters:
        name - name of the ResourceQuota
        namespace - object name and auth scope, such as for teams and projects
      • readNamespacedResourceQuota

        @HTTP(method="GET",
              path="/api/v1/namespaces/{namespace}/resourcequotas/{name}")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.ResourceQuota> readNamespacedResourceQuota​(@Path("name")
                                                                                                                                   java.lang.String name,
                                                                                                                                   @Path("namespace")
                                                                                                                                   java.lang.String namespace,
                                                                                                                                   @QueryMap
                                                                                                                                   CoreV1Api.ReadNamespacedResourceQuota queryParameters)
        read the specified ResourceQuota
        Parameters:
        name - name of the ResourceQuota
        namespace - object name and auth scope, such as for teams and projects
      • patchNamespacedResourceQuota

        @HTTP(method="PATCH",
              path="/api/v1/namespaces/{namespace}/resourcequotas/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/merge-patch+json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.ResourceQuota> patchNamespacedResourceQuota​(@Path("name")
                                                                                                                                    java.lang.String name,
                                                                                                                                    @Path("namespace")
                                                                                                                                    java.lang.String namespace,
                                                                                                                                    @Body
                                                                                                                                    com.marcnuri.yakc.model.io.k8s.api.core.v1.ResourceQuota body)
        partially update the specified ResourceQuota
        Parameters:
        name - name of the ResourceQuota
        namespace - object name and auth scope, such as for teams and projects
      • patchNamespacedResourceQuota

        @HTTP(method="PATCH",
              path="/api/v1/namespaces/{namespace}/resourcequotas/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/merge-patch+json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.ResourceQuota> patchNamespacedResourceQuota​(@Path("name")
                                                                                                                                    java.lang.String name,
                                                                                                                                    @Path("namespace")
                                                                                                                                    java.lang.String namespace,
                                                                                                                                    @Body
                                                                                                                                    com.marcnuri.yakc.model.io.k8s.api.core.v1.ResourceQuota body,
                                                                                                                                    @QueryMap
                                                                                                                                    CoreV1Api.PatchNamespacedResourceQuota queryParameters)
        partially update the specified ResourceQuota
        Parameters:
        name - name of the ResourceQuota
        namespace - object name and auth scope, such as for teams and projects
      • replaceNamespacedResourceQuota

        @HTTP(method="PUT",
              path="/api/v1/namespaces/{namespace}/resourcequotas/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.ResourceQuota> replaceNamespacedResourceQuota​(@Path("name")
                                                                                                                                      java.lang.String name,
                                                                                                                                      @Path("namespace")
                                                                                                                                      java.lang.String namespace,
                                                                                                                                      @Body
                                                                                                                                      com.marcnuri.yakc.model.io.k8s.api.core.v1.ResourceQuota body)
        replace the specified ResourceQuota
        Parameters:
        name - name of the ResourceQuota
        namespace - object name and auth scope, such as for teams and projects
      • replaceNamespacedResourceQuota

        @HTTP(method="PUT",
              path="/api/v1/namespaces/{namespace}/resourcequotas/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.ResourceQuota> replaceNamespacedResourceQuota​(@Path("name")
                                                                                                                                      java.lang.String name,
                                                                                                                                      @Path("namespace")
                                                                                                                                      java.lang.String namespace,
                                                                                                                                      @Body
                                                                                                                                      com.marcnuri.yakc.model.io.k8s.api.core.v1.ResourceQuota body,
                                                                                                                                      @QueryMap
                                                                                                                                      CoreV1Api.ReplaceNamespacedResourceQuota queryParameters)
        replace the specified ResourceQuota
        Parameters:
        name - name of the ResourceQuota
        namespace - object name and auth scope, such as for teams and projects
      • readNamespacedResourceQuotaStatus

        @HTTP(method="GET",
              path="/api/v1/namespaces/{namespace}/resourcequotas/{name}/status")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.ResourceQuota> readNamespacedResourceQuotaStatus​(@Path("name")
                                                                                                                                         java.lang.String name,
                                                                                                                                         @Path("namespace")
                                                                                                                                         java.lang.String namespace)
        read status of the specified ResourceQuota
        Parameters:
        name - name of the ResourceQuota
        namespace - object name and auth scope, such as for teams and projects
      • readNamespacedResourceQuotaStatus

        @HTTP(method="GET",
              path="/api/v1/namespaces/{namespace}/resourcequotas/{name}/status")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.ResourceQuota> readNamespacedResourceQuotaStatus​(@Path("name")
                                                                                                                                         java.lang.String name,
                                                                                                                                         @Path("namespace")
                                                                                                                                         java.lang.String namespace,
                                                                                                                                         @QueryMap
                                                                                                                                         CoreV1Api.ReadNamespacedResourceQuotaStatus queryParameters)
        read status of the specified ResourceQuota
        Parameters:
        name - name of the ResourceQuota
        namespace - object name and auth scope, such as for teams and projects
      • patchNamespacedResourceQuotaStatus

        @HTTP(method="PATCH",
              path="/api/v1/namespaces/{namespace}/resourcequotas/{name}/status",
              hasBody=true)
        @Headers({"Content-Type: application/merge-patch+json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.ResourceQuota> patchNamespacedResourceQuotaStatus​(@Path("name")
                                                                                                                                          java.lang.String name,
                                                                                                                                          @Path("namespace")
                                                                                                                                          java.lang.String namespace,
                                                                                                                                          @Body
                                                                                                                                          com.marcnuri.yakc.model.io.k8s.api.core.v1.ResourceQuota body)
        partially update status of the specified ResourceQuota
        Parameters:
        name - name of the ResourceQuota
        namespace - object name and auth scope, such as for teams and projects
      • patchNamespacedResourceQuotaStatus

        @HTTP(method="PATCH",
              path="/api/v1/namespaces/{namespace}/resourcequotas/{name}/status",
              hasBody=true)
        @Headers({"Content-Type: application/merge-patch+json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.ResourceQuota> patchNamespacedResourceQuotaStatus​(@Path("name")
                                                                                                                                          java.lang.String name,
                                                                                                                                          @Path("namespace")
                                                                                                                                          java.lang.String namespace,
                                                                                                                                          @Body
                                                                                                                                          com.marcnuri.yakc.model.io.k8s.api.core.v1.ResourceQuota body,
                                                                                                                                          @QueryMap
                                                                                                                                          CoreV1Api.PatchNamespacedResourceQuotaStatus queryParameters)
        partially update status of the specified ResourceQuota
        Parameters:
        name - name of the ResourceQuota
        namespace - object name and auth scope, such as for teams and projects
      • replaceNamespacedResourceQuotaStatus

        @HTTP(method="PUT",
              path="/api/v1/namespaces/{namespace}/resourcequotas/{name}/status",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.ResourceQuota> replaceNamespacedResourceQuotaStatus​(@Path("name")
                                                                                                                                            java.lang.String name,
                                                                                                                                            @Path("namespace")
                                                                                                                                            java.lang.String namespace,
                                                                                                                                            @Body
                                                                                                                                            com.marcnuri.yakc.model.io.k8s.api.core.v1.ResourceQuota body)
        replace status of the specified ResourceQuota
        Parameters:
        name - name of the ResourceQuota
        namespace - object name and auth scope, such as for teams and projects
      • replaceNamespacedResourceQuotaStatus

        @HTTP(method="PUT",
              path="/api/v1/namespaces/{namespace}/resourcequotas/{name}/status",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.ResourceQuota> replaceNamespacedResourceQuotaStatus​(@Path("name")
                                                                                                                                            java.lang.String name,
                                                                                                                                            @Path("namespace")
                                                                                                                                            java.lang.String namespace,
                                                                                                                                            @Body
                                                                                                                                            com.marcnuri.yakc.model.io.k8s.api.core.v1.ResourceQuota body,
                                                                                                                                            @QueryMap
                                                                                                                                            CoreV1Api.ReplaceNamespacedResourceQuotaStatus queryParameters)
        replace status of the specified ResourceQuota
        Parameters:
        name - name of the ResourceQuota
        namespace - object name and auth scope, such as for teams and projects
      • deleteCollectionNamespacedSecret

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/secrets",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteCollectionNamespacedSecret​(@Path("namespace")
                                                                                                                                                   java.lang.String namespace,
                                                                                                                                                   @Body
                                                                                                                                                   com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions body)
        delete collection of Secret
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • deleteCollectionNamespacedSecret

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/secrets",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteCollectionNamespacedSecret​(@Path("namespace")
                                                                                                                                                   java.lang.String namespace)
        delete collection of Secret
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • deleteCollectionNamespacedSecret

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/secrets",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteCollectionNamespacedSecret​(@Path("namespace")
                                                                                                                                                   java.lang.String namespace,
                                                                                                                                                   @Body
                                                                                                                                                   com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions body,
                                                                                                                                                   @QueryMap
                                                                                                                                                   CoreV1Api.DeleteCollectionNamespacedSecret queryParameters)
        delete collection of Secret
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • deleteCollectionNamespacedSecret

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/secrets",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteCollectionNamespacedSecret​(@Path("namespace")
                                                                                                                                                   java.lang.String namespace,
                                                                                                                                                   @QueryMap
                                                                                                                                                   CoreV1Api.DeleteCollectionNamespacedSecret queryParameters)
        delete collection of Secret
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • listNamespacedSecret

        @HTTP(method="GET",
              path="/api/v1/namespaces/{namespace}/secrets")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesListCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.SecretList,​com.marcnuri.yakc.model.io.k8s.api.core.v1.Secret> listNamespacedSecret​(@Path("namespace")
                                                                                                                                                                                     java.lang.String namespace)
        list or watch objects of kind Secret
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • listNamespacedSecret

        @HTTP(method="GET",
              path="/api/v1/namespaces/{namespace}/secrets")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesListCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.SecretList,​com.marcnuri.yakc.model.io.k8s.api.core.v1.Secret> listNamespacedSecret​(@Path("namespace")
                                                                                                                                                                                     java.lang.String namespace,
                                                                                                                                                                                     @QueryMap
                                                                                                                                                                                     CoreV1Api.ListNamespacedSecret queryParameters)
        list or watch objects of kind Secret
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • createNamespacedSecret

        @HTTP(method="POST",
              path="/api/v1/namespaces/{namespace}/secrets",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Secret> createNamespacedSecret​(@Path("namespace")
                                                                                                                       java.lang.String namespace,
                                                                                                                       @Body
                                                                                                                       com.marcnuri.yakc.model.io.k8s.api.core.v1.Secret body)
        create a Secret
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • createNamespacedSecret

        @HTTP(method="POST",
              path="/api/v1/namespaces/{namespace}/secrets",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Secret> createNamespacedSecret​(@Path("namespace")
                                                                                                                       java.lang.String namespace,
                                                                                                                       @Body
                                                                                                                       com.marcnuri.yakc.model.io.k8s.api.core.v1.Secret body,
                                                                                                                       @QueryMap
                                                                                                                       CoreV1Api.CreateNamespacedSecret queryParameters)
        create a Secret
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • deleteNamespacedSecret

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/secrets/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteNamespacedSecret​(@Path("name")
                                                                                                                                         java.lang.String name,
                                                                                                                                         @Path("namespace")
                                                                                                                                         java.lang.String namespace,
                                                                                                                                         @Body
                                                                                                                                         com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions body)
        delete a Secret
        Parameters:
        name - name of the Secret
        namespace - object name and auth scope, such as for teams and projects
      • deleteNamespacedSecret

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/secrets/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteNamespacedSecret​(@Path("name")
                                                                                                                                         java.lang.String name,
                                                                                                                                         @Path("namespace")
                                                                                                                                         java.lang.String namespace)
        delete a Secret
        Parameters:
        name - name of the Secret
        namespace - object name and auth scope, such as for teams and projects
      • deleteNamespacedSecret

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/secrets/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteNamespacedSecret​(@Path("name")
                                                                                                                                         java.lang.String name,
                                                                                                                                         @Path("namespace")
                                                                                                                                         java.lang.String namespace,
                                                                                                                                         @Body
                                                                                                                                         com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions body,
                                                                                                                                         @QueryMap
                                                                                                                                         CoreV1Api.DeleteNamespacedSecret queryParameters)
        delete a Secret
        Parameters:
        name - name of the Secret
        namespace - object name and auth scope, such as for teams and projects
      • deleteNamespacedSecret

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/secrets/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteNamespacedSecret​(@Path("name")
                                                                                                                                         java.lang.String name,
                                                                                                                                         @Path("namespace")
                                                                                                                                         java.lang.String namespace,
                                                                                                                                         @QueryMap
                                                                                                                                         CoreV1Api.DeleteNamespacedSecret queryParameters)
        delete a Secret
        Parameters:
        name - name of the Secret
        namespace - object name and auth scope, such as for teams and projects
      • readNamespacedSecret

        @HTTP(method="GET",
              path="/api/v1/namespaces/{namespace}/secrets/{name}")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Secret> readNamespacedSecret​(@Path("name")
                                                                                                                     java.lang.String name,
                                                                                                                     @Path("namespace")
                                                                                                                     java.lang.String namespace)
        read the specified Secret
        Parameters:
        name - name of the Secret
        namespace - object name and auth scope, such as for teams and projects
      • readNamespacedSecret

        @HTTP(method="GET",
              path="/api/v1/namespaces/{namespace}/secrets/{name}")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Secret> readNamespacedSecret​(@Path("name")
                                                                                                                     java.lang.String name,
                                                                                                                     @Path("namespace")
                                                                                                                     java.lang.String namespace,
                                                                                                                     @QueryMap
                                                                                                                     CoreV1Api.ReadNamespacedSecret queryParameters)
        read the specified Secret
        Parameters:
        name - name of the Secret
        namespace - object name and auth scope, such as for teams and projects
      • patchNamespacedSecret

        @HTTP(method="PATCH",
              path="/api/v1/namespaces/{namespace}/secrets/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/merge-patch+json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Secret> patchNamespacedSecret​(@Path("name")
                                                                                                                      java.lang.String name,
                                                                                                                      @Path("namespace")
                                                                                                                      java.lang.String namespace,
                                                                                                                      @Body
                                                                                                                      com.marcnuri.yakc.model.io.k8s.api.core.v1.Secret body)
        partially update the specified Secret
        Parameters:
        name - name of the Secret
        namespace - object name and auth scope, such as for teams and projects
      • patchNamespacedSecret

        @HTTP(method="PATCH",
              path="/api/v1/namespaces/{namespace}/secrets/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/merge-patch+json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Secret> patchNamespacedSecret​(@Path("name")
                                                                                                                      java.lang.String name,
                                                                                                                      @Path("namespace")
                                                                                                                      java.lang.String namespace,
                                                                                                                      @Body
                                                                                                                      com.marcnuri.yakc.model.io.k8s.api.core.v1.Secret body,
                                                                                                                      @QueryMap
                                                                                                                      CoreV1Api.PatchNamespacedSecret queryParameters)
        partially update the specified Secret
        Parameters:
        name - name of the Secret
        namespace - object name and auth scope, such as for teams and projects
      • replaceNamespacedSecret

        @HTTP(method="PUT",
              path="/api/v1/namespaces/{namespace}/secrets/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Secret> replaceNamespacedSecret​(@Path("name")
                                                                                                                        java.lang.String name,
                                                                                                                        @Path("namespace")
                                                                                                                        java.lang.String namespace,
                                                                                                                        @Body
                                                                                                                        com.marcnuri.yakc.model.io.k8s.api.core.v1.Secret body)
        replace the specified Secret
        Parameters:
        name - name of the Secret
        namespace - object name and auth scope, such as for teams and projects
      • replaceNamespacedSecret

        @HTTP(method="PUT",
              path="/api/v1/namespaces/{namespace}/secrets/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Secret> replaceNamespacedSecret​(@Path("name")
                                                                                                                        java.lang.String name,
                                                                                                                        @Path("namespace")
                                                                                                                        java.lang.String namespace,
                                                                                                                        @Body
                                                                                                                        com.marcnuri.yakc.model.io.k8s.api.core.v1.Secret body,
                                                                                                                        @QueryMap
                                                                                                                        CoreV1Api.ReplaceNamespacedSecret queryParameters)
        replace the specified Secret
        Parameters:
        name - name of the Secret
        namespace - object name and auth scope, such as for teams and projects
      • deleteCollectionNamespacedServiceAccount

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/serviceaccounts",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteCollectionNamespacedServiceAccount​(@Path("namespace")
                                                                                                                                                           java.lang.String namespace,
                                                                                                                                                           @Body
                                                                                                                                                           com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions body)
        delete collection of ServiceAccount
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • deleteCollectionNamespacedServiceAccount

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/serviceaccounts",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteCollectionNamespacedServiceAccount​(@Path("namespace")
                                                                                                                                                           java.lang.String namespace)
        delete collection of ServiceAccount
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • deleteCollectionNamespacedServiceAccount

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/serviceaccounts",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteCollectionNamespacedServiceAccount​(@Path("namespace")
                                                                                                                                                           java.lang.String namespace,
                                                                                                                                                           @Body
                                                                                                                                                           com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions body,
                                                                                                                                                           @QueryMap
                                                                                                                                                           CoreV1Api.DeleteCollectionNamespacedServiceAccount queryParameters)
        delete collection of ServiceAccount
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • deleteCollectionNamespacedServiceAccount

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/serviceaccounts",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteCollectionNamespacedServiceAccount​(@Path("namespace")
                                                                                                                                                           java.lang.String namespace,
                                                                                                                                                           @QueryMap
                                                                                                                                                           CoreV1Api.DeleteCollectionNamespacedServiceAccount queryParameters)
        delete collection of ServiceAccount
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • listNamespacedServiceAccount

        @HTTP(method="GET",
              path="/api/v1/namespaces/{namespace}/serviceaccounts")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesListCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.ServiceAccountList,​com.marcnuri.yakc.model.io.k8s.api.core.v1.ServiceAccount> listNamespacedServiceAccount​(@Path("namespace")
                                                                                                                                                                                                             java.lang.String namespace)
        list or watch objects of kind ServiceAccount
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • listNamespacedServiceAccount

        @HTTP(method="GET",
              path="/api/v1/namespaces/{namespace}/serviceaccounts")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesListCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.ServiceAccountList,​com.marcnuri.yakc.model.io.k8s.api.core.v1.ServiceAccount> listNamespacedServiceAccount​(@Path("namespace")
                                                                                                                                                                                                             java.lang.String namespace,
                                                                                                                                                                                                             @QueryMap
                                                                                                                                                                                                             CoreV1Api.ListNamespacedServiceAccount queryParameters)
        list or watch objects of kind ServiceAccount
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • createNamespacedServiceAccount

        @HTTP(method="POST",
              path="/api/v1/namespaces/{namespace}/serviceaccounts",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.ServiceAccount> createNamespacedServiceAccount​(@Path("namespace")
                                                                                                                                       java.lang.String namespace,
                                                                                                                                       @Body
                                                                                                                                       com.marcnuri.yakc.model.io.k8s.api.core.v1.ServiceAccount body)
        create a ServiceAccount
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • createNamespacedServiceAccount

        @HTTP(method="POST",
              path="/api/v1/namespaces/{namespace}/serviceaccounts",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.ServiceAccount> createNamespacedServiceAccount​(@Path("namespace")
                                                                                                                                       java.lang.String namespace,
                                                                                                                                       @Body
                                                                                                                                       com.marcnuri.yakc.model.io.k8s.api.core.v1.ServiceAccount body,
                                                                                                                                       @QueryMap
                                                                                                                                       CoreV1Api.CreateNamespacedServiceAccount queryParameters)
        create a ServiceAccount
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • deleteNamespacedServiceAccount

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/serviceaccounts/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.ServiceAccount> deleteNamespacedServiceAccount​(@Path("name")
                                                                                                                                       java.lang.String name,
                                                                                                                                       @Path("namespace")
                                                                                                                                       java.lang.String namespace,
                                                                                                                                       @Body
                                                                                                                                       com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions body)
        delete a ServiceAccount
        Parameters:
        name - name of the ServiceAccount
        namespace - object name and auth scope, such as for teams and projects
      • deleteNamespacedServiceAccount

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/serviceaccounts/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.ServiceAccount> deleteNamespacedServiceAccount​(@Path("name")
                                                                                                                                       java.lang.String name,
                                                                                                                                       @Path("namespace")
                                                                                                                                       java.lang.String namespace)
        delete a ServiceAccount
        Parameters:
        name - name of the ServiceAccount
        namespace - object name and auth scope, such as for teams and projects
      • deleteNamespacedServiceAccount

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/serviceaccounts/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.ServiceAccount> deleteNamespacedServiceAccount​(@Path("name")
                                                                                                                                       java.lang.String name,
                                                                                                                                       @Path("namespace")
                                                                                                                                       java.lang.String namespace,
                                                                                                                                       @Body
                                                                                                                                       com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions body,
                                                                                                                                       @QueryMap
                                                                                                                                       CoreV1Api.DeleteNamespacedServiceAccount queryParameters)
        delete a ServiceAccount
        Parameters:
        name - name of the ServiceAccount
        namespace - object name and auth scope, such as for teams and projects
      • deleteNamespacedServiceAccount

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/serviceaccounts/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.ServiceAccount> deleteNamespacedServiceAccount​(@Path("name")
                                                                                                                                       java.lang.String name,
                                                                                                                                       @Path("namespace")
                                                                                                                                       java.lang.String namespace,
                                                                                                                                       @QueryMap
                                                                                                                                       CoreV1Api.DeleteNamespacedServiceAccount queryParameters)
        delete a ServiceAccount
        Parameters:
        name - name of the ServiceAccount
        namespace - object name and auth scope, such as for teams and projects
      • readNamespacedServiceAccount

        @HTTP(method="GET",
              path="/api/v1/namespaces/{namespace}/serviceaccounts/{name}")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.ServiceAccount> readNamespacedServiceAccount​(@Path("name")
                                                                                                                                     java.lang.String name,
                                                                                                                                     @Path("namespace")
                                                                                                                                     java.lang.String namespace)
        read the specified ServiceAccount
        Parameters:
        name - name of the ServiceAccount
        namespace - object name and auth scope, such as for teams and projects
      • readNamespacedServiceAccount

        @HTTP(method="GET",
              path="/api/v1/namespaces/{namespace}/serviceaccounts/{name}")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.ServiceAccount> readNamespacedServiceAccount​(@Path("name")
                                                                                                                                     java.lang.String name,
                                                                                                                                     @Path("namespace")
                                                                                                                                     java.lang.String namespace,
                                                                                                                                     @QueryMap
                                                                                                                                     CoreV1Api.ReadNamespacedServiceAccount queryParameters)
        read the specified ServiceAccount
        Parameters:
        name - name of the ServiceAccount
        namespace - object name and auth scope, such as for teams and projects
      • patchNamespacedServiceAccount

        @HTTP(method="PATCH",
              path="/api/v1/namespaces/{namespace}/serviceaccounts/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/merge-patch+json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.ServiceAccount> patchNamespacedServiceAccount​(@Path("name")
                                                                                                                                      java.lang.String name,
                                                                                                                                      @Path("namespace")
                                                                                                                                      java.lang.String namespace,
                                                                                                                                      @Body
                                                                                                                                      com.marcnuri.yakc.model.io.k8s.api.core.v1.ServiceAccount body)
        partially update the specified ServiceAccount
        Parameters:
        name - name of the ServiceAccount
        namespace - object name and auth scope, such as for teams and projects
      • patchNamespacedServiceAccount

        @HTTP(method="PATCH",
              path="/api/v1/namespaces/{namespace}/serviceaccounts/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/merge-patch+json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.ServiceAccount> patchNamespacedServiceAccount​(@Path("name")
                                                                                                                                      java.lang.String name,
                                                                                                                                      @Path("namespace")
                                                                                                                                      java.lang.String namespace,
                                                                                                                                      @Body
                                                                                                                                      com.marcnuri.yakc.model.io.k8s.api.core.v1.ServiceAccount body,
                                                                                                                                      @QueryMap
                                                                                                                                      CoreV1Api.PatchNamespacedServiceAccount queryParameters)
        partially update the specified ServiceAccount
        Parameters:
        name - name of the ServiceAccount
        namespace - object name and auth scope, such as for teams and projects
      • replaceNamespacedServiceAccount

        @HTTP(method="PUT",
              path="/api/v1/namespaces/{namespace}/serviceaccounts/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.ServiceAccount> replaceNamespacedServiceAccount​(@Path("name")
                                                                                                                                        java.lang.String name,
                                                                                                                                        @Path("namespace")
                                                                                                                                        java.lang.String namespace,
                                                                                                                                        @Body
                                                                                                                                        com.marcnuri.yakc.model.io.k8s.api.core.v1.ServiceAccount body)
        replace the specified ServiceAccount
        Parameters:
        name - name of the ServiceAccount
        namespace - object name and auth scope, such as for teams and projects
      • replaceNamespacedServiceAccount

        @HTTP(method="PUT",
              path="/api/v1/namespaces/{namespace}/serviceaccounts/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.ServiceAccount> replaceNamespacedServiceAccount​(@Path("name")
                                                                                                                                        java.lang.String name,
                                                                                                                                        @Path("namespace")
                                                                                                                                        java.lang.String namespace,
                                                                                                                                        @Body
                                                                                                                                        com.marcnuri.yakc.model.io.k8s.api.core.v1.ServiceAccount body,
                                                                                                                                        @QueryMap
                                                                                                                                        CoreV1Api.ReplaceNamespacedServiceAccount queryParameters)
        replace the specified ServiceAccount
        Parameters:
        name - name of the ServiceAccount
        namespace - object name and auth scope, such as for teams and projects
      • createNamespacedServiceAccountToken

        @HTTP(method="POST",
              path="/api/v1/namespaces/{namespace}/serviceaccounts/{name}/token",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.authentication.v1.TokenRequest> createNamespacedServiceAccountToken​(@Path("name")
                                                                                                                                                    java.lang.String name,
                                                                                                                                                    @Path("namespace")
                                                                                                                                                    java.lang.String namespace,
                                                                                                                                                    @Body
                                                                                                                                                    com.marcnuri.yakc.model.io.k8s.api.authentication.v1.TokenRequest body)
        create token of a ServiceAccount
        Parameters:
        name - name of the TokenRequest
        namespace - object name and auth scope, such as for teams and projects
      • createNamespacedServiceAccountToken

        @HTTP(method="POST",
              path="/api/v1/namespaces/{namespace}/serviceaccounts/{name}/token",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.authentication.v1.TokenRequest> createNamespacedServiceAccountToken​(@Path("name")
                                                                                                                                                    java.lang.String name,
                                                                                                                                                    @Path("namespace")
                                                                                                                                                    java.lang.String namespace,
                                                                                                                                                    @Body
                                                                                                                                                    com.marcnuri.yakc.model.io.k8s.api.authentication.v1.TokenRequest body,
                                                                                                                                                    @QueryMap
                                                                                                                                                    CoreV1Api.CreateNamespacedServiceAccountToken queryParameters)
        create token of a ServiceAccount
        Parameters:
        name - name of the TokenRequest
        namespace - object name and auth scope, such as for teams and projects
      • deleteCollectionNamespacedService

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/services",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteCollectionNamespacedService​(@Path("namespace")
                                                                                                                                                    java.lang.String namespace,
                                                                                                                                                    @Body
                                                                                                                                                    com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions body)
        delete collection of Service
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • deleteCollectionNamespacedService

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/services",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteCollectionNamespacedService​(@Path("namespace")
                                                                                                                                                    java.lang.String namespace)
        delete collection of Service
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • deleteCollectionNamespacedService

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/services",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteCollectionNamespacedService​(@Path("namespace")
                                                                                                                                                    java.lang.String namespace,
                                                                                                                                                    @Body
                                                                                                                                                    com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions body,
                                                                                                                                                    @QueryMap
                                                                                                                                                    CoreV1Api.DeleteCollectionNamespacedService queryParameters)
        delete collection of Service
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • deleteCollectionNamespacedService

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/services",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteCollectionNamespacedService​(@Path("namespace")
                                                                                                                                                    java.lang.String namespace,
                                                                                                                                                    @QueryMap
                                                                                                                                                    CoreV1Api.DeleteCollectionNamespacedService queryParameters)
        delete collection of Service
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • listNamespacedService

        @HTTP(method="GET",
              path="/api/v1/namespaces/{namespace}/services")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesListCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.ServiceList,​com.marcnuri.yakc.model.io.k8s.api.core.v1.Service> listNamespacedService​(@Path("namespace")
                                                                                                                                                                                        java.lang.String namespace)
        list or watch objects of kind Service
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • listNamespacedService

        @HTTP(method="GET",
              path="/api/v1/namespaces/{namespace}/services")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesListCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.ServiceList,​com.marcnuri.yakc.model.io.k8s.api.core.v1.Service> listNamespacedService​(@Path("namespace")
                                                                                                                                                                                        java.lang.String namespace,
                                                                                                                                                                                        @QueryMap
                                                                                                                                                                                        CoreV1Api.ListNamespacedService queryParameters)
        list or watch objects of kind Service
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • createNamespacedService

        @HTTP(method="POST",
              path="/api/v1/namespaces/{namespace}/services",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Service> createNamespacedService​(@Path("namespace")
                                                                                                                         java.lang.String namespace,
                                                                                                                         @Body
                                                                                                                         com.marcnuri.yakc.model.io.k8s.api.core.v1.Service body)
        create a Service
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • createNamespacedService

        @HTTP(method="POST",
              path="/api/v1/namespaces/{namespace}/services",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Service> createNamespacedService​(@Path("namespace")
                                                                                                                         java.lang.String namespace,
                                                                                                                         @Body
                                                                                                                         com.marcnuri.yakc.model.io.k8s.api.core.v1.Service body,
                                                                                                                         @QueryMap
                                                                                                                         CoreV1Api.CreateNamespacedService queryParameters)
        create a Service
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • deleteNamespacedService

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/services/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Service> deleteNamespacedService​(@Path("name")
                                                                                                                         java.lang.String name,
                                                                                                                         @Path("namespace")
                                                                                                                         java.lang.String namespace,
                                                                                                                         @Body
                                                                                                                         com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions body)
        delete a Service
        Parameters:
        name - name of the Service
        namespace - object name and auth scope, such as for teams and projects
      • deleteNamespacedService

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/services/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Service> deleteNamespacedService​(@Path("name")
                                                                                                                         java.lang.String name,
                                                                                                                         @Path("namespace")
                                                                                                                         java.lang.String namespace)
        delete a Service
        Parameters:
        name - name of the Service
        namespace - object name and auth scope, such as for teams and projects
      • deleteNamespacedService

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/services/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Service> deleteNamespacedService​(@Path("name")
                                                                                                                         java.lang.String name,
                                                                                                                         @Path("namespace")
                                                                                                                         java.lang.String namespace,
                                                                                                                         @Body
                                                                                                                         com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions body,
                                                                                                                         @QueryMap
                                                                                                                         CoreV1Api.DeleteNamespacedService queryParameters)
        delete a Service
        Parameters:
        name - name of the Service
        namespace - object name and auth scope, such as for teams and projects
      • deleteNamespacedService

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{namespace}/services/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Service> deleteNamespacedService​(@Path("name")
                                                                                                                         java.lang.String name,
                                                                                                                         @Path("namespace")
                                                                                                                         java.lang.String namespace,
                                                                                                                         @QueryMap
                                                                                                                         CoreV1Api.DeleteNamespacedService queryParameters)
        delete a Service
        Parameters:
        name - name of the Service
        namespace - object name and auth scope, such as for teams and projects
      • readNamespacedService

        @HTTP(method="GET",
              path="/api/v1/namespaces/{namespace}/services/{name}")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Service> readNamespacedService​(@Path("name")
                                                                                                                       java.lang.String name,
                                                                                                                       @Path("namespace")
                                                                                                                       java.lang.String namespace)
        read the specified Service
        Parameters:
        name - name of the Service
        namespace - object name and auth scope, such as for teams and projects
      • readNamespacedService

        @HTTP(method="GET",
              path="/api/v1/namespaces/{namespace}/services/{name}")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Service> readNamespacedService​(@Path("name")
                                                                                                                       java.lang.String name,
                                                                                                                       @Path("namespace")
                                                                                                                       java.lang.String namespace,
                                                                                                                       @QueryMap
                                                                                                                       CoreV1Api.ReadNamespacedService queryParameters)
        read the specified Service
        Parameters:
        name - name of the Service
        namespace - object name and auth scope, such as for teams and projects
      • patchNamespacedService

        @HTTP(method="PATCH",
              path="/api/v1/namespaces/{namespace}/services/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/merge-patch+json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Service> patchNamespacedService​(@Path("name")
                                                                                                                        java.lang.String name,
                                                                                                                        @Path("namespace")
                                                                                                                        java.lang.String namespace,
                                                                                                                        @Body
                                                                                                                        com.marcnuri.yakc.model.io.k8s.api.core.v1.Service body)
        partially update the specified Service
        Parameters:
        name - name of the Service
        namespace - object name and auth scope, such as for teams and projects
      • patchNamespacedService

        @HTTP(method="PATCH",
              path="/api/v1/namespaces/{namespace}/services/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/merge-patch+json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Service> patchNamespacedService​(@Path("name")
                                                                                                                        java.lang.String name,
                                                                                                                        @Path("namespace")
                                                                                                                        java.lang.String namespace,
                                                                                                                        @Body
                                                                                                                        com.marcnuri.yakc.model.io.k8s.api.core.v1.Service body,
                                                                                                                        @QueryMap
                                                                                                                        CoreV1Api.PatchNamespacedService queryParameters)
        partially update the specified Service
        Parameters:
        name - name of the Service
        namespace - object name and auth scope, such as for teams and projects
      • replaceNamespacedService

        @HTTP(method="PUT",
              path="/api/v1/namespaces/{namespace}/services/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Service> replaceNamespacedService​(@Path("name")
                                                                                                                          java.lang.String name,
                                                                                                                          @Path("namespace")
                                                                                                                          java.lang.String namespace,
                                                                                                                          @Body
                                                                                                                          com.marcnuri.yakc.model.io.k8s.api.core.v1.Service body)
        replace the specified Service
        Parameters:
        name - name of the Service
        namespace - object name and auth scope, such as for teams and projects
      • replaceNamespacedService

        @HTTP(method="PUT",
              path="/api/v1/namespaces/{namespace}/services/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Service> replaceNamespacedService​(@Path("name")
                                                                                                                          java.lang.String name,
                                                                                                                          @Path("namespace")
                                                                                                                          java.lang.String namespace,
                                                                                                                          @Body
                                                                                                                          com.marcnuri.yakc.model.io.k8s.api.core.v1.Service body,
                                                                                                                          @QueryMap
                                                                                                                          CoreV1Api.ReplaceNamespacedService queryParameters)
        replace the specified Service
        Parameters:
        name - name of the Service
        namespace - object name and auth scope, such as for teams and projects
      • readNamespacedServiceStatus

        @HTTP(method="GET",
              path="/api/v1/namespaces/{namespace}/services/{name}/status")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Service> readNamespacedServiceStatus​(@Path("name")
                                                                                                                             java.lang.String name,
                                                                                                                             @Path("namespace")
                                                                                                                             java.lang.String namespace)
        read status of the specified Service
        Parameters:
        name - name of the Service
        namespace - object name and auth scope, such as for teams and projects
      • readNamespacedServiceStatus

        @HTTP(method="GET",
              path="/api/v1/namespaces/{namespace}/services/{name}/status")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Service> readNamespacedServiceStatus​(@Path("name")
                                                                                                                             java.lang.String name,
                                                                                                                             @Path("namespace")
                                                                                                                             java.lang.String namespace,
                                                                                                                             @QueryMap
                                                                                                                             CoreV1Api.ReadNamespacedServiceStatus queryParameters)
        read status of the specified Service
        Parameters:
        name - name of the Service
        namespace - object name and auth scope, such as for teams and projects
      • patchNamespacedServiceStatus

        @HTTP(method="PATCH",
              path="/api/v1/namespaces/{namespace}/services/{name}/status",
              hasBody=true)
        @Headers({"Content-Type: application/merge-patch+json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Service> patchNamespacedServiceStatus​(@Path("name")
                                                                                                                              java.lang.String name,
                                                                                                                              @Path("namespace")
                                                                                                                              java.lang.String namespace,
                                                                                                                              @Body
                                                                                                                              com.marcnuri.yakc.model.io.k8s.api.core.v1.Service body)
        partially update status of the specified Service
        Parameters:
        name - name of the Service
        namespace - object name and auth scope, such as for teams and projects
      • patchNamespacedServiceStatus

        @HTTP(method="PATCH",
              path="/api/v1/namespaces/{namespace}/services/{name}/status",
              hasBody=true)
        @Headers({"Content-Type: application/merge-patch+json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Service> patchNamespacedServiceStatus​(@Path("name")
                                                                                                                              java.lang.String name,
                                                                                                                              @Path("namespace")
                                                                                                                              java.lang.String namespace,
                                                                                                                              @Body
                                                                                                                              com.marcnuri.yakc.model.io.k8s.api.core.v1.Service body,
                                                                                                                              @QueryMap
                                                                                                                              CoreV1Api.PatchNamespacedServiceStatus queryParameters)
        partially update status of the specified Service
        Parameters:
        name - name of the Service
        namespace - object name and auth scope, such as for teams and projects
      • replaceNamespacedServiceStatus

        @HTTP(method="PUT",
              path="/api/v1/namespaces/{namespace}/services/{name}/status",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Service> replaceNamespacedServiceStatus​(@Path("name")
                                                                                                                                java.lang.String name,
                                                                                                                                @Path("namespace")
                                                                                                                                java.lang.String namespace,
                                                                                                                                @Body
                                                                                                                                com.marcnuri.yakc.model.io.k8s.api.core.v1.Service body)
        replace status of the specified Service
        Parameters:
        name - name of the Service
        namespace - object name and auth scope, such as for teams and projects
      • replaceNamespacedServiceStatus

        @HTTP(method="PUT",
              path="/api/v1/namespaces/{namespace}/services/{name}/status",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Service> replaceNamespacedServiceStatus​(@Path("name")
                                                                                                                                java.lang.String name,
                                                                                                                                @Path("namespace")
                                                                                                                                java.lang.String namespace,
                                                                                                                                @Body
                                                                                                                                com.marcnuri.yakc.model.io.k8s.api.core.v1.Service body,
                                                                                                                                @QueryMap
                                                                                                                                CoreV1Api.ReplaceNamespacedServiceStatus queryParameters)
        replace status of the specified Service
        Parameters:
        name - name of the Service
        namespace - object name and auth scope, such as for teams and projects
      • deleteNamespace

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteNamespace​(@Path("name")
                                                                                                                                  java.lang.String name,
                                                                                                                                  @Body
                                                                                                                                  com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions body)
        delete a Namespace
        Parameters:
        name - name of the Namespace
      • deleteNamespace

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteNamespace​(@Path("name")
                                                                                                                                  java.lang.String name)
        delete a Namespace
        Parameters:
        name - name of the Namespace
      • deleteNamespace

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteNamespace​(@Path("name")
                                                                                                                                  java.lang.String name,
                                                                                                                                  @Body
                                                                                                                                  com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions body,
                                                                                                                                  @QueryMap
                                                                                                                                  CoreV1Api.DeleteNamespace queryParameters)
        delete a Namespace
        Parameters:
        name - name of the Namespace
      • deleteNamespace

        @HTTP(method="DELETE",
              path="/api/v1/namespaces/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteNamespace​(@Path("name")
                                                                                                                                  java.lang.String name,
                                                                                                                                  @QueryMap
                                                                                                                                  CoreV1Api.DeleteNamespace queryParameters)
        delete a Namespace
        Parameters:
        name - name of the Namespace
      • readNamespace

        @HTTP(method="GET",
              path="/api/v1/namespaces/{name}")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Namespace> readNamespace​(@Path("name")
                                                                                                                 java.lang.String name)
        read the specified Namespace
        Parameters:
        name - name of the Namespace
      • readNamespace

        @HTTP(method="GET",
              path="/api/v1/namespaces/{name}")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Namespace> readNamespace​(@Path("name")
                                                                                                                 java.lang.String name,
                                                                                                                 @QueryMap
                                                                                                                 CoreV1Api.ReadNamespace queryParameters)
        read the specified Namespace
        Parameters:
        name - name of the Namespace
      • patchNamespace

        @HTTP(method="PATCH",
              path="/api/v1/namespaces/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/merge-patch+json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Namespace> patchNamespace​(@Path("name")
                                                                                                                  java.lang.String name,
                                                                                                                  @Body
                                                                                                                  com.marcnuri.yakc.model.io.k8s.api.core.v1.Namespace body)
        partially update the specified Namespace
        Parameters:
        name - name of the Namespace
      • patchNamespace

        @HTTP(method="PATCH",
              path="/api/v1/namespaces/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/merge-patch+json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Namespace> patchNamespace​(@Path("name")
                                                                                                                  java.lang.String name,
                                                                                                                  @Body
                                                                                                                  com.marcnuri.yakc.model.io.k8s.api.core.v1.Namespace body,
                                                                                                                  @QueryMap
                                                                                                                  CoreV1Api.PatchNamespace queryParameters)
        partially update the specified Namespace
        Parameters:
        name - name of the Namespace
      • replaceNamespace

        @HTTP(method="PUT",
              path="/api/v1/namespaces/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Namespace> replaceNamespace​(@Path("name")
                                                                                                                    java.lang.String name,
                                                                                                                    @Body
                                                                                                                    com.marcnuri.yakc.model.io.k8s.api.core.v1.Namespace body)
        replace the specified Namespace
        Parameters:
        name - name of the Namespace
      • replaceNamespace

        @HTTP(method="PUT",
              path="/api/v1/namespaces/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Namespace> replaceNamespace​(@Path("name")
                                                                                                                    java.lang.String name,
                                                                                                                    @Body
                                                                                                                    com.marcnuri.yakc.model.io.k8s.api.core.v1.Namespace body,
                                                                                                                    @QueryMap
                                                                                                                    CoreV1Api.ReplaceNamespace queryParameters)
        replace the specified Namespace
        Parameters:
        name - name of the Namespace
      • replaceNamespaceFinalize

        @HTTP(method="PUT",
              path="/api/v1/namespaces/{name}/finalize",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Namespace> replaceNamespaceFinalize​(@Path("name")
                                                                                                                            java.lang.String name,
                                                                                                                            @Body
                                                                                                                            com.marcnuri.yakc.model.io.k8s.api.core.v1.Namespace body)
        replace finalize of the specified Namespace
        Parameters:
        name - name of the Namespace
      • replaceNamespaceFinalize

        @HTTP(method="PUT",
              path="/api/v1/namespaces/{name}/finalize",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Namespace> replaceNamespaceFinalize​(@Path("name")
                                                                                                                            java.lang.String name,
                                                                                                                            @Body
                                                                                                                            com.marcnuri.yakc.model.io.k8s.api.core.v1.Namespace body,
                                                                                                                            @QueryMap
                                                                                                                            CoreV1Api.ReplaceNamespaceFinalize queryParameters)
        replace finalize of the specified Namespace
        Parameters:
        name - name of the Namespace
      • readNamespaceStatus

        @HTTP(method="GET",
              path="/api/v1/namespaces/{name}/status")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Namespace> readNamespaceStatus​(@Path("name")
                                                                                                                       java.lang.String name)
        read status of the specified Namespace
        Parameters:
        name - name of the Namespace
      • readNamespaceStatus

        @HTTP(method="GET",
              path="/api/v1/namespaces/{name}/status")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Namespace> readNamespaceStatus​(@Path("name")
                                                                                                                       java.lang.String name,
                                                                                                                       @QueryMap
                                                                                                                       CoreV1Api.ReadNamespaceStatus queryParameters)
        read status of the specified Namespace
        Parameters:
        name - name of the Namespace
      • patchNamespaceStatus

        @HTTP(method="PATCH",
              path="/api/v1/namespaces/{name}/status",
              hasBody=true)
        @Headers({"Content-Type: application/merge-patch+json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Namespace> patchNamespaceStatus​(@Path("name")
                                                                                                                        java.lang.String name,
                                                                                                                        @Body
                                                                                                                        com.marcnuri.yakc.model.io.k8s.api.core.v1.Namespace body)
        partially update status of the specified Namespace
        Parameters:
        name - name of the Namespace
      • patchNamespaceStatus

        @HTTP(method="PATCH",
              path="/api/v1/namespaces/{name}/status",
              hasBody=true)
        @Headers({"Content-Type: application/merge-patch+json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Namespace> patchNamespaceStatus​(@Path("name")
                                                                                                                        java.lang.String name,
                                                                                                                        @Body
                                                                                                                        com.marcnuri.yakc.model.io.k8s.api.core.v1.Namespace body,
                                                                                                                        @QueryMap
                                                                                                                        CoreV1Api.PatchNamespaceStatus queryParameters)
        partially update status of the specified Namespace
        Parameters:
        name - name of the Namespace
      • replaceNamespaceStatus

        @HTTP(method="PUT",
              path="/api/v1/namespaces/{name}/status",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Namespace> replaceNamespaceStatus​(@Path("name")
                                                                                                                          java.lang.String name,
                                                                                                                          @Body
                                                                                                                          com.marcnuri.yakc.model.io.k8s.api.core.v1.Namespace body)
        replace status of the specified Namespace
        Parameters:
        name - name of the Namespace
      • replaceNamespaceStatus

        @HTTP(method="PUT",
              path="/api/v1/namespaces/{name}/status",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Namespace> replaceNamespaceStatus​(@Path("name")
                                                                                                                          java.lang.String name,
                                                                                                                          @Body
                                                                                                                          com.marcnuri.yakc.model.io.k8s.api.core.v1.Namespace body,
                                                                                                                          @QueryMap
                                                                                                                          CoreV1Api.ReplaceNamespaceStatus queryParameters)
        replace status of the specified Namespace
        Parameters:
        name - name of the Namespace
      • deleteCollectionNode

        @HTTP(method="DELETE",
              path="/api/v1/nodes",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteCollectionNode​(@Body
                                                                                                                                       com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions body)
        delete collection of Node
      • deleteCollectionNode

        @HTTP(method="DELETE",
              path="/api/v1/nodes",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteCollectionNode()
        delete collection of Node
      • deleteCollectionNode

        @HTTP(method="DELETE",
              path="/api/v1/nodes",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteCollectionNode​(@Body
                                                                                                                                       com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions body,
                                                                                                                                       @QueryMap
                                                                                                                                       CoreV1Api.DeleteCollectionNode queryParameters)
        delete collection of Node
      • deleteCollectionNode

        @HTTP(method="DELETE",
              path="/api/v1/nodes",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteCollectionNode​(@QueryMap
                                                                                                                                       CoreV1Api.DeleteCollectionNode queryParameters)
        delete collection of Node
      • listNode

        @HTTP(method="GET",
              path="/api/v1/nodes")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesListCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.NodeList,​com.marcnuri.yakc.model.io.k8s.api.core.v1.Node> listNode()
        list or watch objects of kind Node
      • listNode

        @HTTP(method="GET",
              path="/api/v1/nodes")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesListCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.NodeList,​com.marcnuri.yakc.model.io.k8s.api.core.v1.Node> listNode​(@QueryMap
                                                                                                                                                                     CoreV1Api.ListNode queryParameters)
        list or watch objects of kind Node
      • createNode

        @HTTP(method="POST",
              path="/api/v1/nodes",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Node> createNode​(@Body
                                                                                                         com.marcnuri.yakc.model.io.k8s.api.core.v1.Node body)
        create a Node
      • createNode

        @HTTP(method="POST",
              path="/api/v1/nodes",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Node> createNode​(@Body
                                                                                                         com.marcnuri.yakc.model.io.k8s.api.core.v1.Node body,
                                                                                                         @QueryMap
                                                                                                         CoreV1Api.CreateNode queryParameters)
        create a Node
      • deleteNode

        @HTTP(method="DELETE",
              path="/api/v1/nodes/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteNode​(@Path("name")
                                                                                                                             java.lang.String name,
                                                                                                                             @Body
                                                                                                                             com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions body)
        delete a Node
        Parameters:
        name - name of the Node
      • deleteNode

        @HTTP(method="DELETE",
              path="/api/v1/nodes/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteNode​(@Path("name")
                                                                                                                             java.lang.String name)
        delete a Node
        Parameters:
        name - name of the Node
      • deleteNode

        @HTTP(method="DELETE",
              path="/api/v1/nodes/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteNode​(@Path("name")
                                                                                                                             java.lang.String name,
                                                                                                                             @Body
                                                                                                                             com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions body,
                                                                                                                             @QueryMap
                                                                                                                             CoreV1Api.DeleteNode queryParameters)
        delete a Node
        Parameters:
        name - name of the Node
      • deleteNode

        @HTTP(method="DELETE",
              path="/api/v1/nodes/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteNode​(@Path("name")
                                                                                                                             java.lang.String name,
                                                                                                                             @QueryMap
                                                                                                                             CoreV1Api.DeleteNode queryParameters)
        delete a Node
        Parameters:
        name - name of the Node
      • readNode

        @HTTP(method="GET",
              path="/api/v1/nodes/{name}")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Node> readNode​(@Path("name")
                                                                                                       java.lang.String name)
        read the specified Node
        Parameters:
        name - name of the Node
      • readNode

        @HTTP(method="GET",
              path="/api/v1/nodes/{name}")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Node> readNode​(@Path("name")
                                                                                                       java.lang.String name,
                                                                                                       @QueryMap
                                                                                                       CoreV1Api.ReadNode queryParameters)
        read the specified Node
        Parameters:
        name - name of the Node
      • patchNode

        @HTTP(method="PATCH",
              path="/api/v1/nodes/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/merge-patch+json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Node> patchNode​(@Path("name")
                                                                                                        java.lang.String name,
                                                                                                        @Body
                                                                                                        com.marcnuri.yakc.model.io.k8s.api.core.v1.Node body)
        partially update the specified Node
        Parameters:
        name - name of the Node
      • patchNode

        @HTTP(method="PATCH",
              path="/api/v1/nodes/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/merge-patch+json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Node> patchNode​(@Path("name")
                                                                                                        java.lang.String name,
                                                                                                        @Body
                                                                                                        com.marcnuri.yakc.model.io.k8s.api.core.v1.Node body,
                                                                                                        @QueryMap
                                                                                                        CoreV1Api.PatchNode queryParameters)
        partially update the specified Node
        Parameters:
        name - name of the Node
      • replaceNode

        @HTTP(method="PUT",
              path="/api/v1/nodes/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Node> replaceNode​(@Path("name")
                                                                                                          java.lang.String name,
                                                                                                          @Body
                                                                                                          com.marcnuri.yakc.model.io.k8s.api.core.v1.Node body)
        replace the specified Node
        Parameters:
        name - name of the Node
      • replaceNode

        @HTTP(method="PUT",
              path="/api/v1/nodes/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Node> replaceNode​(@Path("name")
                                                                                                          java.lang.String name,
                                                                                                          @Body
                                                                                                          com.marcnuri.yakc.model.io.k8s.api.core.v1.Node body,
                                                                                                          @QueryMap
                                                                                                          CoreV1Api.ReplaceNode queryParameters)
        replace the specified Node
        Parameters:
        name - name of the Node
      • readNodeStatus

        @HTTP(method="GET",
              path="/api/v1/nodes/{name}/status")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Node> readNodeStatus​(@Path("name")
                                                                                                             java.lang.String name)
        read status of the specified Node
        Parameters:
        name - name of the Node
      • readNodeStatus

        @HTTP(method="GET",
              path="/api/v1/nodes/{name}/status")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Node> readNodeStatus​(@Path("name")
                                                                                                             java.lang.String name,
                                                                                                             @QueryMap
                                                                                                             CoreV1Api.ReadNodeStatus queryParameters)
        read status of the specified Node
        Parameters:
        name - name of the Node
      • patchNodeStatus

        @HTTP(method="PATCH",
              path="/api/v1/nodes/{name}/status",
              hasBody=true)
        @Headers({"Content-Type: application/merge-patch+json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Node> patchNodeStatus​(@Path("name")
                                                                                                              java.lang.String name,
                                                                                                              @Body
                                                                                                              com.marcnuri.yakc.model.io.k8s.api.core.v1.Node body)
        partially update status of the specified Node
        Parameters:
        name - name of the Node
      • patchNodeStatus

        @HTTP(method="PATCH",
              path="/api/v1/nodes/{name}/status",
              hasBody=true)
        @Headers({"Content-Type: application/merge-patch+json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Node> patchNodeStatus​(@Path("name")
                                                                                                              java.lang.String name,
                                                                                                              @Body
                                                                                                              com.marcnuri.yakc.model.io.k8s.api.core.v1.Node body,
                                                                                                              @QueryMap
                                                                                                              CoreV1Api.PatchNodeStatus queryParameters)
        partially update status of the specified Node
        Parameters:
        name - name of the Node
      • replaceNodeStatus

        @HTTP(method="PUT",
              path="/api/v1/nodes/{name}/status",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Node> replaceNodeStatus​(@Path("name")
                                                                                                                java.lang.String name,
                                                                                                                @Body
                                                                                                                com.marcnuri.yakc.model.io.k8s.api.core.v1.Node body)
        replace status of the specified Node
        Parameters:
        name - name of the Node
      • replaceNodeStatus

        @HTTP(method="PUT",
              path="/api/v1/nodes/{name}/status",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.Node> replaceNodeStatus​(@Path("name")
                                                                                                                java.lang.String name,
                                                                                                                @Body
                                                                                                                com.marcnuri.yakc.model.io.k8s.api.core.v1.Node body,
                                                                                                                @QueryMap
                                                                                                                CoreV1Api.ReplaceNodeStatus queryParameters)
        replace status of the specified Node
        Parameters:
        name - name of the Node
      • listPersistentVolumeClaimForAllNamespaces

        @HTTP(method="GET",
              path="/api/v1/persistentvolumeclaims")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesListCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.PersistentVolumeClaimList,​com.marcnuri.yakc.model.io.k8s.api.core.v1.PersistentVolumeClaim> listPersistentVolumeClaimForAllNamespaces()
        list or watch objects of kind PersistentVolumeClaim
      • listPersistentVolumeClaimForAllNamespaces

        @HTTP(method="GET",
              path="/api/v1/persistentvolumeclaims")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesListCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.PersistentVolumeClaimList,​com.marcnuri.yakc.model.io.k8s.api.core.v1.PersistentVolumeClaim> listPersistentVolumeClaimForAllNamespaces​(@QueryMap
                                                                                                                                                                                                                                        CoreV1Api.ListPersistentVolumeClaimForAllNamespaces queryParameters)
        list or watch objects of kind PersistentVolumeClaim
      • deleteCollectionPersistentVolume

        @HTTP(method="DELETE",
              path="/api/v1/persistentvolumes",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteCollectionPersistentVolume​(@Body
                                                                                                                                                   com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions body)
        delete collection of PersistentVolume
      • deleteCollectionPersistentVolume

        @HTTP(method="DELETE",
              path="/api/v1/persistentvolumes",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteCollectionPersistentVolume()
        delete collection of PersistentVolume
      • deleteCollectionPersistentVolume

        @HTTP(method="DELETE",
              path="/api/v1/persistentvolumes",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteCollectionPersistentVolume​(@Body
                                                                                                                                                   com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions body,
                                                                                                                                                   @QueryMap
                                                                                                                                                   CoreV1Api.DeleteCollectionPersistentVolume queryParameters)
        delete collection of PersistentVolume
      • deleteCollectionPersistentVolume

        @HTTP(method="DELETE",
              path="/api/v1/persistentvolumes",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.Status> deleteCollectionPersistentVolume​(@QueryMap
                                                                                                                                                   CoreV1Api.DeleteCollectionPersistentVolume queryParameters)
        delete collection of PersistentVolume
      • listPersistentVolume

        @HTTP(method="GET",
              path="/api/v1/persistentvolumes")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesListCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.PersistentVolumeList,​com.marcnuri.yakc.model.io.k8s.api.core.v1.PersistentVolume> listPersistentVolume()
        list or watch objects of kind PersistentVolume
      • listPersistentVolume

        @HTTP(method="GET",
              path="/api/v1/persistentvolumes")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesListCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.PersistentVolumeList,​com.marcnuri.yakc.model.io.k8s.api.core.v1.PersistentVolume> listPersistentVolume​(@QueryMap
                                                                                                                                                                                                         CoreV1Api.ListPersistentVolume queryParameters)
        list or watch objects of kind PersistentVolume
      • createPersistentVolume

        @HTTP(method="POST",
              path="/api/v1/persistentvolumes",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.PersistentVolume> createPersistentVolume​(@Body
                                                                                                                                 com.marcnuri.yakc.model.io.k8s.api.core.v1.PersistentVolume body)
        create a PersistentVolume
      • createPersistentVolume

        @HTTP(method="POST",
              path="/api/v1/persistentvolumes",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.PersistentVolume> createPersistentVolume​(@Body
                                                                                                                                 com.marcnuri.yakc.model.io.k8s.api.core.v1.PersistentVolume body,
                                                                                                                                 @QueryMap
                                                                                                                                 CoreV1Api.CreatePersistentVolume queryParameters)
        create a PersistentVolume
      • deletePersistentVolume

        @HTTP(method="DELETE",
              path="/api/v1/persistentvolumes/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.PersistentVolume> deletePersistentVolume​(@Path("name")
                                                                                                                                 java.lang.String name,
                                                                                                                                 @Body
                                                                                                                                 com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions body)
        delete a PersistentVolume
        Parameters:
        name - name of the PersistentVolume
      • deletePersistentVolume

        @HTTP(method="DELETE",
              path="/api/v1/persistentvolumes/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.PersistentVolume> deletePersistentVolume​(@Path("name")
                                                                                                                                 java.lang.String name)
        delete a PersistentVolume
        Parameters:
        name - name of the PersistentVolume
      • deletePersistentVolume

        @HTTP(method="DELETE",
              path="/api/v1/persistentvolumes/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.PersistentVolume> deletePersistentVolume​(@Path("name")
                                                                                                                                 java.lang.String name,
                                                                                                                                 @Body
                                                                                                                                 com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions body,
                                                                                                                                 @QueryMap
                                                                                                                                 CoreV1Api.DeletePersistentVolume queryParameters)
        delete a PersistentVolume
        Parameters:
        name - name of the PersistentVolume
      • deletePersistentVolume

        @HTTP(method="DELETE",
              path="/api/v1/persistentvolumes/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.PersistentVolume> deletePersistentVolume​(@Path("name")
                                                                                                                                 java.lang.String name,
                                                                                                                                 @QueryMap
                                                                                                                                 CoreV1Api.DeletePersistentVolume queryParameters)
        delete a PersistentVolume
        Parameters:
        name - name of the PersistentVolume
      • readPersistentVolume

        @HTTP(method="GET",
              path="/api/v1/persistentvolumes/{name}")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.PersistentVolume> readPersistentVolume​(@Path("name")
                                                                                                                               java.lang.String name)
        read the specified PersistentVolume
        Parameters:
        name - name of the PersistentVolume
      • readPersistentVolume

        @HTTP(method="GET",
              path="/api/v1/persistentvolumes/{name}")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.PersistentVolume> readPersistentVolume​(@Path("name")
                                                                                                                               java.lang.String name,
                                                                                                                               @QueryMap
                                                                                                                               CoreV1Api.ReadPersistentVolume queryParameters)
        read the specified PersistentVolume
        Parameters:
        name - name of the PersistentVolume
      • patchPersistentVolume

        @HTTP(method="PATCH",
              path="/api/v1/persistentvolumes/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/merge-patch+json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.PersistentVolume> patchPersistentVolume​(@Path("name")
                                                                                                                                java.lang.String name,
                                                                                                                                @Body
                                                                                                                                com.marcnuri.yakc.model.io.k8s.api.core.v1.PersistentVolume body)
        partially update the specified PersistentVolume
        Parameters:
        name - name of the PersistentVolume
      • patchPersistentVolume

        @HTTP(method="PATCH",
              path="/api/v1/persistentvolumes/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/merge-patch+json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.PersistentVolume> patchPersistentVolume​(@Path("name")
                                                                                                                                java.lang.String name,
                                                                                                                                @Body
                                                                                                                                com.marcnuri.yakc.model.io.k8s.api.core.v1.PersistentVolume body,
                                                                                                                                @QueryMap
                                                                                                                                CoreV1Api.PatchPersistentVolume queryParameters)
        partially update the specified PersistentVolume
        Parameters:
        name - name of the PersistentVolume
      • replacePersistentVolume

        @HTTP(method="PUT",
              path="/api/v1/persistentvolumes/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.PersistentVolume> replacePersistentVolume​(@Path("name")
                                                                                                                                  java.lang.String name,
                                                                                                                                  @Body
                                                                                                                                  com.marcnuri.yakc.model.io.k8s.api.core.v1.PersistentVolume body)
        replace the specified PersistentVolume
        Parameters:
        name - name of the PersistentVolume
      • replacePersistentVolume

        @HTTP(method="PUT",
              path="/api/v1/persistentvolumes/{name}",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.PersistentVolume> replacePersistentVolume​(@Path("name")
                                                                                                                                  java.lang.String name,
                                                                                                                                  @Body
                                                                                                                                  com.marcnuri.yakc.model.io.k8s.api.core.v1.PersistentVolume body,
                                                                                                                                  @QueryMap
                                                                                                                                  CoreV1Api.ReplacePersistentVolume queryParameters)
        replace the specified PersistentVolume
        Parameters:
        name - name of the PersistentVolume
      • readPersistentVolumeStatus

        @HTTP(method="GET",
              path="/api/v1/persistentvolumes/{name}/status")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.PersistentVolume> readPersistentVolumeStatus​(@Path("name")
                                                                                                                                     java.lang.String name)
        read status of the specified PersistentVolume
        Parameters:
        name - name of the PersistentVolume
      • readPersistentVolumeStatus

        @HTTP(method="GET",
              path="/api/v1/persistentvolumes/{name}/status")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.PersistentVolume> readPersistentVolumeStatus​(@Path("name")
                                                                                                                                     java.lang.String name,
                                                                                                                                     @QueryMap
                                                                                                                                     CoreV1Api.ReadPersistentVolumeStatus queryParameters)
        read status of the specified PersistentVolume
        Parameters:
        name - name of the PersistentVolume
      • patchPersistentVolumeStatus

        @HTTP(method="PATCH",
              path="/api/v1/persistentvolumes/{name}/status",
              hasBody=true)
        @Headers({"Content-Type: application/merge-patch+json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.PersistentVolume> patchPersistentVolumeStatus​(@Path("name")
                                                                                                                                      java.lang.String name,
                                                                                                                                      @Body
                                                                                                                                      com.marcnuri.yakc.model.io.k8s.api.core.v1.PersistentVolume body)
        partially update status of the specified PersistentVolume
        Parameters:
        name - name of the PersistentVolume
      • patchPersistentVolumeStatus

        @HTTP(method="PATCH",
              path="/api/v1/persistentvolumes/{name}/status",
              hasBody=true)
        @Headers({"Content-Type: application/merge-patch+json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.PersistentVolume> patchPersistentVolumeStatus​(@Path("name")
                                                                                                                                      java.lang.String name,
                                                                                                                                      @Body
                                                                                                                                      com.marcnuri.yakc.model.io.k8s.api.core.v1.PersistentVolume body,
                                                                                                                                      @QueryMap
                                                                                                                                      CoreV1Api.PatchPersistentVolumeStatus queryParameters)
        partially update status of the specified PersistentVolume
        Parameters:
        name - name of the PersistentVolume
      • replacePersistentVolumeStatus

        @HTTP(method="PUT",
              path="/api/v1/persistentvolumes/{name}/status",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.PersistentVolume> replacePersistentVolumeStatus​(@Path("name")
                                                                                                                                        java.lang.String name,
                                                                                                                                        @Body
                                                                                                                                        com.marcnuri.yakc.model.io.k8s.api.core.v1.PersistentVolume body)
        replace status of the specified PersistentVolume
        Parameters:
        name - name of the PersistentVolume
      • replacePersistentVolumeStatus

        @HTTP(method="PUT",
              path="/api/v1/persistentvolumes/{name}/status",
              hasBody=true)
        @Headers({"Content-Type: application/json","Accept: */*"})
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.PersistentVolume> replacePersistentVolumeStatus​(@Path("name")
                                                                                                                                        java.lang.String name,
                                                                                                                                        @Body
                                                                                                                                        com.marcnuri.yakc.model.io.k8s.api.core.v1.PersistentVolume body,
                                                                                                                                        @QueryMap
                                                                                                                                        CoreV1Api.ReplacePersistentVolumeStatus queryParameters)
        replace status of the specified PersistentVolume
        Parameters:
        name - name of the PersistentVolume
      • listPodForAllNamespaces

        @HTTP(method="GET",
              path="/api/v1/pods")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesListCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.PodList,​com.marcnuri.yakc.model.io.k8s.api.core.v1.Pod> listPodForAllNamespaces()
        list or watch objects of kind Pod
      • listPodForAllNamespaces

        @HTTP(method="GET",
              path="/api/v1/pods")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesListCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.PodList,​com.marcnuri.yakc.model.io.k8s.api.core.v1.Pod> listPodForAllNamespaces​(@QueryMap
                                                                                                                                                                                  CoreV1Api.ListPodForAllNamespaces queryParameters)
        list or watch objects of kind Pod
      • listPodTemplateForAllNamespaces

        @HTTP(method="GET",
              path="/api/v1/podtemplates")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesListCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.PodTemplateList,​com.marcnuri.yakc.model.io.k8s.api.core.v1.PodTemplate> listPodTemplateForAllNamespaces()
        list or watch objects of kind PodTemplate
      • listPodTemplateForAllNamespaces

        @HTTP(method="GET",
              path="/api/v1/podtemplates")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesListCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.PodTemplateList,​com.marcnuri.yakc.model.io.k8s.api.core.v1.PodTemplate> listPodTemplateForAllNamespaces​(@QueryMap
                                                                                                                                                                                                          CoreV1Api.ListPodTemplateForAllNamespaces queryParameters)
        list or watch objects of kind PodTemplate
      • listReplicationControllerForAllNamespaces

        @HTTP(method="GET",
              path="/api/v1/replicationcontrollers")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesListCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.ReplicationControllerList,​com.marcnuri.yakc.model.io.k8s.api.core.v1.ReplicationController> listReplicationControllerForAllNamespaces()
        list or watch objects of kind ReplicationController
      • listReplicationControllerForAllNamespaces

        @HTTP(method="GET",
              path="/api/v1/replicationcontrollers")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesListCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.ReplicationControllerList,​com.marcnuri.yakc.model.io.k8s.api.core.v1.ReplicationController> listReplicationControllerForAllNamespaces​(@QueryMap
                                                                                                                                                                                                                                        CoreV1Api.ListReplicationControllerForAllNamespaces queryParameters)
        list or watch objects of kind ReplicationController
      • listResourceQuotaForAllNamespaces

        @HTTP(method="GET",
              path="/api/v1/resourcequotas")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesListCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.ResourceQuotaList,​com.marcnuri.yakc.model.io.k8s.api.core.v1.ResourceQuota> listResourceQuotaForAllNamespaces()
        list or watch objects of kind ResourceQuota
      • listResourceQuotaForAllNamespaces

        @HTTP(method="GET",
              path="/api/v1/resourcequotas")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesListCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.ResourceQuotaList,​com.marcnuri.yakc.model.io.k8s.api.core.v1.ResourceQuota> listResourceQuotaForAllNamespaces​(@QueryMap
                                                                                                                                                                                                                CoreV1Api.ListResourceQuotaForAllNamespaces queryParameters)
        list or watch objects of kind ResourceQuota
      • listSecretForAllNamespaces

        @HTTP(method="GET",
              path="/api/v1/secrets")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesListCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.SecretList,​com.marcnuri.yakc.model.io.k8s.api.core.v1.Secret> listSecretForAllNamespaces()
        list or watch objects of kind Secret
      • listSecretForAllNamespaces

        @HTTP(method="GET",
              path="/api/v1/secrets")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesListCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.SecretList,​com.marcnuri.yakc.model.io.k8s.api.core.v1.Secret> listSecretForAllNamespaces​(@QueryMap
                                                                                                                                                                                           CoreV1Api.ListSecretForAllNamespaces queryParameters)
        list or watch objects of kind Secret
      • listServiceAccountForAllNamespaces

        @HTTP(method="GET",
              path="/api/v1/serviceaccounts")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesListCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.ServiceAccountList,​com.marcnuri.yakc.model.io.k8s.api.core.v1.ServiceAccount> listServiceAccountForAllNamespaces()
        list or watch objects of kind ServiceAccount
      • listServiceAccountForAllNamespaces

        @HTTP(method="GET",
              path="/api/v1/serviceaccounts")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesListCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.ServiceAccountList,​com.marcnuri.yakc.model.io.k8s.api.core.v1.ServiceAccount> listServiceAccountForAllNamespaces​(@QueryMap
                                                                                                                                                                                                                   CoreV1Api.ListServiceAccountForAllNamespaces queryParameters)
        list or watch objects of kind ServiceAccount
      • listServiceForAllNamespaces

        @HTTP(method="GET",
              path="/api/v1/services")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesListCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.ServiceList,​com.marcnuri.yakc.model.io.k8s.api.core.v1.Service> listServiceForAllNamespaces()
        list or watch objects of kind Service
      • listServiceForAllNamespaces

        @HTTP(method="GET",
              path="/api/v1/services")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesListCall<com.marcnuri.yakc.model.io.k8s.api.core.v1.ServiceList,​com.marcnuri.yakc.model.io.k8s.api.core.v1.Service> listServiceForAllNamespaces​(@QueryMap
                                                                                                                                                                                              CoreV1Api.ListServiceForAllNamespaces queryParameters)
        list or watch objects of kind Service
      • watchConfigMapListForAllNamespaces

        @HTTP(method="GET",
              path="/api/v1/watch/configmaps")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchConfigMapListForAllNamespaces()
        watch individual changes to a list of ConfigMap. deprecated: use the 'watch' parameter with a list operation instead.
      • watchConfigMapListForAllNamespaces

        @HTTP(method="GET",
              path="/api/v1/watch/configmaps")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchConfigMapListForAllNamespaces​(@QueryMap
                                                                                                                                                         CoreV1Api.WatchConfigMapListForAllNamespaces queryParameters)
        watch individual changes to a list of ConfigMap. deprecated: use the 'watch' parameter with a list operation instead.
      • watchEndpointsListForAllNamespaces

        @HTTP(method="GET",
              path="/api/v1/watch/endpoints")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchEndpointsListForAllNamespaces()
        watch individual changes to a list of Endpoints. deprecated: use the 'watch' parameter with a list operation instead.
      • watchEndpointsListForAllNamespaces

        @HTTP(method="GET",
              path="/api/v1/watch/endpoints")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchEndpointsListForAllNamespaces​(@QueryMap
                                                                                                                                                         CoreV1Api.WatchEndpointsListForAllNamespaces queryParameters)
        watch individual changes to a list of Endpoints. deprecated: use the 'watch' parameter with a list operation instead.
      • watchEventListForAllNamespaces

        @HTTP(method="GET",
              path="/api/v1/watch/events")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchEventListForAllNamespaces()
        watch individual changes to a list of Event. deprecated: use the 'watch' parameter with a list operation instead.
      • watchEventListForAllNamespaces

        @HTTP(method="GET",
              path="/api/v1/watch/events")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchEventListForAllNamespaces​(@QueryMap
                                                                                                                                                     CoreV1Api.WatchEventListForAllNamespaces queryParameters)
        watch individual changes to a list of Event. deprecated: use the 'watch' parameter with a list operation instead.
      • watchLimitRangeListForAllNamespaces

        @HTTP(method="GET",
              path="/api/v1/watch/limitranges")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchLimitRangeListForAllNamespaces()
        watch individual changes to a list of LimitRange. deprecated: use the 'watch' parameter with a list operation instead.
      • watchLimitRangeListForAllNamespaces

        @HTTP(method="GET",
              path="/api/v1/watch/limitranges")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchLimitRangeListForAllNamespaces​(@QueryMap
                                                                                                                                                          CoreV1Api.WatchLimitRangeListForAllNamespaces queryParameters)
        watch individual changes to a list of LimitRange. deprecated: use the 'watch' parameter with a list operation instead.
      • watchNamespaceList

        @HTTP(method="GET",
              path="/api/v1/watch/namespaces")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchNamespaceList()
        watch individual changes to a list of Namespace. deprecated: use the 'watch' parameter with a list operation instead.
      • watchNamespaceList

        @HTTP(method="GET",
              path="/api/v1/watch/namespaces")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchNamespaceList​(@QueryMap
                                                                                                                                         CoreV1Api.WatchNamespaceList queryParameters)
        watch individual changes to a list of Namespace. deprecated: use the 'watch' parameter with a list operation instead.
      • watchNamespacedConfigMapList

        @HTTP(method="GET",
              path="/api/v1/watch/namespaces/{namespace}/configmaps")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchNamespacedConfigMapList​(@Path("namespace")
                                                                                                                                                   java.lang.String namespace)
        watch individual changes to a list of ConfigMap. deprecated: use the 'watch' parameter with a list operation instead.
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • watchNamespacedConfigMapList

        @HTTP(method="GET",
              path="/api/v1/watch/namespaces/{namespace}/configmaps")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchNamespacedConfigMapList​(@Path("namespace")
                                                                                                                                                   java.lang.String namespace,
                                                                                                                                                   @QueryMap
                                                                                                                                                   CoreV1Api.WatchNamespacedConfigMapList queryParameters)
        watch individual changes to a list of ConfigMap. deprecated: use the 'watch' parameter with a list operation instead.
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • watchNamespacedConfigMap

        @HTTP(method="GET",
              path="/api/v1/watch/namespaces/{namespace}/configmaps/{name}")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchNamespacedConfigMap​(@Path("name")
                                                                                                                                               java.lang.String name,
                                                                                                                                               @Path("namespace")
                                                                                                                                               java.lang.String namespace)
        watch changes to an object of kind ConfigMap. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.
        Parameters:
        name - name of the ConfigMap
        namespace - object name and auth scope, such as for teams and projects
      • watchNamespacedConfigMap

        @HTTP(method="GET",
              path="/api/v1/watch/namespaces/{namespace}/configmaps/{name}")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchNamespacedConfigMap​(@Path("name")
                                                                                                                                               java.lang.String name,
                                                                                                                                               @Path("namespace")
                                                                                                                                               java.lang.String namespace,
                                                                                                                                               @QueryMap
                                                                                                                                               CoreV1Api.WatchNamespacedConfigMap queryParameters)
        watch changes to an object of kind ConfigMap. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.
        Parameters:
        name - name of the ConfigMap
        namespace - object name and auth scope, such as for teams and projects
      • watchNamespacedEndpointsList

        @HTTP(method="GET",
              path="/api/v1/watch/namespaces/{namespace}/endpoints")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchNamespacedEndpointsList​(@Path("namespace")
                                                                                                                                                   java.lang.String namespace)
        watch individual changes to a list of Endpoints. deprecated: use the 'watch' parameter with a list operation instead.
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • watchNamespacedEndpointsList

        @HTTP(method="GET",
              path="/api/v1/watch/namespaces/{namespace}/endpoints")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchNamespacedEndpointsList​(@Path("namespace")
                                                                                                                                                   java.lang.String namespace,
                                                                                                                                                   @QueryMap
                                                                                                                                                   CoreV1Api.WatchNamespacedEndpointsList queryParameters)
        watch individual changes to a list of Endpoints. deprecated: use the 'watch' parameter with a list operation instead.
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • watchNamespacedEndpoints

        @HTTP(method="GET",
              path="/api/v1/watch/namespaces/{namespace}/endpoints/{name}")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchNamespacedEndpoints​(@Path("name")
                                                                                                                                               java.lang.String name,
                                                                                                                                               @Path("namespace")
                                                                                                                                               java.lang.String namespace)
        watch changes to an object of kind Endpoints. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.
        Parameters:
        name - name of the Endpoints
        namespace - object name and auth scope, such as for teams and projects
      • watchNamespacedEndpoints

        @HTTP(method="GET",
              path="/api/v1/watch/namespaces/{namespace}/endpoints/{name}")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchNamespacedEndpoints​(@Path("name")
                                                                                                                                               java.lang.String name,
                                                                                                                                               @Path("namespace")
                                                                                                                                               java.lang.String namespace,
                                                                                                                                               @QueryMap
                                                                                                                                               CoreV1Api.WatchNamespacedEndpoints queryParameters)
        watch changes to an object of kind Endpoints. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.
        Parameters:
        name - name of the Endpoints
        namespace - object name and auth scope, such as for teams and projects
      • watchNamespacedEventList

        @HTTP(method="GET",
              path="/api/v1/watch/namespaces/{namespace}/events")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchNamespacedEventList​(@Path("namespace")
                                                                                                                                               java.lang.String namespace)
        watch individual changes to a list of Event. deprecated: use the 'watch' parameter with a list operation instead.
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • watchNamespacedEventList

        @HTTP(method="GET",
              path="/api/v1/watch/namespaces/{namespace}/events")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchNamespacedEventList​(@Path("namespace")
                                                                                                                                               java.lang.String namespace,
                                                                                                                                               @QueryMap
                                                                                                                                               CoreV1Api.WatchNamespacedEventList queryParameters)
        watch individual changes to a list of Event. deprecated: use the 'watch' parameter with a list operation instead.
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • watchNamespacedEvent

        @HTTP(method="GET",
              path="/api/v1/watch/namespaces/{namespace}/events/{name}")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchNamespacedEvent​(@Path("name")
                                                                                                                                           java.lang.String name,
                                                                                                                                           @Path("namespace")
                                                                                                                                           java.lang.String namespace)
        watch changes to an object of kind Event. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.
        Parameters:
        name - name of the Event
        namespace - object name and auth scope, such as for teams and projects
      • watchNamespacedEvent

        @HTTP(method="GET",
              path="/api/v1/watch/namespaces/{namespace}/events/{name}")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchNamespacedEvent​(@Path("name")
                                                                                                                                           java.lang.String name,
                                                                                                                                           @Path("namespace")
                                                                                                                                           java.lang.String namespace,
                                                                                                                                           @QueryMap
                                                                                                                                           CoreV1Api.WatchNamespacedEvent queryParameters)
        watch changes to an object of kind Event. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.
        Parameters:
        name - name of the Event
        namespace - object name and auth scope, such as for teams and projects
      • watchNamespacedLimitRangeList

        @HTTP(method="GET",
              path="/api/v1/watch/namespaces/{namespace}/limitranges")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchNamespacedLimitRangeList​(@Path("namespace")
                                                                                                                                                    java.lang.String namespace)
        watch individual changes to a list of LimitRange. deprecated: use the 'watch' parameter with a list operation instead.
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • watchNamespacedLimitRangeList

        @HTTP(method="GET",
              path="/api/v1/watch/namespaces/{namespace}/limitranges")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchNamespacedLimitRangeList​(@Path("namespace")
                                                                                                                                                    java.lang.String namespace,
                                                                                                                                                    @QueryMap
                                                                                                                                                    CoreV1Api.WatchNamespacedLimitRangeList queryParameters)
        watch individual changes to a list of LimitRange. deprecated: use the 'watch' parameter with a list operation instead.
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • watchNamespacedLimitRange

        @HTTP(method="GET",
              path="/api/v1/watch/namespaces/{namespace}/limitranges/{name}")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchNamespacedLimitRange​(@Path("name")
                                                                                                                                                java.lang.String name,
                                                                                                                                                @Path("namespace")
                                                                                                                                                java.lang.String namespace)
        watch changes to an object of kind LimitRange. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.
        Parameters:
        name - name of the LimitRange
        namespace - object name and auth scope, such as for teams and projects
      • watchNamespacedLimitRange

        @HTTP(method="GET",
              path="/api/v1/watch/namespaces/{namespace}/limitranges/{name}")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchNamespacedLimitRange​(@Path("name")
                                                                                                                                                java.lang.String name,
                                                                                                                                                @Path("namespace")
                                                                                                                                                java.lang.String namespace,
                                                                                                                                                @QueryMap
                                                                                                                                                CoreV1Api.WatchNamespacedLimitRange queryParameters)
        watch changes to an object of kind LimitRange. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.
        Parameters:
        name - name of the LimitRange
        namespace - object name and auth scope, such as for teams and projects
      • watchNamespacedPersistentVolumeClaimList

        @HTTP(method="GET",
              path="/api/v1/watch/namespaces/{namespace}/persistentvolumeclaims")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchNamespacedPersistentVolumeClaimList​(@Path("namespace")
                                                                                                                                                               java.lang.String namespace)
        watch individual changes to a list of PersistentVolumeClaim. deprecated: use the 'watch' parameter with a list operation instead.
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • watchNamespacedPersistentVolumeClaimList

        @HTTP(method="GET",
              path="/api/v1/watch/namespaces/{namespace}/persistentvolumeclaims")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchNamespacedPersistentVolumeClaimList​(@Path("namespace")
                                                                                                                                                               java.lang.String namespace,
                                                                                                                                                               @QueryMap
                                                                                                                                                               CoreV1Api.WatchNamespacedPersistentVolumeClaimList queryParameters)
        watch individual changes to a list of PersistentVolumeClaim. deprecated: use the 'watch' parameter with a list operation instead.
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • watchNamespacedPersistentVolumeClaim

        @HTTP(method="GET",
              path="/api/v1/watch/namespaces/{namespace}/persistentvolumeclaims/{name}")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchNamespacedPersistentVolumeClaim​(@Path("name")
                                                                                                                                                           java.lang.String name,
                                                                                                                                                           @Path("namespace")
                                                                                                                                                           java.lang.String namespace)
        watch changes to an object of kind PersistentVolumeClaim. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.
        Parameters:
        name - name of the PersistentVolumeClaim
        namespace - object name and auth scope, such as for teams and projects
      • watchNamespacedPersistentVolumeClaim

        @HTTP(method="GET",
              path="/api/v1/watch/namespaces/{namespace}/persistentvolumeclaims/{name}")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchNamespacedPersistentVolumeClaim​(@Path("name")
                                                                                                                                                           java.lang.String name,
                                                                                                                                                           @Path("namespace")
                                                                                                                                                           java.lang.String namespace,
                                                                                                                                                           @QueryMap
                                                                                                                                                           CoreV1Api.WatchNamespacedPersistentVolumeClaim queryParameters)
        watch changes to an object of kind PersistentVolumeClaim. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.
        Parameters:
        name - name of the PersistentVolumeClaim
        namespace - object name and auth scope, such as for teams and projects
      • watchNamespacedPodList

        @HTTP(method="GET",
              path="/api/v1/watch/namespaces/{namespace}/pods")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchNamespacedPodList​(@Path("namespace")
                                                                                                                                             java.lang.String namespace)
        watch individual changes to a list of Pod. deprecated: use the 'watch' parameter with a list operation instead.
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • watchNamespacedPodList

        @HTTP(method="GET",
              path="/api/v1/watch/namespaces/{namespace}/pods")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchNamespacedPodList​(@Path("namespace")
                                                                                                                                             java.lang.String namespace,
                                                                                                                                             @QueryMap
                                                                                                                                             CoreV1Api.WatchNamespacedPodList queryParameters)
        watch individual changes to a list of Pod. deprecated: use the 'watch' parameter with a list operation instead.
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • watchNamespacedPod

        @HTTP(method="GET",
              path="/api/v1/watch/namespaces/{namespace}/pods/{name}")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchNamespacedPod​(@Path("name")
                                                                                                                                         java.lang.String name,
                                                                                                                                         @Path("namespace")
                                                                                                                                         java.lang.String namespace)
        watch changes to an object of kind Pod. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.
        Parameters:
        name - name of the Pod
        namespace - object name and auth scope, such as for teams and projects
      • watchNamespacedPod

        @HTTP(method="GET",
              path="/api/v1/watch/namespaces/{namespace}/pods/{name}")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchNamespacedPod​(@Path("name")
                                                                                                                                         java.lang.String name,
                                                                                                                                         @Path("namespace")
                                                                                                                                         java.lang.String namespace,
                                                                                                                                         @QueryMap
                                                                                                                                         CoreV1Api.WatchNamespacedPod queryParameters)
        watch changes to an object of kind Pod. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.
        Parameters:
        name - name of the Pod
        namespace - object name and auth scope, such as for teams and projects
      • watchNamespacedPodTemplateList

        @HTTP(method="GET",
              path="/api/v1/watch/namespaces/{namespace}/podtemplates")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchNamespacedPodTemplateList​(@Path("namespace")
                                                                                                                                                     java.lang.String namespace)
        watch individual changes to a list of PodTemplate. deprecated: use the 'watch' parameter with a list operation instead.
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • watchNamespacedPodTemplateList

        @HTTP(method="GET",
              path="/api/v1/watch/namespaces/{namespace}/podtemplates")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchNamespacedPodTemplateList​(@Path("namespace")
                                                                                                                                                     java.lang.String namespace,
                                                                                                                                                     @QueryMap
                                                                                                                                                     CoreV1Api.WatchNamespacedPodTemplateList queryParameters)
        watch individual changes to a list of PodTemplate. deprecated: use the 'watch' parameter with a list operation instead.
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • watchNamespacedPodTemplate

        @HTTP(method="GET",
              path="/api/v1/watch/namespaces/{namespace}/podtemplates/{name}")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchNamespacedPodTemplate​(@Path("name")
                                                                                                                                                 java.lang.String name,
                                                                                                                                                 @Path("namespace")
                                                                                                                                                 java.lang.String namespace)
        watch changes to an object of kind PodTemplate. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.
        Parameters:
        name - name of the PodTemplate
        namespace - object name and auth scope, such as for teams and projects
      • watchNamespacedPodTemplate

        @HTTP(method="GET",
              path="/api/v1/watch/namespaces/{namespace}/podtemplates/{name}")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchNamespacedPodTemplate​(@Path("name")
                                                                                                                                                 java.lang.String name,
                                                                                                                                                 @Path("namespace")
                                                                                                                                                 java.lang.String namespace,
                                                                                                                                                 @QueryMap
                                                                                                                                                 CoreV1Api.WatchNamespacedPodTemplate queryParameters)
        watch changes to an object of kind PodTemplate. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.
        Parameters:
        name - name of the PodTemplate
        namespace - object name and auth scope, such as for teams and projects
      • watchNamespacedReplicationControllerList

        @HTTP(method="GET",
              path="/api/v1/watch/namespaces/{namespace}/replicationcontrollers")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchNamespacedReplicationControllerList​(@Path("namespace")
                                                                                                                                                               java.lang.String namespace)
        watch individual changes to a list of ReplicationController. deprecated: use the 'watch' parameter with a list operation instead.
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • watchNamespacedReplicationControllerList

        @HTTP(method="GET",
              path="/api/v1/watch/namespaces/{namespace}/replicationcontrollers")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchNamespacedReplicationControllerList​(@Path("namespace")
                                                                                                                                                               java.lang.String namespace,
                                                                                                                                                               @QueryMap
                                                                                                                                                               CoreV1Api.WatchNamespacedReplicationControllerList queryParameters)
        watch individual changes to a list of ReplicationController. deprecated: use the 'watch' parameter with a list operation instead.
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • watchNamespacedReplicationController

        @HTTP(method="GET",
              path="/api/v1/watch/namespaces/{namespace}/replicationcontrollers/{name}")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchNamespacedReplicationController​(@Path("name")
                                                                                                                                                           java.lang.String name,
                                                                                                                                                           @Path("namespace")
                                                                                                                                                           java.lang.String namespace)
        watch changes to an object of kind ReplicationController. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.
        Parameters:
        name - name of the ReplicationController
        namespace - object name and auth scope, such as for teams and projects
      • watchNamespacedReplicationController

        @HTTP(method="GET",
              path="/api/v1/watch/namespaces/{namespace}/replicationcontrollers/{name}")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchNamespacedReplicationController​(@Path("name")
                                                                                                                                                           java.lang.String name,
                                                                                                                                                           @Path("namespace")
                                                                                                                                                           java.lang.String namespace,
                                                                                                                                                           @QueryMap
                                                                                                                                                           CoreV1Api.WatchNamespacedReplicationController queryParameters)
        watch changes to an object of kind ReplicationController. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.
        Parameters:
        name - name of the ReplicationController
        namespace - object name and auth scope, such as for teams and projects
      • watchNamespacedResourceQuotaList

        @HTTP(method="GET",
              path="/api/v1/watch/namespaces/{namespace}/resourcequotas")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchNamespacedResourceQuotaList​(@Path("namespace")
                                                                                                                                                       java.lang.String namespace)
        watch individual changes to a list of ResourceQuota. deprecated: use the 'watch' parameter with a list operation instead.
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • watchNamespacedResourceQuotaList

        @HTTP(method="GET",
              path="/api/v1/watch/namespaces/{namespace}/resourcequotas")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchNamespacedResourceQuotaList​(@Path("namespace")
                                                                                                                                                       java.lang.String namespace,
                                                                                                                                                       @QueryMap
                                                                                                                                                       CoreV1Api.WatchNamespacedResourceQuotaList queryParameters)
        watch individual changes to a list of ResourceQuota. deprecated: use the 'watch' parameter with a list operation instead.
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • watchNamespacedResourceQuota

        @HTTP(method="GET",
              path="/api/v1/watch/namespaces/{namespace}/resourcequotas/{name}")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchNamespacedResourceQuota​(@Path("name")
                                                                                                                                                   java.lang.String name,
                                                                                                                                                   @Path("namespace")
                                                                                                                                                   java.lang.String namespace)
        watch changes to an object of kind ResourceQuota. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.
        Parameters:
        name - name of the ResourceQuota
        namespace - object name and auth scope, such as for teams and projects
      • watchNamespacedResourceQuota

        @HTTP(method="GET",
              path="/api/v1/watch/namespaces/{namespace}/resourcequotas/{name}")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchNamespacedResourceQuota​(@Path("name")
                                                                                                                                                   java.lang.String name,
                                                                                                                                                   @Path("namespace")
                                                                                                                                                   java.lang.String namespace,
                                                                                                                                                   @QueryMap
                                                                                                                                                   CoreV1Api.WatchNamespacedResourceQuota queryParameters)
        watch changes to an object of kind ResourceQuota. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.
        Parameters:
        name - name of the ResourceQuota
        namespace - object name and auth scope, such as for teams and projects
      • watchNamespacedSecretList

        @HTTP(method="GET",
              path="/api/v1/watch/namespaces/{namespace}/secrets")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchNamespacedSecretList​(@Path("namespace")
                                                                                                                                                java.lang.String namespace)
        watch individual changes to a list of Secret. deprecated: use the 'watch' parameter with a list operation instead.
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • watchNamespacedSecretList

        @HTTP(method="GET",
              path="/api/v1/watch/namespaces/{namespace}/secrets")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchNamespacedSecretList​(@Path("namespace")
                                                                                                                                                java.lang.String namespace,
                                                                                                                                                @QueryMap
                                                                                                                                                CoreV1Api.WatchNamespacedSecretList queryParameters)
        watch individual changes to a list of Secret. deprecated: use the 'watch' parameter with a list operation instead.
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • watchNamespacedSecret

        @HTTP(method="GET",
              path="/api/v1/watch/namespaces/{namespace}/secrets/{name}")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchNamespacedSecret​(@Path("name")
                                                                                                                                            java.lang.String name,
                                                                                                                                            @Path("namespace")
                                                                                                                                            java.lang.String namespace)
        watch changes to an object of kind Secret. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.
        Parameters:
        name - name of the Secret
        namespace - object name and auth scope, such as for teams and projects
      • watchNamespacedSecret

        @HTTP(method="GET",
              path="/api/v1/watch/namespaces/{namespace}/secrets/{name}")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchNamespacedSecret​(@Path("name")
                                                                                                                                            java.lang.String name,
                                                                                                                                            @Path("namespace")
                                                                                                                                            java.lang.String namespace,
                                                                                                                                            @QueryMap
                                                                                                                                            CoreV1Api.WatchNamespacedSecret queryParameters)
        watch changes to an object of kind Secret. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.
        Parameters:
        name - name of the Secret
        namespace - object name and auth scope, such as for teams and projects
      • watchNamespacedServiceAccountList

        @HTTP(method="GET",
              path="/api/v1/watch/namespaces/{namespace}/serviceaccounts")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchNamespacedServiceAccountList​(@Path("namespace")
                                                                                                                                                        java.lang.String namespace)
        watch individual changes to a list of ServiceAccount. deprecated: use the 'watch' parameter with a list operation instead.
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • watchNamespacedServiceAccountList

        @HTTP(method="GET",
              path="/api/v1/watch/namespaces/{namespace}/serviceaccounts")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchNamespacedServiceAccountList​(@Path("namespace")
                                                                                                                                                        java.lang.String namespace,
                                                                                                                                                        @QueryMap
                                                                                                                                                        CoreV1Api.WatchNamespacedServiceAccountList queryParameters)
        watch individual changes to a list of ServiceAccount. deprecated: use the 'watch' parameter with a list operation instead.
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • watchNamespacedServiceAccount

        @HTTP(method="GET",
              path="/api/v1/watch/namespaces/{namespace}/serviceaccounts/{name}")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchNamespacedServiceAccount​(@Path("name")
                                                                                                                                                    java.lang.String name,
                                                                                                                                                    @Path("namespace")
                                                                                                                                                    java.lang.String namespace)
        watch changes to an object of kind ServiceAccount. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.
        Parameters:
        name - name of the ServiceAccount
        namespace - object name and auth scope, such as for teams and projects
      • watchNamespacedServiceAccount

        @HTTP(method="GET",
              path="/api/v1/watch/namespaces/{namespace}/serviceaccounts/{name}")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchNamespacedServiceAccount​(@Path("name")
                                                                                                                                                    java.lang.String name,
                                                                                                                                                    @Path("namespace")
                                                                                                                                                    java.lang.String namespace,
                                                                                                                                                    @QueryMap
                                                                                                                                                    CoreV1Api.WatchNamespacedServiceAccount queryParameters)
        watch changes to an object of kind ServiceAccount. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.
        Parameters:
        name - name of the ServiceAccount
        namespace - object name and auth scope, such as for teams and projects
      • watchNamespacedServiceList

        @HTTP(method="GET",
              path="/api/v1/watch/namespaces/{namespace}/services")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchNamespacedServiceList​(@Path("namespace")
                                                                                                                                                 java.lang.String namespace)
        watch individual changes to a list of Service. deprecated: use the 'watch' parameter with a list operation instead.
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • watchNamespacedServiceList

        @HTTP(method="GET",
              path="/api/v1/watch/namespaces/{namespace}/services")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchNamespacedServiceList​(@Path("namespace")
                                                                                                                                                 java.lang.String namespace,
                                                                                                                                                 @QueryMap
                                                                                                                                                 CoreV1Api.WatchNamespacedServiceList queryParameters)
        watch individual changes to a list of Service. deprecated: use the 'watch' parameter with a list operation instead.
        Parameters:
        namespace - object name and auth scope, such as for teams and projects
      • watchNamespacedService

        @HTTP(method="GET",
              path="/api/v1/watch/namespaces/{namespace}/services/{name}")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchNamespacedService​(@Path("name")
                                                                                                                                             java.lang.String name,
                                                                                                                                             @Path("namespace")
                                                                                                                                             java.lang.String namespace)
        watch changes to an object of kind Service. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.
        Parameters:
        name - name of the Service
        namespace - object name and auth scope, such as for teams and projects
      • watchNamespacedService

        @HTTP(method="GET",
              path="/api/v1/watch/namespaces/{namespace}/services/{name}")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchNamespacedService​(@Path("name")
                                                                                                                                             java.lang.String name,
                                                                                                                                             @Path("namespace")
                                                                                                                                             java.lang.String namespace,
                                                                                                                                             @QueryMap
                                                                                                                                             CoreV1Api.WatchNamespacedService queryParameters)
        watch changes to an object of kind Service. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.
        Parameters:
        name - name of the Service
        namespace - object name and auth scope, such as for teams and projects
      • watchNamespace

        @HTTP(method="GET",
              path="/api/v1/watch/namespaces/{name}")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchNamespace​(@Path("name")
                                                                                                                                     java.lang.String name)
        watch changes to an object of kind Namespace. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.
        Parameters:
        name - name of the Namespace
      • watchNamespace

        @HTTP(method="GET",
              path="/api/v1/watch/namespaces/{name}")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchNamespace​(@Path("name")
                                                                                                                                     java.lang.String name,
                                                                                                                                     @QueryMap
                                                                                                                                     CoreV1Api.WatchNamespace queryParameters)
        watch changes to an object of kind Namespace. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.
        Parameters:
        name - name of the Namespace
      • watchNodeList

        @HTTP(method="GET",
              path="/api/v1/watch/nodes")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchNodeList()
        watch individual changes to a list of Node. deprecated: use the 'watch' parameter with a list operation instead.
      • watchNodeList

        @HTTP(method="GET",
              path="/api/v1/watch/nodes")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchNodeList​(@QueryMap
                                                                                                                                    CoreV1Api.WatchNodeList queryParameters)
        watch individual changes to a list of Node. deprecated: use the 'watch' parameter with a list operation instead.
      • watchNode

        @HTTP(method="GET",
              path="/api/v1/watch/nodes/{name}")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchNode​(@Path("name")
                                                                                                                                java.lang.String name)
        watch changes to an object of kind Node. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.
        Parameters:
        name - name of the Node
      • watchNode

        @HTTP(method="GET",
              path="/api/v1/watch/nodes/{name}")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchNode​(@Path("name")
                                                                                                                                java.lang.String name,
                                                                                                                                @QueryMap
                                                                                                                                CoreV1Api.WatchNode queryParameters)
        watch changes to an object of kind Node. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.
        Parameters:
        name - name of the Node
      • watchPersistentVolumeClaimListForAllNamespaces

        @HTTP(method="GET",
              path="/api/v1/watch/persistentvolumeclaims")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchPersistentVolumeClaimListForAllNamespaces()
        watch individual changes to a list of PersistentVolumeClaim. deprecated: use the 'watch' parameter with a list operation instead.
      • watchPersistentVolumeClaimListForAllNamespaces

        @HTTP(method="GET",
              path="/api/v1/watch/persistentvolumeclaims")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchPersistentVolumeClaimListForAllNamespaces​(@QueryMap
                                                                                                                                                                     CoreV1Api.WatchPersistentVolumeClaimListForAllNamespaces queryParameters)
        watch individual changes to a list of PersistentVolumeClaim. deprecated: use the 'watch' parameter with a list operation instead.
      • watchPersistentVolumeList

        @HTTP(method="GET",
              path="/api/v1/watch/persistentvolumes")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchPersistentVolumeList()
        watch individual changes to a list of PersistentVolume. deprecated: use the 'watch' parameter with a list operation instead.
      • watchPersistentVolumeList

        @HTTP(method="GET",
              path="/api/v1/watch/persistentvolumes")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchPersistentVolumeList​(@QueryMap
                                                                                                                                                CoreV1Api.WatchPersistentVolumeList queryParameters)
        watch individual changes to a list of PersistentVolume. deprecated: use the 'watch' parameter with a list operation instead.
      • watchPersistentVolume

        @HTTP(method="GET",
              path="/api/v1/watch/persistentvolumes/{name}")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchPersistentVolume​(@Path("name")
                                                                                                                                            java.lang.String name)
        watch changes to an object of kind PersistentVolume. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.
        Parameters:
        name - name of the PersistentVolume
      • watchPersistentVolume

        @HTTP(method="GET",
              path="/api/v1/watch/persistentvolumes/{name}")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchPersistentVolume​(@Path("name")
                                                                                                                                            java.lang.String name,
                                                                                                                                            @QueryMap
                                                                                                                                            CoreV1Api.WatchPersistentVolume queryParameters)
        watch changes to an object of kind PersistentVolume. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter.
        Parameters:
        name - name of the PersistentVolume
      • watchPodListForAllNamespaces

        @HTTP(method="GET",
              path="/api/v1/watch/pods")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchPodListForAllNamespaces()
        watch individual changes to a list of Pod. deprecated: use the 'watch' parameter with a list operation instead.
      • watchPodListForAllNamespaces

        @HTTP(method="GET",
              path="/api/v1/watch/pods")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchPodListForAllNamespaces​(@QueryMap
                                                                                                                                                   CoreV1Api.WatchPodListForAllNamespaces queryParameters)
        watch individual changes to a list of Pod. deprecated: use the 'watch' parameter with a list operation instead.
      • watchPodTemplateListForAllNamespaces

        @HTTP(method="GET",
              path="/api/v1/watch/podtemplates")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchPodTemplateListForAllNamespaces()
        watch individual changes to a list of PodTemplate. deprecated: use the 'watch' parameter with a list operation instead.
      • watchPodTemplateListForAllNamespaces

        @HTTP(method="GET",
              path="/api/v1/watch/podtemplates")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchPodTemplateListForAllNamespaces​(@QueryMap
                                                                                                                                                           CoreV1Api.WatchPodTemplateListForAllNamespaces queryParameters)
        watch individual changes to a list of PodTemplate. deprecated: use the 'watch' parameter with a list operation instead.
      • watchReplicationControllerListForAllNamespaces

        @HTTP(method="GET",
              path="/api/v1/watch/replicationcontrollers")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchReplicationControllerListForAllNamespaces()
        watch individual changes to a list of ReplicationController. deprecated: use the 'watch' parameter with a list operation instead.
      • watchReplicationControllerListForAllNamespaces

        @HTTP(method="GET",
              path="/api/v1/watch/replicationcontrollers")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchReplicationControllerListForAllNamespaces​(@QueryMap
                                                                                                                                                                     CoreV1Api.WatchReplicationControllerListForAllNamespaces queryParameters)
        watch individual changes to a list of ReplicationController. deprecated: use the 'watch' parameter with a list operation instead.
      • watchResourceQuotaListForAllNamespaces

        @HTTP(method="GET",
              path="/api/v1/watch/resourcequotas")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchResourceQuotaListForAllNamespaces()
        watch individual changes to a list of ResourceQuota. deprecated: use the 'watch' parameter with a list operation instead.
      • watchResourceQuotaListForAllNamespaces

        @HTTP(method="GET",
              path="/api/v1/watch/resourcequotas")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchResourceQuotaListForAllNamespaces​(@QueryMap
                                                                                                                                                             CoreV1Api.WatchResourceQuotaListForAllNamespaces queryParameters)
        watch individual changes to a list of ResourceQuota. deprecated: use the 'watch' parameter with a list operation instead.
      • watchSecretListForAllNamespaces

        @HTTP(method="GET",
              path="/api/v1/watch/secrets")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchSecretListForAllNamespaces()
        watch individual changes to a list of Secret. deprecated: use the 'watch' parameter with a list operation instead.
      • watchSecretListForAllNamespaces

        @HTTP(method="GET",
              path="/api/v1/watch/secrets")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchSecretListForAllNamespaces​(@QueryMap
                                                                                                                                                      CoreV1Api.WatchSecretListForAllNamespaces queryParameters)
        watch individual changes to a list of Secret. deprecated: use the 'watch' parameter with a list operation instead.
      • watchServiceAccountListForAllNamespaces

        @HTTP(method="GET",
              path="/api/v1/watch/serviceaccounts")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchServiceAccountListForAllNamespaces()
        watch individual changes to a list of ServiceAccount. deprecated: use the 'watch' parameter with a list operation instead.
      • watchServiceAccountListForAllNamespaces

        @HTTP(method="GET",
              path="/api/v1/watch/serviceaccounts")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchServiceAccountListForAllNamespaces​(@QueryMap
                                                                                                                                                              CoreV1Api.WatchServiceAccountListForAllNamespaces queryParameters)
        watch individual changes to a list of ServiceAccount. deprecated: use the 'watch' parameter with a list operation instead.
      • watchServiceListForAllNamespaces

        @HTTP(method="GET",
              path="/api/v1/watch/services")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchServiceListForAllNamespaces()
        watch individual changes to a list of Service. deprecated: use the 'watch' parameter with a list operation instead.
      • watchServiceListForAllNamespaces

        @HTTP(method="GET",
              path="/api/v1/watch/services")
        @Headers("Accept: */*")
        com.marcnuri.yakc.api.KubernetesCall<com.marcnuri.yakc.model.io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent> watchServiceListForAllNamespaces​(@QueryMap
                                                                                                                                                       CoreV1Api.WatchServiceListForAllNamespaces queryParameters)
        watch individual changes to a list of Service. deprecated: use the 'watch' parameter with a list operation instead.