From 24f4a55fff999a6efe899b1d745b7143b87bc4bc Mon Sep 17 00:00:00 2001
From: "K.Himeno" <6715229+Himenon@users.noreply.github.com>
Date: Mon, 20 Mar 2023 23:38:51 +0900
Subject: [PATCH] fix: comment for functional api (#100)

---
 .../{Method.ts => ArrowFunction.ts}           |    22 +-
 .../ClientTypeDefinition.ts                   |    11 +
 .../FunctionalApiClient/ReturnStatement.ts    |     1 +
 .../FunctionalApiClient/index.ts              |    26 +-
 .../functional-api-client/index.ts            |     2 +
 .../TsGenerator/factory/ArrowFunction.ts      |     1 +
 .../TsGenerator/factory/PropertyAssignment.ts |     7 +
 .../factory/VariableDeclaration.ts            |     1 +
 .../factory/VariableDeclarationList.ts        |     2 +
 src/meta.ts                                   |     2 +-
 .../__snapshots__/argo-rollout-test.ts.snap   |   182 +-
 .../__snapshots__/format.domain.ts.snap       |     1 +
 .../__snapshots__/kubernetes-test.ts.snap     | 30069 ++++++++--------
 .../multi-type.test.domain.ts.snap            |    38 +-
 .../__snapshots__/spit-code-test.ts.snap      |   170 +-
 .../__snapshots__/template-only-test.ts.snap  |   277 +-
 .../typedef-with-template-test.ts.snap        |   415 +-
 .../unknown-schema-domain-test.ts.snap        |    16 +-
 18 files changed, 16157 insertions(+), 15086 deletions(-)
 rename src/code-templates/functional-api-client/FunctionalApiClient/{Method.ts => ArrowFunction.ts} (87%)
 create mode 100644 src/code-templates/functional-api-client/FunctionalApiClient/ClientTypeDefinition.ts

diff --git a/src/code-templates/functional-api-client/FunctionalApiClient/Method.ts b/src/code-templates/functional-api-client/FunctionalApiClient/ArrowFunction.ts
similarity index 87%
rename from src/code-templates/functional-api-client/FunctionalApiClient/Method.ts
rename to src/code-templates/functional-api-client/FunctionalApiClient/ArrowFunction.ts
index ace52ef1..cdc53a7d 100644
--- a/src/code-templates/functional-api-client/FunctionalApiClient/Method.ts
+++ b/src/code-templates/functional-api-client/FunctionalApiClient/ArrowFunction.ts
@@ -117,11 +117,9 @@ const methodTypeParameters = (factory: TsGenerator.Factory.Type, { convertedPara
 };
 
 /**
- * const {functionName} = async (params: {argumentParamsTypeDeclaration}<{RequestContentType}>): Promise<{requestBodyName}[ResponseContentType]> => {
- *
- * }
+ * async (params: {argumentParamsTypeDeclaration}<{RequestContentType}>): Promise<{requestBodyName}[ResponseContentType]> => {}
  */
-export const create = (factory: TsGenerator.Factory.Type, params: CodeGenerator.Params, option: Option): ts.VariableStatement => {
+export const create = (factory: TsGenerator.Factory.Type, params: CodeGenerator.Params, option: Option): ts.ArrowFunction => {
   const { convertedParams } = params;
   const typeParameters: ts.TypeParameterDeclaration[] = methodTypeParameters(factory, params);
   const methodArguments: ts.ParameterDeclaration[] = [];
@@ -153,7 +151,7 @@ export const create = (factory: TsGenerator.Factory.Type, params: CodeGenerator.
     }),
   );
 
-  const arrowFunction = factory.ArrowFunction.create({
+  return factory.ArrowFunction.create({
     typeParameters: typeParameters,
     parameters: methodArguments,
     type: returnType,
@@ -162,18 +160,4 @@ export const create = (factory: TsGenerator.Factory.Type, params: CodeGenerator.
       multiLine: true,
     }),
   });
-
-  const variableDeclarationList = factory.VariableDeclarationList.create({
-    declarations: [
-      factory.VariableDeclaration.create({
-        name: convertedParams.functionName,
-        initializer: arrowFunction,
-      }),
-    ],
-    flag: "const",
-  });
-
-  return factory.VariableStatement.create({
-    declarationList: variableDeclarationList,
-  });
 };
diff --git a/src/code-templates/functional-api-client/FunctionalApiClient/ClientTypeDefinition.ts b/src/code-templates/functional-api-client/FunctionalApiClient/ClientTypeDefinition.ts
new file mode 100644
index 00000000..b80ff55c
--- /dev/null
+++ b/src/code-templates/functional-api-client/FunctionalApiClient/ClientTypeDefinition.ts
@@ -0,0 +1,11 @@
+import type { TsGenerator } from "../../../api";
+
+export const create = (factory: TsGenerator.Factory.Type) => {
+  return factory.TypeAliasDeclaration.create({
+    export: true,
+    name: "Client",
+    type: factory.TypeReferenceNode.create({
+      name: `ReturnType<typeof createClient>`,
+    })
+  })
+};
diff --git a/src/code-templates/functional-api-client/FunctionalApiClient/ReturnStatement.ts b/src/code-templates/functional-api-client/FunctionalApiClient/ReturnStatement.ts
index 49663c83..e5a77398 100644
--- a/src/code-templates/functional-api-client/FunctionalApiClient/ReturnStatement.ts
+++ b/src/code-templates/functional-api-client/FunctionalApiClient/ReturnStatement.ts
@@ -13,6 +13,7 @@ export const create = (factory: TsGenerator.Factory.Type, list: CodeGenerator.Pa
   return factory.ReturnStatement.create({
     expression: factory.ObjectLiteralExpression.create({
       properties,
+      multiLine: true,
     }),
   });
 };
diff --git a/src/code-templates/functional-api-client/FunctionalApiClient/index.ts b/src/code-templates/functional-api-client/FunctionalApiClient/index.ts
index 8d622aa5..5dfe55dc 100644
--- a/src/code-templates/functional-api-client/FunctionalApiClient/index.ts
+++ b/src/code-templates/functional-api-client/FunctionalApiClient/index.ts
@@ -1,15 +1,29 @@
+import { EOL } from "os";
 import ts from "typescript";
 
 import type { TsGenerator } from "../../../api";
 import type { CodeGenerator } from "../../../types";
 import type { Option } from "../../_shared/types";
-import * as Method from "./Method";
-import * as ReturnStatement from "./ReturnStatement";
-export { Method };
+import * as ArrowFunction from "./ArrowFunction";
 
 export const create = (factory: TsGenerator.Factory.Type, list: CodeGenerator.Params[], option: Option): ts.VariableStatement => {
-  const variableStatements = list.map(params => {
-    return Method.create(factory, params, option);
+  const properties = list.map(params => {
+    return factory.PropertyAssignment.create({
+      name: params.convertedParams.functionName,
+      initializer: ArrowFunction.create(factory, params, option),
+      comment: option.additionalMethodComment
+        ? [params.operationParams.comment, `operationId: ${params.operationId}`, `Request URI: ${params.operationParams.requestUri}`]
+            .filter(t => !!t)
+            .join(EOL)
+        : params.operationParams.comment,
+    });
+  });
+
+  const returnValue = factory.ReturnStatement.create({
+    expression: factory.ObjectLiteralExpression.create({
+      properties,
+      multiLine: true,
+    }),
   });
 
   const arrowFunction = factory.ArrowFunction.create({
@@ -36,7 +50,7 @@ export const create = (factory: TsGenerator.Factory.Type, list: CodeGenerator.Pa
       }),
     ],
     body: factory.Block.create({
-      statements: [...variableStatements, ReturnStatement.create(factory, list)],
+      statements: [returnValue],
       multiLine: true,
     }),
   });
diff --git a/src/code-templates/functional-api-client/index.ts b/src/code-templates/functional-api-client/index.ts
index 9a69887d..a45ad3bf 100644
--- a/src/code-templates/functional-api-client/index.ts
+++ b/src/code-templates/functional-api-client/index.ts
@@ -5,6 +5,7 @@ import type { CodeGenerator } from "../../types";
 import * as ApiClientArgument from "../_shared/ApiClientArgument";
 import * as FunctionalApiClient from "./FunctionalApiClient";
 import * as ApiClientInterface from "../_shared/ApiClientInterface";
+import * as ClientTypeDefinition from "./FunctionalApiClient/ClientTypeDefinition";
 
 import type { Option } from "../_shared/types";
 
@@ -36,5 +37,6 @@ export const generator: CodeGenerator.GenerateFunction<Option> = (
 
   const apiClientStatement = FunctionalApiClient.create(factory, codeGeneratorParamsList, option || {});
   statements.push(apiClientStatement);
+  statements.push(ClientTypeDefinition.create(factory));
   return statements;
 };
diff --git a/src/internal/TsGenerator/factory/ArrowFunction.ts b/src/internal/TsGenerator/factory/ArrowFunction.ts
index bcf1db31..fe09bee4 100644
--- a/src/internal/TsGenerator/factory/ArrowFunction.ts
+++ b/src/internal/TsGenerator/factory/ArrowFunction.ts
@@ -23,6 +23,7 @@ export const create =
       params.equalsGreaterThanToken,
       params.body,
     );
+
     return node;
   };
 
diff --git a/src/internal/TsGenerator/factory/PropertyAssignment.ts b/src/internal/TsGenerator/factory/PropertyAssignment.ts
index fbaee43e..6eb8de08 100644
--- a/src/internal/TsGenerator/factory/PropertyAssignment.ts
+++ b/src/internal/TsGenerator/factory/PropertyAssignment.ts
@@ -1,8 +1,11 @@
 import ts from "typescript";
+import { generateComment } from "./utils";
 
 export interface Params {
   name: string;
   initializer: ts.Expression;
+  comment?: string;
+  deprecated?: boolean;
 }
 
 export interface Factory {
@@ -13,6 +16,10 @@ export const create =
   ({ factory }: Pick<ts.TransformationContext, "factory">): Factory["create"] =>
   (params: Params): ts.PropertyAssignment => {
     const node = factory.createPropertyAssignment(params.name, params.initializer);
+    if (params.comment) {
+      const comment = generateComment(params.comment, params.deprecated);
+      return ts.addSyntheticLeadingComment(node, ts.SyntaxKind.MultiLineCommentTrivia, comment.value, comment.hasTrailingNewLine);
+    }
     return node;
   };
 
diff --git a/src/internal/TsGenerator/factory/VariableDeclaration.ts b/src/internal/TsGenerator/factory/VariableDeclaration.ts
index 41e98a6c..4f34e290 100644
--- a/src/internal/TsGenerator/factory/VariableDeclaration.ts
+++ b/src/internal/TsGenerator/factory/VariableDeclaration.ts
@@ -1,4 +1,5 @@
 import ts from "typescript";
+import { generateComment } from "./utils";
 
 export interface Params {
   name: string | ts.BindingName;
diff --git a/src/internal/TsGenerator/factory/VariableDeclarationList.ts b/src/internal/TsGenerator/factory/VariableDeclarationList.ts
index c7ad8d68..c35112f0 100644
--- a/src/internal/TsGenerator/factory/VariableDeclarationList.ts
+++ b/src/internal/TsGenerator/factory/VariableDeclarationList.ts
@@ -1,4 +1,5 @@
 import ts from "typescript";
+import { generateComment } from "./utils";
 
 const flags = {
   const: ts.NodeFlags.Const,
@@ -7,6 +8,7 @@ const flags = {
 export interface Params {
   declarations: readonly ts.VariableDeclaration[];
   flag: keyof typeof flags;
+
 }
 
 export interface Factory {
diff --git a/src/meta.ts b/src/meta.ts
index 730168c8..04e02a68 100644
--- a/src/meta.ts
+++ b/src/meta.ts
@@ -1,2 +1,2 @@
 export const Name = "@himenon/openapi-typescript-code-generator";
-export const Version = "0.21.0";
+export const Version = "0.22.0";
\ No newline at end of file
diff --git a/test/__tests__/functional/__snapshots__/argo-rollout-test.ts.snap b/test/__tests__/functional/__snapshots__/argo-rollout-test.ts.snap
index 2acb2164..670458d8 100644
--- a/test/__tests__/functional/__snapshots__/argo-rollout-test.ts.snap
+++ b/test/__tests__/functional/__snapshots__/argo-rollout-test.ts.snap
@@ -3830,97 +3830,99 @@ export interface ApiClient<RequestOption> {
     request: <T = SuccessResponses>(httpMethod: HttpMethod, url: string, headers: ObjectLike | any, requestBody: ObjectLike | any, queryParameters: QueryParameters | undefined, options?: RequestOption) => Promise<T>;
 }
 export const createClient = <RequestOption>(apiClient: ApiClient<RequestOption>, baseUrl: string) => {
-    const RolloutService_GetNamespace = (option?: RequestOption): Promise<Response$RolloutService_GetNamespace$Status$200["application/json"]> => {
-        const url = baseUrl + \`/api/v1/namespace\`;
-        const headers = {
-            Accept: "application/json"
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const RolloutService_ListRolloutInfos = (params: Params$RolloutService_ListRolloutInfos, option?: RequestOption): Promise<Response$RolloutService_ListRolloutInfos$Status$200["application/json"]> => {
-        const url = baseUrl + \`/api/v1/rollouts/\${params.parameter.namespace}/info\`;
-        const headers = {
-            Accept: "application/json"
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const RolloutService_WatchRolloutInfos = (params: Params$RolloutService_WatchRolloutInfos, option?: RequestOption): Promise<Response$RolloutService_WatchRolloutInfos$Status$200["application/json"]> => {
-        const url = baseUrl + \`/api/v1/rollouts/\${params.parameter.namespace}/info/watch\`;
-        const headers = {
-            Accept: "application/json"
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const RolloutService_AbortRollout = (params: Params$RolloutService_AbortRollout, option?: RequestOption): Promise<Response$RolloutService_AbortRollout$Status$200["application/json"]> => {
-        const url = baseUrl + \`/api/v1/rollouts/\${params.parameter.namespace}/\${params.parameter.name}/abort\`;
-        const headers = {
-            "Content-Type": "application/json",
-            Accept: "application/json"
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, undefined, option);
-    };
-    const RolloutService_GetRolloutInfo = (params: Params$RolloutService_GetRolloutInfo, option?: RequestOption): Promise<Response$RolloutService_GetRolloutInfo$Status$200["application/json"]> => {
-        const url = baseUrl + \`/api/v1/rollouts/\${params.parameter.namespace}/\${params.parameter.name}/info\`;
-        const headers = {
-            Accept: "application/json"
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const RolloutService_WatchRolloutInfo = (params: Params$RolloutService_WatchRolloutInfo, option?: RequestOption): Promise<Response$RolloutService_WatchRolloutInfo$Status$200["application/json"]> => {
-        const url = baseUrl + \`/api/v1/rollouts/\${params.parameter.namespace}/\${params.parameter.name}/info/watch\`;
-        const headers = {
-            Accept: "application/json"
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const RolloutService_PromoteRollout = (params: Params$RolloutService_PromoteRollout, option?: RequestOption): Promise<Response$RolloutService_PromoteRollout$Status$200["application/json"]> => {
-        const url = baseUrl + \`/api/v1/rollouts/\${params.parameter.namespace}/\${params.parameter.name}/promote\`;
-        const headers = {
-            "Content-Type": "application/json",
-            Accept: "application/json"
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, undefined, option);
-    };
-    const RolloutService_RestartRollout = (params: Params$RolloutService_RestartRollout, option?: RequestOption): Promise<Response$RolloutService_RestartRollout$Status$200["application/json"]> => {
-        const url = baseUrl + \`/api/v1/rollouts/\${params.parameter.namespace}/\${params.parameter.name}/restart\`;
-        const headers = {
-            "Content-Type": "application/json",
-            Accept: "application/json"
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, undefined, option);
-    };
-    const RolloutService_RetryRollout = (params: Params$RolloutService_RetryRollout, option?: RequestOption): Promise<Response$RolloutService_RetryRollout$Status$200["application/json"]> => {
-        const url = baseUrl + \`/api/v1/rollouts/\${params.parameter.namespace}/\${params.parameter.name}/retry\`;
-        const headers = {
-            "Content-Type": "application/json",
-            Accept: "application/json"
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, undefined, option);
-    };
-    const RolloutService_SetRolloutImage = (params: Params$RolloutService_SetRolloutImage, option?: RequestOption): Promise<Response$RolloutService_SetRolloutImage$Status$200["application/json"]> => {
-        const url = baseUrl + \`/api/v1/rollouts/\${params.parameter.namespace}/\${params.parameter.rollout}/set/\${params.parameter.container}/\${params.parameter.image}/\${params.parameter.tag}\`;
-        const headers = {
-            "Content-Type": "application/json",
-            Accept: "application/json"
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, undefined, option);
-    };
-    const RolloutService_UndoRollout = (params: Params$RolloutService_UndoRollout, option?: RequestOption): Promise<Response$RolloutService_UndoRollout$Status$200["application/json"]> => {
-        const url = baseUrl + \`/api/v1/rollouts/\${params.parameter.namespace}/\${params.parameter.rollout}/undo/\${params.parameter.revision}\`;
-        const headers = {
-            "Content-Type": "application/json",
-            Accept: "application/json"
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, undefined, option);
-    };
-    const RolloutService_Version = (option?: RequestOption): Promise<Response$RolloutService_Version$Status$200["application/json"]> => {
-        const url = baseUrl + \`/api/v1/version\`;
-        const headers = {
-            Accept: "application/json"
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
+    return {
+        RolloutService_GetNamespace: (option?: RequestOption): Promise<Response$RolloutService_GetNamespace$Status$200["application/json"]> => {
+            const url = baseUrl + \`/api/v1/namespace\`;
+            const headers = {
+                Accept: "application/json"
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        RolloutService_ListRolloutInfos: (params: Params$RolloutService_ListRolloutInfos, option?: RequestOption): Promise<Response$RolloutService_ListRolloutInfos$Status$200["application/json"]> => {
+            const url = baseUrl + \`/api/v1/rollouts/\${params.parameter.namespace}/info\`;
+            const headers = {
+                Accept: "application/json"
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        RolloutService_WatchRolloutInfos: (params: Params$RolloutService_WatchRolloutInfos, option?: RequestOption): Promise<Response$RolloutService_WatchRolloutInfos$Status$200["application/json"]> => {
+            const url = baseUrl + \`/api/v1/rollouts/\${params.parameter.namespace}/info/watch\`;
+            const headers = {
+                Accept: "application/json"
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        RolloutService_AbortRollout: (params: Params$RolloutService_AbortRollout, option?: RequestOption): Promise<Response$RolloutService_AbortRollout$Status$200["application/json"]> => {
+            const url = baseUrl + \`/api/v1/rollouts/\${params.parameter.namespace}/\${params.parameter.name}/abort\`;
+            const headers = {
+                "Content-Type": "application/json",
+                Accept: "application/json"
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, undefined, option);
+        },
+        RolloutService_GetRolloutInfo: (params: Params$RolloutService_GetRolloutInfo, option?: RequestOption): Promise<Response$RolloutService_GetRolloutInfo$Status$200["application/json"]> => {
+            const url = baseUrl + \`/api/v1/rollouts/\${params.parameter.namespace}/\${params.parameter.name}/info\`;
+            const headers = {
+                Accept: "application/json"
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        RolloutService_WatchRolloutInfo: (params: Params$RolloutService_WatchRolloutInfo, option?: RequestOption): Promise<Response$RolloutService_WatchRolloutInfo$Status$200["application/json"]> => {
+            const url = baseUrl + \`/api/v1/rollouts/\${params.parameter.namespace}/\${params.parameter.name}/info/watch\`;
+            const headers = {
+                Accept: "application/json"
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        RolloutService_PromoteRollout: (params: Params$RolloutService_PromoteRollout, option?: RequestOption): Promise<Response$RolloutService_PromoteRollout$Status$200["application/json"]> => {
+            const url = baseUrl + \`/api/v1/rollouts/\${params.parameter.namespace}/\${params.parameter.name}/promote\`;
+            const headers = {
+                "Content-Type": "application/json",
+                Accept: "application/json"
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, undefined, option);
+        },
+        RolloutService_RestartRollout: (params: Params$RolloutService_RestartRollout, option?: RequestOption): Promise<Response$RolloutService_RestartRollout$Status$200["application/json"]> => {
+            const url = baseUrl + \`/api/v1/rollouts/\${params.parameter.namespace}/\${params.parameter.name}/restart\`;
+            const headers = {
+                "Content-Type": "application/json",
+                Accept: "application/json"
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, undefined, option);
+        },
+        RolloutService_RetryRollout: (params: Params$RolloutService_RetryRollout, option?: RequestOption): Promise<Response$RolloutService_RetryRollout$Status$200["application/json"]> => {
+            const url = baseUrl + \`/api/v1/rollouts/\${params.parameter.namespace}/\${params.parameter.name}/retry\`;
+            const headers = {
+                "Content-Type": "application/json",
+                Accept: "application/json"
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, undefined, option);
+        },
+        RolloutService_SetRolloutImage: (params: Params$RolloutService_SetRolloutImage, option?: RequestOption): Promise<Response$RolloutService_SetRolloutImage$Status$200["application/json"]> => {
+            const url = baseUrl + \`/api/v1/rollouts/\${params.parameter.namespace}/\${params.parameter.rollout}/set/\${params.parameter.container}/\${params.parameter.image}/\${params.parameter.tag}\`;
+            const headers = {
+                "Content-Type": "application/json",
+                Accept: "application/json"
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, undefined, option);
+        },
+        RolloutService_UndoRollout: (params: Params$RolloutService_UndoRollout, option?: RequestOption): Promise<Response$RolloutService_UndoRollout$Status$200["application/json"]> => {
+            const url = baseUrl + \`/api/v1/rollouts/\${params.parameter.namespace}/\${params.parameter.rollout}/undo/\${params.parameter.revision}\`;
+            const headers = {
+                "Content-Type": "application/json",
+                Accept: "application/json"
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, undefined, option);
+        },
+        RolloutService_Version: (option?: RequestOption): Promise<Response$RolloutService_Version$Status$200["application/json"]> => {
+            const url = baseUrl + \`/api/v1/version\`;
+            const headers = {
+                Accept: "application/json"
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        }
     };
-    return { RolloutService_GetNamespace, RolloutService_ListRolloutInfos, RolloutService_WatchRolloutInfos, RolloutService_AbortRollout, RolloutService_GetRolloutInfo, RolloutService_WatchRolloutInfo, RolloutService_PromoteRollout, RolloutService_RestartRollout, RolloutService_RetryRollout, RolloutService_SetRolloutImage, RolloutService_UndoRollout, RolloutService_Version };
 };
+export type Client = ReturnType<typeof createClient>;
 "
 `;
diff --git a/test/__tests__/functional/__snapshots__/format.domain.ts.snap b/test/__tests__/functional/__snapshots__/format.domain.ts.snap
index 3a76492d..39a52a0f 100644
--- a/test/__tests__/functional/__snapshots__/format.domain.ts.snap
+++ b/test/__tests__/functional/__snapshots__/format.domain.ts.snap
@@ -49,5 +49,6 @@ export interface ApiClient<RequestOption> {
 export const createClient = <RequestOption>(apiClient: ApiClient<RequestOption>, baseUrl: string) => {
     return {};
 };
+export type Client = ReturnType<typeof createClient>;
 "
 `;
diff --git a/test/__tests__/functional/__snapshots__/kubernetes-test.ts.snap b/test/__tests__/functional/__snapshots__/kubernetes-test.ts.snap
index 59ec82ba..fa431c31 100644
--- a/test/__tests__/functional/__snapshots__/kubernetes-test.ts.snap
+++ b/test/__tests__/functional/__snapshots__/kubernetes-test.ts.snap
@@ -41029,14550 +41029,15533 @@ export interface ApiClient<RequestOption> {
     request: <T = SuccessResponses>(httpMethod: HttpMethod, url: string, headers: ObjectLike | any, requestBody: ObjectLike | any, queryParameters: QueryParameters | undefined, options?: RequestOption) => Promise<T>;
 }
 export const createClient = <RequestOption>(apiClient: ApiClient<RequestOption>, baseUrl: string) => {
-    const getCoreAPIVersions = <ResponseContentType extends ResponseContentType$getCoreAPIVersions>(params: Params$getCoreAPIVersions<ResponseContentType>, option?: RequestOption): Promise<Response$getCoreAPIVersions$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const getCoreV1APIResources = <ResponseContentType extends ResponseContentType$getCoreV1APIResources>(params: Params$getCoreV1APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getCoreV1APIResources$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const listCoreV1ComponentStatus = <ResponseContentType extends ResponseContentType$listCoreV1ComponentStatus>(params: Params$listCoreV1ComponentStatus<ResponseContentType>, option?: RequestOption): Promise<Response$listCoreV1ComponentStatus$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/componentstatuses\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const readCoreV1ComponentStatus = <ResponseContentType extends ResponseContentType$readCoreV1ComponentStatus>(params: Params$readCoreV1ComponentStatus<ResponseContentType>, option?: RequestOption): Promise<Response$readCoreV1ComponentStatus$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/componentstatuses/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const listCoreV1ConfigMapForAllNamespaces = <ResponseContentType extends ResponseContentType$listCoreV1ConfigMapForAllNamespaces>(params: Params$listCoreV1ConfigMapForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$listCoreV1ConfigMapForAllNamespaces$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/configmaps\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const listCoreV1EndpointsForAllNamespaces = <ResponseContentType extends ResponseContentType$listCoreV1EndpointsForAllNamespaces>(params: Params$listCoreV1EndpointsForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$listCoreV1EndpointsForAllNamespaces$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/endpoints\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const listCoreV1EventForAllNamespaces = <ResponseContentType extends ResponseContentType$listCoreV1EventForAllNamespaces>(params: Params$listCoreV1EventForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$listCoreV1EventForAllNamespaces$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/events\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const listCoreV1LimitRangeForAllNamespaces = <ResponseContentType extends ResponseContentType$listCoreV1LimitRangeForAllNamespaces>(params: Params$listCoreV1LimitRangeForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$listCoreV1LimitRangeForAllNamespaces$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/limitranges\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const listCoreV1Namespace = <ResponseContentType extends ResponseContentType$listCoreV1Namespace>(params: Params$listCoreV1Namespace<ResponseContentType>, option?: RequestOption): Promise<Response$listCoreV1Namespace$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const createCoreV1Namespace = <ResponseContentType extends ResponseContentType$createCoreV1Namespace>(params: Params$createCoreV1Namespace<ResponseContentType>, option?: RequestOption): Promise<(Response$createCoreV1Namespace$Status$200 | Response$createCoreV1Namespace$Status$201 | Response$createCoreV1Namespace$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const createCoreV1NamespacedBinding = <ResponseContentType extends ResponseContentType$createCoreV1NamespacedBinding>(params: Params$createCoreV1NamespacedBinding<ResponseContentType>, option?: RequestOption): Promise<(Response$createCoreV1NamespacedBinding$Status$200 | Response$createCoreV1NamespacedBinding$Status$201 | Response$createCoreV1NamespacedBinding$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/bindings\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const listCoreV1NamespacedConfigMap = <ResponseContentType extends ResponseContentType$listCoreV1NamespacedConfigMap>(params: Params$listCoreV1NamespacedConfigMap<ResponseContentType>, option?: RequestOption): Promise<Response$listCoreV1NamespacedConfigMap$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/configmaps\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const createCoreV1NamespacedConfigMap = <ResponseContentType extends ResponseContentType$createCoreV1NamespacedConfigMap>(params: Params$createCoreV1NamespacedConfigMap<ResponseContentType>, option?: RequestOption): Promise<(Response$createCoreV1NamespacedConfigMap$Status$200 | Response$createCoreV1NamespacedConfigMap$Status$201 | Response$createCoreV1NamespacedConfigMap$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/configmaps\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteCoreV1CollectionNamespacedConfigMap = <ResponseContentType extends ResponseContentType$deleteCoreV1CollectionNamespacedConfigMap>(params: Params$deleteCoreV1CollectionNamespacedConfigMap<ResponseContentType>, option?: RequestOption): Promise<Response$deleteCoreV1CollectionNamespacedConfigMap$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/configmaps\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readCoreV1NamespacedConfigMap = <ResponseContentType extends ResponseContentType$readCoreV1NamespacedConfigMap>(params: Params$readCoreV1NamespacedConfigMap<ResponseContentType>, option?: RequestOption): Promise<Response$readCoreV1NamespacedConfigMap$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/configmaps/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            exact: { value: params.parameter.exact, explode: false },
-            export: { value: params.parameter.export, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceCoreV1NamespacedConfigMap = <ResponseContentType extends ResponseContentType$replaceCoreV1NamespacedConfigMap>(params: Params$replaceCoreV1NamespacedConfigMap<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceCoreV1NamespacedConfigMap$Status$200 | Response$replaceCoreV1NamespacedConfigMap$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/configmaps/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteCoreV1NamespacedConfigMap = <ResponseContentType extends ResponseContentType$deleteCoreV1NamespacedConfigMap>(params: Params$deleteCoreV1NamespacedConfigMap<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteCoreV1NamespacedConfigMap$Status$200 | Response$deleteCoreV1NamespacedConfigMap$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/configmaps/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchCoreV1NamespacedConfigMap = <RequestContentType extends RequestContentType$patchCoreV1NamespacedConfigMap, ResponseContentType extends ResponseContentType$patchCoreV1NamespacedConfigMap>(params: Params$patchCoreV1NamespacedConfigMap<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchCoreV1NamespacedConfigMap$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/configmaps/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const listCoreV1NamespacedEndpoints = <ResponseContentType extends ResponseContentType$listCoreV1NamespacedEndpoints>(params: Params$listCoreV1NamespacedEndpoints<ResponseContentType>, option?: RequestOption): Promise<Response$listCoreV1NamespacedEndpoints$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/endpoints\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const createCoreV1NamespacedEndpoints = <ResponseContentType extends ResponseContentType$createCoreV1NamespacedEndpoints>(params: Params$createCoreV1NamespacedEndpoints<ResponseContentType>, option?: RequestOption): Promise<(Response$createCoreV1NamespacedEndpoints$Status$200 | Response$createCoreV1NamespacedEndpoints$Status$201 | Response$createCoreV1NamespacedEndpoints$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/endpoints\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteCoreV1CollectionNamespacedEndpoints = <ResponseContentType extends ResponseContentType$deleteCoreV1CollectionNamespacedEndpoints>(params: Params$deleteCoreV1CollectionNamespacedEndpoints<ResponseContentType>, option?: RequestOption): Promise<Response$deleteCoreV1CollectionNamespacedEndpoints$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/endpoints\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readCoreV1NamespacedEndpoints = <ResponseContentType extends ResponseContentType$readCoreV1NamespacedEndpoints>(params: Params$readCoreV1NamespacedEndpoints<ResponseContentType>, option?: RequestOption): Promise<Response$readCoreV1NamespacedEndpoints$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/endpoints/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            exact: { value: params.parameter.exact, explode: false },
-            export: { value: params.parameter.export, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceCoreV1NamespacedEndpoints = <ResponseContentType extends ResponseContentType$replaceCoreV1NamespacedEndpoints>(params: Params$replaceCoreV1NamespacedEndpoints<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceCoreV1NamespacedEndpoints$Status$200 | Response$replaceCoreV1NamespacedEndpoints$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/endpoints/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteCoreV1NamespacedEndpoints = <ResponseContentType extends ResponseContentType$deleteCoreV1NamespacedEndpoints>(params: Params$deleteCoreV1NamespacedEndpoints<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteCoreV1NamespacedEndpoints$Status$200 | Response$deleteCoreV1NamespacedEndpoints$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/endpoints/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchCoreV1NamespacedEndpoints = <RequestContentType extends RequestContentType$patchCoreV1NamespacedEndpoints, ResponseContentType extends ResponseContentType$patchCoreV1NamespacedEndpoints>(params: Params$patchCoreV1NamespacedEndpoints<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchCoreV1NamespacedEndpoints$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/endpoints/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const listCoreV1NamespacedEvent = <ResponseContentType extends ResponseContentType$listCoreV1NamespacedEvent>(params: Params$listCoreV1NamespacedEvent<ResponseContentType>, option?: RequestOption): Promise<Response$listCoreV1NamespacedEvent$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/events\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const createCoreV1NamespacedEvent = <ResponseContentType extends ResponseContentType$createCoreV1NamespacedEvent>(params: Params$createCoreV1NamespacedEvent<ResponseContentType>, option?: RequestOption): Promise<(Response$createCoreV1NamespacedEvent$Status$200 | Response$createCoreV1NamespacedEvent$Status$201 | Response$createCoreV1NamespacedEvent$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/events\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteCoreV1CollectionNamespacedEvent = <ResponseContentType extends ResponseContentType$deleteCoreV1CollectionNamespacedEvent>(params: Params$deleteCoreV1CollectionNamespacedEvent<ResponseContentType>, option?: RequestOption): Promise<Response$deleteCoreV1CollectionNamespacedEvent$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/events\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readCoreV1NamespacedEvent = <ResponseContentType extends ResponseContentType$readCoreV1NamespacedEvent>(params: Params$readCoreV1NamespacedEvent<ResponseContentType>, option?: RequestOption): Promise<Response$readCoreV1NamespacedEvent$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/events/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            exact: { value: params.parameter.exact, explode: false },
-            export: { value: params.parameter.export, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceCoreV1NamespacedEvent = <ResponseContentType extends ResponseContentType$replaceCoreV1NamespacedEvent>(params: Params$replaceCoreV1NamespacedEvent<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceCoreV1NamespacedEvent$Status$200 | Response$replaceCoreV1NamespacedEvent$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/events/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteCoreV1NamespacedEvent = <ResponseContentType extends ResponseContentType$deleteCoreV1NamespacedEvent>(params: Params$deleteCoreV1NamespacedEvent<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteCoreV1NamespacedEvent$Status$200 | Response$deleteCoreV1NamespacedEvent$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/events/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchCoreV1NamespacedEvent = <RequestContentType extends RequestContentType$patchCoreV1NamespacedEvent, ResponseContentType extends ResponseContentType$patchCoreV1NamespacedEvent>(params: Params$patchCoreV1NamespacedEvent<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchCoreV1NamespacedEvent$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/events/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const listCoreV1NamespacedLimitRange = <ResponseContentType extends ResponseContentType$listCoreV1NamespacedLimitRange>(params: Params$listCoreV1NamespacedLimitRange<ResponseContentType>, option?: RequestOption): Promise<Response$listCoreV1NamespacedLimitRange$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/limitranges\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const createCoreV1NamespacedLimitRange = <ResponseContentType extends ResponseContentType$createCoreV1NamespacedLimitRange>(params: Params$createCoreV1NamespacedLimitRange<ResponseContentType>, option?: RequestOption): Promise<(Response$createCoreV1NamespacedLimitRange$Status$200 | Response$createCoreV1NamespacedLimitRange$Status$201 | Response$createCoreV1NamespacedLimitRange$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/limitranges\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteCoreV1CollectionNamespacedLimitRange = <ResponseContentType extends ResponseContentType$deleteCoreV1CollectionNamespacedLimitRange>(params: Params$deleteCoreV1CollectionNamespacedLimitRange<ResponseContentType>, option?: RequestOption): Promise<Response$deleteCoreV1CollectionNamespacedLimitRange$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/limitranges\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readCoreV1NamespacedLimitRange = <ResponseContentType extends ResponseContentType$readCoreV1NamespacedLimitRange>(params: Params$readCoreV1NamespacedLimitRange<ResponseContentType>, option?: RequestOption): Promise<Response$readCoreV1NamespacedLimitRange$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/limitranges/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            exact: { value: params.parameter.exact, explode: false },
-            export: { value: params.parameter.export, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceCoreV1NamespacedLimitRange = <ResponseContentType extends ResponseContentType$replaceCoreV1NamespacedLimitRange>(params: Params$replaceCoreV1NamespacedLimitRange<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceCoreV1NamespacedLimitRange$Status$200 | Response$replaceCoreV1NamespacedLimitRange$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/limitranges/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteCoreV1NamespacedLimitRange = <ResponseContentType extends ResponseContentType$deleteCoreV1NamespacedLimitRange>(params: Params$deleteCoreV1NamespacedLimitRange<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteCoreV1NamespacedLimitRange$Status$200 | Response$deleteCoreV1NamespacedLimitRange$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/limitranges/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchCoreV1NamespacedLimitRange = <RequestContentType extends RequestContentType$patchCoreV1NamespacedLimitRange, ResponseContentType extends ResponseContentType$patchCoreV1NamespacedLimitRange>(params: Params$patchCoreV1NamespacedLimitRange<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchCoreV1NamespacedLimitRange$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/limitranges/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const listCoreV1NamespacedPersistentVolumeClaim = <ResponseContentType extends ResponseContentType$listCoreV1NamespacedPersistentVolumeClaim>(params: Params$listCoreV1NamespacedPersistentVolumeClaim<ResponseContentType>, option?: RequestOption): Promise<Response$listCoreV1NamespacedPersistentVolumeClaim$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/persistentvolumeclaims\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const createCoreV1NamespacedPersistentVolumeClaim = <ResponseContentType extends ResponseContentType$createCoreV1NamespacedPersistentVolumeClaim>(params: Params$createCoreV1NamespacedPersistentVolumeClaim<ResponseContentType>, option?: RequestOption): Promise<(Response$createCoreV1NamespacedPersistentVolumeClaim$Status$200 | Response$createCoreV1NamespacedPersistentVolumeClaim$Status$201 | Response$createCoreV1NamespacedPersistentVolumeClaim$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/persistentvolumeclaims\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteCoreV1CollectionNamespacedPersistentVolumeClaim = <ResponseContentType extends ResponseContentType$deleteCoreV1CollectionNamespacedPersistentVolumeClaim>(params: Params$deleteCoreV1CollectionNamespacedPersistentVolumeClaim<ResponseContentType>, option?: RequestOption): Promise<Response$deleteCoreV1CollectionNamespacedPersistentVolumeClaim$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/persistentvolumeclaims\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readCoreV1NamespacedPersistentVolumeClaim = <ResponseContentType extends ResponseContentType$readCoreV1NamespacedPersistentVolumeClaim>(params: Params$readCoreV1NamespacedPersistentVolumeClaim<ResponseContentType>, option?: RequestOption): Promise<Response$readCoreV1NamespacedPersistentVolumeClaim$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/persistentvolumeclaims/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            exact: { value: params.parameter.exact, explode: false },
-            export: { value: params.parameter.export, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceCoreV1NamespacedPersistentVolumeClaim = <ResponseContentType extends ResponseContentType$replaceCoreV1NamespacedPersistentVolumeClaim>(params: Params$replaceCoreV1NamespacedPersistentVolumeClaim<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceCoreV1NamespacedPersistentVolumeClaim$Status$200 | Response$replaceCoreV1NamespacedPersistentVolumeClaim$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/persistentvolumeclaims/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteCoreV1NamespacedPersistentVolumeClaim = <ResponseContentType extends ResponseContentType$deleteCoreV1NamespacedPersistentVolumeClaim>(params: Params$deleteCoreV1NamespacedPersistentVolumeClaim<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteCoreV1NamespacedPersistentVolumeClaim$Status$200 | Response$deleteCoreV1NamespacedPersistentVolumeClaim$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/persistentvolumeclaims/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchCoreV1NamespacedPersistentVolumeClaim = <RequestContentType extends RequestContentType$patchCoreV1NamespacedPersistentVolumeClaim, ResponseContentType extends ResponseContentType$patchCoreV1NamespacedPersistentVolumeClaim>(params: Params$patchCoreV1NamespacedPersistentVolumeClaim<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchCoreV1NamespacedPersistentVolumeClaim$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/persistentvolumeclaims/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readCoreV1NamespacedPersistentVolumeClaimStatus = <ResponseContentType extends ResponseContentType$readCoreV1NamespacedPersistentVolumeClaimStatus>(params: Params$readCoreV1NamespacedPersistentVolumeClaimStatus<ResponseContentType>, option?: RequestOption): Promise<Response$readCoreV1NamespacedPersistentVolumeClaimStatus$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/persistentvolumeclaims/\${params.parameter.name}/status\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceCoreV1NamespacedPersistentVolumeClaimStatus = <ResponseContentType extends ResponseContentType$replaceCoreV1NamespacedPersistentVolumeClaimStatus>(params: Params$replaceCoreV1NamespacedPersistentVolumeClaimStatus<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceCoreV1NamespacedPersistentVolumeClaimStatus$Status$200 | Response$replaceCoreV1NamespacedPersistentVolumeClaimStatus$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/persistentvolumeclaims/\${params.parameter.name}/status\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchCoreV1NamespacedPersistentVolumeClaimStatus = <RequestContentType extends RequestContentType$patchCoreV1NamespacedPersistentVolumeClaimStatus, ResponseContentType extends ResponseContentType$patchCoreV1NamespacedPersistentVolumeClaimStatus>(params: Params$patchCoreV1NamespacedPersistentVolumeClaimStatus<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchCoreV1NamespacedPersistentVolumeClaimStatus$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/persistentvolumeclaims/\${params.parameter.name}/status\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const listCoreV1NamespacedPod = <ResponseContentType extends ResponseContentType$listCoreV1NamespacedPod>(params: Params$listCoreV1NamespacedPod<ResponseContentType>, option?: RequestOption): Promise<Response$listCoreV1NamespacedPod$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/pods\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const createCoreV1NamespacedPod = <ResponseContentType extends ResponseContentType$createCoreV1NamespacedPod>(params: Params$createCoreV1NamespacedPod<ResponseContentType>, option?: RequestOption): Promise<(Response$createCoreV1NamespacedPod$Status$200 | Response$createCoreV1NamespacedPod$Status$201 | Response$createCoreV1NamespacedPod$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/pods\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteCoreV1CollectionNamespacedPod = <ResponseContentType extends ResponseContentType$deleteCoreV1CollectionNamespacedPod>(params: Params$deleteCoreV1CollectionNamespacedPod<ResponseContentType>, option?: RequestOption): Promise<Response$deleteCoreV1CollectionNamespacedPod$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/pods\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readCoreV1NamespacedPod = <ResponseContentType extends ResponseContentType$readCoreV1NamespacedPod>(params: Params$readCoreV1NamespacedPod<ResponseContentType>, option?: RequestOption): Promise<Response$readCoreV1NamespacedPod$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/pods/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            exact: { value: params.parameter.exact, explode: false },
-            export: { value: params.parameter.export, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceCoreV1NamespacedPod = <ResponseContentType extends ResponseContentType$replaceCoreV1NamespacedPod>(params: Params$replaceCoreV1NamespacedPod<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceCoreV1NamespacedPod$Status$200 | Response$replaceCoreV1NamespacedPod$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/pods/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteCoreV1NamespacedPod = <ResponseContentType extends ResponseContentType$deleteCoreV1NamespacedPod>(params: Params$deleteCoreV1NamespacedPod<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteCoreV1NamespacedPod$Status$200 | Response$deleteCoreV1NamespacedPod$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/pods/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchCoreV1NamespacedPod = <RequestContentType extends RequestContentType$patchCoreV1NamespacedPod, ResponseContentType extends ResponseContentType$patchCoreV1NamespacedPod>(params: Params$patchCoreV1NamespacedPod<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchCoreV1NamespacedPod$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/pods/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const connectCoreV1GetNamespacedPodAttach = (params: Params$connectCoreV1GetNamespacedPodAttach, option?: RequestOption): Promise<Response$connectCoreV1GetNamespacedPodAttach$Status$200["*/*"]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/pods/\${params.parameter.name}/attach\`;
-        const headers = {
-            Accept: "*/*"
-        };
-        const queryParameters: QueryParameters = {
-            container: { value: params.parameter.container, explode: false },
-            stderr: { value: params.parameter.stderr, explode: false },
-            stdin: { value: params.parameter.stdin, explode: false },
-            stdout: { value: params.parameter.stdout, explode: false },
-            tty: { value: params.parameter.tty, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const connectCoreV1PostNamespacedPodAttach = (params: Params$connectCoreV1PostNamespacedPodAttach, option?: RequestOption): Promise<Response$connectCoreV1PostNamespacedPodAttach$Status$200["*/*"]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/pods/\${params.parameter.name}/attach\`;
-        const headers = {
-            Accept: "*/*"
-        };
-        const queryParameters: QueryParameters = {
-            container: { value: params.parameter.container, explode: false },
-            stderr: { value: params.parameter.stderr, explode: false },
-            stdin: { value: params.parameter.stdin, explode: false },
-            stdout: { value: params.parameter.stdout, explode: false },
-            tty: { value: params.parameter.tty, explode: false }
-        };
-        return apiClient.request("POST", url, headers, undefined, queryParameters, option);
-    };
-    const createCoreV1NamespacedPodBinding = <ResponseContentType extends ResponseContentType$createCoreV1NamespacedPodBinding>(params: Params$createCoreV1NamespacedPodBinding<ResponseContentType>, option?: RequestOption): Promise<(Response$createCoreV1NamespacedPodBinding$Status$200 | Response$createCoreV1NamespacedPodBinding$Status$201 | Response$createCoreV1NamespacedPodBinding$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/pods/\${params.parameter.name}/binding\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const createCoreV1NamespacedPodEviction = <ResponseContentType extends ResponseContentType$createCoreV1NamespacedPodEviction>(params: Params$createCoreV1NamespacedPodEviction<ResponseContentType>, option?: RequestOption): Promise<(Response$createCoreV1NamespacedPodEviction$Status$200 | Response$createCoreV1NamespacedPodEviction$Status$201 | Response$createCoreV1NamespacedPodEviction$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/pods/\${params.parameter.name}/eviction\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const connectCoreV1GetNamespacedPodExec = (params: Params$connectCoreV1GetNamespacedPodExec, option?: RequestOption): Promise<Response$connectCoreV1GetNamespacedPodExec$Status$200["*/*"]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/pods/\${params.parameter.name}/exec\`;
-        const headers = {
-            Accept: "*/*"
-        };
-        const queryParameters: QueryParameters = {
-            command: { value: params.parameter.command, explode: false },
-            container: { value: params.parameter.container, explode: false },
-            stderr: { value: params.parameter.stderr, explode: false },
-            stdin: { value: params.parameter.stdin, explode: false },
-            stdout: { value: params.parameter.stdout, explode: false },
-            tty: { value: params.parameter.tty, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const connectCoreV1PostNamespacedPodExec = (params: Params$connectCoreV1PostNamespacedPodExec, option?: RequestOption): Promise<Response$connectCoreV1PostNamespacedPodExec$Status$200["*/*"]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/pods/\${params.parameter.name}/exec\`;
-        const headers = {
-            Accept: "*/*"
-        };
-        const queryParameters: QueryParameters = {
-            command: { value: params.parameter.command, explode: false },
-            container: { value: params.parameter.container, explode: false },
-            stderr: { value: params.parameter.stderr, explode: false },
-            stdin: { value: params.parameter.stdin, explode: false },
-            stdout: { value: params.parameter.stdout, explode: false },
-            tty: { value: params.parameter.tty, explode: false }
-        };
-        return apiClient.request("POST", url, headers, undefined, queryParameters, option);
-    };
-    const readCoreV1NamespacedPodLog = <ResponseContentType extends ResponseContentType$readCoreV1NamespacedPodLog>(params: Params$readCoreV1NamespacedPodLog<ResponseContentType>, option?: RequestOption): Promise<Response$readCoreV1NamespacedPodLog$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/pods/\${params.parameter.name}/log\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            container: { value: params.parameter.container, explode: false },
-            follow: { value: params.parameter.follow, explode: false },
-            insecureSkipTLSVerifyBackend: { value: params.parameter.insecureSkipTLSVerifyBackend, explode: false },
-            limitBytes: { value: params.parameter.limitBytes, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            previous: { value: params.parameter.previous, explode: false },
-            sinceSeconds: { value: params.parameter.sinceSeconds, explode: false },
-            tailLines: { value: params.parameter.tailLines, explode: false },
-            timestamps: { value: params.parameter.timestamps, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const connectCoreV1GetNamespacedPodPortforward = (params: Params$connectCoreV1GetNamespacedPodPortforward, option?: RequestOption): Promise<Response$connectCoreV1GetNamespacedPodPortforward$Status$200["*/*"]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/pods/\${params.parameter.name}/portforward\`;
-        const headers = {
-            Accept: "*/*"
-        };
-        const queryParameters: QueryParameters = {
-            ports: { value: params.parameter.ports, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const connectCoreV1PostNamespacedPodPortforward = (params: Params$connectCoreV1PostNamespacedPodPortforward, option?: RequestOption): Promise<Response$connectCoreV1PostNamespacedPodPortforward$Status$200["*/*"]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/pods/\${params.parameter.name}/portforward\`;
-        const headers = {
-            Accept: "*/*"
-        };
-        const queryParameters: QueryParameters = {
-            ports: { value: params.parameter.ports, explode: false }
-        };
-        return apiClient.request("POST", url, headers, undefined, queryParameters, option);
-    };
-    const connectCoreV1GetNamespacedPodProxy = (params: Params$connectCoreV1GetNamespacedPodProxy, option?: RequestOption): Promise<Response$connectCoreV1GetNamespacedPodProxy$Status$200["*/*"]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/pods/\${params.parameter.name}/proxy\`;
-        const headers = {
-            Accept: "*/*"
-        };
-        const queryParameters: QueryParameters = {
-            path: { value: params.parameter.path, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const connectCoreV1PutNamespacedPodProxy = (params: Params$connectCoreV1PutNamespacedPodProxy, option?: RequestOption): Promise<Response$connectCoreV1PutNamespacedPodProxy$Status$200["*/*"]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/pods/\${params.parameter.name}/proxy\`;
-        const headers = {
-            Accept: "*/*"
-        };
-        const queryParameters: QueryParameters = {
-            path: { value: params.parameter.path, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, undefined, queryParameters, option);
-    };
-    const connectCoreV1PostNamespacedPodProxy = (params: Params$connectCoreV1PostNamespacedPodProxy, option?: RequestOption): Promise<Response$connectCoreV1PostNamespacedPodProxy$Status$200["*/*"]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/pods/\${params.parameter.name}/proxy\`;
-        const headers = {
-            Accept: "*/*"
-        };
-        const queryParameters: QueryParameters = {
-            path: { value: params.parameter.path, explode: false }
-        };
-        return apiClient.request("POST", url, headers, undefined, queryParameters, option);
-    };
-    const connectCoreV1DeleteNamespacedPodProxy = (params: Params$connectCoreV1DeleteNamespacedPodProxy, option?: RequestOption): Promise<Response$connectCoreV1DeleteNamespacedPodProxy$Status$200["*/*"]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/pods/\${params.parameter.name}/proxy\`;
-        const headers = {
-            Accept: "*/*"
-        };
-        const queryParameters: QueryParameters = {
-            path: { value: params.parameter.path, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, undefined, queryParameters, option);
-    };
-    const connectCoreV1OptionsNamespacedPodProxy = (params: Params$connectCoreV1OptionsNamespacedPodProxy, option?: RequestOption): Promise<Response$connectCoreV1OptionsNamespacedPodProxy$Status$200["*/*"]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/pods/\${params.parameter.name}/proxy\`;
-        const headers = {
-            Accept: "*/*"
-        };
-        const queryParameters: QueryParameters = {
-            path: { value: params.parameter.path, explode: false }
-        };
-        return apiClient.request("OPTIONS", url, headers, undefined, queryParameters, option);
-    };
-    const connectCoreV1HeadNamespacedPodProxy = (params: Params$connectCoreV1HeadNamespacedPodProxy, option?: RequestOption): Promise<Response$connectCoreV1HeadNamespacedPodProxy$Status$200["*/*"]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/pods/\${params.parameter.name}/proxy\`;
-        const headers = {
-            Accept: "*/*"
-        };
-        const queryParameters: QueryParameters = {
-            path: { value: params.parameter.path, explode: false }
-        };
-        return apiClient.request("HEAD", url, headers, undefined, queryParameters, option);
-    };
-    const connectCoreV1PatchNamespacedPodProxy = (params: Params$connectCoreV1PatchNamespacedPodProxy, option?: RequestOption): Promise<Response$connectCoreV1PatchNamespacedPodProxy$Status$200["*/*"]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/pods/\${params.parameter.name}/proxy\`;
-        const headers = {
-            Accept: "*/*"
-        };
-        const queryParameters: QueryParameters = {
-            path: { value: params.parameter.path, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, undefined, queryParameters, option);
-    };
-    const connectCoreV1GetNamespacedPodProxyWithPath = (params: Params$connectCoreV1GetNamespacedPodProxyWithPath, option?: RequestOption): Promise<Response$connectCoreV1GetNamespacedPodProxyWithPath$Status$200["*/*"]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/pods/\${params.parameter.name}/proxy/\${params.parameter.path}\`;
-        const headers = {
-            Accept: "*/*"
-        };
-        const queryParameters: QueryParameters = {
-            path: { value: params.parameter.path, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const connectCoreV1PutNamespacedPodProxyWithPath = (params: Params$connectCoreV1PutNamespacedPodProxyWithPath, option?: RequestOption): Promise<Response$connectCoreV1PutNamespacedPodProxyWithPath$Status$200["*/*"]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/pods/\${params.parameter.name}/proxy/\${params.parameter.path}\`;
-        const headers = {
-            Accept: "*/*"
-        };
-        const queryParameters: QueryParameters = {
-            path: { value: params.parameter.path, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, undefined, queryParameters, option);
-    };
-    const connectCoreV1PostNamespacedPodProxyWithPath = (params: Params$connectCoreV1PostNamespacedPodProxyWithPath, option?: RequestOption): Promise<Response$connectCoreV1PostNamespacedPodProxyWithPath$Status$200["*/*"]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/pods/\${params.parameter.name}/proxy/\${params.parameter.path}\`;
-        const headers = {
-            Accept: "*/*"
-        };
-        const queryParameters: QueryParameters = {
-            path: { value: params.parameter.path, explode: false }
-        };
-        return apiClient.request("POST", url, headers, undefined, queryParameters, option);
-    };
-    const connectCoreV1DeleteNamespacedPodProxyWithPath = (params: Params$connectCoreV1DeleteNamespacedPodProxyWithPath, option?: RequestOption): Promise<Response$connectCoreV1DeleteNamespacedPodProxyWithPath$Status$200["*/*"]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/pods/\${params.parameter.name}/proxy/\${params.parameter.path}\`;
-        const headers = {
-            Accept: "*/*"
-        };
-        const queryParameters: QueryParameters = {
-            path: { value: params.parameter.path, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, undefined, queryParameters, option);
-    };
-    const connectCoreV1OptionsNamespacedPodProxyWithPath = (params: Params$connectCoreV1OptionsNamespacedPodProxyWithPath, option?: RequestOption): Promise<Response$connectCoreV1OptionsNamespacedPodProxyWithPath$Status$200["*/*"]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/pods/\${params.parameter.name}/proxy/\${params.parameter.path}\`;
-        const headers = {
-            Accept: "*/*"
-        };
-        const queryParameters: QueryParameters = {
-            path: { value: params.parameter.path, explode: false }
-        };
-        return apiClient.request("OPTIONS", url, headers, undefined, queryParameters, option);
-    };
-    const connectCoreV1HeadNamespacedPodProxyWithPath = (params: Params$connectCoreV1HeadNamespacedPodProxyWithPath, option?: RequestOption): Promise<Response$connectCoreV1HeadNamespacedPodProxyWithPath$Status$200["*/*"]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/pods/\${params.parameter.name}/proxy/\${params.parameter.path}\`;
-        const headers = {
-            Accept: "*/*"
-        };
-        const queryParameters: QueryParameters = {
-            path: { value: params.parameter.path, explode: false }
-        };
-        return apiClient.request("HEAD", url, headers, undefined, queryParameters, option);
-    };
-    const connectCoreV1PatchNamespacedPodProxyWithPath = (params: Params$connectCoreV1PatchNamespacedPodProxyWithPath, option?: RequestOption): Promise<Response$connectCoreV1PatchNamespacedPodProxyWithPath$Status$200["*/*"]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/pods/\${params.parameter.name}/proxy/\${params.parameter.path}\`;
-        const headers = {
-            Accept: "*/*"
-        };
-        const queryParameters: QueryParameters = {
-            path: { value: params.parameter.path, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, undefined, queryParameters, option);
-    };
-    const readCoreV1NamespacedPodStatus = <ResponseContentType extends ResponseContentType$readCoreV1NamespacedPodStatus>(params: Params$readCoreV1NamespacedPodStatus<ResponseContentType>, option?: RequestOption): Promise<Response$readCoreV1NamespacedPodStatus$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/pods/\${params.parameter.name}/status\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceCoreV1NamespacedPodStatus = <ResponseContentType extends ResponseContentType$replaceCoreV1NamespacedPodStatus>(params: Params$replaceCoreV1NamespacedPodStatus<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceCoreV1NamespacedPodStatus$Status$200 | Response$replaceCoreV1NamespacedPodStatus$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/pods/\${params.parameter.name}/status\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchCoreV1NamespacedPodStatus = <RequestContentType extends RequestContentType$patchCoreV1NamespacedPodStatus, ResponseContentType extends ResponseContentType$patchCoreV1NamespacedPodStatus>(params: Params$patchCoreV1NamespacedPodStatus<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchCoreV1NamespacedPodStatus$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/pods/\${params.parameter.name}/status\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const listCoreV1NamespacedPodTemplate = <ResponseContentType extends ResponseContentType$listCoreV1NamespacedPodTemplate>(params: Params$listCoreV1NamespacedPodTemplate<ResponseContentType>, option?: RequestOption): Promise<Response$listCoreV1NamespacedPodTemplate$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/podtemplates\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const createCoreV1NamespacedPodTemplate = <ResponseContentType extends ResponseContentType$createCoreV1NamespacedPodTemplate>(params: Params$createCoreV1NamespacedPodTemplate<ResponseContentType>, option?: RequestOption): Promise<(Response$createCoreV1NamespacedPodTemplate$Status$200 | Response$createCoreV1NamespacedPodTemplate$Status$201 | Response$createCoreV1NamespacedPodTemplate$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/podtemplates\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteCoreV1CollectionNamespacedPodTemplate = <ResponseContentType extends ResponseContentType$deleteCoreV1CollectionNamespacedPodTemplate>(params: Params$deleteCoreV1CollectionNamespacedPodTemplate<ResponseContentType>, option?: RequestOption): Promise<Response$deleteCoreV1CollectionNamespacedPodTemplate$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/podtemplates\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readCoreV1NamespacedPodTemplate = <ResponseContentType extends ResponseContentType$readCoreV1NamespacedPodTemplate>(params: Params$readCoreV1NamespacedPodTemplate<ResponseContentType>, option?: RequestOption): Promise<Response$readCoreV1NamespacedPodTemplate$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/podtemplates/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            exact: { value: params.parameter.exact, explode: false },
-            export: { value: params.parameter.export, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceCoreV1NamespacedPodTemplate = <ResponseContentType extends ResponseContentType$replaceCoreV1NamespacedPodTemplate>(params: Params$replaceCoreV1NamespacedPodTemplate<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceCoreV1NamespacedPodTemplate$Status$200 | Response$replaceCoreV1NamespacedPodTemplate$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/podtemplates/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteCoreV1NamespacedPodTemplate = <ResponseContentType extends ResponseContentType$deleteCoreV1NamespacedPodTemplate>(params: Params$deleteCoreV1NamespacedPodTemplate<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteCoreV1NamespacedPodTemplate$Status$200 | Response$deleteCoreV1NamespacedPodTemplate$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/podtemplates/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchCoreV1NamespacedPodTemplate = <RequestContentType extends RequestContentType$patchCoreV1NamespacedPodTemplate, ResponseContentType extends ResponseContentType$patchCoreV1NamespacedPodTemplate>(params: Params$patchCoreV1NamespacedPodTemplate<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchCoreV1NamespacedPodTemplate$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/podtemplates/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const listCoreV1NamespacedReplicationController = <ResponseContentType extends ResponseContentType$listCoreV1NamespacedReplicationController>(params: Params$listCoreV1NamespacedReplicationController<ResponseContentType>, option?: RequestOption): Promise<Response$listCoreV1NamespacedReplicationController$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/replicationcontrollers\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const createCoreV1NamespacedReplicationController = <ResponseContentType extends ResponseContentType$createCoreV1NamespacedReplicationController>(params: Params$createCoreV1NamespacedReplicationController<ResponseContentType>, option?: RequestOption): Promise<(Response$createCoreV1NamespacedReplicationController$Status$200 | Response$createCoreV1NamespacedReplicationController$Status$201 | Response$createCoreV1NamespacedReplicationController$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/replicationcontrollers\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteCoreV1CollectionNamespacedReplicationController = <ResponseContentType extends ResponseContentType$deleteCoreV1CollectionNamespacedReplicationController>(params: Params$deleteCoreV1CollectionNamespacedReplicationController<ResponseContentType>, option?: RequestOption): Promise<Response$deleteCoreV1CollectionNamespacedReplicationController$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/replicationcontrollers\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readCoreV1NamespacedReplicationController = <ResponseContentType extends ResponseContentType$readCoreV1NamespacedReplicationController>(params: Params$readCoreV1NamespacedReplicationController<ResponseContentType>, option?: RequestOption): Promise<Response$readCoreV1NamespacedReplicationController$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/replicationcontrollers/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            exact: { value: params.parameter.exact, explode: false },
-            export: { value: params.parameter.export, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceCoreV1NamespacedReplicationController = <ResponseContentType extends ResponseContentType$replaceCoreV1NamespacedReplicationController>(params: Params$replaceCoreV1NamespacedReplicationController<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceCoreV1NamespacedReplicationController$Status$200 | Response$replaceCoreV1NamespacedReplicationController$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/replicationcontrollers/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteCoreV1NamespacedReplicationController = <ResponseContentType extends ResponseContentType$deleteCoreV1NamespacedReplicationController>(params: Params$deleteCoreV1NamespacedReplicationController<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteCoreV1NamespacedReplicationController$Status$200 | Response$deleteCoreV1NamespacedReplicationController$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/replicationcontrollers/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchCoreV1NamespacedReplicationController = <RequestContentType extends RequestContentType$patchCoreV1NamespacedReplicationController, ResponseContentType extends ResponseContentType$patchCoreV1NamespacedReplicationController>(params: Params$patchCoreV1NamespacedReplicationController<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchCoreV1NamespacedReplicationController$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/replicationcontrollers/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readCoreV1NamespacedReplicationControllerScale = <ResponseContentType extends ResponseContentType$readCoreV1NamespacedReplicationControllerScale>(params: Params$readCoreV1NamespacedReplicationControllerScale<ResponseContentType>, option?: RequestOption): Promise<Response$readCoreV1NamespacedReplicationControllerScale$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/replicationcontrollers/\${params.parameter.name}/scale\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceCoreV1NamespacedReplicationControllerScale = <ResponseContentType extends ResponseContentType$replaceCoreV1NamespacedReplicationControllerScale>(params: Params$replaceCoreV1NamespacedReplicationControllerScale<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceCoreV1NamespacedReplicationControllerScale$Status$200 | Response$replaceCoreV1NamespacedReplicationControllerScale$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/replicationcontrollers/\${params.parameter.name}/scale\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchCoreV1NamespacedReplicationControllerScale = <RequestContentType extends RequestContentType$patchCoreV1NamespacedReplicationControllerScale, ResponseContentType extends ResponseContentType$patchCoreV1NamespacedReplicationControllerScale>(params: Params$patchCoreV1NamespacedReplicationControllerScale<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchCoreV1NamespacedReplicationControllerScale$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/replicationcontrollers/\${params.parameter.name}/scale\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readCoreV1NamespacedReplicationControllerStatus = <ResponseContentType extends ResponseContentType$readCoreV1NamespacedReplicationControllerStatus>(params: Params$readCoreV1NamespacedReplicationControllerStatus<ResponseContentType>, option?: RequestOption): Promise<Response$readCoreV1NamespacedReplicationControllerStatus$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/replicationcontrollers/\${params.parameter.name}/status\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceCoreV1NamespacedReplicationControllerStatus = <ResponseContentType extends ResponseContentType$replaceCoreV1NamespacedReplicationControllerStatus>(params: Params$replaceCoreV1NamespacedReplicationControllerStatus<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceCoreV1NamespacedReplicationControllerStatus$Status$200 | Response$replaceCoreV1NamespacedReplicationControllerStatus$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/replicationcontrollers/\${params.parameter.name}/status\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchCoreV1NamespacedReplicationControllerStatus = <RequestContentType extends RequestContentType$patchCoreV1NamespacedReplicationControllerStatus, ResponseContentType extends ResponseContentType$patchCoreV1NamespacedReplicationControllerStatus>(params: Params$patchCoreV1NamespacedReplicationControllerStatus<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchCoreV1NamespacedReplicationControllerStatus$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/replicationcontrollers/\${params.parameter.name}/status\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const listCoreV1NamespacedResourceQuota = <ResponseContentType extends ResponseContentType$listCoreV1NamespacedResourceQuota>(params: Params$listCoreV1NamespacedResourceQuota<ResponseContentType>, option?: RequestOption): Promise<Response$listCoreV1NamespacedResourceQuota$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/resourcequotas\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const createCoreV1NamespacedResourceQuota = <ResponseContentType extends ResponseContentType$createCoreV1NamespacedResourceQuota>(params: Params$createCoreV1NamespacedResourceQuota<ResponseContentType>, option?: RequestOption): Promise<(Response$createCoreV1NamespacedResourceQuota$Status$200 | Response$createCoreV1NamespacedResourceQuota$Status$201 | Response$createCoreV1NamespacedResourceQuota$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/resourcequotas\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteCoreV1CollectionNamespacedResourceQuota = <ResponseContentType extends ResponseContentType$deleteCoreV1CollectionNamespacedResourceQuota>(params: Params$deleteCoreV1CollectionNamespacedResourceQuota<ResponseContentType>, option?: RequestOption): Promise<Response$deleteCoreV1CollectionNamespacedResourceQuota$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/resourcequotas\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readCoreV1NamespacedResourceQuota = <ResponseContentType extends ResponseContentType$readCoreV1NamespacedResourceQuota>(params: Params$readCoreV1NamespacedResourceQuota<ResponseContentType>, option?: RequestOption): Promise<Response$readCoreV1NamespacedResourceQuota$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/resourcequotas/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            exact: { value: params.parameter.exact, explode: false },
-            export: { value: params.parameter.export, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceCoreV1NamespacedResourceQuota = <ResponseContentType extends ResponseContentType$replaceCoreV1NamespacedResourceQuota>(params: Params$replaceCoreV1NamespacedResourceQuota<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceCoreV1NamespacedResourceQuota$Status$200 | Response$replaceCoreV1NamespacedResourceQuota$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/resourcequotas/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteCoreV1NamespacedResourceQuota = <ResponseContentType extends ResponseContentType$deleteCoreV1NamespacedResourceQuota>(params: Params$deleteCoreV1NamespacedResourceQuota<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteCoreV1NamespacedResourceQuota$Status$200 | Response$deleteCoreV1NamespacedResourceQuota$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/resourcequotas/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchCoreV1NamespacedResourceQuota = <RequestContentType extends RequestContentType$patchCoreV1NamespacedResourceQuota, ResponseContentType extends ResponseContentType$patchCoreV1NamespacedResourceQuota>(params: Params$patchCoreV1NamespacedResourceQuota<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchCoreV1NamespacedResourceQuota$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/resourcequotas/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readCoreV1NamespacedResourceQuotaStatus = <ResponseContentType extends ResponseContentType$readCoreV1NamespacedResourceQuotaStatus>(params: Params$readCoreV1NamespacedResourceQuotaStatus<ResponseContentType>, option?: RequestOption): Promise<Response$readCoreV1NamespacedResourceQuotaStatus$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/resourcequotas/\${params.parameter.name}/status\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceCoreV1NamespacedResourceQuotaStatus = <ResponseContentType extends ResponseContentType$replaceCoreV1NamespacedResourceQuotaStatus>(params: Params$replaceCoreV1NamespacedResourceQuotaStatus<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceCoreV1NamespacedResourceQuotaStatus$Status$200 | Response$replaceCoreV1NamespacedResourceQuotaStatus$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/resourcequotas/\${params.parameter.name}/status\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchCoreV1NamespacedResourceQuotaStatus = <RequestContentType extends RequestContentType$patchCoreV1NamespacedResourceQuotaStatus, ResponseContentType extends ResponseContentType$patchCoreV1NamespacedResourceQuotaStatus>(params: Params$patchCoreV1NamespacedResourceQuotaStatus<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchCoreV1NamespacedResourceQuotaStatus$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/resourcequotas/\${params.parameter.name}/status\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const listCoreV1NamespacedSecret = <ResponseContentType extends ResponseContentType$listCoreV1NamespacedSecret>(params: Params$listCoreV1NamespacedSecret<ResponseContentType>, option?: RequestOption): Promise<Response$listCoreV1NamespacedSecret$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/secrets\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const createCoreV1NamespacedSecret = <ResponseContentType extends ResponseContentType$createCoreV1NamespacedSecret>(params: Params$createCoreV1NamespacedSecret<ResponseContentType>, option?: RequestOption): Promise<(Response$createCoreV1NamespacedSecret$Status$200 | Response$createCoreV1NamespacedSecret$Status$201 | Response$createCoreV1NamespacedSecret$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/secrets\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteCoreV1CollectionNamespacedSecret = <ResponseContentType extends ResponseContentType$deleteCoreV1CollectionNamespacedSecret>(params: Params$deleteCoreV1CollectionNamespacedSecret<ResponseContentType>, option?: RequestOption): Promise<Response$deleteCoreV1CollectionNamespacedSecret$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/secrets\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readCoreV1NamespacedSecret = <ResponseContentType extends ResponseContentType$readCoreV1NamespacedSecret>(params: Params$readCoreV1NamespacedSecret<ResponseContentType>, option?: RequestOption): Promise<Response$readCoreV1NamespacedSecret$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/secrets/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            exact: { value: params.parameter.exact, explode: false },
-            export: { value: params.parameter.export, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceCoreV1NamespacedSecret = <ResponseContentType extends ResponseContentType$replaceCoreV1NamespacedSecret>(params: Params$replaceCoreV1NamespacedSecret<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceCoreV1NamespacedSecret$Status$200 | Response$replaceCoreV1NamespacedSecret$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/secrets/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteCoreV1NamespacedSecret = <ResponseContentType extends ResponseContentType$deleteCoreV1NamespacedSecret>(params: Params$deleteCoreV1NamespacedSecret<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteCoreV1NamespacedSecret$Status$200 | Response$deleteCoreV1NamespacedSecret$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/secrets/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchCoreV1NamespacedSecret = <RequestContentType extends RequestContentType$patchCoreV1NamespacedSecret, ResponseContentType extends ResponseContentType$patchCoreV1NamespacedSecret>(params: Params$patchCoreV1NamespacedSecret<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchCoreV1NamespacedSecret$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/secrets/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const listCoreV1NamespacedServiceAccount = <ResponseContentType extends ResponseContentType$listCoreV1NamespacedServiceAccount>(params: Params$listCoreV1NamespacedServiceAccount<ResponseContentType>, option?: RequestOption): Promise<Response$listCoreV1NamespacedServiceAccount$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/serviceaccounts\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const createCoreV1NamespacedServiceAccount = <ResponseContentType extends ResponseContentType$createCoreV1NamespacedServiceAccount>(params: Params$createCoreV1NamespacedServiceAccount<ResponseContentType>, option?: RequestOption): Promise<(Response$createCoreV1NamespacedServiceAccount$Status$200 | Response$createCoreV1NamespacedServiceAccount$Status$201 | Response$createCoreV1NamespacedServiceAccount$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/serviceaccounts\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteCoreV1CollectionNamespacedServiceAccount = <ResponseContentType extends ResponseContentType$deleteCoreV1CollectionNamespacedServiceAccount>(params: Params$deleteCoreV1CollectionNamespacedServiceAccount<ResponseContentType>, option?: RequestOption): Promise<Response$deleteCoreV1CollectionNamespacedServiceAccount$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/serviceaccounts\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readCoreV1NamespacedServiceAccount = <ResponseContentType extends ResponseContentType$readCoreV1NamespacedServiceAccount>(params: Params$readCoreV1NamespacedServiceAccount<ResponseContentType>, option?: RequestOption): Promise<Response$readCoreV1NamespacedServiceAccount$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/serviceaccounts/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            exact: { value: params.parameter.exact, explode: false },
-            export: { value: params.parameter.export, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceCoreV1NamespacedServiceAccount = <ResponseContentType extends ResponseContentType$replaceCoreV1NamespacedServiceAccount>(params: Params$replaceCoreV1NamespacedServiceAccount<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceCoreV1NamespacedServiceAccount$Status$200 | Response$replaceCoreV1NamespacedServiceAccount$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/serviceaccounts/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteCoreV1NamespacedServiceAccount = <ResponseContentType extends ResponseContentType$deleteCoreV1NamespacedServiceAccount>(params: Params$deleteCoreV1NamespacedServiceAccount<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteCoreV1NamespacedServiceAccount$Status$200 | Response$deleteCoreV1NamespacedServiceAccount$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/serviceaccounts/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchCoreV1NamespacedServiceAccount = <RequestContentType extends RequestContentType$patchCoreV1NamespacedServiceAccount, ResponseContentType extends ResponseContentType$patchCoreV1NamespacedServiceAccount>(params: Params$patchCoreV1NamespacedServiceAccount<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchCoreV1NamespacedServiceAccount$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/serviceaccounts/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const createCoreV1NamespacedServiceAccountToken = <ResponseContentType extends ResponseContentType$createCoreV1NamespacedServiceAccountToken>(params: Params$createCoreV1NamespacedServiceAccountToken<ResponseContentType>, option?: RequestOption): Promise<(Response$createCoreV1NamespacedServiceAccountToken$Status$200 | Response$createCoreV1NamespacedServiceAccountToken$Status$201 | Response$createCoreV1NamespacedServiceAccountToken$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/serviceaccounts/\${params.parameter.name}/token\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const listCoreV1NamespacedService = <ResponseContentType extends ResponseContentType$listCoreV1NamespacedService>(params: Params$listCoreV1NamespacedService<ResponseContentType>, option?: RequestOption): Promise<Response$listCoreV1NamespacedService$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/services\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const createCoreV1NamespacedService = <ResponseContentType extends ResponseContentType$createCoreV1NamespacedService>(params: Params$createCoreV1NamespacedService<ResponseContentType>, option?: RequestOption): Promise<(Response$createCoreV1NamespacedService$Status$200 | Response$createCoreV1NamespacedService$Status$201 | Response$createCoreV1NamespacedService$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/services\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readCoreV1NamespacedService = <ResponseContentType extends ResponseContentType$readCoreV1NamespacedService>(params: Params$readCoreV1NamespacedService<ResponseContentType>, option?: RequestOption): Promise<Response$readCoreV1NamespacedService$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/services/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            exact: { value: params.parameter.exact, explode: false },
-            export: { value: params.parameter.export, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceCoreV1NamespacedService = <ResponseContentType extends ResponseContentType$replaceCoreV1NamespacedService>(params: Params$replaceCoreV1NamespacedService<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceCoreV1NamespacedService$Status$200 | Response$replaceCoreV1NamespacedService$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/services/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteCoreV1NamespacedService = <ResponseContentType extends ResponseContentType$deleteCoreV1NamespacedService>(params: Params$deleteCoreV1NamespacedService<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteCoreV1NamespacedService$Status$200 | Response$deleteCoreV1NamespacedService$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/services/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchCoreV1NamespacedService = <RequestContentType extends RequestContentType$patchCoreV1NamespacedService, ResponseContentType extends ResponseContentType$patchCoreV1NamespacedService>(params: Params$patchCoreV1NamespacedService<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchCoreV1NamespacedService$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/services/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const connectCoreV1GetNamespacedServiceProxy = (params: Params$connectCoreV1GetNamespacedServiceProxy, option?: RequestOption): Promise<Response$connectCoreV1GetNamespacedServiceProxy$Status$200["*/*"]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/services/\${params.parameter.name}/proxy\`;
-        const headers = {
-            Accept: "*/*"
-        };
-        const queryParameters: QueryParameters = {
-            path: { value: params.parameter.path, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const connectCoreV1PutNamespacedServiceProxy = (params: Params$connectCoreV1PutNamespacedServiceProxy, option?: RequestOption): Promise<Response$connectCoreV1PutNamespacedServiceProxy$Status$200["*/*"]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/services/\${params.parameter.name}/proxy\`;
-        const headers = {
-            Accept: "*/*"
-        };
-        const queryParameters: QueryParameters = {
-            path: { value: params.parameter.path, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, undefined, queryParameters, option);
-    };
-    const connectCoreV1PostNamespacedServiceProxy = (params: Params$connectCoreV1PostNamespacedServiceProxy, option?: RequestOption): Promise<Response$connectCoreV1PostNamespacedServiceProxy$Status$200["*/*"]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/services/\${params.parameter.name}/proxy\`;
-        const headers = {
-            Accept: "*/*"
-        };
-        const queryParameters: QueryParameters = {
-            path: { value: params.parameter.path, explode: false }
-        };
-        return apiClient.request("POST", url, headers, undefined, queryParameters, option);
-    };
-    const connectCoreV1DeleteNamespacedServiceProxy = (params: Params$connectCoreV1DeleteNamespacedServiceProxy, option?: RequestOption): Promise<Response$connectCoreV1DeleteNamespacedServiceProxy$Status$200["*/*"]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/services/\${params.parameter.name}/proxy\`;
-        const headers = {
-            Accept: "*/*"
-        };
-        const queryParameters: QueryParameters = {
-            path: { value: params.parameter.path, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, undefined, queryParameters, option);
-    };
-    const connectCoreV1OptionsNamespacedServiceProxy = (params: Params$connectCoreV1OptionsNamespacedServiceProxy, option?: RequestOption): Promise<Response$connectCoreV1OptionsNamespacedServiceProxy$Status$200["*/*"]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/services/\${params.parameter.name}/proxy\`;
-        const headers = {
-            Accept: "*/*"
-        };
-        const queryParameters: QueryParameters = {
-            path: { value: params.parameter.path, explode: false }
-        };
-        return apiClient.request("OPTIONS", url, headers, undefined, queryParameters, option);
-    };
-    const connectCoreV1HeadNamespacedServiceProxy = (params: Params$connectCoreV1HeadNamespacedServiceProxy, option?: RequestOption): Promise<Response$connectCoreV1HeadNamespacedServiceProxy$Status$200["*/*"]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/services/\${params.parameter.name}/proxy\`;
-        const headers = {
-            Accept: "*/*"
-        };
-        const queryParameters: QueryParameters = {
-            path: { value: params.parameter.path, explode: false }
-        };
-        return apiClient.request("HEAD", url, headers, undefined, queryParameters, option);
-    };
-    const connectCoreV1PatchNamespacedServiceProxy = (params: Params$connectCoreV1PatchNamespacedServiceProxy, option?: RequestOption): Promise<Response$connectCoreV1PatchNamespacedServiceProxy$Status$200["*/*"]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/services/\${params.parameter.name}/proxy\`;
-        const headers = {
-            Accept: "*/*"
-        };
-        const queryParameters: QueryParameters = {
-            path: { value: params.parameter.path, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, undefined, queryParameters, option);
-    };
-    const connectCoreV1GetNamespacedServiceProxyWithPath = (params: Params$connectCoreV1GetNamespacedServiceProxyWithPath, option?: RequestOption): Promise<Response$connectCoreV1GetNamespacedServiceProxyWithPath$Status$200["*/*"]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/services/\${params.parameter.name}/proxy/\${params.parameter.path}\`;
-        const headers = {
-            Accept: "*/*"
-        };
-        const queryParameters: QueryParameters = {
-            path: { value: params.parameter.path, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const connectCoreV1PutNamespacedServiceProxyWithPath = (params: Params$connectCoreV1PutNamespacedServiceProxyWithPath, option?: RequestOption): Promise<Response$connectCoreV1PutNamespacedServiceProxyWithPath$Status$200["*/*"]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/services/\${params.parameter.name}/proxy/\${params.parameter.path}\`;
-        const headers = {
-            Accept: "*/*"
-        };
-        const queryParameters: QueryParameters = {
-            path: { value: params.parameter.path, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, undefined, queryParameters, option);
-    };
-    const connectCoreV1PostNamespacedServiceProxyWithPath = (params: Params$connectCoreV1PostNamespacedServiceProxyWithPath, option?: RequestOption): Promise<Response$connectCoreV1PostNamespacedServiceProxyWithPath$Status$200["*/*"]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/services/\${params.parameter.name}/proxy/\${params.parameter.path}\`;
-        const headers = {
-            Accept: "*/*"
-        };
-        const queryParameters: QueryParameters = {
-            path: { value: params.parameter.path, explode: false }
-        };
-        return apiClient.request("POST", url, headers, undefined, queryParameters, option);
-    };
-    const connectCoreV1DeleteNamespacedServiceProxyWithPath = (params: Params$connectCoreV1DeleteNamespacedServiceProxyWithPath, option?: RequestOption): Promise<Response$connectCoreV1DeleteNamespacedServiceProxyWithPath$Status$200["*/*"]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/services/\${params.parameter.name}/proxy/\${params.parameter.path}\`;
-        const headers = {
-            Accept: "*/*"
-        };
-        const queryParameters: QueryParameters = {
-            path: { value: params.parameter.path, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, undefined, queryParameters, option);
-    };
-    const connectCoreV1OptionsNamespacedServiceProxyWithPath = (params: Params$connectCoreV1OptionsNamespacedServiceProxyWithPath, option?: RequestOption): Promise<Response$connectCoreV1OptionsNamespacedServiceProxyWithPath$Status$200["*/*"]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/services/\${params.parameter.name}/proxy/\${params.parameter.path}\`;
-        const headers = {
-            Accept: "*/*"
-        };
-        const queryParameters: QueryParameters = {
-            path: { value: params.parameter.path, explode: false }
-        };
-        return apiClient.request("OPTIONS", url, headers, undefined, queryParameters, option);
-    };
-    const connectCoreV1HeadNamespacedServiceProxyWithPath = (params: Params$connectCoreV1HeadNamespacedServiceProxyWithPath, option?: RequestOption): Promise<Response$connectCoreV1HeadNamespacedServiceProxyWithPath$Status$200["*/*"]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/services/\${params.parameter.name}/proxy/\${params.parameter.path}\`;
-        const headers = {
-            Accept: "*/*"
-        };
-        const queryParameters: QueryParameters = {
-            path: { value: params.parameter.path, explode: false }
-        };
-        return apiClient.request("HEAD", url, headers, undefined, queryParameters, option);
-    };
-    const connectCoreV1PatchNamespacedServiceProxyWithPath = (params: Params$connectCoreV1PatchNamespacedServiceProxyWithPath, option?: RequestOption): Promise<Response$connectCoreV1PatchNamespacedServiceProxyWithPath$Status$200["*/*"]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/services/\${params.parameter.name}/proxy/\${params.parameter.path}\`;
-        const headers = {
-            Accept: "*/*"
-        };
-        const queryParameters: QueryParameters = {
-            path: { value: params.parameter.path, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, undefined, queryParameters, option);
-    };
-    const readCoreV1NamespacedServiceStatus = <ResponseContentType extends ResponseContentType$readCoreV1NamespacedServiceStatus>(params: Params$readCoreV1NamespacedServiceStatus<ResponseContentType>, option?: RequestOption): Promise<Response$readCoreV1NamespacedServiceStatus$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/services/\${params.parameter.name}/status\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceCoreV1NamespacedServiceStatus = <ResponseContentType extends ResponseContentType$replaceCoreV1NamespacedServiceStatus>(params: Params$replaceCoreV1NamespacedServiceStatus<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceCoreV1NamespacedServiceStatus$Status$200 | Response$replaceCoreV1NamespacedServiceStatus$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/services/\${params.parameter.name}/status\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchCoreV1NamespacedServiceStatus = <RequestContentType extends RequestContentType$patchCoreV1NamespacedServiceStatus, ResponseContentType extends ResponseContentType$patchCoreV1NamespacedServiceStatus>(params: Params$patchCoreV1NamespacedServiceStatus<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchCoreV1NamespacedServiceStatus$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/services/\${params.parameter.name}/status\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readCoreV1Namespace = <ResponseContentType extends ResponseContentType$readCoreV1Namespace>(params: Params$readCoreV1Namespace<ResponseContentType>, option?: RequestOption): Promise<Response$readCoreV1Namespace$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            exact: { value: params.parameter.exact, explode: false },
-            export: { value: params.parameter.export, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceCoreV1Namespace = <ResponseContentType extends ResponseContentType$replaceCoreV1Namespace>(params: Params$replaceCoreV1Namespace<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceCoreV1Namespace$Status$200 | Response$replaceCoreV1Namespace$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteCoreV1Namespace = <ResponseContentType extends ResponseContentType$deleteCoreV1Namespace>(params: Params$deleteCoreV1Namespace<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteCoreV1Namespace$Status$200 | Response$deleteCoreV1Namespace$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchCoreV1Namespace = <RequestContentType extends RequestContentType$patchCoreV1Namespace, ResponseContentType extends ResponseContentType$patchCoreV1Namespace>(params: Params$patchCoreV1Namespace<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchCoreV1Namespace$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const replaceCoreV1NamespaceFinalize = <ResponseContentType extends ResponseContentType$replaceCoreV1NamespaceFinalize>(params: Params$replaceCoreV1NamespaceFinalize<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceCoreV1NamespaceFinalize$Status$200 | Response$replaceCoreV1NamespaceFinalize$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.name}/finalize\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readCoreV1NamespaceStatus = <ResponseContentType extends ResponseContentType$readCoreV1NamespaceStatus>(params: Params$readCoreV1NamespaceStatus<ResponseContentType>, option?: RequestOption): Promise<Response$readCoreV1NamespaceStatus$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.name}/status\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceCoreV1NamespaceStatus = <ResponseContentType extends ResponseContentType$replaceCoreV1NamespaceStatus>(params: Params$replaceCoreV1NamespaceStatus<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceCoreV1NamespaceStatus$Status$200 | Response$replaceCoreV1NamespaceStatus$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.name}/status\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchCoreV1NamespaceStatus = <RequestContentType extends RequestContentType$patchCoreV1NamespaceStatus, ResponseContentType extends ResponseContentType$patchCoreV1NamespaceStatus>(params: Params$patchCoreV1NamespaceStatus<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchCoreV1NamespaceStatus$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.name}/status\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const listCoreV1Node = <ResponseContentType extends ResponseContentType$listCoreV1Node>(params: Params$listCoreV1Node<ResponseContentType>, option?: RequestOption): Promise<Response$listCoreV1Node$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/nodes\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const createCoreV1Node = <ResponseContentType extends ResponseContentType$createCoreV1Node>(params: Params$createCoreV1Node<ResponseContentType>, option?: RequestOption): Promise<(Response$createCoreV1Node$Status$200 | Response$createCoreV1Node$Status$201 | Response$createCoreV1Node$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/nodes\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteCoreV1CollectionNode = <ResponseContentType extends ResponseContentType$deleteCoreV1CollectionNode>(params: Params$deleteCoreV1CollectionNode<ResponseContentType>, option?: RequestOption): Promise<Response$deleteCoreV1CollectionNode$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/nodes\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readCoreV1Node = <ResponseContentType extends ResponseContentType$readCoreV1Node>(params: Params$readCoreV1Node<ResponseContentType>, option?: RequestOption): Promise<Response$readCoreV1Node$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/nodes/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            exact: { value: params.parameter.exact, explode: false },
-            export: { value: params.parameter.export, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceCoreV1Node = <ResponseContentType extends ResponseContentType$replaceCoreV1Node>(params: Params$replaceCoreV1Node<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceCoreV1Node$Status$200 | Response$replaceCoreV1Node$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/nodes/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteCoreV1Node = <ResponseContentType extends ResponseContentType$deleteCoreV1Node>(params: Params$deleteCoreV1Node<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteCoreV1Node$Status$200 | Response$deleteCoreV1Node$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/nodes/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchCoreV1Node = <RequestContentType extends RequestContentType$patchCoreV1Node, ResponseContentType extends ResponseContentType$patchCoreV1Node>(params: Params$patchCoreV1Node<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchCoreV1Node$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/nodes/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const connectCoreV1GetNodeProxy = (params: Params$connectCoreV1GetNodeProxy, option?: RequestOption): Promise<Response$connectCoreV1GetNodeProxy$Status$200["*/*"]> => {
-        const url = baseUrl + \`/api/v1/nodes/\${params.parameter.name}/proxy\`;
-        const headers = {
-            Accept: "*/*"
-        };
-        const queryParameters: QueryParameters = {
-            path: { value: params.parameter.path, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const connectCoreV1PutNodeProxy = (params: Params$connectCoreV1PutNodeProxy, option?: RequestOption): Promise<Response$connectCoreV1PutNodeProxy$Status$200["*/*"]> => {
-        const url = baseUrl + \`/api/v1/nodes/\${params.parameter.name}/proxy\`;
-        const headers = {
-            Accept: "*/*"
-        };
-        const queryParameters: QueryParameters = {
-            path: { value: params.parameter.path, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, undefined, queryParameters, option);
-    };
-    const connectCoreV1PostNodeProxy = (params: Params$connectCoreV1PostNodeProxy, option?: RequestOption): Promise<Response$connectCoreV1PostNodeProxy$Status$200["*/*"]> => {
-        const url = baseUrl + \`/api/v1/nodes/\${params.parameter.name}/proxy\`;
-        const headers = {
-            Accept: "*/*"
-        };
-        const queryParameters: QueryParameters = {
-            path: { value: params.parameter.path, explode: false }
-        };
-        return apiClient.request("POST", url, headers, undefined, queryParameters, option);
-    };
-    const connectCoreV1DeleteNodeProxy = (params: Params$connectCoreV1DeleteNodeProxy, option?: RequestOption): Promise<Response$connectCoreV1DeleteNodeProxy$Status$200["*/*"]> => {
-        const url = baseUrl + \`/api/v1/nodes/\${params.parameter.name}/proxy\`;
-        const headers = {
-            Accept: "*/*"
-        };
-        const queryParameters: QueryParameters = {
-            path: { value: params.parameter.path, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, undefined, queryParameters, option);
-    };
-    const connectCoreV1OptionsNodeProxy = (params: Params$connectCoreV1OptionsNodeProxy, option?: RequestOption): Promise<Response$connectCoreV1OptionsNodeProxy$Status$200["*/*"]> => {
-        const url = baseUrl + \`/api/v1/nodes/\${params.parameter.name}/proxy\`;
-        const headers = {
-            Accept: "*/*"
-        };
-        const queryParameters: QueryParameters = {
-            path: { value: params.parameter.path, explode: false }
-        };
-        return apiClient.request("OPTIONS", url, headers, undefined, queryParameters, option);
-    };
-    const connectCoreV1HeadNodeProxy = (params: Params$connectCoreV1HeadNodeProxy, option?: RequestOption): Promise<Response$connectCoreV1HeadNodeProxy$Status$200["*/*"]> => {
-        const url = baseUrl + \`/api/v1/nodes/\${params.parameter.name}/proxy\`;
-        const headers = {
-            Accept: "*/*"
-        };
-        const queryParameters: QueryParameters = {
-            path: { value: params.parameter.path, explode: false }
-        };
-        return apiClient.request("HEAD", url, headers, undefined, queryParameters, option);
-    };
-    const connectCoreV1PatchNodeProxy = (params: Params$connectCoreV1PatchNodeProxy, option?: RequestOption): Promise<Response$connectCoreV1PatchNodeProxy$Status$200["*/*"]> => {
-        const url = baseUrl + \`/api/v1/nodes/\${params.parameter.name}/proxy\`;
-        const headers = {
-            Accept: "*/*"
-        };
-        const queryParameters: QueryParameters = {
-            path: { value: params.parameter.path, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, undefined, queryParameters, option);
-    };
-    const connectCoreV1GetNodeProxyWithPath = (params: Params$connectCoreV1GetNodeProxyWithPath, option?: RequestOption): Promise<Response$connectCoreV1GetNodeProxyWithPath$Status$200["*/*"]> => {
-        const url = baseUrl + \`/api/v1/nodes/\${params.parameter.name}/proxy/\${params.parameter.path}\`;
-        const headers = {
-            Accept: "*/*"
-        };
-        const queryParameters: QueryParameters = {
-            path: { value: params.parameter.path, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const connectCoreV1PutNodeProxyWithPath = (params: Params$connectCoreV1PutNodeProxyWithPath, option?: RequestOption): Promise<Response$connectCoreV1PutNodeProxyWithPath$Status$200["*/*"]> => {
-        const url = baseUrl + \`/api/v1/nodes/\${params.parameter.name}/proxy/\${params.parameter.path}\`;
-        const headers = {
-            Accept: "*/*"
-        };
-        const queryParameters: QueryParameters = {
-            path: { value: params.parameter.path, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, undefined, queryParameters, option);
-    };
-    const connectCoreV1PostNodeProxyWithPath = (params: Params$connectCoreV1PostNodeProxyWithPath, option?: RequestOption): Promise<Response$connectCoreV1PostNodeProxyWithPath$Status$200["*/*"]> => {
-        const url = baseUrl + \`/api/v1/nodes/\${params.parameter.name}/proxy/\${params.parameter.path}\`;
-        const headers = {
-            Accept: "*/*"
-        };
-        const queryParameters: QueryParameters = {
-            path: { value: params.parameter.path, explode: false }
-        };
-        return apiClient.request("POST", url, headers, undefined, queryParameters, option);
-    };
-    const connectCoreV1DeleteNodeProxyWithPath = (params: Params$connectCoreV1DeleteNodeProxyWithPath, option?: RequestOption): Promise<Response$connectCoreV1DeleteNodeProxyWithPath$Status$200["*/*"]> => {
-        const url = baseUrl + \`/api/v1/nodes/\${params.parameter.name}/proxy/\${params.parameter.path}\`;
-        const headers = {
-            Accept: "*/*"
-        };
-        const queryParameters: QueryParameters = {
-            path: { value: params.parameter.path, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, undefined, queryParameters, option);
-    };
-    const connectCoreV1OptionsNodeProxyWithPath = (params: Params$connectCoreV1OptionsNodeProxyWithPath, option?: RequestOption): Promise<Response$connectCoreV1OptionsNodeProxyWithPath$Status$200["*/*"]> => {
-        const url = baseUrl + \`/api/v1/nodes/\${params.parameter.name}/proxy/\${params.parameter.path}\`;
-        const headers = {
-            Accept: "*/*"
-        };
-        const queryParameters: QueryParameters = {
-            path: { value: params.parameter.path, explode: false }
-        };
-        return apiClient.request("OPTIONS", url, headers, undefined, queryParameters, option);
-    };
-    const connectCoreV1HeadNodeProxyWithPath = (params: Params$connectCoreV1HeadNodeProxyWithPath, option?: RequestOption): Promise<Response$connectCoreV1HeadNodeProxyWithPath$Status$200["*/*"]> => {
-        const url = baseUrl + \`/api/v1/nodes/\${params.parameter.name}/proxy/\${params.parameter.path}\`;
-        const headers = {
-            Accept: "*/*"
-        };
-        const queryParameters: QueryParameters = {
-            path: { value: params.parameter.path, explode: false }
-        };
-        return apiClient.request("HEAD", url, headers, undefined, queryParameters, option);
-    };
-    const connectCoreV1PatchNodeProxyWithPath = (params: Params$connectCoreV1PatchNodeProxyWithPath, option?: RequestOption): Promise<Response$connectCoreV1PatchNodeProxyWithPath$Status$200["*/*"]> => {
-        const url = baseUrl + \`/api/v1/nodes/\${params.parameter.name}/proxy/\${params.parameter.path}\`;
-        const headers = {
-            Accept: "*/*"
-        };
-        const queryParameters: QueryParameters = {
-            path: { value: params.parameter.path, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, undefined, queryParameters, option);
-    };
-    const readCoreV1NodeStatus = <ResponseContentType extends ResponseContentType$readCoreV1NodeStatus>(params: Params$readCoreV1NodeStatus<ResponseContentType>, option?: RequestOption): Promise<Response$readCoreV1NodeStatus$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/nodes/\${params.parameter.name}/status\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceCoreV1NodeStatus = <ResponseContentType extends ResponseContentType$replaceCoreV1NodeStatus>(params: Params$replaceCoreV1NodeStatus<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceCoreV1NodeStatus$Status$200 | Response$replaceCoreV1NodeStatus$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/nodes/\${params.parameter.name}/status\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchCoreV1NodeStatus = <RequestContentType extends RequestContentType$patchCoreV1NodeStatus, ResponseContentType extends ResponseContentType$patchCoreV1NodeStatus>(params: Params$patchCoreV1NodeStatus<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchCoreV1NodeStatus$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/nodes/\${params.parameter.name}/status\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const listCoreV1PersistentVolumeClaimForAllNamespaces = <ResponseContentType extends ResponseContentType$listCoreV1PersistentVolumeClaimForAllNamespaces>(params: Params$listCoreV1PersistentVolumeClaimForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$listCoreV1PersistentVolumeClaimForAllNamespaces$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/persistentvolumeclaims\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const listCoreV1PersistentVolume = <ResponseContentType extends ResponseContentType$listCoreV1PersistentVolume>(params: Params$listCoreV1PersistentVolume<ResponseContentType>, option?: RequestOption): Promise<Response$listCoreV1PersistentVolume$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/persistentvolumes\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const createCoreV1PersistentVolume = <ResponseContentType extends ResponseContentType$createCoreV1PersistentVolume>(params: Params$createCoreV1PersistentVolume<ResponseContentType>, option?: RequestOption): Promise<(Response$createCoreV1PersistentVolume$Status$200 | Response$createCoreV1PersistentVolume$Status$201 | Response$createCoreV1PersistentVolume$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/persistentvolumes\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteCoreV1CollectionPersistentVolume = <ResponseContentType extends ResponseContentType$deleteCoreV1CollectionPersistentVolume>(params: Params$deleteCoreV1CollectionPersistentVolume<ResponseContentType>, option?: RequestOption): Promise<Response$deleteCoreV1CollectionPersistentVolume$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/persistentvolumes\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readCoreV1PersistentVolume = <ResponseContentType extends ResponseContentType$readCoreV1PersistentVolume>(params: Params$readCoreV1PersistentVolume<ResponseContentType>, option?: RequestOption): Promise<Response$readCoreV1PersistentVolume$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/persistentvolumes/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            exact: { value: params.parameter.exact, explode: false },
-            export: { value: params.parameter.export, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceCoreV1PersistentVolume = <ResponseContentType extends ResponseContentType$replaceCoreV1PersistentVolume>(params: Params$replaceCoreV1PersistentVolume<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceCoreV1PersistentVolume$Status$200 | Response$replaceCoreV1PersistentVolume$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/persistentvolumes/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteCoreV1PersistentVolume = <ResponseContentType extends ResponseContentType$deleteCoreV1PersistentVolume>(params: Params$deleteCoreV1PersistentVolume<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteCoreV1PersistentVolume$Status$200 | Response$deleteCoreV1PersistentVolume$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/persistentvolumes/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchCoreV1PersistentVolume = <RequestContentType extends RequestContentType$patchCoreV1PersistentVolume, ResponseContentType extends ResponseContentType$patchCoreV1PersistentVolume>(params: Params$patchCoreV1PersistentVolume<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchCoreV1PersistentVolume$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/persistentvolumes/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readCoreV1PersistentVolumeStatus = <ResponseContentType extends ResponseContentType$readCoreV1PersistentVolumeStatus>(params: Params$readCoreV1PersistentVolumeStatus<ResponseContentType>, option?: RequestOption): Promise<Response$readCoreV1PersistentVolumeStatus$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/persistentvolumes/\${params.parameter.name}/status\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceCoreV1PersistentVolumeStatus = <ResponseContentType extends ResponseContentType$replaceCoreV1PersistentVolumeStatus>(params: Params$replaceCoreV1PersistentVolumeStatus<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceCoreV1PersistentVolumeStatus$Status$200 | Response$replaceCoreV1PersistentVolumeStatus$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/persistentvolumes/\${params.parameter.name}/status\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchCoreV1PersistentVolumeStatus = <RequestContentType extends RequestContentType$patchCoreV1PersistentVolumeStatus, ResponseContentType extends ResponseContentType$patchCoreV1PersistentVolumeStatus>(params: Params$patchCoreV1PersistentVolumeStatus<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchCoreV1PersistentVolumeStatus$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/persistentvolumes/\${params.parameter.name}/status\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const listCoreV1PodForAllNamespaces = <ResponseContentType extends ResponseContentType$listCoreV1PodForAllNamespaces>(params: Params$listCoreV1PodForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$listCoreV1PodForAllNamespaces$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/pods\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const listCoreV1PodTemplateForAllNamespaces = <ResponseContentType extends ResponseContentType$listCoreV1PodTemplateForAllNamespaces>(params: Params$listCoreV1PodTemplateForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$listCoreV1PodTemplateForAllNamespaces$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/podtemplates\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const listCoreV1ReplicationControllerForAllNamespaces = <ResponseContentType extends ResponseContentType$listCoreV1ReplicationControllerForAllNamespaces>(params: Params$listCoreV1ReplicationControllerForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$listCoreV1ReplicationControllerForAllNamespaces$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/replicationcontrollers\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const listCoreV1ResourceQuotaForAllNamespaces = <ResponseContentType extends ResponseContentType$listCoreV1ResourceQuotaForAllNamespaces>(params: Params$listCoreV1ResourceQuotaForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$listCoreV1ResourceQuotaForAllNamespaces$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/resourcequotas\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const listCoreV1SecretForAllNamespaces = <ResponseContentType extends ResponseContentType$listCoreV1SecretForAllNamespaces>(params: Params$listCoreV1SecretForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$listCoreV1SecretForAllNamespaces$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/secrets\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const listCoreV1ServiceAccountForAllNamespaces = <ResponseContentType extends ResponseContentType$listCoreV1ServiceAccountForAllNamespaces>(params: Params$listCoreV1ServiceAccountForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$listCoreV1ServiceAccountForAllNamespaces$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/serviceaccounts\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const listCoreV1ServiceForAllNamespaces = <ResponseContentType extends ResponseContentType$listCoreV1ServiceForAllNamespaces>(params: Params$listCoreV1ServiceForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$listCoreV1ServiceForAllNamespaces$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/services\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchCoreV1ConfigMapListForAllNamespaces = <ResponseContentType extends ResponseContentType$watchCoreV1ConfigMapListForAllNamespaces>(params: Params$watchCoreV1ConfigMapListForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1ConfigMapListForAllNamespaces$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/watch/configmaps\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchCoreV1EndpointsListForAllNamespaces = <ResponseContentType extends ResponseContentType$watchCoreV1EndpointsListForAllNamespaces>(params: Params$watchCoreV1EndpointsListForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1EndpointsListForAllNamespaces$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/watch/endpoints\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchCoreV1EventListForAllNamespaces = <ResponseContentType extends ResponseContentType$watchCoreV1EventListForAllNamespaces>(params: Params$watchCoreV1EventListForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1EventListForAllNamespaces$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/watch/events\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchCoreV1LimitRangeListForAllNamespaces = <ResponseContentType extends ResponseContentType$watchCoreV1LimitRangeListForAllNamespaces>(params: Params$watchCoreV1LimitRangeListForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1LimitRangeListForAllNamespaces$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/watch/limitranges\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchCoreV1NamespaceList = <ResponseContentType extends ResponseContentType$watchCoreV1NamespaceList>(params: Params$watchCoreV1NamespaceList<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1NamespaceList$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/watch/namespaces\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchCoreV1NamespacedConfigMapList = <ResponseContentType extends ResponseContentType$watchCoreV1NamespacedConfigMapList>(params: Params$watchCoreV1NamespacedConfigMapList<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1NamespacedConfigMapList$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/watch/namespaces/\${params.parameter.namespace}/configmaps\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchCoreV1NamespacedConfigMap = <ResponseContentType extends ResponseContentType$watchCoreV1NamespacedConfigMap>(params: Params$watchCoreV1NamespacedConfigMap<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1NamespacedConfigMap$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/watch/namespaces/\${params.parameter.namespace}/configmaps/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchCoreV1NamespacedEndpointsList = <ResponseContentType extends ResponseContentType$watchCoreV1NamespacedEndpointsList>(params: Params$watchCoreV1NamespacedEndpointsList<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1NamespacedEndpointsList$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/watch/namespaces/\${params.parameter.namespace}/endpoints\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchCoreV1NamespacedEndpoints = <ResponseContentType extends ResponseContentType$watchCoreV1NamespacedEndpoints>(params: Params$watchCoreV1NamespacedEndpoints<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1NamespacedEndpoints$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/watch/namespaces/\${params.parameter.namespace}/endpoints/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchCoreV1NamespacedEventList = <ResponseContentType extends ResponseContentType$watchCoreV1NamespacedEventList>(params: Params$watchCoreV1NamespacedEventList<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1NamespacedEventList$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/watch/namespaces/\${params.parameter.namespace}/events\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchCoreV1NamespacedEvent = <ResponseContentType extends ResponseContentType$watchCoreV1NamespacedEvent>(params: Params$watchCoreV1NamespacedEvent<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1NamespacedEvent$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/watch/namespaces/\${params.parameter.namespace}/events/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchCoreV1NamespacedLimitRangeList = <ResponseContentType extends ResponseContentType$watchCoreV1NamespacedLimitRangeList>(params: Params$watchCoreV1NamespacedLimitRangeList<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1NamespacedLimitRangeList$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/watch/namespaces/\${params.parameter.namespace}/limitranges\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchCoreV1NamespacedLimitRange = <ResponseContentType extends ResponseContentType$watchCoreV1NamespacedLimitRange>(params: Params$watchCoreV1NamespacedLimitRange<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1NamespacedLimitRange$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/watch/namespaces/\${params.parameter.namespace}/limitranges/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchCoreV1NamespacedPersistentVolumeClaimList = <ResponseContentType extends ResponseContentType$watchCoreV1NamespacedPersistentVolumeClaimList>(params: Params$watchCoreV1NamespacedPersistentVolumeClaimList<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1NamespacedPersistentVolumeClaimList$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/watch/namespaces/\${params.parameter.namespace}/persistentvolumeclaims\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchCoreV1NamespacedPersistentVolumeClaim = <ResponseContentType extends ResponseContentType$watchCoreV1NamespacedPersistentVolumeClaim>(params: Params$watchCoreV1NamespacedPersistentVolumeClaim<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1NamespacedPersistentVolumeClaim$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/watch/namespaces/\${params.parameter.namespace}/persistentvolumeclaims/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchCoreV1NamespacedPodList = <ResponseContentType extends ResponseContentType$watchCoreV1NamespacedPodList>(params: Params$watchCoreV1NamespacedPodList<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1NamespacedPodList$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/watch/namespaces/\${params.parameter.namespace}/pods\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchCoreV1NamespacedPod = <ResponseContentType extends ResponseContentType$watchCoreV1NamespacedPod>(params: Params$watchCoreV1NamespacedPod<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1NamespacedPod$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/watch/namespaces/\${params.parameter.namespace}/pods/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchCoreV1NamespacedPodTemplateList = <ResponseContentType extends ResponseContentType$watchCoreV1NamespacedPodTemplateList>(params: Params$watchCoreV1NamespacedPodTemplateList<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1NamespacedPodTemplateList$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/watch/namespaces/\${params.parameter.namespace}/podtemplates\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchCoreV1NamespacedPodTemplate = <ResponseContentType extends ResponseContentType$watchCoreV1NamespacedPodTemplate>(params: Params$watchCoreV1NamespacedPodTemplate<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1NamespacedPodTemplate$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/watch/namespaces/\${params.parameter.namespace}/podtemplates/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchCoreV1NamespacedReplicationControllerList = <ResponseContentType extends ResponseContentType$watchCoreV1NamespacedReplicationControllerList>(params: Params$watchCoreV1NamespacedReplicationControllerList<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1NamespacedReplicationControllerList$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/watch/namespaces/\${params.parameter.namespace}/replicationcontrollers\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchCoreV1NamespacedReplicationController = <ResponseContentType extends ResponseContentType$watchCoreV1NamespacedReplicationController>(params: Params$watchCoreV1NamespacedReplicationController<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1NamespacedReplicationController$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/watch/namespaces/\${params.parameter.namespace}/replicationcontrollers/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchCoreV1NamespacedResourceQuotaList = <ResponseContentType extends ResponseContentType$watchCoreV1NamespacedResourceQuotaList>(params: Params$watchCoreV1NamespacedResourceQuotaList<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1NamespacedResourceQuotaList$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/watch/namespaces/\${params.parameter.namespace}/resourcequotas\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchCoreV1NamespacedResourceQuota = <ResponseContentType extends ResponseContentType$watchCoreV1NamespacedResourceQuota>(params: Params$watchCoreV1NamespacedResourceQuota<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1NamespacedResourceQuota$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/watch/namespaces/\${params.parameter.namespace}/resourcequotas/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchCoreV1NamespacedSecretList = <ResponseContentType extends ResponseContentType$watchCoreV1NamespacedSecretList>(params: Params$watchCoreV1NamespacedSecretList<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1NamespacedSecretList$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/watch/namespaces/\${params.parameter.namespace}/secrets\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchCoreV1NamespacedSecret = <ResponseContentType extends ResponseContentType$watchCoreV1NamespacedSecret>(params: Params$watchCoreV1NamespacedSecret<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1NamespacedSecret$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/watch/namespaces/\${params.parameter.namespace}/secrets/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchCoreV1NamespacedServiceAccountList = <ResponseContentType extends ResponseContentType$watchCoreV1NamespacedServiceAccountList>(params: Params$watchCoreV1NamespacedServiceAccountList<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1NamespacedServiceAccountList$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/watch/namespaces/\${params.parameter.namespace}/serviceaccounts\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchCoreV1NamespacedServiceAccount = <ResponseContentType extends ResponseContentType$watchCoreV1NamespacedServiceAccount>(params: Params$watchCoreV1NamespacedServiceAccount<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1NamespacedServiceAccount$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/watch/namespaces/\${params.parameter.namespace}/serviceaccounts/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchCoreV1NamespacedServiceList = <ResponseContentType extends ResponseContentType$watchCoreV1NamespacedServiceList>(params: Params$watchCoreV1NamespacedServiceList<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1NamespacedServiceList$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/watch/namespaces/\${params.parameter.namespace}/services\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchCoreV1NamespacedService = <ResponseContentType extends ResponseContentType$watchCoreV1NamespacedService>(params: Params$watchCoreV1NamespacedService<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1NamespacedService$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/watch/namespaces/\${params.parameter.namespace}/services/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchCoreV1Namespace = <ResponseContentType extends ResponseContentType$watchCoreV1Namespace>(params: Params$watchCoreV1Namespace<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1Namespace$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/watch/namespaces/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchCoreV1NodeList = <ResponseContentType extends ResponseContentType$watchCoreV1NodeList>(params: Params$watchCoreV1NodeList<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1NodeList$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/watch/nodes\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchCoreV1Node = <ResponseContentType extends ResponseContentType$watchCoreV1Node>(params: Params$watchCoreV1Node<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1Node$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/watch/nodes/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchCoreV1PersistentVolumeClaimListForAllNamespaces = <ResponseContentType extends ResponseContentType$watchCoreV1PersistentVolumeClaimListForAllNamespaces>(params: Params$watchCoreV1PersistentVolumeClaimListForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1PersistentVolumeClaimListForAllNamespaces$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/watch/persistentvolumeclaims\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchCoreV1PersistentVolumeList = <ResponseContentType extends ResponseContentType$watchCoreV1PersistentVolumeList>(params: Params$watchCoreV1PersistentVolumeList<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1PersistentVolumeList$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/watch/persistentvolumes\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchCoreV1PersistentVolume = <ResponseContentType extends ResponseContentType$watchCoreV1PersistentVolume>(params: Params$watchCoreV1PersistentVolume<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1PersistentVolume$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/watch/persistentvolumes/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchCoreV1PodListForAllNamespaces = <ResponseContentType extends ResponseContentType$watchCoreV1PodListForAllNamespaces>(params: Params$watchCoreV1PodListForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1PodListForAllNamespaces$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/watch/pods\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchCoreV1PodTemplateListForAllNamespaces = <ResponseContentType extends ResponseContentType$watchCoreV1PodTemplateListForAllNamespaces>(params: Params$watchCoreV1PodTemplateListForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1PodTemplateListForAllNamespaces$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/watch/podtemplates\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchCoreV1ReplicationControllerListForAllNamespaces = <ResponseContentType extends ResponseContentType$watchCoreV1ReplicationControllerListForAllNamespaces>(params: Params$watchCoreV1ReplicationControllerListForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1ReplicationControllerListForAllNamespaces$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/watch/replicationcontrollers\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchCoreV1ResourceQuotaListForAllNamespaces = <ResponseContentType extends ResponseContentType$watchCoreV1ResourceQuotaListForAllNamespaces>(params: Params$watchCoreV1ResourceQuotaListForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1ResourceQuotaListForAllNamespaces$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/watch/resourcequotas\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchCoreV1SecretListForAllNamespaces = <ResponseContentType extends ResponseContentType$watchCoreV1SecretListForAllNamespaces>(params: Params$watchCoreV1SecretListForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1SecretListForAllNamespaces$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/watch/secrets\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchCoreV1ServiceAccountListForAllNamespaces = <ResponseContentType extends ResponseContentType$watchCoreV1ServiceAccountListForAllNamespaces>(params: Params$watchCoreV1ServiceAccountListForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1ServiceAccountListForAllNamespaces$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/watch/serviceaccounts\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchCoreV1ServiceListForAllNamespaces = <ResponseContentType extends ResponseContentType$watchCoreV1ServiceListForAllNamespaces>(params: Params$watchCoreV1ServiceListForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1ServiceListForAllNamespaces$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/api/v1/watch/services\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const getAPIVersions = <ResponseContentType extends ResponseContentType$getAPIVersions>(params: Params$getAPIVersions<ResponseContentType>, option?: RequestOption): Promise<Response$getAPIVersions$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const getAdmissionregistrationAPIGroup = <ResponseContentType extends ResponseContentType$getAdmissionregistrationAPIGroup>(params: Params$getAdmissionregistrationAPIGroup<ResponseContentType>, option?: RequestOption): Promise<Response$getAdmissionregistrationAPIGroup$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/admissionregistration.k8s.io/\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const getAdmissionregistrationV1APIResources = <ResponseContentType extends ResponseContentType$getAdmissionregistrationV1APIResources>(params: Params$getAdmissionregistrationV1APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getAdmissionregistrationV1APIResources$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/admissionregistration.k8s.io/v1/\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const listAdmissionregistrationV1MutatingWebhookConfiguration = <ResponseContentType extends ResponseContentType$listAdmissionregistrationV1MutatingWebhookConfiguration>(params: Params$listAdmissionregistrationV1MutatingWebhookConfiguration<ResponseContentType>, option?: RequestOption): Promise<Response$listAdmissionregistrationV1MutatingWebhookConfiguration$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/admissionregistration.k8s.io/v1/mutatingwebhookconfigurations\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const createAdmissionregistrationV1MutatingWebhookConfiguration = <ResponseContentType extends ResponseContentType$createAdmissionregistrationV1MutatingWebhookConfiguration>(params: Params$createAdmissionregistrationV1MutatingWebhookConfiguration<ResponseContentType>, option?: RequestOption): Promise<(Response$createAdmissionregistrationV1MutatingWebhookConfiguration$Status$200 | Response$createAdmissionregistrationV1MutatingWebhookConfiguration$Status$201 | Response$createAdmissionregistrationV1MutatingWebhookConfiguration$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/admissionregistration.k8s.io/v1/mutatingwebhookconfigurations\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteAdmissionregistrationV1CollectionMutatingWebhookConfiguration = <ResponseContentType extends ResponseContentType$deleteAdmissionregistrationV1CollectionMutatingWebhookConfiguration>(params: Params$deleteAdmissionregistrationV1CollectionMutatingWebhookConfiguration<ResponseContentType>, option?: RequestOption): Promise<Response$deleteAdmissionregistrationV1CollectionMutatingWebhookConfiguration$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/admissionregistration.k8s.io/v1/mutatingwebhookconfigurations\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readAdmissionregistrationV1MutatingWebhookConfiguration = <ResponseContentType extends ResponseContentType$readAdmissionregistrationV1MutatingWebhookConfiguration>(params: Params$readAdmissionregistrationV1MutatingWebhookConfiguration<ResponseContentType>, option?: RequestOption): Promise<Response$readAdmissionregistrationV1MutatingWebhookConfiguration$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/admissionregistration.k8s.io/v1/mutatingwebhookconfigurations/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            exact: { value: params.parameter.exact, explode: false },
-            export: { value: params.parameter.export, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceAdmissionregistrationV1MutatingWebhookConfiguration = <ResponseContentType extends ResponseContentType$replaceAdmissionregistrationV1MutatingWebhookConfiguration>(params: Params$replaceAdmissionregistrationV1MutatingWebhookConfiguration<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceAdmissionregistrationV1MutatingWebhookConfiguration$Status$200 | Response$replaceAdmissionregistrationV1MutatingWebhookConfiguration$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/admissionregistration.k8s.io/v1/mutatingwebhookconfigurations/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteAdmissionregistrationV1MutatingWebhookConfiguration = <ResponseContentType extends ResponseContentType$deleteAdmissionregistrationV1MutatingWebhookConfiguration>(params: Params$deleteAdmissionregistrationV1MutatingWebhookConfiguration<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteAdmissionregistrationV1MutatingWebhookConfiguration$Status$200 | Response$deleteAdmissionregistrationV1MutatingWebhookConfiguration$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/admissionregistration.k8s.io/v1/mutatingwebhookconfigurations/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchAdmissionregistrationV1MutatingWebhookConfiguration = <RequestContentType extends RequestContentType$patchAdmissionregistrationV1MutatingWebhookConfiguration, ResponseContentType extends ResponseContentType$patchAdmissionregistrationV1MutatingWebhookConfiguration>(params: Params$patchAdmissionregistrationV1MutatingWebhookConfiguration<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchAdmissionregistrationV1MutatingWebhookConfiguration$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/admissionregistration.k8s.io/v1/mutatingwebhookconfigurations/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const listAdmissionregistrationV1ValidatingWebhookConfiguration = <ResponseContentType extends ResponseContentType$listAdmissionregistrationV1ValidatingWebhookConfiguration>(params: Params$listAdmissionregistrationV1ValidatingWebhookConfiguration<ResponseContentType>, option?: RequestOption): Promise<Response$listAdmissionregistrationV1ValidatingWebhookConfiguration$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/admissionregistration.k8s.io/v1/validatingwebhookconfigurations\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const createAdmissionregistrationV1ValidatingWebhookConfiguration = <ResponseContentType extends ResponseContentType$createAdmissionregistrationV1ValidatingWebhookConfiguration>(params: Params$createAdmissionregistrationV1ValidatingWebhookConfiguration<ResponseContentType>, option?: RequestOption): Promise<(Response$createAdmissionregistrationV1ValidatingWebhookConfiguration$Status$200 | Response$createAdmissionregistrationV1ValidatingWebhookConfiguration$Status$201 | Response$createAdmissionregistrationV1ValidatingWebhookConfiguration$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/admissionregistration.k8s.io/v1/validatingwebhookconfigurations\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteAdmissionregistrationV1CollectionValidatingWebhookConfiguration = <ResponseContentType extends ResponseContentType$deleteAdmissionregistrationV1CollectionValidatingWebhookConfiguration>(params: Params$deleteAdmissionregistrationV1CollectionValidatingWebhookConfiguration<ResponseContentType>, option?: RequestOption): Promise<Response$deleteAdmissionregistrationV1CollectionValidatingWebhookConfiguration$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/admissionregistration.k8s.io/v1/validatingwebhookconfigurations\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readAdmissionregistrationV1ValidatingWebhookConfiguration = <ResponseContentType extends ResponseContentType$readAdmissionregistrationV1ValidatingWebhookConfiguration>(params: Params$readAdmissionregistrationV1ValidatingWebhookConfiguration<ResponseContentType>, option?: RequestOption): Promise<Response$readAdmissionregistrationV1ValidatingWebhookConfiguration$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/admissionregistration.k8s.io/v1/validatingwebhookconfigurations/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            exact: { value: params.parameter.exact, explode: false },
-            export: { value: params.parameter.export, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceAdmissionregistrationV1ValidatingWebhookConfiguration = <ResponseContentType extends ResponseContentType$replaceAdmissionregistrationV1ValidatingWebhookConfiguration>(params: Params$replaceAdmissionregistrationV1ValidatingWebhookConfiguration<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceAdmissionregistrationV1ValidatingWebhookConfiguration$Status$200 | Response$replaceAdmissionregistrationV1ValidatingWebhookConfiguration$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/admissionregistration.k8s.io/v1/validatingwebhookconfigurations/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteAdmissionregistrationV1ValidatingWebhookConfiguration = <ResponseContentType extends ResponseContentType$deleteAdmissionregistrationV1ValidatingWebhookConfiguration>(params: Params$deleteAdmissionregistrationV1ValidatingWebhookConfiguration<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteAdmissionregistrationV1ValidatingWebhookConfiguration$Status$200 | Response$deleteAdmissionregistrationV1ValidatingWebhookConfiguration$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/admissionregistration.k8s.io/v1/validatingwebhookconfigurations/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchAdmissionregistrationV1ValidatingWebhookConfiguration = <RequestContentType extends RequestContentType$patchAdmissionregistrationV1ValidatingWebhookConfiguration, ResponseContentType extends ResponseContentType$patchAdmissionregistrationV1ValidatingWebhookConfiguration>(params: Params$patchAdmissionregistrationV1ValidatingWebhookConfiguration<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchAdmissionregistrationV1ValidatingWebhookConfiguration$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/admissionregistration.k8s.io/v1/validatingwebhookconfigurations/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const watchAdmissionregistrationV1MutatingWebhookConfigurationList = <ResponseContentType extends ResponseContentType$watchAdmissionregistrationV1MutatingWebhookConfigurationList>(params: Params$watchAdmissionregistrationV1MutatingWebhookConfigurationList<ResponseContentType>, option?: RequestOption): Promise<Response$watchAdmissionregistrationV1MutatingWebhookConfigurationList$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/admissionregistration.k8s.io/v1/watch/mutatingwebhookconfigurations\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchAdmissionregistrationV1MutatingWebhookConfiguration = <ResponseContentType extends ResponseContentType$watchAdmissionregistrationV1MutatingWebhookConfiguration>(params: Params$watchAdmissionregistrationV1MutatingWebhookConfiguration<ResponseContentType>, option?: RequestOption): Promise<Response$watchAdmissionregistrationV1MutatingWebhookConfiguration$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/admissionregistration.k8s.io/v1/watch/mutatingwebhookconfigurations/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchAdmissionregistrationV1ValidatingWebhookConfigurationList = <ResponseContentType extends ResponseContentType$watchAdmissionregistrationV1ValidatingWebhookConfigurationList>(params: Params$watchAdmissionregistrationV1ValidatingWebhookConfigurationList<ResponseContentType>, option?: RequestOption): Promise<Response$watchAdmissionregistrationV1ValidatingWebhookConfigurationList$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/admissionregistration.k8s.io/v1/watch/validatingwebhookconfigurations\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchAdmissionregistrationV1ValidatingWebhookConfiguration = <ResponseContentType extends ResponseContentType$watchAdmissionregistrationV1ValidatingWebhookConfiguration>(params: Params$watchAdmissionregistrationV1ValidatingWebhookConfiguration<ResponseContentType>, option?: RequestOption): Promise<Response$watchAdmissionregistrationV1ValidatingWebhookConfiguration$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/admissionregistration.k8s.io/v1/watch/validatingwebhookconfigurations/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const getAdmissionregistrationV1beta1APIResources = <ResponseContentType extends ResponseContentType$getAdmissionregistrationV1beta1APIResources>(params: Params$getAdmissionregistrationV1beta1APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getAdmissionregistrationV1beta1APIResources$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/admissionregistration.k8s.io/v1beta1/\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const listAdmissionregistrationV1beta1MutatingWebhookConfiguration = <ResponseContentType extends ResponseContentType$listAdmissionregistrationV1beta1MutatingWebhookConfiguration>(params: Params$listAdmissionregistrationV1beta1MutatingWebhookConfiguration<ResponseContentType>, option?: RequestOption): Promise<Response$listAdmissionregistrationV1beta1MutatingWebhookConfiguration$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/admissionregistration.k8s.io/v1beta1/mutatingwebhookconfigurations\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const createAdmissionregistrationV1beta1MutatingWebhookConfiguration = <ResponseContentType extends ResponseContentType$createAdmissionregistrationV1beta1MutatingWebhookConfiguration>(params: Params$createAdmissionregistrationV1beta1MutatingWebhookConfiguration<ResponseContentType>, option?: RequestOption): Promise<(Response$createAdmissionregistrationV1beta1MutatingWebhookConfiguration$Status$200 | Response$createAdmissionregistrationV1beta1MutatingWebhookConfiguration$Status$201 | Response$createAdmissionregistrationV1beta1MutatingWebhookConfiguration$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/admissionregistration.k8s.io/v1beta1/mutatingwebhookconfigurations\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteAdmissionregistrationV1beta1CollectionMutatingWebhookConfiguration = <ResponseContentType extends ResponseContentType$deleteAdmissionregistrationV1beta1CollectionMutatingWebhookConfiguration>(params: Params$deleteAdmissionregistrationV1beta1CollectionMutatingWebhookConfiguration<ResponseContentType>, option?: RequestOption): Promise<Response$deleteAdmissionregistrationV1beta1CollectionMutatingWebhookConfiguration$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/admissionregistration.k8s.io/v1beta1/mutatingwebhookconfigurations\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readAdmissionregistrationV1beta1MutatingWebhookConfiguration = <ResponseContentType extends ResponseContentType$readAdmissionregistrationV1beta1MutatingWebhookConfiguration>(params: Params$readAdmissionregistrationV1beta1MutatingWebhookConfiguration<ResponseContentType>, option?: RequestOption): Promise<Response$readAdmissionregistrationV1beta1MutatingWebhookConfiguration$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/admissionregistration.k8s.io/v1beta1/mutatingwebhookconfigurations/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            exact: { value: params.parameter.exact, explode: false },
-            export: { value: params.parameter.export, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceAdmissionregistrationV1beta1MutatingWebhookConfiguration = <ResponseContentType extends ResponseContentType$replaceAdmissionregistrationV1beta1MutatingWebhookConfiguration>(params: Params$replaceAdmissionregistrationV1beta1MutatingWebhookConfiguration<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceAdmissionregistrationV1beta1MutatingWebhookConfiguration$Status$200 | Response$replaceAdmissionregistrationV1beta1MutatingWebhookConfiguration$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/admissionregistration.k8s.io/v1beta1/mutatingwebhookconfigurations/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteAdmissionregistrationV1beta1MutatingWebhookConfiguration = <ResponseContentType extends ResponseContentType$deleteAdmissionregistrationV1beta1MutatingWebhookConfiguration>(params: Params$deleteAdmissionregistrationV1beta1MutatingWebhookConfiguration<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteAdmissionregistrationV1beta1MutatingWebhookConfiguration$Status$200 | Response$deleteAdmissionregistrationV1beta1MutatingWebhookConfiguration$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/admissionregistration.k8s.io/v1beta1/mutatingwebhookconfigurations/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchAdmissionregistrationV1beta1MutatingWebhookConfiguration = <RequestContentType extends RequestContentType$patchAdmissionregistrationV1beta1MutatingWebhookConfiguration, ResponseContentType extends ResponseContentType$patchAdmissionregistrationV1beta1MutatingWebhookConfiguration>(params: Params$patchAdmissionregistrationV1beta1MutatingWebhookConfiguration<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchAdmissionregistrationV1beta1MutatingWebhookConfiguration$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/admissionregistration.k8s.io/v1beta1/mutatingwebhookconfigurations/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const listAdmissionregistrationV1beta1ValidatingWebhookConfiguration = <ResponseContentType extends ResponseContentType$listAdmissionregistrationV1beta1ValidatingWebhookConfiguration>(params: Params$listAdmissionregistrationV1beta1ValidatingWebhookConfiguration<ResponseContentType>, option?: RequestOption): Promise<Response$listAdmissionregistrationV1beta1ValidatingWebhookConfiguration$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/admissionregistration.k8s.io/v1beta1/validatingwebhookconfigurations\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const createAdmissionregistrationV1beta1ValidatingWebhookConfiguration = <ResponseContentType extends ResponseContentType$createAdmissionregistrationV1beta1ValidatingWebhookConfiguration>(params: Params$createAdmissionregistrationV1beta1ValidatingWebhookConfiguration<ResponseContentType>, option?: RequestOption): Promise<(Response$createAdmissionregistrationV1beta1ValidatingWebhookConfiguration$Status$200 | Response$createAdmissionregistrationV1beta1ValidatingWebhookConfiguration$Status$201 | Response$createAdmissionregistrationV1beta1ValidatingWebhookConfiguration$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/admissionregistration.k8s.io/v1beta1/validatingwebhookconfigurations\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteAdmissionregistrationV1beta1CollectionValidatingWebhookConfiguration = <ResponseContentType extends ResponseContentType$deleteAdmissionregistrationV1beta1CollectionValidatingWebhookConfiguration>(params: Params$deleteAdmissionregistrationV1beta1CollectionValidatingWebhookConfiguration<ResponseContentType>, option?: RequestOption): Promise<Response$deleteAdmissionregistrationV1beta1CollectionValidatingWebhookConfiguration$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/admissionregistration.k8s.io/v1beta1/validatingwebhookconfigurations\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readAdmissionregistrationV1beta1ValidatingWebhookConfiguration = <ResponseContentType extends ResponseContentType$readAdmissionregistrationV1beta1ValidatingWebhookConfiguration>(params: Params$readAdmissionregistrationV1beta1ValidatingWebhookConfiguration<ResponseContentType>, option?: RequestOption): Promise<Response$readAdmissionregistrationV1beta1ValidatingWebhookConfiguration$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/admissionregistration.k8s.io/v1beta1/validatingwebhookconfigurations/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            exact: { value: params.parameter.exact, explode: false },
-            export: { value: params.parameter.export, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceAdmissionregistrationV1beta1ValidatingWebhookConfiguration = <ResponseContentType extends ResponseContentType$replaceAdmissionregistrationV1beta1ValidatingWebhookConfiguration>(params: Params$replaceAdmissionregistrationV1beta1ValidatingWebhookConfiguration<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceAdmissionregistrationV1beta1ValidatingWebhookConfiguration$Status$200 | Response$replaceAdmissionregistrationV1beta1ValidatingWebhookConfiguration$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/admissionregistration.k8s.io/v1beta1/validatingwebhookconfigurations/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteAdmissionregistrationV1beta1ValidatingWebhookConfiguration = <ResponseContentType extends ResponseContentType$deleteAdmissionregistrationV1beta1ValidatingWebhookConfiguration>(params: Params$deleteAdmissionregistrationV1beta1ValidatingWebhookConfiguration<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteAdmissionregistrationV1beta1ValidatingWebhookConfiguration$Status$200 | Response$deleteAdmissionregistrationV1beta1ValidatingWebhookConfiguration$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/admissionregistration.k8s.io/v1beta1/validatingwebhookconfigurations/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchAdmissionregistrationV1beta1ValidatingWebhookConfiguration = <RequestContentType extends RequestContentType$patchAdmissionregistrationV1beta1ValidatingWebhookConfiguration, ResponseContentType extends ResponseContentType$patchAdmissionregistrationV1beta1ValidatingWebhookConfiguration>(params: Params$patchAdmissionregistrationV1beta1ValidatingWebhookConfiguration<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchAdmissionregistrationV1beta1ValidatingWebhookConfiguration$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/admissionregistration.k8s.io/v1beta1/validatingwebhookconfigurations/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const watchAdmissionregistrationV1beta1MutatingWebhookConfigurationList = <ResponseContentType extends ResponseContentType$watchAdmissionregistrationV1beta1MutatingWebhookConfigurationList>(params: Params$watchAdmissionregistrationV1beta1MutatingWebhookConfigurationList<ResponseContentType>, option?: RequestOption): Promise<Response$watchAdmissionregistrationV1beta1MutatingWebhookConfigurationList$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/admissionregistration.k8s.io/v1beta1/watch/mutatingwebhookconfigurations\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchAdmissionregistrationV1beta1MutatingWebhookConfiguration = <ResponseContentType extends ResponseContentType$watchAdmissionregistrationV1beta1MutatingWebhookConfiguration>(params: Params$watchAdmissionregistrationV1beta1MutatingWebhookConfiguration<ResponseContentType>, option?: RequestOption): Promise<Response$watchAdmissionregistrationV1beta1MutatingWebhookConfiguration$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/admissionregistration.k8s.io/v1beta1/watch/mutatingwebhookconfigurations/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchAdmissionregistrationV1beta1ValidatingWebhookConfigurationList = <ResponseContentType extends ResponseContentType$watchAdmissionregistrationV1beta1ValidatingWebhookConfigurationList>(params: Params$watchAdmissionregistrationV1beta1ValidatingWebhookConfigurationList<ResponseContentType>, option?: RequestOption): Promise<Response$watchAdmissionregistrationV1beta1ValidatingWebhookConfigurationList$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/admissionregistration.k8s.io/v1beta1/watch/validatingwebhookconfigurations\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchAdmissionregistrationV1beta1ValidatingWebhookConfiguration = <ResponseContentType extends ResponseContentType$watchAdmissionregistrationV1beta1ValidatingWebhookConfiguration>(params: Params$watchAdmissionregistrationV1beta1ValidatingWebhookConfiguration<ResponseContentType>, option?: RequestOption): Promise<Response$watchAdmissionregistrationV1beta1ValidatingWebhookConfiguration$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/admissionregistration.k8s.io/v1beta1/watch/validatingwebhookconfigurations/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const getApiextensionsAPIGroup = <ResponseContentType extends ResponseContentType$getApiextensionsAPIGroup>(params: Params$getApiextensionsAPIGroup<ResponseContentType>, option?: RequestOption): Promise<Response$getApiextensionsAPIGroup$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apiextensions.k8s.io/\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const getApiextensionsV1APIResources = <ResponseContentType extends ResponseContentType$getApiextensionsV1APIResources>(params: Params$getApiextensionsV1APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getApiextensionsV1APIResources$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apiextensions.k8s.io/v1/\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const listApiextensionsV1CustomResourceDefinition = <ResponseContentType extends ResponseContentType$listApiextensionsV1CustomResourceDefinition>(params: Params$listApiextensionsV1CustomResourceDefinition<ResponseContentType>, option?: RequestOption): Promise<Response$listApiextensionsV1CustomResourceDefinition$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apiextensions.k8s.io/v1/customresourcedefinitions\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const createApiextensionsV1CustomResourceDefinition = <ResponseContentType extends ResponseContentType$createApiextensionsV1CustomResourceDefinition>(params: Params$createApiextensionsV1CustomResourceDefinition<ResponseContentType>, option?: RequestOption): Promise<(Response$createApiextensionsV1CustomResourceDefinition$Status$200 | Response$createApiextensionsV1CustomResourceDefinition$Status$201 | Response$createApiextensionsV1CustomResourceDefinition$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apiextensions.k8s.io/v1/customresourcedefinitions\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteApiextensionsV1CollectionCustomResourceDefinition = <ResponseContentType extends ResponseContentType$deleteApiextensionsV1CollectionCustomResourceDefinition>(params: Params$deleteApiextensionsV1CollectionCustomResourceDefinition<ResponseContentType>, option?: RequestOption): Promise<Response$deleteApiextensionsV1CollectionCustomResourceDefinition$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apiextensions.k8s.io/v1/customresourcedefinitions\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readApiextensionsV1CustomResourceDefinition = <ResponseContentType extends ResponseContentType$readApiextensionsV1CustomResourceDefinition>(params: Params$readApiextensionsV1CustomResourceDefinition<ResponseContentType>, option?: RequestOption): Promise<Response$readApiextensionsV1CustomResourceDefinition$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apiextensions.k8s.io/v1/customresourcedefinitions/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            exact: { value: params.parameter.exact, explode: false },
-            export: { value: params.parameter.export, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceApiextensionsV1CustomResourceDefinition = <ResponseContentType extends ResponseContentType$replaceApiextensionsV1CustomResourceDefinition>(params: Params$replaceApiextensionsV1CustomResourceDefinition<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceApiextensionsV1CustomResourceDefinition$Status$200 | Response$replaceApiextensionsV1CustomResourceDefinition$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apiextensions.k8s.io/v1/customresourcedefinitions/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteApiextensionsV1CustomResourceDefinition = <ResponseContentType extends ResponseContentType$deleteApiextensionsV1CustomResourceDefinition>(params: Params$deleteApiextensionsV1CustomResourceDefinition<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteApiextensionsV1CustomResourceDefinition$Status$200 | Response$deleteApiextensionsV1CustomResourceDefinition$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apiextensions.k8s.io/v1/customresourcedefinitions/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchApiextensionsV1CustomResourceDefinition = <RequestContentType extends RequestContentType$patchApiextensionsV1CustomResourceDefinition, ResponseContentType extends ResponseContentType$patchApiextensionsV1CustomResourceDefinition>(params: Params$patchApiextensionsV1CustomResourceDefinition<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchApiextensionsV1CustomResourceDefinition$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apiextensions.k8s.io/v1/customresourcedefinitions/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readApiextensionsV1CustomResourceDefinitionStatus = <ResponseContentType extends ResponseContentType$readApiextensionsV1CustomResourceDefinitionStatus>(params: Params$readApiextensionsV1CustomResourceDefinitionStatus<ResponseContentType>, option?: RequestOption): Promise<Response$readApiextensionsV1CustomResourceDefinitionStatus$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apiextensions.k8s.io/v1/customresourcedefinitions/\${params.parameter.name}/status\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceApiextensionsV1CustomResourceDefinitionStatus = <ResponseContentType extends ResponseContentType$replaceApiextensionsV1CustomResourceDefinitionStatus>(params: Params$replaceApiextensionsV1CustomResourceDefinitionStatus<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceApiextensionsV1CustomResourceDefinitionStatus$Status$200 | Response$replaceApiextensionsV1CustomResourceDefinitionStatus$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apiextensions.k8s.io/v1/customresourcedefinitions/\${params.parameter.name}/status\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchApiextensionsV1CustomResourceDefinitionStatus = <RequestContentType extends RequestContentType$patchApiextensionsV1CustomResourceDefinitionStatus, ResponseContentType extends ResponseContentType$patchApiextensionsV1CustomResourceDefinitionStatus>(params: Params$patchApiextensionsV1CustomResourceDefinitionStatus<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchApiextensionsV1CustomResourceDefinitionStatus$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apiextensions.k8s.io/v1/customresourcedefinitions/\${params.parameter.name}/status\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const watchApiextensionsV1CustomResourceDefinitionList = <ResponseContentType extends ResponseContentType$watchApiextensionsV1CustomResourceDefinitionList>(params: Params$watchApiextensionsV1CustomResourceDefinitionList<ResponseContentType>, option?: RequestOption): Promise<Response$watchApiextensionsV1CustomResourceDefinitionList$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apiextensions.k8s.io/v1/watch/customresourcedefinitions\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchApiextensionsV1CustomResourceDefinition = <ResponseContentType extends ResponseContentType$watchApiextensionsV1CustomResourceDefinition>(params: Params$watchApiextensionsV1CustomResourceDefinition<ResponseContentType>, option?: RequestOption): Promise<Response$watchApiextensionsV1CustomResourceDefinition$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apiextensions.k8s.io/v1/watch/customresourcedefinitions/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const getApiextensionsV1beta1APIResources = <ResponseContentType extends ResponseContentType$getApiextensionsV1beta1APIResources>(params: Params$getApiextensionsV1beta1APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getApiextensionsV1beta1APIResources$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apiextensions.k8s.io/v1beta1/\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const listApiextensionsV1beta1CustomResourceDefinition = <ResponseContentType extends ResponseContentType$listApiextensionsV1beta1CustomResourceDefinition>(params: Params$listApiextensionsV1beta1CustomResourceDefinition<ResponseContentType>, option?: RequestOption): Promise<Response$listApiextensionsV1beta1CustomResourceDefinition$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apiextensions.k8s.io/v1beta1/customresourcedefinitions\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const createApiextensionsV1beta1CustomResourceDefinition = <ResponseContentType extends ResponseContentType$createApiextensionsV1beta1CustomResourceDefinition>(params: Params$createApiextensionsV1beta1CustomResourceDefinition<ResponseContentType>, option?: RequestOption): Promise<(Response$createApiextensionsV1beta1CustomResourceDefinition$Status$200 | Response$createApiextensionsV1beta1CustomResourceDefinition$Status$201 | Response$createApiextensionsV1beta1CustomResourceDefinition$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apiextensions.k8s.io/v1beta1/customresourcedefinitions\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteApiextensionsV1beta1CollectionCustomResourceDefinition = <ResponseContentType extends ResponseContentType$deleteApiextensionsV1beta1CollectionCustomResourceDefinition>(params: Params$deleteApiextensionsV1beta1CollectionCustomResourceDefinition<ResponseContentType>, option?: RequestOption): Promise<Response$deleteApiextensionsV1beta1CollectionCustomResourceDefinition$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apiextensions.k8s.io/v1beta1/customresourcedefinitions\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readApiextensionsV1beta1CustomResourceDefinition = <ResponseContentType extends ResponseContentType$readApiextensionsV1beta1CustomResourceDefinition>(params: Params$readApiextensionsV1beta1CustomResourceDefinition<ResponseContentType>, option?: RequestOption): Promise<Response$readApiextensionsV1beta1CustomResourceDefinition$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apiextensions.k8s.io/v1beta1/customresourcedefinitions/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            exact: { value: params.parameter.exact, explode: false },
-            export: { value: params.parameter.export, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceApiextensionsV1beta1CustomResourceDefinition = <ResponseContentType extends ResponseContentType$replaceApiextensionsV1beta1CustomResourceDefinition>(params: Params$replaceApiextensionsV1beta1CustomResourceDefinition<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceApiextensionsV1beta1CustomResourceDefinition$Status$200 | Response$replaceApiextensionsV1beta1CustomResourceDefinition$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apiextensions.k8s.io/v1beta1/customresourcedefinitions/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteApiextensionsV1beta1CustomResourceDefinition = <ResponseContentType extends ResponseContentType$deleteApiextensionsV1beta1CustomResourceDefinition>(params: Params$deleteApiextensionsV1beta1CustomResourceDefinition<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteApiextensionsV1beta1CustomResourceDefinition$Status$200 | Response$deleteApiextensionsV1beta1CustomResourceDefinition$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apiextensions.k8s.io/v1beta1/customresourcedefinitions/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchApiextensionsV1beta1CustomResourceDefinition = <RequestContentType extends RequestContentType$patchApiextensionsV1beta1CustomResourceDefinition, ResponseContentType extends ResponseContentType$patchApiextensionsV1beta1CustomResourceDefinition>(params: Params$patchApiextensionsV1beta1CustomResourceDefinition<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchApiextensionsV1beta1CustomResourceDefinition$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apiextensions.k8s.io/v1beta1/customresourcedefinitions/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readApiextensionsV1beta1CustomResourceDefinitionStatus = <ResponseContentType extends ResponseContentType$readApiextensionsV1beta1CustomResourceDefinitionStatus>(params: Params$readApiextensionsV1beta1CustomResourceDefinitionStatus<ResponseContentType>, option?: RequestOption): Promise<Response$readApiextensionsV1beta1CustomResourceDefinitionStatus$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apiextensions.k8s.io/v1beta1/customresourcedefinitions/\${params.parameter.name}/status\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceApiextensionsV1beta1CustomResourceDefinitionStatus = <ResponseContentType extends ResponseContentType$replaceApiextensionsV1beta1CustomResourceDefinitionStatus>(params: Params$replaceApiextensionsV1beta1CustomResourceDefinitionStatus<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceApiextensionsV1beta1CustomResourceDefinitionStatus$Status$200 | Response$replaceApiextensionsV1beta1CustomResourceDefinitionStatus$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apiextensions.k8s.io/v1beta1/customresourcedefinitions/\${params.parameter.name}/status\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchApiextensionsV1beta1CustomResourceDefinitionStatus = <RequestContentType extends RequestContentType$patchApiextensionsV1beta1CustomResourceDefinitionStatus, ResponseContentType extends ResponseContentType$patchApiextensionsV1beta1CustomResourceDefinitionStatus>(params: Params$patchApiextensionsV1beta1CustomResourceDefinitionStatus<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchApiextensionsV1beta1CustomResourceDefinitionStatus$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apiextensions.k8s.io/v1beta1/customresourcedefinitions/\${params.parameter.name}/status\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const watchApiextensionsV1beta1CustomResourceDefinitionList = <ResponseContentType extends ResponseContentType$watchApiextensionsV1beta1CustomResourceDefinitionList>(params: Params$watchApiextensionsV1beta1CustomResourceDefinitionList<ResponseContentType>, option?: RequestOption): Promise<Response$watchApiextensionsV1beta1CustomResourceDefinitionList$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apiextensions.k8s.io/v1beta1/watch/customresourcedefinitions\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchApiextensionsV1beta1CustomResourceDefinition = <ResponseContentType extends ResponseContentType$watchApiextensionsV1beta1CustomResourceDefinition>(params: Params$watchApiextensionsV1beta1CustomResourceDefinition<ResponseContentType>, option?: RequestOption): Promise<Response$watchApiextensionsV1beta1CustomResourceDefinition$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apiextensions.k8s.io/v1beta1/watch/customresourcedefinitions/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const getApiregistrationAPIGroup = <ResponseContentType extends ResponseContentType$getApiregistrationAPIGroup>(params: Params$getApiregistrationAPIGroup<ResponseContentType>, option?: RequestOption): Promise<Response$getApiregistrationAPIGroup$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apiregistration.k8s.io/\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const getApiregistrationV1APIResources = <ResponseContentType extends ResponseContentType$getApiregistrationV1APIResources>(params: Params$getApiregistrationV1APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getApiregistrationV1APIResources$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apiregistration.k8s.io/v1/\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const listApiregistrationV1APIService = <ResponseContentType extends ResponseContentType$listApiregistrationV1APIService>(params: Params$listApiregistrationV1APIService<ResponseContentType>, option?: RequestOption): Promise<Response$listApiregistrationV1APIService$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apiregistration.k8s.io/v1/apiservices\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const createApiregistrationV1APIService = <ResponseContentType extends ResponseContentType$createApiregistrationV1APIService>(params: Params$createApiregistrationV1APIService<ResponseContentType>, option?: RequestOption): Promise<(Response$createApiregistrationV1APIService$Status$200 | Response$createApiregistrationV1APIService$Status$201 | Response$createApiregistrationV1APIService$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apiregistration.k8s.io/v1/apiservices\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteApiregistrationV1CollectionAPIService = <ResponseContentType extends ResponseContentType$deleteApiregistrationV1CollectionAPIService>(params: Params$deleteApiregistrationV1CollectionAPIService<ResponseContentType>, option?: RequestOption): Promise<Response$deleteApiregistrationV1CollectionAPIService$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apiregistration.k8s.io/v1/apiservices\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readApiregistrationV1APIService = <ResponseContentType extends ResponseContentType$readApiregistrationV1APIService>(params: Params$readApiregistrationV1APIService<ResponseContentType>, option?: RequestOption): Promise<Response$readApiregistrationV1APIService$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apiregistration.k8s.io/v1/apiservices/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            exact: { value: params.parameter.exact, explode: false },
-            export: { value: params.parameter.export, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceApiregistrationV1APIService = <ResponseContentType extends ResponseContentType$replaceApiregistrationV1APIService>(params: Params$replaceApiregistrationV1APIService<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceApiregistrationV1APIService$Status$200 | Response$replaceApiregistrationV1APIService$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apiregistration.k8s.io/v1/apiservices/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteApiregistrationV1APIService = <ResponseContentType extends ResponseContentType$deleteApiregistrationV1APIService>(params: Params$deleteApiregistrationV1APIService<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteApiregistrationV1APIService$Status$200 | Response$deleteApiregistrationV1APIService$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apiregistration.k8s.io/v1/apiservices/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchApiregistrationV1APIService = <RequestContentType extends RequestContentType$patchApiregistrationV1APIService, ResponseContentType extends ResponseContentType$patchApiregistrationV1APIService>(params: Params$patchApiregistrationV1APIService<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchApiregistrationV1APIService$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apiregistration.k8s.io/v1/apiservices/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readApiregistrationV1APIServiceStatus = <ResponseContentType extends ResponseContentType$readApiregistrationV1APIServiceStatus>(params: Params$readApiregistrationV1APIServiceStatus<ResponseContentType>, option?: RequestOption): Promise<Response$readApiregistrationV1APIServiceStatus$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apiregistration.k8s.io/v1/apiservices/\${params.parameter.name}/status\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceApiregistrationV1APIServiceStatus = <ResponseContentType extends ResponseContentType$replaceApiregistrationV1APIServiceStatus>(params: Params$replaceApiregistrationV1APIServiceStatus<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceApiregistrationV1APIServiceStatus$Status$200 | Response$replaceApiregistrationV1APIServiceStatus$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apiregistration.k8s.io/v1/apiservices/\${params.parameter.name}/status\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchApiregistrationV1APIServiceStatus = <RequestContentType extends RequestContentType$patchApiregistrationV1APIServiceStatus, ResponseContentType extends ResponseContentType$patchApiregistrationV1APIServiceStatus>(params: Params$patchApiregistrationV1APIServiceStatus<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchApiregistrationV1APIServiceStatus$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apiregistration.k8s.io/v1/apiservices/\${params.parameter.name}/status\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const watchApiregistrationV1APIServiceList = <ResponseContentType extends ResponseContentType$watchApiregistrationV1APIServiceList>(params: Params$watchApiregistrationV1APIServiceList<ResponseContentType>, option?: RequestOption): Promise<Response$watchApiregistrationV1APIServiceList$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apiregistration.k8s.io/v1/watch/apiservices\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchApiregistrationV1APIService = <ResponseContentType extends ResponseContentType$watchApiregistrationV1APIService>(params: Params$watchApiregistrationV1APIService<ResponseContentType>, option?: RequestOption): Promise<Response$watchApiregistrationV1APIService$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apiregistration.k8s.io/v1/watch/apiservices/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const getApiregistrationV1beta1APIResources = <ResponseContentType extends ResponseContentType$getApiregistrationV1beta1APIResources>(params: Params$getApiregistrationV1beta1APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getApiregistrationV1beta1APIResources$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apiregistration.k8s.io/v1beta1/\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const listApiregistrationV1beta1APIService = <ResponseContentType extends ResponseContentType$listApiregistrationV1beta1APIService>(params: Params$listApiregistrationV1beta1APIService<ResponseContentType>, option?: RequestOption): Promise<Response$listApiregistrationV1beta1APIService$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apiregistration.k8s.io/v1beta1/apiservices\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const createApiregistrationV1beta1APIService = <ResponseContentType extends ResponseContentType$createApiregistrationV1beta1APIService>(params: Params$createApiregistrationV1beta1APIService<ResponseContentType>, option?: RequestOption): Promise<(Response$createApiregistrationV1beta1APIService$Status$200 | Response$createApiregistrationV1beta1APIService$Status$201 | Response$createApiregistrationV1beta1APIService$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apiregistration.k8s.io/v1beta1/apiservices\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteApiregistrationV1beta1CollectionAPIService = <ResponseContentType extends ResponseContentType$deleteApiregistrationV1beta1CollectionAPIService>(params: Params$deleteApiregistrationV1beta1CollectionAPIService<ResponseContentType>, option?: RequestOption): Promise<Response$deleteApiregistrationV1beta1CollectionAPIService$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apiregistration.k8s.io/v1beta1/apiservices\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readApiregistrationV1beta1APIService = <ResponseContentType extends ResponseContentType$readApiregistrationV1beta1APIService>(params: Params$readApiregistrationV1beta1APIService<ResponseContentType>, option?: RequestOption): Promise<Response$readApiregistrationV1beta1APIService$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apiregistration.k8s.io/v1beta1/apiservices/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            exact: { value: params.parameter.exact, explode: false },
-            export: { value: params.parameter.export, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceApiregistrationV1beta1APIService = <ResponseContentType extends ResponseContentType$replaceApiregistrationV1beta1APIService>(params: Params$replaceApiregistrationV1beta1APIService<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceApiregistrationV1beta1APIService$Status$200 | Response$replaceApiregistrationV1beta1APIService$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apiregistration.k8s.io/v1beta1/apiservices/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteApiregistrationV1beta1APIService = <ResponseContentType extends ResponseContentType$deleteApiregistrationV1beta1APIService>(params: Params$deleteApiregistrationV1beta1APIService<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteApiregistrationV1beta1APIService$Status$200 | Response$deleteApiregistrationV1beta1APIService$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apiregistration.k8s.io/v1beta1/apiservices/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchApiregistrationV1beta1APIService = <RequestContentType extends RequestContentType$patchApiregistrationV1beta1APIService, ResponseContentType extends ResponseContentType$patchApiregistrationV1beta1APIService>(params: Params$patchApiregistrationV1beta1APIService<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchApiregistrationV1beta1APIService$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apiregistration.k8s.io/v1beta1/apiservices/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readApiregistrationV1beta1APIServiceStatus = <ResponseContentType extends ResponseContentType$readApiregistrationV1beta1APIServiceStatus>(params: Params$readApiregistrationV1beta1APIServiceStatus<ResponseContentType>, option?: RequestOption): Promise<Response$readApiregistrationV1beta1APIServiceStatus$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apiregistration.k8s.io/v1beta1/apiservices/\${params.parameter.name}/status\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceApiregistrationV1beta1APIServiceStatus = <ResponseContentType extends ResponseContentType$replaceApiregistrationV1beta1APIServiceStatus>(params: Params$replaceApiregistrationV1beta1APIServiceStatus<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceApiregistrationV1beta1APIServiceStatus$Status$200 | Response$replaceApiregistrationV1beta1APIServiceStatus$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apiregistration.k8s.io/v1beta1/apiservices/\${params.parameter.name}/status\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchApiregistrationV1beta1APIServiceStatus = <RequestContentType extends RequestContentType$patchApiregistrationV1beta1APIServiceStatus, ResponseContentType extends ResponseContentType$patchApiregistrationV1beta1APIServiceStatus>(params: Params$patchApiregistrationV1beta1APIServiceStatus<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchApiregistrationV1beta1APIServiceStatus$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apiregistration.k8s.io/v1beta1/apiservices/\${params.parameter.name}/status\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const watchApiregistrationV1beta1APIServiceList = <ResponseContentType extends ResponseContentType$watchApiregistrationV1beta1APIServiceList>(params: Params$watchApiregistrationV1beta1APIServiceList<ResponseContentType>, option?: RequestOption): Promise<Response$watchApiregistrationV1beta1APIServiceList$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apiregistration.k8s.io/v1beta1/watch/apiservices\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchApiregistrationV1beta1APIService = <ResponseContentType extends ResponseContentType$watchApiregistrationV1beta1APIService>(params: Params$watchApiregistrationV1beta1APIService<ResponseContentType>, option?: RequestOption): Promise<Response$watchApiregistrationV1beta1APIService$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apiregistration.k8s.io/v1beta1/watch/apiservices/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const getAppsAPIGroup = <ResponseContentType extends ResponseContentType$getAppsAPIGroup>(params: Params$getAppsAPIGroup<ResponseContentType>, option?: RequestOption): Promise<Response$getAppsAPIGroup$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apps/\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const getAppsV1APIResources = <ResponseContentType extends ResponseContentType$getAppsV1APIResources>(params: Params$getAppsV1APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getAppsV1APIResources$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apps/v1/\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const listAppsV1ControllerRevisionForAllNamespaces = <ResponseContentType extends ResponseContentType$listAppsV1ControllerRevisionForAllNamespaces>(params: Params$listAppsV1ControllerRevisionForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$listAppsV1ControllerRevisionForAllNamespaces$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apps/v1/controllerrevisions\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const listAppsV1DaemonSetForAllNamespaces = <ResponseContentType extends ResponseContentType$listAppsV1DaemonSetForAllNamespaces>(params: Params$listAppsV1DaemonSetForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$listAppsV1DaemonSetForAllNamespaces$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apps/v1/daemonsets\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const listAppsV1DeploymentForAllNamespaces = <ResponseContentType extends ResponseContentType$listAppsV1DeploymentForAllNamespaces>(params: Params$listAppsV1DeploymentForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$listAppsV1DeploymentForAllNamespaces$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apps/v1/deployments\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const listAppsV1NamespacedControllerRevision = <ResponseContentType extends ResponseContentType$listAppsV1NamespacedControllerRevision>(params: Params$listAppsV1NamespacedControllerRevision<ResponseContentType>, option?: RequestOption): Promise<Response$listAppsV1NamespacedControllerRevision$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/controllerrevisions\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const createAppsV1NamespacedControllerRevision = <ResponseContentType extends ResponseContentType$createAppsV1NamespacedControllerRevision>(params: Params$createAppsV1NamespacedControllerRevision<ResponseContentType>, option?: RequestOption): Promise<(Response$createAppsV1NamespacedControllerRevision$Status$200 | Response$createAppsV1NamespacedControllerRevision$Status$201 | Response$createAppsV1NamespacedControllerRevision$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/controllerrevisions\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteAppsV1CollectionNamespacedControllerRevision = <ResponseContentType extends ResponseContentType$deleteAppsV1CollectionNamespacedControllerRevision>(params: Params$deleteAppsV1CollectionNamespacedControllerRevision<ResponseContentType>, option?: RequestOption): Promise<Response$deleteAppsV1CollectionNamespacedControllerRevision$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/controllerrevisions\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readAppsV1NamespacedControllerRevision = <ResponseContentType extends ResponseContentType$readAppsV1NamespacedControllerRevision>(params: Params$readAppsV1NamespacedControllerRevision<ResponseContentType>, option?: RequestOption): Promise<Response$readAppsV1NamespacedControllerRevision$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/controllerrevisions/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            exact: { value: params.parameter.exact, explode: false },
-            export: { value: params.parameter.export, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceAppsV1NamespacedControllerRevision = <ResponseContentType extends ResponseContentType$replaceAppsV1NamespacedControllerRevision>(params: Params$replaceAppsV1NamespacedControllerRevision<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceAppsV1NamespacedControllerRevision$Status$200 | Response$replaceAppsV1NamespacedControllerRevision$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/controllerrevisions/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteAppsV1NamespacedControllerRevision = <ResponseContentType extends ResponseContentType$deleteAppsV1NamespacedControllerRevision>(params: Params$deleteAppsV1NamespacedControllerRevision<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteAppsV1NamespacedControllerRevision$Status$200 | Response$deleteAppsV1NamespacedControllerRevision$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/controllerrevisions/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchAppsV1NamespacedControllerRevision = <RequestContentType extends RequestContentType$patchAppsV1NamespacedControllerRevision, ResponseContentType extends ResponseContentType$patchAppsV1NamespacedControllerRevision>(params: Params$patchAppsV1NamespacedControllerRevision<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchAppsV1NamespacedControllerRevision$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/controllerrevisions/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const listAppsV1NamespacedDaemonSet = <ResponseContentType extends ResponseContentType$listAppsV1NamespacedDaemonSet>(params: Params$listAppsV1NamespacedDaemonSet<ResponseContentType>, option?: RequestOption): Promise<Response$listAppsV1NamespacedDaemonSet$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/daemonsets\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const createAppsV1NamespacedDaemonSet = <ResponseContentType extends ResponseContentType$createAppsV1NamespacedDaemonSet>(params: Params$createAppsV1NamespacedDaemonSet<ResponseContentType>, option?: RequestOption): Promise<(Response$createAppsV1NamespacedDaemonSet$Status$200 | Response$createAppsV1NamespacedDaemonSet$Status$201 | Response$createAppsV1NamespacedDaemonSet$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/daemonsets\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteAppsV1CollectionNamespacedDaemonSet = <ResponseContentType extends ResponseContentType$deleteAppsV1CollectionNamespacedDaemonSet>(params: Params$deleteAppsV1CollectionNamespacedDaemonSet<ResponseContentType>, option?: RequestOption): Promise<Response$deleteAppsV1CollectionNamespacedDaemonSet$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/daemonsets\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readAppsV1NamespacedDaemonSet = <ResponseContentType extends ResponseContentType$readAppsV1NamespacedDaemonSet>(params: Params$readAppsV1NamespacedDaemonSet<ResponseContentType>, option?: RequestOption): Promise<Response$readAppsV1NamespacedDaemonSet$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/daemonsets/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            exact: { value: params.parameter.exact, explode: false },
-            export: { value: params.parameter.export, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceAppsV1NamespacedDaemonSet = <ResponseContentType extends ResponseContentType$replaceAppsV1NamespacedDaemonSet>(params: Params$replaceAppsV1NamespacedDaemonSet<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceAppsV1NamespacedDaemonSet$Status$200 | Response$replaceAppsV1NamespacedDaemonSet$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/daemonsets/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteAppsV1NamespacedDaemonSet = <ResponseContentType extends ResponseContentType$deleteAppsV1NamespacedDaemonSet>(params: Params$deleteAppsV1NamespacedDaemonSet<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteAppsV1NamespacedDaemonSet$Status$200 | Response$deleteAppsV1NamespacedDaemonSet$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/daemonsets/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchAppsV1NamespacedDaemonSet = <RequestContentType extends RequestContentType$patchAppsV1NamespacedDaemonSet, ResponseContentType extends ResponseContentType$patchAppsV1NamespacedDaemonSet>(params: Params$patchAppsV1NamespacedDaemonSet<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchAppsV1NamespacedDaemonSet$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/daemonsets/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readAppsV1NamespacedDaemonSetStatus = <ResponseContentType extends ResponseContentType$readAppsV1NamespacedDaemonSetStatus>(params: Params$readAppsV1NamespacedDaemonSetStatus<ResponseContentType>, option?: RequestOption): Promise<Response$readAppsV1NamespacedDaemonSetStatus$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/daemonsets/\${params.parameter.name}/status\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceAppsV1NamespacedDaemonSetStatus = <ResponseContentType extends ResponseContentType$replaceAppsV1NamespacedDaemonSetStatus>(params: Params$replaceAppsV1NamespacedDaemonSetStatus<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceAppsV1NamespacedDaemonSetStatus$Status$200 | Response$replaceAppsV1NamespacedDaemonSetStatus$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/daemonsets/\${params.parameter.name}/status\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchAppsV1NamespacedDaemonSetStatus = <RequestContentType extends RequestContentType$patchAppsV1NamespacedDaemonSetStatus, ResponseContentType extends ResponseContentType$patchAppsV1NamespacedDaemonSetStatus>(params: Params$patchAppsV1NamespacedDaemonSetStatus<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchAppsV1NamespacedDaemonSetStatus$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/daemonsets/\${params.parameter.name}/status\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const listAppsV1NamespacedDeployment = <ResponseContentType extends ResponseContentType$listAppsV1NamespacedDeployment>(params: Params$listAppsV1NamespacedDeployment<ResponseContentType>, option?: RequestOption): Promise<Response$listAppsV1NamespacedDeployment$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/deployments\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const createAppsV1NamespacedDeployment = <ResponseContentType extends ResponseContentType$createAppsV1NamespacedDeployment>(params: Params$createAppsV1NamespacedDeployment<ResponseContentType>, option?: RequestOption): Promise<(Response$createAppsV1NamespacedDeployment$Status$200 | Response$createAppsV1NamespacedDeployment$Status$201 | Response$createAppsV1NamespacedDeployment$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/deployments\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteAppsV1CollectionNamespacedDeployment = <ResponseContentType extends ResponseContentType$deleteAppsV1CollectionNamespacedDeployment>(params: Params$deleteAppsV1CollectionNamespacedDeployment<ResponseContentType>, option?: RequestOption): Promise<Response$deleteAppsV1CollectionNamespacedDeployment$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/deployments\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readAppsV1NamespacedDeployment = <ResponseContentType extends ResponseContentType$readAppsV1NamespacedDeployment>(params: Params$readAppsV1NamespacedDeployment<ResponseContentType>, option?: RequestOption): Promise<Response$readAppsV1NamespacedDeployment$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/deployments/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            exact: { value: params.parameter.exact, explode: false },
-            export: { value: params.parameter.export, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceAppsV1NamespacedDeployment = <ResponseContentType extends ResponseContentType$replaceAppsV1NamespacedDeployment>(params: Params$replaceAppsV1NamespacedDeployment<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceAppsV1NamespacedDeployment$Status$200 | Response$replaceAppsV1NamespacedDeployment$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/deployments/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteAppsV1NamespacedDeployment = <ResponseContentType extends ResponseContentType$deleteAppsV1NamespacedDeployment>(params: Params$deleteAppsV1NamespacedDeployment<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteAppsV1NamespacedDeployment$Status$200 | Response$deleteAppsV1NamespacedDeployment$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/deployments/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchAppsV1NamespacedDeployment = <RequestContentType extends RequestContentType$patchAppsV1NamespacedDeployment, ResponseContentType extends ResponseContentType$patchAppsV1NamespacedDeployment>(params: Params$patchAppsV1NamespacedDeployment<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchAppsV1NamespacedDeployment$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/deployments/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readAppsV1NamespacedDeploymentScale = <ResponseContentType extends ResponseContentType$readAppsV1NamespacedDeploymentScale>(params: Params$readAppsV1NamespacedDeploymentScale<ResponseContentType>, option?: RequestOption): Promise<Response$readAppsV1NamespacedDeploymentScale$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/deployments/\${params.parameter.name}/scale\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceAppsV1NamespacedDeploymentScale = <ResponseContentType extends ResponseContentType$replaceAppsV1NamespacedDeploymentScale>(params: Params$replaceAppsV1NamespacedDeploymentScale<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceAppsV1NamespacedDeploymentScale$Status$200 | Response$replaceAppsV1NamespacedDeploymentScale$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/deployments/\${params.parameter.name}/scale\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchAppsV1NamespacedDeploymentScale = <RequestContentType extends RequestContentType$patchAppsV1NamespacedDeploymentScale, ResponseContentType extends ResponseContentType$patchAppsV1NamespacedDeploymentScale>(params: Params$patchAppsV1NamespacedDeploymentScale<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchAppsV1NamespacedDeploymentScale$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/deployments/\${params.parameter.name}/scale\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readAppsV1NamespacedDeploymentStatus = <ResponseContentType extends ResponseContentType$readAppsV1NamespacedDeploymentStatus>(params: Params$readAppsV1NamespacedDeploymentStatus<ResponseContentType>, option?: RequestOption): Promise<Response$readAppsV1NamespacedDeploymentStatus$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/deployments/\${params.parameter.name}/status\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceAppsV1NamespacedDeploymentStatus = <ResponseContentType extends ResponseContentType$replaceAppsV1NamespacedDeploymentStatus>(params: Params$replaceAppsV1NamespacedDeploymentStatus<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceAppsV1NamespacedDeploymentStatus$Status$200 | Response$replaceAppsV1NamespacedDeploymentStatus$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/deployments/\${params.parameter.name}/status\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchAppsV1NamespacedDeploymentStatus = <RequestContentType extends RequestContentType$patchAppsV1NamespacedDeploymentStatus, ResponseContentType extends ResponseContentType$patchAppsV1NamespacedDeploymentStatus>(params: Params$patchAppsV1NamespacedDeploymentStatus<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchAppsV1NamespacedDeploymentStatus$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/deployments/\${params.parameter.name}/status\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const listAppsV1NamespacedReplicaSet = <ResponseContentType extends ResponseContentType$listAppsV1NamespacedReplicaSet>(params: Params$listAppsV1NamespacedReplicaSet<ResponseContentType>, option?: RequestOption): Promise<Response$listAppsV1NamespacedReplicaSet$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/replicasets\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const createAppsV1NamespacedReplicaSet = <ResponseContentType extends ResponseContentType$createAppsV1NamespacedReplicaSet>(params: Params$createAppsV1NamespacedReplicaSet<ResponseContentType>, option?: RequestOption): Promise<(Response$createAppsV1NamespacedReplicaSet$Status$200 | Response$createAppsV1NamespacedReplicaSet$Status$201 | Response$createAppsV1NamespacedReplicaSet$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/replicasets\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteAppsV1CollectionNamespacedReplicaSet = <ResponseContentType extends ResponseContentType$deleteAppsV1CollectionNamespacedReplicaSet>(params: Params$deleteAppsV1CollectionNamespacedReplicaSet<ResponseContentType>, option?: RequestOption): Promise<Response$deleteAppsV1CollectionNamespacedReplicaSet$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/replicasets\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readAppsV1NamespacedReplicaSet = <ResponseContentType extends ResponseContentType$readAppsV1NamespacedReplicaSet>(params: Params$readAppsV1NamespacedReplicaSet<ResponseContentType>, option?: RequestOption): Promise<Response$readAppsV1NamespacedReplicaSet$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/replicasets/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            exact: { value: params.parameter.exact, explode: false },
-            export: { value: params.parameter.export, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceAppsV1NamespacedReplicaSet = <ResponseContentType extends ResponseContentType$replaceAppsV1NamespacedReplicaSet>(params: Params$replaceAppsV1NamespacedReplicaSet<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceAppsV1NamespacedReplicaSet$Status$200 | Response$replaceAppsV1NamespacedReplicaSet$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/replicasets/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteAppsV1NamespacedReplicaSet = <ResponseContentType extends ResponseContentType$deleteAppsV1NamespacedReplicaSet>(params: Params$deleteAppsV1NamespacedReplicaSet<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteAppsV1NamespacedReplicaSet$Status$200 | Response$deleteAppsV1NamespacedReplicaSet$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/replicasets/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchAppsV1NamespacedReplicaSet = <RequestContentType extends RequestContentType$patchAppsV1NamespacedReplicaSet, ResponseContentType extends ResponseContentType$patchAppsV1NamespacedReplicaSet>(params: Params$patchAppsV1NamespacedReplicaSet<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchAppsV1NamespacedReplicaSet$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/replicasets/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readAppsV1NamespacedReplicaSetScale = <ResponseContentType extends ResponseContentType$readAppsV1NamespacedReplicaSetScale>(params: Params$readAppsV1NamespacedReplicaSetScale<ResponseContentType>, option?: RequestOption): Promise<Response$readAppsV1NamespacedReplicaSetScale$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/replicasets/\${params.parameter.name}/scale\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceAppsV1NamespacedReplicaSetScale = <ResponseContentType extends ResponseContentType$replaceAppsV1NamespacedReplicaSetScale>(params: Params$replaceAppsV1NamespacedReplicaSetScale<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceAppsV1NamespacedReplicaSetScale$Status$200 | Response$replaceAppsV1NamespacedReplicaSetScale$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/replicasets/\${params.parameter.name}/scale\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchAppsV1NamespacedReplicaSetScale = <RequestContentType extends RequestContentType$patchAppsV1NamespacedReplicaSetScale, ResponseContentType extends ResponseContentType$patchAppsV1NamespacedReplicaSetScale>(params: Params$patchAppsV1NamespacedReplicaSetScale<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchAppsV1NamespacedReplicaSetScale$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/replicasets/\${params.parameter.name}/scale\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readAppsV1NamespacedReplicaSetStatus = <ResponseContentType extends ResponseContentType$readAppsV1NamespacedReplicaSetStatus>(params: Params$readAppsV1NamespacedReplicaSetStatus<ResponseContentType>, option?: RequestOption): Promise<Response$readAppsV1NamespacedReplicaSetStatus$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/replicasets/\${params.parameter.name}/status\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceAppsV1NamespacedReplicaSetStatus = <ResponseContentType extends ResponseContentType$replaceAppsV1NamespacedReplicaSetStatus>(params: Params$replaceAppsV1NamespacedReplicaSetStatus<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceAppsV1NamespacedReplicaSetStatus$Status$200 | Response$replaceAppsV1NamespacedReplicaSetStatus$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/replicasets/\${params.parameter.name}/status\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchAppsV1NamespacedReplicaSetStatus = <RequestContentType extends RequestContentType$patchAppsV1NamespacedReplicaSetStatus, ResponseContentType extends ResponseContentType$patchAppsV1NamespacedReplicaSetStatus>(params: Params$patchAppsV1NamespacedReplicaSetStatus<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchAppsV1NamespacedReplicaSetStatus$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/replicasets/\${params.parameter.name}/status\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const listAppsV1NamespacedStatefulSet = <ResponseContentType extends ResponseContentType$listAppsV1NamespacedStatefulSet>(params: Params$listAppsV1NamespacedStatefulSet<ResponseContentType>, option?: RequestOption): Promise<Response$listAppsV1NamespacedStatefulSet$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/statefulsets\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const createAppsV1NamespacedStatefulSet = <ResponseContentType extends ResponseContentType$createAppsV1NamespacedStatefulSet>(params: Params$createAppsV1NamespacedStatefulSet<ResponseContentType>, option?: RequestOption): Promise<(Response$createAppsV1NamespacedStatefulSet$Status$200 | Response$createAppsV1NamespacedStatefulSet$Status$201 | Response$createAppsV1NamespacedStatefulSet$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/statefulsets\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteAppsV1CollectionNamespacedStatefulSet = <ResponseContentType extends ResponseContentType$deleteAppsV1CollectionNamespacedStatefulSet>(params: Params$deleteAppsV1CollectionNamespacedStatefulSet<ResponseContentType>, option?: RequestOption): Promise<Response$deleteAppsV1CollectionNamespacedStatefulSet$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/statefulsets\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readAppsV1NamespacedStatefulSet = <ResponseContentType extends ResponseContentType$readAppsV1NamespacedStatefulSet>(params: Params$readAppsV1NamespacedStatefulSet<ResponseContentType>, option?: RequestOption): Promise<Response$readAppsV1NamespacedStatefulSet$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/statefulsets/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            exact: { value: params.parameter.exact, explode: false },
-            export: { value: params.parameter.export, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceAppsV1NamespacedStatefulSet = <ResponseContentType extends ResponseContentType$replaceAppsV1NamespacedStatefulSet>(params: Params$replaceAppsV1NamespacedStatefulSet<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceAppsV1NamespacedStatefulSet$Status$200 | Response$replaceAppsV1NamespacedStatefulSet$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/statefulsets/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteAppsV1NamespacedStatefulSet = <ResponseContentType extends ResponseContentType$deleteAppsV1NamespacedStatefulSet>(params: Params$deleteAppsV1NamespacedStatefulSet<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteAppsV1NamespacedStatefulSet$Status$200 | Response$deleteAppsV1NamespacedStatefulSet$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/statefulsets/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchAppsV1NamespacedStatefulSet = <RequestContentType extends RequestContentType$patchAppsV1NamespacedStatefulSet, ResponseContentType extends ResponseContentType$patchAppsV1NamespacedStatefulSet>(params: Params$patchAppsV1NamespacedStatefulSet<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchAppsV1NamespacedStatefulSet$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/statefulsets/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readAppsV1NamespacedStatefulSetScale = <ResponseContentType extends ResponseContentType$readAppsV1NamespacedStatefulSetScale>(params: Params$readAppsV1NamespacedStatefulSetScale<ResponseContentType>, option?: RequestOption): Promise<Response$readAppsV1NamespacedStatefulSetScale$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/statefulsets/\${params.parameter.name}/scale\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceAppsV1NamespacedStatefulSetScale = <ResponseContentType extends ResponseContentType$replaceAppsV1NamespacedStatefulSetScale>(params: Params$replaceAppsV1NamespacedStatefulSetScale<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceAppsV1NamespacedStatefulSetScale$Status$200 | Response$replaceAppsV1NamespacedStatefulSetScale$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/statefulsets/\${params.parameter.name}/scale\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchAppsV1NamespacedStatefulSetScale = <RequestContentType extends RequestContentType$patchAppsV1NamespacedStatefulSetScale, ResponseContentType extends ResponseContentType$patchAppsV1NamespacedStatefulSetScale>(params: Params$patchAppsV1NamespacedStatefulSetScale<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchAppsV1NamespacedStatefulSetScale$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/statefulsets/\${params.parameter.name}/scale\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readAppsV1NamespacedStatefulSetStatus = <ResponseContentType extends ResponseContentType$readAppsV1NamespacedStatefulSetStatus>(params: Params$readAppsV1NamespacedStatefulSetStatus<ResponseContentType>, option?: RequestOption): Promise<Response$readAppsV1NamespacedStatefulSetStatus$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/statefulsets/\${params.parameter.name}/status\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceAppsV1NamespacedStatefulSetStatus = <ResponseContentType extends ResponseContentType$replaceAppsV1NamespacedStatefulSetStatus>(params: Params$replaceAppsV1NamespacedStatefulSetStatus<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceAppsV1NamespacedStatefulSetStatus$Status$200 | Response$replaceAppsV1NamespacedStatefulSetStatus$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/statefulsets/\${params.parameter.name}/status\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchAppsV1NamespacedStatefulSetStatus = <RequestContentType extends RequestContentType$patchAppsV1NamespacedStatefulSetStatus, ResponseContentType extends ResponseContentType$patchAppsV1NamespacedStatefulSetStatus>(params: Params$patchAppsV1NamespacedStatefulSetStatus<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchAppsV1NamespacedStatefulSetStatus$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/statefulsets/\${params.parameter.name}/status\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const listAppsV1ReplicaSetForAllNamespaces = <ResponseContentType extends ResponseContentType$listAppsV1ReplicaSetForAllNamespaces>(params: Params$listAppsV1ReplicaSetForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$listAppsV1ReplicaSetForAllNamespaces$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apps/v1/replicasets\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const listAppsV1StatefulSetForAllNamespaces = <ResponseContentType extends ResponseContentType$listAppsV1StatefulSetForAllNamespaces>(params: Params$listAppsV1StatefulSetForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$listAppsV1StatefulSetForAllNamespaces$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apps/v1/statefulsets\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchAppsV1ControllerRevisionListForAllNamespaces = <ResponseContentType extends ResponseContentType$watchAppsV1ControllerRevisionListForAllNamespaces>(params: Params$watchAppsV1ControllerRevisionListForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$watchAppsV1ControllerRevisionListForAllNamespaces$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apps/v1/watch/controllerrevisions\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchAppsV1DaemonSetListForAllNamespaces = <ResponseContentType extends ResponseContentType$watchAppsV1DaemonSetListForAllNamespaces>(params: Params$watchAppsV1DaemonSetListForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$watchAppsV1DaemonSetListForAllNamespaces$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apps/v1/watch/daemonsets\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchAppsV1DeploymentListForAllNamespaces = <ResponseContentType extends ResponseContentType$watchAppsV1DeploymentListForAllNamespaces>(params: Params$watchAppsV1DeploymentListForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$watchAppsV1DeploymentListForAllNamespaces$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apps/v1/watch/deployments\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchAppsV1NamespacedControllerRevisionList = <ResponseContentType extends ResponseContentType$watchAppsV1NamespacedControllerRevisionList>(params: Params$watchAppsV1NamespacedControllerRevisionList<ResponseContentType>, option?: RequestOption): Promise<Response$watchAppsV1NamespacedControllerRevisionList$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apps/v1/watch/namespaces/\${params.parameter.namespace}/controllerrevisions\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchAppsV1NamespacedControllerRevision = <ResponseContentType extends ResponseContentType$watchAppsV1NamespacedControllerRevision>(params: Params$watchAppsV1NamespacedControllerRevision<ResponseContentType>, option?: RequestOption): Promise<Response$watchAppsV1NamespacedControllerRevision$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apps/v1/watch/namespaces/\${params.parameter.namespace}/controllerrevisions/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchAppsV1NamespacedDaemonSetList = <ResponseContentType extends ResponseContentType$watchAppsV1NamespacedDaemonSetList>(params: Params$watchAppsV1NamespacedDaemonSetList<ResponseContentType>, option?: RequestOption): Promise<Response$watchAppsV1NamespacedDaemonSetList$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apps/v1/watch/namespaces/\${params.parameter.namespace}/daemonsets\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchAppsV1NamespacedDaemonSet = <ResponseContentType extends ResponseContentType$watchAppsV1NamespacedDaemonSet>(params: Params$watchAppsV1NamespacedDaemonSet<ResponseContentType>, option?: RequestOption): Promise<Response$watchAppsV1NamespacedDaemonSet$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apps/v1/watch/namespaces/\${params.parameter.namespace}/daemonsets/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchAppsV1NamespacedDeploymentList = <ResponseContentType extends ResponseContentType$watchAppsV1NamespacedDeploymentList>(params: Params$watchAppsV1NamespacedDeploymentList<ResponseContentType>, option?: RequestOption): Promise<Response$watchAppsV1NamespacedDeploymentList$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apps/v1/watch/namespaces/\${params.parameter.namespace}/deployments\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchAppsV1NamespacedDeployment = <ResponseContentType extends ResponseContentType$watchAppsV1NamespacedDeployment>(params: Params$watchAppsV1NamespacedDeployment<ResponseContentType>, option?: RequestOption): Promise<Response$watchAppsV1NamespacedDeployment$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apps/v1/watch/namespaces/\${params.parameter.namespace}/deployments/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchAppsV1NamespacedReplicaSetList = <ResponseContentType extends ResponseContentType$watchAppsV1NamespacedReplicaSetList>(params: Params$watchAppsV1NamespacedReplicaSetList<ResponseContentType>, option?: RequestOption): Promise<Response$watchAppsV1NamespacedReplicaSetList$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apps/v1/watch/namespaces/\${params.parameter.namespace}/replicasets\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchAppsV1NamespacedReplicaSet = <ResponseContentType extends ResponseContentType$watchAppsV1NamespacedReplicaSet>(params: Params$watchAppsV1NamespacedReplicaSet<ResponseContentType>, option?: RequestOption): Promise<Response$watchAppsV1NamespacedReplicaSet$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apps/v1/watch/namespaces/\${params.parameter.namespace}/replicasets/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchAppsV1NamespacedStatefulSetList = <ResponseContentType extends ResponseContentType$watchAppsV1NamespacedStatefulSetList>(params: Params$watchAppsV1NamespacedStatefulSetList<ResponseContentType>, option?: RequestOption): Promise<Response$watchAppsV1NamespacedStatefulSetList$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apps/v1/watch/namespaces/\${params.parameter.namespace}/statefulsets\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchAppsV1NamespacedStatefulSet = <ResponseContentType extends ResponseContentType$watchAppsV1NamespacedStatefulSet>(params: Params$watchAppsV1NamespacedStatefulSet<ResponseContentType>, option?: RequestOption): Promise<Response$watchAppsV1NamespacedStatefulSet$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apps/v1/watch/namespaces/\${params.parameter.namespace}/statefulsets/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchAppsV1ReplicaSetListForAllNamespaces = <ResponseContentType extends ResponseContentType$watchAppsV1ReplicaSetListForAllNamespaces>(params: Params$watchAppsV1ReplicaSetListForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$watchAppsV1ReplicaSetListForAllNamespaces$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apps/v1/watch/replicasets\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchAppsV1StatefulSetListForAllNamespaces = <ResponseContentType extends ResponseContentType$watchAppsV1StatefulSetListForAllNamespaces>(params: Params$watchAppsV1StatefulSetListForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$watchAppsV1StatefulSetListForAllNamespaces$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/apps/v1/watch/statefulsets\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const getAuditregistrationAPIGroup = <ResponseContentType extends ResponseContentType$getAuditregistrationAPIGroup>(params: Params$getAuditregistrationAPIGroup<ResponseContentType>, option?: RequestOption): Promise<Response$getAuditregistrationAPIGroup$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/auditregistration.k8s.io/\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const getAuditregistrationV1alpha1APIResources = <ResponseContentType extends ResponseContentType$getAuditregistrationV1alpha1APIResources>(params: Params$getAuditregistrationV1alpha1APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getAuditregistrationV1alpha1APIResources$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/auditregistration.k8s.io/v1alpha1/\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const listAuditregistrationV1alpha1AuditSink = <ResponseContentType extends ResponseContentType$listAuditregistrationV1alpha1AuditSink>(params: Params$listAuditregistrationV1alpha1AuditSink<ResponseContentType>, option?: RequestOption): Promise<Response$listAuditregistrationV1alpha1AuditSink$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/auditregistration.k8s.io/v1alpha1/auditsinks\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const createAuditregistrationV1alpha1AuditSink = <ResponseContentType extends ResponseContentType$createAuditregistrationV1alpha1AuditSink>(params: Params$createAuditregistrationV1alpha1AuditSink<ResponseContentType>, option?: RequestOption): Promise<(Response$createAuditregistrationV1alpha1AuditSink$Status$200 | Response$createAuditregistrationV1alpha1AuditSink$Status$201 | Response$createAuditregistrationV1alpha1AuditSink$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/auditregistration.k8s.io/v1alpha1/auditsinks\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteAuditregistrationV1alpha1CollectionAuditSink = <ResponseContentType extends ResponseContentType$deleteAuditregistrationV1alpha1CollectionAuditSink>(params: Params$deleteAuditregistrationV1alpha1CollectionAuditSink<ResponseContentType>, option?: RequestOption): Promise<Response$deleteAuditregistrationV1alpha1CollectionAuditSink$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/auditregistration.k8s.io/v1alpha1/auditsinks\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readAuditregistrationV1alpha1AuditSink = <ResponseContentType extends ResponseContentType$readAuditregistrationV1alpha1AuditSink>(params: Params$readAuditregistrationV1alpha1AuditSink<ResponseContentType>, option?: RequestOption): Promise<Response$readAuditregistrationV1alpha1AuditSink$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/auditregistration.k8s.io/v1alpha1/auditsinks/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            exact: { value: params.parameter.exact, explode: false },
-            export: { value: params.parameter.export, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceAuditregistrationV1alpha1AuditSink = <ResponseContentType extends ResponseContentType$replaceAuditregistrationV1alpha1AuditSink>(params: Params$replaceAuditregistrationV1alpha1AuditSink<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceAuditregistrationV1alpha1AuditSink$Status$200 | Response$replaceAuditregistrationV1alpha1AuditSink$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/auditregistration.k8s.io/v1alpha1/auditsinks/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteAuditregistrationV1alpha1AuditSink = <ResponseContentType extends ResponseContentType$deleteAuditregistrationV1alpha1AuditSink>(params: Params$deleteAuditregistrationV1alpha1AuditSink<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteAuditregistrationV1alpha1AuditSink$Status$200 | Response$deleteAuditregistrationV1alpha1AuditSink$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/auditregistration.k8s.io/v1alpha1/auditsinks/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchAuditregistrationV1alpha1AuditSink = <RequestContentType extends RequestContentType$patchAuditregistrationV1alpha1AuditSink, ResponseContentType extends ResponseContentType$patchAuditregistrationV1alpha1AuditSink>(params: Params$patchAuditregistrationV1alpha1AuditSink<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchAuditregistrationV1alpha1AuditSink$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/auditregistration.k8s.io/v1alpha1/auditsinks/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const watchAuditregistrationV1alpha1AuditSinkList = <ResponseContentType extends ResponseContentType$watchAuditregistrationV1alpha1AuditSinkList>(params: Params$watchAuditregistrationV1alpha1AuditSinkList<ResponseContentType>, option?: RequestOption): Promise<Response$watchAuditregistrationV1alpha1AuditSinkList$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/auditregistration.k8s.io/v1alpha1/watch/auditsinks\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchAuditregistrationV1alpha1AuditSink = <ResponseContentType extends ResponseContentType$watchAuditregistrationV1alpha1AuditSink>(params: Params$watchAuditregistrationV1alpha1AuditSink<ResponseContentType>, option?: RequestOption): Promise<Response$watchAuditregistrationV1alpha1AuditSink$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/auditregistration.k8s.io/v1alpha1/watch/auditsinks/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const getAuthenticationAPIGroup = <ResponseContentType extends ResponseContentType$getAuthenticationAPIGroup>(params: Params$getAuthenticationAPIGroup<ResponseContentType>, option?: RequestOption): Promise<Response$getAuthenticationAPIGroup$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/authentication.k8s.io/\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const getAuthenticationV1APIResources = <ResponseContentType extends ResponseContentType$getAuthenticationV1APIResources>(params: Params$getAuthenticationV1APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getAuthenticationV1APIResources$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/authentication.k8s.io/v1/\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const createAuthenticationV1TokenReview = <ResponseContentType extends ResponseContentType$createAuthenticationV1TokenReview>(params: Params$createAuthenticationV1TokenReview<ResponseContentType>, option?: RequestOption): Promise<(Response$createAuthenticationV1TokenReview$Status$200 | Response$createAuthenticationV1TokenReview$Status$201 | Response$createAuthenticationV1TokenReview$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/authentication.k8s.io/v1/tokenreviews\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const getAuthenticationV1beta1APIResources = <ResponseContentType extends ResponseContentType$getAuthenticationV1beta1APIResources>(params: Params$getAuthenticationV1beta1APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getAuthenticationV1beta1APIResources$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/authentication.k8s.io/v1beta1/\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const createAuthenticationV1beta1TokenReview = <ResponseContentType extends ResponseContentType$createAuthenticationV1beta1TokenReview>(params: Params$createAuthenticationV1beta1TokenReview<ResponseContentType>, option?: RequestOption): Promise<(Response$createAuthenticationV1beta1TokenReview$Status$200 | Response$createAuthenticationV1beta1TokenReview$Status$201 | Response$createAuthenticationV1beta1TokenReview$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/authentication.k8s.io/v1beta1/tokenreviews\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const getAuthorizationAPIGroup = <ResponseContentType extends ResponseContentType$getAuthorizationAPIGroup>(params: Params$getAuthorizationAPIGroup<ResponseContentType>, option?: RequestOption): Promise<Response$getAuthorizationAPIGroup$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/authorization.k8s.io/\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const getAuthorizationV1APIResources = <ResponseContentType extends ResponseContentType$getAuthorizationV1APIResources>(params: Params$getAuthorizationV1APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getAuthorizationV1APIResources$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/authorization.k8s.io/v1/\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const createAuthorizationV1NamespacedLocalSubjectAccessReview = <ResponseContentType extends ResponseContentType$createAuthorizationV1NamespacedLocalSubjectAccessReview>(params: Params$createAuthorizationV1NamespacedLocalSubjectAccessReview<ResponseContentType>, option?: RequestOption): Promise<(Response$createAuthorizationV1NamespacedLocalSubjectAccessReview$Status$200 | Response$createAuthorizationV1NamespacedLocalSubjectAccessReview$Status$201 | Response$createAuthorizationV1NamespacedLocalSubjectAccessReview$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/authorization.k8s.io/v1/namespaces/\${params.parameter.namespace}/localsubjectaccessreviews\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const createAuthorizationV1SelfSubjectAccessReview = <ResponseContentType extends ResponseContentType$createAuthorizationV1SelfSubjectAccessReview>(params: Params$createAuthorizationV1SelfSubjectAccessReview<ResponseContentType>, option?: RequestOption): Promise<(Response$createAuthorizationV1SelfSubjectAccessReview$Status$200 | Response$createAuthorizationV1SelfSubjectAccessReview$Status$201 | Response$createAuthorizationV1SelfSubjectAccessReview$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/authorization.k8s.io/v1/selfsubjectaccessreviews\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const createAuthorizationV1SelfSubjectRulesReview = <ResponseContentType extends ResponseContentType$createAuthorizationV1SelfSubjectRulesReview>(params: Params$createAuthorizationV1SelfSubjectRulesReview<ResponseContentType>, option?: RequestOption): Promise<(Response$createAuthorizationV1SelfSubjectRulesReview$Status$200 | Response$createAuthorizationV1SelfSubjectRulesReview$Status$201 | Response$createAuthorizationV1SelfSubjectRulesReview$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/authorization.k8s.io/v1/selfsubjectrulesreviews\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const createAuthorizationV1SubjectAccessReview = <ResponseContentType extends ResponseContentType$createAuthorizationV1SubjectAccessReview>(params: Params$createAuthorizationV1SubjectAccessReview<ResponseContentType>, option?: RequestOption): Promise<(Response$createAuthorizationV1SubjectAccessReview$Status$200 | Response$createAuthorizationV1SubjectAccessReview$Status$201 | Response$createAuthorizationV1SubjectAccessReview$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/authorization.k8s.io/v1/subjectaccessreviews\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const getAuthorizationV1beta1APIResources = <ResponseContentType extends ResponseContentType$getAuthorizationV1beta1APIResources>(params: Params$getAuthorizationV1beta1APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getAuthorizationV1beta1APIResources$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/authorization.k8s.io/v1beta1/\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const createAuthorizationV1beta1NamespacedLocalSubjectAccessReview = <ResponseContentType extends ResponseContentType$createAuthorizationV1beta1NamespacedLocalSubjectAccessReview>(params: Params$createAuthorizationV1beta1NamespacedLocalSubjectAccessReview<ResponseContentType>, option?: RequestOption): Promise<(Response$createAuthorizationV1beta1NamespacedLocalSubjectAccessReview$Status$200 | Response$createAuthorizationV1beta1NamespacedLocalSubjectAccessReview$Status$201 | Response$createAuthorizationV1beta1NamespacedLocalSubjectAccessReview$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/authorization.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/localsubjectaccessreviews\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const createAuthorizationV1beta1SelfSubjectAccessReview = <ResponseContentType extends ResponseContentType$createAuthorizationV1beta1SelfSubjectAccessReview>(params: Params$createAuthorizationV1beta1SelfSubjectAccessReview<ResponseContentType>, option?: RequestOption): Promise<(Response$createAuthorizationV1beta1SelfSubjectAccessReview$Status$200 | Response$createAuthorizationV1beta1SelfSubjectAccessReview$Status$201 | Response$createAuthorizationV1beta1SelfSubjectAccessReview$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/authorization.k8s.io/v1beta1/selfsubjectaccessreviews\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const createAuthorizationV1beta1SelfSubjectRulesReview = <ResponseContentType extends ResponseContentType$createAuthorizationV1beta1SelfSubjectRulesReview>(params: Params$createAuthorizationV1beta1SelfSubjectRulesReview<ResponseContentType>, option?: RequestOption): Promise<(Response$createAuthorizationV1beta1SelfSubjectRulesReview$Status$200 | Response$createAuthorizationV1beta1SelfSubjectRulesReview$Status$201 | Response$createAuthorizationV1beta1SelfSubjectRulesReview$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/authorization.k8s.io/v1beta1/selfsubjectrulesreviews\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const createAuthorizationV1beta1SubjectAccessReview = <ResponseContentType extends ResponseContentType$createAuthorizationV1beta1SubjectAccessReview>(params: Params$createAuthorizationV1beta1SubjectAccessReview<ResponseContentType>, option?: RequestOption): Promise<(Response$createAuthorizationV1beta1SubjectAccessReview$Status$200 | Response$createAuthorizationV1beta1SubjectAccessReview$Status$201 | Response$createAuthorizationV1beta1SubjectAccessReview$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/authorization.k8s.io/v1beta1/subjectaccessreviews\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const getAutoscalingAPIGroup = <ResponseContentType extends ResponseContentType$getAutoscalingAPIGroup>(params: Params$getAutoscalingAPIGroup<ResponseContentType>, option?: RequestOption): Promise<Response$getAutoscalingAPIGroup$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/autoscaling/\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const getAutoscalingV1APIResources = <ResponseContentType extends ResponseContentType$getAutoscalingV1APIResources>(params: Params$getAutoscalingV1APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getAutoscalingV1APIResources$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/autoscaling/v1/\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const listAutoscalingV1HorizontalPodAutoscalerForAllNamespaces = <ResponseContentType extends ResponseContentType$listAutoscalingV1HorizontalPodAutoscalerForAllNamespaces>(params: Params$listAutoscalingV1HorizontalPodAutoscalerForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$listAutoscalingV1HorizontalPodAutoscalerForAllNamespaces$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/autoscaling/v1/horizontalpodautoscalers\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const listAutoscalingV1NamespacedHorizontalPodAutoscaler = <ResponseContentType extends ResponseContentType$listAutoscalingV1NamespacedHorizontalPodAutoscaler>(params: Params$listAutoscalingV1NamespacedHorizontalPodAutoscaler<ResponseContentType>, option?: RequestOption): Promise<Response$listAutoscalingV1NamespacedHorizontalPodAutoscaler$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/autoscaling/v1/namespaces/\${params.parameter.namespace}/horizontalpodautoscalers\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const createAutoscalingV1NamespacedHorizontalPodAutoscaler = <ResponseContentType extends ResponseContentType$createAutoscalingV1NamespacedHorizontalPodAutoscaler>(params: Params$createAutoscalingV1NamespacedHorizontalPodAutoscaler<ResponseContentType>, option?: RequestOption): Promise<(Response$createAutoscalingV1NamespacedHorizontalPodAutoscaler$Status$200 | Response$createAutoscalingV1NamespacedHorizontalPodAutoscaler$Status$201 | Response$createAutoscalingV1NamespacedHorizontalPodAutoscaler$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/autoscaling/v1/namespaces/\${params.parameter.namespace}/horizontalpodautoscalers\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteAutoscalingV1CollectionNamespacedHorizontalPodAutoscaler = <ResponseContentType extends ResponseContentType$deleteAutoscalingV1CollectionNamespacedHorizontalPodAutoscaler>(params: Params$deleteAutoscalingV1CollectionNamespacedHorizontalPodAutoscaler<ResponseContentType>, option?: RequestOption): Promise<Response$deleteAutoscalingV1CollectionNamespacedHorizontalPodAutoscaler$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/autoscaling/v1/namespaces/\${params.parameter.namespace}/horizontalpodautoscalers\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readAutoscalingV1NamespacedHorizontalPodAutoscaler = <ResponseContentType extends ResponseContentType$readAutoscalingV1NamespacedHorizontalPodAutoscaler>(params: Params$readAutoscalingV1NamespacedHorizontalPodAutoscaler<ResponseContentType>, option?: RequestOption): Promise<Response$readAutoscalingV1NamespacedHorizontalPodAutoscaler$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/autoscaling/v1/namespaces/\${params.parameter.namespace}/horizontalpodautoscalers/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            exact: { value: params.parameter.exact, explode: false },
-            export: { value: params.parameter.export, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceAutoscalingV1NamespacedHorizontalPodAutoscaler = <ResponseContentType extends ResponseContentType$replaceAutoscalingV1NamespacedHorizontalPodAutoscaler>(params: Params$replaceAutoscalingV1NamespacedHorizontalPodAutoscaler<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceAutoscalingV1NamespacedHorizontalPodAutoscaler$Status$200 | Response$replaceAutoscalingV1NamespacedHorizontalPodAutoscaler$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/autoscaling/v1/namespaces/\${params.parameter.namespace}/horizontalpodautoscalers/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteAutoscalingV1NamespacedHorizontalPodAutoscaler = <ResponseContentType extends ResponseContentType$deleteAutoscalingV1NamespacedHorizontalPodAutoscaler>(params: Params$deleteAutoscalingV1NamespacedHorizontalPodAutoscaler<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteAutoscalingV1NamespacedHorizontalPodAutoscaler$Status$200 | Response$deleteAutoscalingV1NamespacedHorizontalPodAutoscaler$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/autoscaling/v1/namespaces/\${params.parameter.namespace}/horizontalpodautoscalers/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchAutoscalingV1NamespacedHorizontalPodAutoscaler = <RequestContentType extends RequestContentType$patchAutoscalingV1NamespacedHorizontalPodAutoscaler, ResponseContentType extends ResponseContentType$patchAutoscalingV1NamespacedHorizontalPodAutoscaler>(params: Params$patchAutoscalingV1NamespacedHorizontalPodAutoscaler<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchAutoscalingV1NamespacedHorizontalPodAutoscaler$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/autoscaling/v1/namespaces/\${params.parameter.namespace}/horizontalpodautoscalers/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readAutoscalingV1NamespacedHorizontalPodAutoscalerStatus = <ResponseContentType extends ResponseContentType$readAutoscalingV1NamespacedHorizontalPodAutoscalerStatus>(params: Params$readAutoscalingV1NamespacedHorizontalPodAutoscalerStatus<ResponseContentType>, option?: RequestOption): Promise<Response$readAutoscalingV1NamespacedHorizontalPodAutoscalerStatus$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/autoscaling/v1/namespaces/\${params.parameter.namespace}/horizontalpodautoscalers/\${params.parameter.name}/status\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceAutoscalingV1NamespacedHorizontalPodAutoscalerStatus = <ResponseContentType extends ResponseContentType$replaceAutoscalingV1NamespacedHorizontalPodAutoscalerStatus>(params: Params$replaceAutoscalingV1NamespacedHorizontalPodAutoscalerStatus<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceAutoscalingV1NamespacedHorizontalPodAutoscalerStatus$Status$200 | Response$replaceAutoscalingV1NamespacedHorizontalPodAutoscalerStatus$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/autoscaling/v1/namespaces/\${params.parameter.namespace}/horizontalpodautoscalers/\${params.parameter.name}/status\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchAutoscalingV1NamespacedHorizontalPodAutoscalerStatus = <RequestContentType extends RequestContentType$patchAutoscalingV1NamespacedHorizontalPodAutoscalerStatus, ResponseContentType extends ResponseContentType$patchAutoscalingV1NamespacedHorizontalPodAutoscalerStatus>(params: Params$patchAutoscalingV1NamespacedHorizontalPodAutoscalerStatus<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchAutoscalingV1NamespacedHorizontalPodAutoscalerStatus$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/autoscaling/v1/namespaces/\${params.parameter.namespace}/horizontalpodautoscalers/\${params.parameter.name}/status\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const watchAutoscalingV1HorizontalPodAutoscalerListForAllNamespaces = <ResponseContentType extends ResponseContentType$watchAutoscalingV1HorizontalPodAutoscalerListForAllNamespaces>(params: Params$watchAutoscalingV1HorizontalPodAutoscalerListForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$watchAutoscalingV1HorizontalPodAutoscalerListForAllNamespaces$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/autoscaling/v1/watch/horizontalpodautoscalers\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchAutoscalingV1NamespacedHorizontalPodAutoscalerList = <ResponseContentType extends ResponseContentType$watchAutoscalingV1NamespacedHorizontalPodAutoscalerList>(params: Params$watchAutoscalingV1NamespacedHorizontalPodAutoscalerList<ResponseContentType>, option?: RequestOption): Promise<Response$watchAutoscalingV1NamespacedHorizontalPodAutoscalerList$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/autoscaling/v1/watch/namespaces/\${params.parameter.namespace}/horizontalpodautoscalers\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchAutoscalingV1NamespacedHorizontalPodAutoscaler = <ResponseContentType extends ResponseContentType$watchAutoscalingV1NamespacedHorizontalPodAutoscaler>(params: Params$watchAutoscalingV1NamespacedHorizontalPodAutoscaler<ResponseContentType>, option?: RequestOption): Promise<Response$watchAutoscalingV1NamespacedHorizontalPodAutoscaler$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/autoscaling/v1/watch/namespaces/\${params.parameter.namespace}/horizontalpodautoscalers/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const getAutoscalingV2beta1APIResources = <ResponseContentType extends ResponseContentType$getAutoscalingV2beta1APIResources>(params: Params$getAutoscalingV2beta1APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getAutoscalingV2beta1APIResources$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/autoscaling/v2beta1/\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const listAutoscalingV2beta1HorizontalPodAutoscalerForAllNamespaces = <ResponseContentType extends ResponseContentType$listAutoscalingV2beta1HorizontalPodAutoscalerForAllNamespaces>(params: Params$listAutoscalingV2beta1HorizontalPodAutoscalerForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$listAutoscalingV2beta1HorizontalPodAutoscalerForAllNamespaces$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/autoscaling/v2beta1/horizontalpodautoscalers\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const listAutoscalingV2beta1NamespacedHorizontalPodAutoscaler = <ResponseContentType extends ResponseContentType$listAutoscalingV2beta1NamespacedHorizontalPodAutoscaler>(params: Params$listAutoscalingV2beta1NamespacedHorizontalPodAutoscaler<ResponseContentType>, option?: RequestOption): Promise<Response$listAutoscalingV2beta1NamespacedHorizontalPodAutoscaler$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/autoscaling/v2beta1/namespaces/\${params.parameter.namespace}/horizontalpodautoscalers\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const createAutoscalingV2beta1NamespacedHorizontalPodAutoscaler = <ResponseContentType extends ResponseContentType$createAutoscalingV2beta1NamespacedHorizontalPodAutoscaler>(params: Params$createAutoscalingV2beta1NamespacedHorizontalPodAutoscaler<ResponseContentType>, option?: RequestOption): Promise<(Response$createAutoscalingV2beta1NamespacedHorizontalPodAutoscaler$Status$200 | Response$createAutoscalingV2beta1NamespacedHorizontalPodAutoscaler$Status$201 | Response$createAutoscalingV2beta1NamespacedHorizontalPodAutoscaler$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/autoscaling/v2beta1/namespaces/\${params.parameter.namespace}/horizontalpodautoscalers\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteAutoscalingV2beta1CollectionNamespacedHorizontalPodAutoscaler = <ResponseContentType extends ResponseContentType$deleteAutoscalingV2beta1CollectionNamespacedHorizontalPodAutoscaler>(params: Params$deleteAutoscalingV2beta1CollectionNamespacedHorizontalPodAutoscaler<ResponseContentType>, option?: RequestOption): Promise<Response$deleteAutoscalingV2beta1CollectionNamespacedHorizontalPodAutoscaler$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/autoscaling/v2beta1/namespaces/\${params.parameter.namespace}/horizontalpodautoscalers\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readAutoscalingV2beta1NamespacedHorizontalPodAutoscaler = <ResponseContentType extends ResponseContentType$readAutoscalingV2beta1NamespacedHorizontalPodAutoscaler>(params: Params$readAutoscalingV2beta1NamespacedHorizontalPodAutoscaler<ResponseContentType>, option?: RequestOption): Promise<Response$readAutoscalingV2beta1NamespacedHorizontalPodAutoscaler$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/autoscaling/v2beta1/namespaces/\${params.parameter.namespace}/horizontalpodautoscalers/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            exact: { value: params.parameter.exact, explode: false },
-            export: { value: params.parameter.export, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceAutoscalingV2beta1NamespacedHorizontalPodAutoscaler = <ResponseContentType extends ResponseContentType$replaceAutoscalingV2beta1NamespacedHorizontalPodAutoscaler>(params: Params$replaceAutoscalingV2beta1NamespacedHorizontalPodAutoscaler<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceAutoscalingV2beta1NamespacedHorizontalPodAutoscaler$Status$200 | Response$replaceAutoscalingV2beta1NamespacedHorizontalPodAutoscaler$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/autoscaling/v2beta1/namespaces/\${params.parameter.namespace}/horizontalpodautoscalers/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteAutoscalingV2beta1NamespacedHorizontalPodAutoscaler = <ResponseContentType extends ResponseContentType$deleteAutoscalingV2beta1NamespacedHorizontalPodAutoscaler>(params: Params$deleteAutoscalingV2beta1NamespacedHorizontalPodAutoscaler<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteAutoscalingV2beta1NamespacedHorizontalPodAutoscaler$Status$200 | Response$deleteAutoscalingV2beta1NamespacedHorizontalPodAutoscaler$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/autoscaling/v2beta1/namespaces/\${params.parameter.namespace}/horizontalpodautoscalers/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchAutoscalingV2beta1NamespacedHorizontalPodAutoscaler = <RequestContentType extends RequestContentType$patchAutoscalingV2beta1NamespacedHorizontalPodAutoscaler, ResponseContentType extends ResponseContentType$patchAutoscalingV2beta1NamespacedHorizontalPodAutoscaler>(params: Params$patchAutoscalingV2beta1NamespacedHorizontalPodAutoscaler<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchAutoscalingV2beta1NamespacedHorizontalPodAutoscaler$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/autoscaling/v2beta1/namespaces/\${params.parameter.namespace}/horizontalpodautoscalers/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readAutoscalingV2beta1NamespacedHorizontalPodAutoscalerStatus = <ResponseContentType extends ResponseContentType$readAutoscalingV2beta1NamespacedHorizontalPodAutoscalerStatus>(params: Params$readAutoscalingV2beta1NamespacedHorizontalPodAutoscalerStatus<ResponseContentType>, option?: RequestOption): Promise<Response$readAutoscalingV2beta1NamespacedHorizontalPodAutoscalerStatus$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/autoscaling/v2beta1/namespaces/\${params.parameter.namespace}/horizontalpodautoscalers/\${params.parameter.name}/status\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceAutoscalingV2beta1NamespacedHorizontalPodAutoscalerStatus = <ResponseContentType extends ResponseContentType$replaceAutoscalingV2beta1NamespacedHorizontalPodAutoscalerStatus>(params: Params$replaceAutoscalingV2beta1NamespacedHorizontalPodAutoscalerStatus<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceAutoscalingV2beta1NamespacedHorizontalPodAutoscalerStatus$Status$200 | Response$replaceAutoscalingV2beta1NamespacedHorizontalPodAutoscalerStatus$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/autoscaling/v2beta1/namespaces/\${params.parameter.namespace}/horizontalpodautoscalers/\${params.parameter.name}/status\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchAutoscalingV2beta1NamespacedHorizontalPodAutoscalerStatus = <RequestContentType extends RequestContentType$patchAutoscalingV2beta1NamespacedHorizontalPodAutoscalerStatus, ResponseContentType extends ResponseContentType$patchAutoscalingV2beta1NamespacedHorizontalPodAutoscalerStatus>(params: Params$patchAutoscalingV2beta1NamespacedHorizontalPodAutoscalerStatus<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchAutoscalingV2beta1NamespacedHorizontalPodAutoscalerStatus$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/autoscaling/v2beta1/namespaces/\${params.parameter.namespace}/horizontalpodautoscalers/\${params.parameter.name}/status\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const watchAutoscalingV2beta1HorizontalPodAutoscalerListForAllNamespaces = <ResponseContentType extends ResponseContentType$watchAutoscalingV2beta1HorizontalPodAutoscalerListForAllNamespaces>(params: Params$watchAutoscalingV2beta1HorizontalPodAutoscalerListForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$watchAutoscalingV2beta1HorizontalPodAutoscalerListForAllNamespaces$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/autoscaling/v2beta1/watch/horizontalpodautoscalers\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchAutoscalingV2beta1NamespacedHorizontalPodAutoscalerList = <ResponseContentType extends ResponseContentType$watchAutoscalingV2beta1NamespacedHorizontalPodAutoscalerList>(params: Params$watchAutoscalingV2beta1NamespacedHorizontalPodAutoscalerList<ResponseContentType>, option?: RequestOption): Promise<Response$watchAutoscalingV2beta1NamespacedHorizontalPodAutoscalerList$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/autoscaling/v2beta1/watch/namespaces/\${params.parameter.namespace}/horizontalpodautoscalers\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchAutoscalingV2beta1NamespacedHorizontalPodAutoscaler = <ResponseContentType extends ResponseContentType$watchAutoscalingV2beta1NamespacedHorizontalPodAutoscaler>(params: Params$watchAutoscalingV2beta1NamespacedHorizontalPodAutoscaler<ResponseContentType>, option?: RequestOption): Promise<Response$watchAutoscalingV2beta1NamespacedHorizontalPodAutoscaler$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/autoscaling/v2beta1/watch/namespaces/\${params.parameter.namespace}/horizontalpodautoscalers/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const getAutoscalingV2beta2APIResources = <ResponseContentType extends ResponseContentType$getAutoscalingV2beta2APIResources>(params: Params$getAutoscalingV2beta2APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getAutoscalingV2beta2APIResources$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/autoscaling/v2beta2/\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const listAutoscalingV2beta2HorizontalPodAutoscalerForAllNamespaces = <ResponseContentType extends ResponseContentType$listAutoscalingV2beta2HorizontalPodAutoscalerForAllNamespaces>(params: Params$listAutoscalingV2beta2HorizontalPodAutoscalerForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$listAutoscalingV2beta2HorizontalPodAutoscalerForAllNamespaces$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/autoscaling/v2beta2/horizontalpodautoscalers\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const listAutoscalingV2beta2NamespacedHorizontalPodAutoscaler = <ResponseContentType extends ResponseContentType$listAutoscalingV2beta2NamespacedHorizontalPodAutoscaler>(params: Params$listAutoscalingV2beta2NamespacedHorizontalPodAutoscaler<ResponseContentType>, option?: RequestOption): Promise<Response$listAutoscalingV2beta2NamespacedHorizontalPodAutoscaler$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/autoscaling/v2beta2/namespaces/\${params.parameter.namespace}/horizontalpodautoscalers\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const createAutoscalingV2beta2NamespacedHorizontalPodAutoscaler = <ResponseContentType extends ResponseContentType$createAutoscalingV2beta2NamespacedHorizontalPodAutoscaler>(params: Params$createAutoscalingV2beta2NamespacedHorizontalPodAutoscaler<ResponseContentType>, option?: RequestOption): Promise<(Response$createAutoscalingV2beta2NamespacedHorizontalPodAutoscaler$Status$200 | Response$createAutoscalingV2beta2NamespacedHorizontalPodAutoscaler$Status$201 | Response$createAutoscalingV2beta2NamespacedHorizontalPodAutoscaler$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/autoscaling/v2beta2/namespaces/\${params.parameter.namespace}/horizontalpodautoscalers\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteAutoscalingV2beta2CollectionNamespacedHorizontalPodAutoscaler = <ResponseContentType extends ResponseContentType$deleteAutoscalingV2beta2CollectionNamespacedHorizontalPodAutoscaler>(params: Params$deleteAutoscalingV2beta2CollectionNamespacedHorizontalPodAutoscaler<ResponseContentType>, option?: RequestOption): Promise<Response$deleteAutoscalingV2beta2CollectionNamespacedHorizontalPodAutoscaler$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/autoscaling/v2beta2/namespaces/\${params.parameter.namespace}/horizontalpodautoscalers\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readAutoscalingV2beta2NamespacedHorizontalPodAutoscaler = <ResponseContentType extends ResponseContentType$readAutoscalingV2beta2NamespacedHorizontalPodAutoscaler>(params: Params$readAutoscalingV2beta2NamespacedHorizontalPodAutoscaler<ResponseContentType>, option?: RequestOption): Promise<Response$readAutoscalingV2beta2NamespacedHorizontalPodAutoscaler$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/autoscaling/v2beta2/namespaces/\${params.parameter.namespace}/horizontalpodautoscalers/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            exact: { value: params.parameter.exact, explode: false },
-            export: { value: params.parameter.export, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceAutoscalingV2beta2NamespacedHorizontalPodAutoscaler = <ResponseContentType extends ResponseContentType$replaceAutoscalingV2beta2NamespacedHorizontalPodAutoscaler>(params: Params$replaceAutoscalingV2beta2NamespacedHorizontalPodAutoscaler<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceAutoscalingV2beta2NamespacedHorizontalPodAutoscaler$Status$200 | Response$replaceAutoscalingV2beta2NamespacedHorizontalPodAutoscaler$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/autoscaling/v2beta2/namespaces/\${params.parameter.namespace}/horizontalpodautoscalers/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteAutoscalingV2beta2NamespacedHorizontalPodAutoscaler = <ResponseContentType extends ResponseContentType$deleteAutoscalingV2beta2NamespacedHorizontalPodAutoscaler>(params: Params$deleteAutoscalingV2beta2NamespacedHorizontalPodAutoscaler<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteAutoscalingV2beta2NamespacedHorizontalPodAutoscaler$Status$200 | Response$deleteAutoscalingV2beta2NamespacedHorizontalPodAutoscaler$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/autoscaling/v2beta2/namespaces/\${params.parameter.namespace}/horizontalpodautoscalers/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchAutoscalingV2beta2NamespacedHorizontalPodAutoscaler = <RequestContentType extends RequestContentType$patchAutoscalingV2beta2NamespacedHorizontalPodAutoscaler, ResponseContentType extends ResponseContentType$patchAutoscalingV2beta2NamespacedHorizontalPodAutoscaler>(params: Params$patchAutoscalingV2beta2NamespacedHorizontalPodAutoscaler<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchAutoscalingV2beta2NamespacedHorizontalPodAutoscaler$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/autoscaling/v2beta2/namespaces/\${params.parameter.namespace}/horizontalpodautoscalers/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readAutoscalingV2beta2NamespacedHorizontalPodAutoscalerStatus = <ResponseContentType extends ResponseContentType$readAutoscalingV2beta2NamespacedHorizontalPodAutoscalerStatus>(params: Params$readAutoscalingV2beta2NamespacedHorizontalPodAutoscalerStatus<ResponseContentType>, option?: RequestOption): Promise<Response$readAutoscalingV2beta2NamespacedHorizontalPodAutoscalerStatus$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/autoscaling/v2beta2/namespaces/\${params.parameter.namespace}/horizontalpodautoscalers/\${params.parameter.name}/status\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceAutoscalingV2beta2NamespacedHorizontalPodAutoscalerStatus = <ResponseContentType extends ResponseContentType$replaceAutoscalingV2beta2NamespacedHorizontalPodAutoscalerStatus>(params: Params$replaceAutoscalingV2beta2NamespacedHorizontalPodAutoscalerStatus<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceAutoscalingV2beta2NamespacedHorizontalPodAutoscalerStatus$Status$200 | Response$replaceAutoscalingV2beta2NamespacedHorizontalPodAutoscalerStatus$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/autoscaling/v2beta2/namespaces/\${params.parameter.namespace}/horizontalpodautoscalers/\${params.parameter.name}/status\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchAutoscalingV2beta2NamespacedHorizontalPodAutoscalerStatus = <RequestContentType extends RequestContentType$patchAutoscalingV2beta2NamespacedHorizontalPodAutoscalerStatus, ResponseContentType extends ResponseContentType$patchAutoscalingV2beta2NamespacedHorizontalPodAutoscalerStatus>(params: Params$patchAutoscalingV2beta2NamespacedHorizontalPodAutoscalerStatus<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchAutoscalingV2beta2NamespacedHorizontalPodAutoscalerStatus$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/autoscaling/v2beta2/namespaces/\${params.parameter.namespace}/horizontalpodautoscalers/\${params.parameter.name}/status\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const watchAutoscalingV2beta2HorizontalPodAutoscalerListForAllNamespaces = <ResponseContentType extends ResponseContentType$watchAutoscalingV2beta2HorizontalPodAutoscalerListForAllNamespaces>(params: Params$watchAutoscalingV2beta2HorizontalPodAutoscalerListForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$watchAutoscalingV2beta2HorizontalPodAutoscalerListForAllNamespaces$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/autoscaling/v2beta2/watch/horizontalpodautoscalers\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchAutoscalingV2beta2NamespacedHorizontalPodAutoscalerList = <ResponseContentType extends ResponseContentType$watchAutoscalingV2beta2NamespacedHorizontalPodAutoscalerList>(params: Params$watchAutoscalingV2beta2NamespacedHorizontalPodAutoscalerList<ResponseContentType>, option?: RequestOption): Promise<Response$watchAutoscalingV2beta2NamespacedHorizontalPodAutoscalerList$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/autoscaling/v2beta2/watch/namespaces/\${params.parameter.namespace}/horizontalpodautoscalers\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchAutoscalingV2beta2NamespacedHorizontalPodAutoscaler = <ResponseContentType extends ResponseContentType$watchAutoscalingV2beta2NamespacedHorizontalPodAutoscaler>(params: Params$watchAutoscalingV2beta2NamespacedHorizontalPodAutoscaler<ResponseContentType>, option?: RequestOption): Promise<Response$watchAutoscalingV2beta2NamespacedHorizontalPodAutoscaler$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/autoscaling/v2beta2/watch/namespaces/\${params.parameter.namespace}/horizontalpodautoscalers/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const getBatchAPIGroup = <ResponseContentType extends ResponseContentType$getBatchAPIGroup>(params: Params$getBatchAPIGroup<ResponseContentType>, option?: RequestOption): Promise<Response$getBatchAPIGroup$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/batch/\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const getBatchV1APIResources = <ResponseContentType extends ResponseContentType$getBatchV1APIResources>(params: Params$getBatchV1APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getBatchV1APIResources$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/batch/v1/\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const listBatchV1JobForAllNamespaces = <ResponseContentType extends ResponseContentType$listBatchV1JobForAllNamespaces>(params: Params$listBatchV1JobForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$listBatchV1JobForAllNamespaces$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/batch/v1/jobs\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const listBatchV1NamespacedJob = <ResponseContentType extends ResponseContentType$listBatchV1NamespacedJob>(params: Params$listBatchV1NamespacedJob<ResponseContentType>, option?: RequestOption): Promise<Response$listBatchV1NamespacedJob$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/batch/v1/namespaces/\${params.parameter.namespace}/jobs\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const createBatchV1NamespacedJob = <ResponseContentType extends ResponseContentType$createBatchV1NamespacedJob>(params: Params$createBatchV1NamespacedJob<ResponseContentType>, option?: RequestOption): Promise<(Response$createBatchV1NamespacedJob$Status$200 | Response$createBatchV1NamespacedJob$Status$201 | Response$createBatchV1NamespacedJob$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/batch/v1/namespaces/\${params.parameter.namespace}/jobs\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteBatchV1CollectionNamespacedJob = <ResponseContentType extends ResponseContentType$deleteBatchV1CollectionNamespacedJob>(params: Params$deleteBatchV1CollectionNamespacedJob<ResponseContentType>, option?: RequestOption): Promise<Response$deleteBatchV1CollectionNamespacedJob$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/batch/v1/namespaces/\${params.parameter.namespace}/jobs\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readBatchV1NamespacedJob = <ResponseContentType extends ResponseContentType$readBatchV1NamespacedJob>(params: Params$readBatchV1NamespacedJob<ResponseContentType>, option?: RequestOption): Promise<Response$readBatchV1NamespacedJob$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/batch/v1/namespaces/\${params.parameter.namespace}/jobs/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            exact: { value: params.parameter.exact, explode: false },
-            export: { value: params.parameter.export, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceBatchV1NamespacedJob = <ResponseContentType extends ResponseContentType$replaceBatchV1NamespacedJob>(params: Params$replaceBatchV1NamespacedJob<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceBatchV1NamespacedJob$Status$200 | Response$replaceBatchV1NamespacedJob$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/batch/v1/namespaces/\${params.parameter.namespace}/jobs/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteBatchV1NamespacedJob = <ResponseContentType extends ResponseContentType$deleteBatchV1NamespacedJob>(params: Params$deleteBatchV1NamespacedJob<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteBatchV1NamespacedJob$Status$200 | Response$deleteBatchV1NamespacedJob$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/batch/v1/namespaces/\${params.parameter.namespace}/jobs/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchBatchV1NamespacedJob = <RequestContentType extends RequestContentType$patchBatchV1NamespacedJob, ResponseContentType extends ResponseContentType$patchBatchV1NamespacedJob>(params: Params$patchBatchV1NamespacedJob<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchBatchV1NamespacedJob$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/batch/v1/namespaces/\${params.parameter.namespace}/jobs/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readBatchV1NamespacedJobStatus = <ResponseContentType extends ResponseContentType$readBatchV1NamespacedJobStatus>(params: Params$readBatchV1NamespacedJobStatus<ResponseContentType>, option?: RequestOption): Promise<Response$readBatchV1NamespacedJobStatus$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/batch/v1/namespaces/\${params.parameter.namespace}/jobs/\${params.parameter.name}/status\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceBatchV1NamespacedJobStatus = <ResponseContentType extends ResponseContentType$replaceBatchV1NamespacedJobStatus>(params: Params$replaceBatchV1NamespacedJobStatus<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceBatchV1NamespacedJobStatus$Status$200 | Response$replaceBatchV1NamespacedJobStatus$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/batch/v1/namespaces/\${params.parameter.namespace}/jobs/\${params.parameter.name}/status\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchBatchV1NamespacedJobStatus = <RequestContentType extends RequestContentType$patchBatchV1NamespacedJobStatus, ResponseContentType extends ResponseContentType$patchBatchV1NamespacedJobStatus>(params: Params$patchBatchV1NamespacedJobStatus<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchBatchV1NamespacedJobStatus$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/batch/v1/namespaces/\${params.parameter.namespace}/jobs/\${params.parameter.name}/status\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const watchBatchV1JobListForAllNamespaces = <ResponseContentType extends ResponseContentType$watchBatchV1JobListForAllNamespaces>(params: Params$watchBatchV1JobListForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$watchBatchV1JobListForAllNamespaces$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/batch/v1/watch/jobs\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchBatchV1NamespacedJobList = <ResponseContentType extends ResponseContentType$watchBatchV1NamespacedJobList>(params: Params$watchBatchV1NamespacedJobList<ResponseContentType>, option?: RequestOption): Promise<Response$watchBatchV1NamespacedJobList$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/batch/v1/watch/namespaces/\${params.parameter.namespace}/jobs\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchBatchV1NamespacedJob = <ResponseContentType extends ResponseContentType$watchBatchV1NamespacedJob>(params: Params$watchBatchV1NamespacedJob<ResponseContentType>, option?: RequestOption): Promise<Response$watchBatchV1NamespacedJob$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/batch/v1/watch/namespaces/\${params.parameter.namespace}/jobs/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const getBatchV1beta1APIResources = <ResponseContentType extends ResponseContentType$getBatchV1beta1APIResources>(params: Params$getBatchV1beta1APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getBatchV1beta1APIResources$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/batch/v1beta1/\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const listBatchV1beta1CronJobForAllNamespaces = <ResponseContentType extends ResponseContentType$listBatchV1beta1CronJobForAllNamespaces>(params: Params$listBatchV1beta1CronJobForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$listBatchV1beta1CronJobForAllNamespaces$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/batch/v1beta1/cronjobs\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const listBatchV1beta1NamespacedCronJob = <ResponseContentType extends ResponseContentType$listBatchV1beta1NamespacedCronJob>(params: Params$listBatchV1beta1NamespacedCronJob<ResponseContentType>, option?: RequestOption): Promise<Response$listBatchV1beta1NamespacedCronJob$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/batch/v1beta1/namespaces/\${params.parameter.namespace}/cronjobs\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const createBatchV1beta1NamespacedCronJob = <ResponseContentType extends ResponseContentType$createBatchV1beta1NamespacedCronJob>(params: Params$createBatchV1beta1NamespacedCronJob<ResponseContentType>, option?: RequestOption): Promise<(Response$createBatchV1beta1NamespacedCronJob$Status$200 | Response$createBatchV1beta1NamespacedCronJob$Status$201 | Response$createBatchV1beta1NamespacedCronJob$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/batch/v1beta1/namespaces/\${params.parameter.namespace}/cronjobs\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteBatchV1beta1CollectionNamespacedCronJob = <ResponseContentType extends ResponseContentType$deleteBatchV1beta1CollectionNamespacedCronJob>(params: Params$deleteBatchV1beta1CollectionNamespacedCronJob<ResponseContentType>, option?: RequestOption): Promise<Response$deleteBatchV1beta1CollectionNamespacedCronJob$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/batch/v1beta1/namespaces/\${params.parameter.namespace}/cronjobs\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readBatchV1beta1NamespacedCronJob = <ResponseContentType extends ResponseContentType$readBatchV1beta1NamespacedCronJob>(params: Params$readBatchV1beta1NamespacedCronJob<ResponseContentType>, option?: RequestOption): Promise<Response$readBatchV1beta1NamespacedCronJob$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/batch/v1beta1/namespaces/\${params.parameter.namespace}/cronjobs/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            exact: { value: params.parameter.exact, explode: false },
-            export: { value: params.parameter.export, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceBatchV1beta1NamespacedCronJob = <ResponseContentType extends ResponseContentType$replaceBatchV1beta1NamespacedCronJob>(params: Params$replaceBatchV1beta1NamespacedCronJob<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceBatchV1beta1NamespacedCronJob$Status$200 | Response$replaceBatchV1beta1NamespacedCronJob$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/batch/v1beta1/namespaces/\${params.parameter.namespace}/cronjobs/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteBatchV1beta1NamespacedCronJob = <ResponseContentType extends ResponseContentType$deleteBatchV1beta1NamespacedCronJob>(params: Params$deleteBatchV1beta1NamespacedCronJob<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteBatchV1beta1NamespacedCronJob$Status$200 | Response$deleteBatchV1beta1NamespacedCronJob$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/batch/v1beta1/namespaces/\${params.parameter.namespace}/cronjobs/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchBatchV1beta1NamespacedCronJob = <RequestContentType extends RequestContentType$patchBatchV1beta1NamespacedCronJob, ResponseContentType extends ResponseContentType$patchBatchV1beta1NamespacedCronJob>(params: Params$patchBatchV1beta1NamespacedCronJob<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchBatchV1beta1NamespacedCronJob$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/batch/v1beta1/namespaces/\${params.parameter.namespace}/cronjobs/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readBatchV1beta1NamespacedCronJobStatus = <ResponseContentType extends ResponseContentType$readBatchV1beta1NamespacedCronJobStatus>(params: Params$readBatchV1beta1NamespacedCronJobStatus<ResponseContentType>, option?: RequestOption): Promise<Response$readBatchV1beta1NamespacedCronJobStatus$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/batch/v1beta1/namespaces/\${params.parameter.namespace}/cronjobs/\${params.parameter.name}/status\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceBatchV1beta1NamespacedCronJobStatus = <ResponseContentType extends ResponseContentType$replaceBatchV1beta1NamespacedCronJobStatus>(params: Params$replaceBatchV1beta1NamespacedCronJobStatus<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceBatchV1beta1NamespacedCronJobStatus$Status$200 | Response$replaceBatchV1beta1NamespacedCronJobStatus$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/batch/v1beta1/namespaces/\${params.parameter.namespace}/cronjobs/\${params.parameter.name}/status\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchBatchV1beta1NamespacedCronJobStatus = <RequestContentType extends RequestContentType$patchBatchV1beta1NamespacedCronJobStatus, ResponseContentType extends ResponseContentType$patchBatchV1beta1NamespacedCronJobStatus>(params: Params$patchBatchV1beta1NamespacedCronJobStatus<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchBatchV1beta1NamespacedCronJobStatus$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/batch/v1beta1/namespaces/\${params.parameter.namespace}/cronjobs/\${params.parameter.name}/status\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const watchBatchV1beta1CronJobListForAllNamespaces = <ResponseContentType extends ResponseContentType$watchBatchV1beta1CronJobListForAllNamespaces>(params: Params$watchBatchV1beta1CronJobListForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$watchBatchV1beta1CronJobListForAllNamespaces$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/batch/v1beta1/watch/cronjobs\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchBatchV1beta1NamespacedCronJobList = <ResponseContentType extends ResponseContentType$watchBatchV1beta1NamespacedCronJobList>(params: Params$watchBatchV1beta1NamespacedCronJobList<ResponseContentType>, option?: RequestOption): Promise<Response$watchBatchV1beta1NamespacedCronJobList$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/batch/v1beta1/watch/namespaces/\${params.parameter.namespace}/cronjobs\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchBatchV1beta1NamespacedCronJob = <ResponseContentType extends ResponseContentType$watchBatchV1beta1NamespacedCronJob>(params: Params$watchBatchV1beta1NamespacedCronJob<ResponseContentType>, option?: RequestOption): Promise<Response$watchBatchV1beta1NamespacedCronJob$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/batch/v1beta1/watch/namespaces/\${params.parameter.namespace}/cronjobs/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const getBatchV2alpha1APIResources = <ResponseContentType extends ResponseContentType$getBatchV2alpha1APIResources>(params: Params$getBatchV2alpha1APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getBatchV2alpha1APIResources$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/batch/v2alpha1/\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const listBatchV2alpha1CronJobForAllNamespaces = <ResponseContentType extends ResponseContentType$listBatchV2alpha1CronJobForAllNamespaces>(params: Params$listBatchV2alpha1CronJobForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$listBatchV2alpha1CronJobForAllNamespaces$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/batch/v2alpha1/cronjobs\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const listBatchV2alpha1NamespacedCronJob = <ResponseContentType extends ResponseContentType$listBatchV2alpha1NamespacedCronJob>(params: Params$listBatchV2alpha1NamespacedCronJob<ResponseContentType>, option?: RequestOption): Promise<Response$listBatchV2alpha1NamespacedCronJob$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/batch/v2alpha1/namespaces/\${params.parameter.namespace}/cronjobs\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const createBatchV2alpha1NamespacedCronJob = <ResponseContentType extends ResponseContentType$createBatchV2alpha1NamespacedCronJob>(params: Params$createBatchV2alpha1NamespacedCronJob<ResponseContentType>, option?: RequestOption): Promise<(Response$createBatchV2alpha1NamespacedCronJob$Status$200 | Response$createBatchV2alpha1NamespacedCronJob$Status$201 | Response$createBatchV2alpha1NamespacedCronJob$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/batch/v2alpha1/namespaces/\${params.parameter.namespace}/cronjobs\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteBatchV2alpha1CollectionNamespacedCronJob = <ResponseContentType extends ResponseContentType$deleteBatchV2alpha1CollectionNamespacedCronJob>(params: Params$deleteBatchV2alpha1CollectionNamespacedCronJob<ResponseContentType>, option?: RequestOption): Promise<Response$deleteBatchV2alpha1CollectionNamespacedCronJob$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/batch/v2alpha1/namespaces/\${params.parameter.namespace}/cronjobs\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readBatchV2alpha1NamespacedCronJob = <ResponseContentType extends ResponseContentType$readBatchV2alpha1NamespacedCronJob>(params: Params$readBatchV2alpha1NamespacedCronJob<ResponseContentType>, option?: RequestOption): Promise<Response$readBatchV2alpha1NamespacedCronJob$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/batch/v2alpha1/namespaces/\${params.parameter.namespace}/cronjobs/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            exact: { value: params.parameter.exact, explode: false },
-            export: { value: params.parameter.export, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceBatchV2alpha1NamespacedCronJob = <ResponseContentType extends ResponseContentType$replaceBatchV2alpha1NamespacedCronJob>(params: Params$replaceBatchV2alpha1NamespacedCronJob<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceBatchV2alpha1NamespacedCronJob$Status$200 | Response$replaceBatchV2alpha1NamespacedCronJob$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/batch/v2alpha1/namespaces/\${params.parameter.namespace}/cronjobs/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteBatchV2alpha1NamespacedCronJob = <ResponseContentType extends ResponseContentType$deleteBatchV2alpha1NamespacedCronJob>(params: Params$deleteBatchV2alpha1NamespacedCronJob<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteBatchV2alpha1NamespacedCronJob$Status$200 | Response$deleteBatchV2alpha1NamespacedCronJob$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/batch/v2alpha1/namespaces/\${params.parameter.namespace}/cronjobs/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchBatchV2alpha1NamespacedCronJob = <RequestContentType extends RequestContentType$patchBatchV2alpha1NamespacedCronJob, ResponseContentType extends ResponseContentType$patchBatchV2alpha1NamespacedCronJob>(params: Params$patchBatchV2alpha1NamespacedCronJob<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchBatchV2alpha1NamespacedCronJob$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/batch/v2alpha1/namespaces/\${params.parameter.namespace}/cronjobs/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readBatchV2alpha1NamespacedCronJobStatus = <ResponseContentType extends ResponseContentType$readBatchV2alpha1NamespacedCronJobStatus>(params: Params$readBatchV2alpha1NamespacedCronJobStatus<ResponseContentType>, option?: RequestOption): Promise<Response$readBatchV2alpha1NamespacedCronJobStatus$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/batch/v2alpha1/namespaces/\${params.parameter.namespace}/cronjobs/\${params.parameter.name}/status\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceBatchV2alpha1NamespacedCronJobStatus = <ResponseContentType extends ResponseContentType$replaceBatchV2alpha1NamespacedCronJobStatus>(params: Params$replaceBatchV2alpha1NamespacedCronJobStatus<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceBatchV2alpha1NamespacedCronJobStatus$Status$200 | Response$replaceBatchV2alpha1NamespacedCronJobStatus$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/batch/v2alpha1/namespaces/\${params.parameter.namespace}/cronjobs/\${params.parameter.name}/status\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchBatchV2alpha1NamespacedCronJobStatus = <RequestContentType extends RequestContentType$patchBatchV2alpha1NamespacedCronJobStatus, ResponseContentType extends ResponseContentType$patchBatchV2alpha1NamespacedCronJobStatus>(params: Params$patchBatchV2alpha1NamespacedCronJobStatus<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchBatchV2alpha1NamespacedCronJobStatus$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/batch/v2alpha1/namespaces/\${params.parameter.namespace}/cronjobs/\${params.parameter.name}/status\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const watchBatchV2alpha1CronJobListForAllNamespaces = <ResponseContentType extends ResponseContentType$watchBatchV2alpha1CronJobListForAllNamespaces>(params: Params$watchBatchV2alpha1CronJobListForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$watchBatchV2alpha1CronJobListForAllNamespaces$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/batch/v2alpha1/watch/cronjobs\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchBatchV2alpha1NamespacedCronJobList = <ResponseContentType extends ResponseContentType$watchBatchV2alpha1NamespacedCronJobList>(params: Params$watchBatchV2alpha1NamespacedCronJobList<ResponseContentType>, option?: RequestOption): Promise<Response$watchBatchV2alpha1NamespacedCronJobList$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/batch/v2alpha1/watch/namespaces/\${params.parameter.namespace}/cronjobs\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchBatchV2alpha1NamespacedCronJob = <ResponseContentType extends ResponseContentType$watchBatchV2alpha1NamespacedCronJob>(params: Params$watchBatchV2alpha1NamespacedCronJob<ResponseContentType>, option?: RequestOption): Promise<Response$watchBatchV2alpha1NamespacedCronJob$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/batch/v2alpha1/watch/namespaces/\${params.parameter.namespace}/cronjobs/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const getCertificatesAPIGroup = <ResponseContentType extends ResponseContentType$getCertificatesAPIGroup>(params: Params$getCertificatesAPIGroup<ResponseContentType>, option?: RequestOption): Promise<Response$getCertificatesAPIGroup$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/certificates.k8s.io/\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const getCertificatesV1beta1APIResources = <ResponseContentType extends ResponseContentType$getCertificatesV1beta1APIResources>(params: Params$getCertificatesV1beta1APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getCertificatesV1beta1APIResources$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/certificates.k8s.io/v1beta1/\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const listCertificatesV1beta1CertificateSigningRequest = <ResponseContentType extends ResponseContentType$listCertificatesV1beta1CertificateSigningRequest>(params: Params$listCertificatesV1beta1CertificateSigningRequest<ResponseContentType>, option?: RequestOption): Promise<Response$listCertificatesV1beta1CertificateSigningRequest$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/certificates.k8s.io/v1beta1/certificatesigningrequests\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const createCertificatesV1beta1CertificateSigningRequest = <ResponseContentType extends ResponseContentType$createCertificatesV1beta1CertificateSigningRequest>(params: Params$createCertificatesV1beta1CertificateSigningRequest<ResponseContentType>, option?: RequestOption): Promise<(Response$createCertificatesV1beta1CertificateSigningRequest$Status$200 | Response$createCertificatesV1beta1CertificateSigningRequest$Status$201 | Response$createCertificatesV1beta1CertificateSigningRequest$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/certificates.k8s.io/v1beta1/certificatesigningrequests\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteCertificatesV1beta1CollectionCertificateSigningRequest = <ResponseContentType extends ResponseContentType$deleteCertificatesV1beta1CollectionCertificateSigningRequest>(params: Params$deleteCertificatesV1beta1CollectionCertificateSigningRequest<ResponseContentType>, option?: RequestOption): Promise<Response$deleteCertificatesV1beta1CollectionCertificateSigningRequest$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/certificates.k8s.io/v1beta1/certificatesigningrequests\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readCertificatesV1beta1CertificateSigningRequest = <ResponseContentType extends ResponseContentType$readCertificatesV1beta1CertificateSigningRequest>(params: Params$readCertificatesV1beta1CertificateSigningRequest<ResponseContentType>, option?: RequestOption): Promise<Response$readCertificatesV1beta1CertificateSigningRequest$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/certificates.k8s.io/v1beta1/certificatesigningrequests/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            exact: { value: params.parameter.exact, explode: false },
-            export: { value: params.parameter.export, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceCertificatesV1beta1CertificateSigningRequest = <ResponseContentType extends ResponseContentType$replaceCertificatesV1beta1CertificateSigningRequest>(params: Params$replaceCertificatesV1beta1CertificateSigningRequest<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceCertificatesV1beta1CertificateSigningRequest$Status$200 | Response$replaceCertificatesV1beta1CertificateSigningRequest$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/certificates.k8s.io/v1beta1/certificatesigningrequests/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteCertificatesV1beta1CertificateSigningRequest = <ResponseContentType extends ResponseContentType$deleteCertificatesV1beta1CertificateSigningRequest>(params: Params$deleteCertificatesV1beta1CertificateSigningRequest<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteCertificatesV1beta1CertificateSigningRequest$Status$200 | Response$deleteCertificatesV1beta1CertificateSigningRequest$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/certificates.k8s.io/v1beta1/certificatesigningrequests/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchCertificatesV1beta1CertificateSigningRequest = <RequestContentType extends RequestContentType$patchCertificatesV1beta1CertificateSigningRequest, ResponseContentType extends ResponseContentType$patchCertificatesV1beta1CertificateSigningRequest>(params: Params$patchCertificatesV1beta1CertificateSigningRequest<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchCertificatesV1beta1CertificateSigningRequest$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/certificates.k8s.io/v1beta1/certificatesigningrequests/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const replaceCertificatesV1beta1CertificateSigningRequestApproval = <ResponseContentType extends ResponseContentType$replaceCertificatesV1beta1CertificateSigningRequestApproval>(params: Params$replaceCertificatesV1beta1CertificateSigningRequestApproval<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceCertificatesV1beta1CertificateSigningRequestApproval$Status$200 | Response$replaceCertificatesV1beta1CertificateSigningRequestApproval$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/certificates.k8s.io/v1beta1/certificatesigningrequests/\${params.parameter.name}/approval\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readCertificatesV1beta1CertificateSigningRequestStatus = <ResponseContentType extends ResponseContentType$readCertificatesV1beta1CertificateSigningRequestStatus>(params: Params$readCertificatesV1beta1CertificateSigningRequestStatus<ResponseContentType>, option?: RequestOption): Promise<Response$readCertificatesV1beta1CertificateSigningRequestStatus$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/certificates.k8s.io/v1beta1/certificatesigningrequests/\${params.parameter.name}/status\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceCertificatesV1beta1CertificateSigningRequestStatus = <ResponseContentType extends ResponseContentType$replaceCertificatesV1beta1CertificateSigningRequestStatus>(params: Params$replaceCertificatesV1beta1CertificateSigningRequestStatus<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceCertificatesV1beta1CertificateSigningRequestStatus$Status$200 | Response$replaceCertificatesV1beta1CertificateSigningRequestStatus$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/certificates.k8s.io/v1beta1/certificatesigningrequests/\${params.parameter.name}/status\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchCertificatesV1beta1CertificateSigningRequestStatus = <RequestContentType extends RequestContentType$patchCertificatesV1beta1CertificateSigningRequestStatus, ResponseContentType extends ResponseContentType$patchCertificatesV1beta1CertificateSigningRequestStatus>(params: Params$patchCertificatesV1beta1CertificateSigningRequestStatus<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchCertificatesV1beta1CertificateSigningRequestStatus$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/certificates.k8s.io/v1beta1/certificatesigningrequests/\${params.parameter.name}/status\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const watchCertificatesV1beta1CertificateSigningRequestList = <ResponseContentType extends ResponseContentType$watchCertificatesV1beta1CertificateSigningRequestList>(params: Params$watchCertificatesV1beta1CertificateSigningRequestList<ResponseContentType>, option?: RequestOption): Promise<Response$watchCertificatesV1beta1CertificateSigningRequestList$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/certificates.k8s.io/v1beta1/watch/certificatesigningrequests\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchCertificatesV1beta1CertificateSigningRequest = <ResponseContentType extends ResponseContentType$watchCertificatesV1beta1CertificateSigningRequest>(params: Params$watchCertificatesV1beta1CertificateSigningRequest<ResponseContentType>, option?: RequestOption): Promise<Response$watchCertificatesV1beta1CertificateSigningRequest$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/certificates.k8s.io/v1beta1/watch/certificatesigningrequests/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const getCoordinationAPIGroup = <ResponseContentType extends ResponseContentType$getCoordinationAPIGroup>(params: Params$getCoordinationAPIGroup<ResponseContentType>, option?: RequestOption): Promise<Response$getCoordinationAPIGroup$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/coordination.k8s.io/\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const getCoordinationV1APIResources = <ResponseContentType extends ResponseContentType$getCoordinationV1APIResources>(params: Params$getCoordinationV1APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getCoordinationV1APIResources$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/coordination.k8s.io/v1/\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const listCoordinationV1LeaseForAllNamespaces = <ResponseContentType extends ResponseContentType$listCoordinationV1LeaseForAllNamespaces>(params: Params$listCoordinationV1LeaseForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$listCoordinationV1LeaseForAllNamespaces$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/coordination.k8s.io/v1/leases\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const listCoordinationV1NamespacedLease = <ResponseContentType extends ResponseContentType$listCoordinationV1NamespacedLease>(params: Params$listCoordinationV1NamespacedLease<ResponseContentType>, option?: RequestOption): Promise<Response$listCoordinationV1NamespacedLease$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/coordination.k8s.io/v1/namespaces/\${params.parameter.namespace}/leases\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const createCoordinationV1NamespacedLease = <ResponseContentType extends ResponseContentType$createCoordinationV1NamespacedLease>(params: Params$createCoordinationV1NamespacedLease<ResponseContentType>, option?: RequestOption): Promise<(Response$createCoordinationV1NamespacedLease$Status$200 | Response$createCoordinationV1NamespacedLease$Status$201 | Response$createCoordinationV1NamespacedLease$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/coordination.k8s.io/v1/namespaces/\${params.parameter.namespace}/leases\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteCoordinationV1CollectionNamespacedLease = <ResponseContentType extends ResponseContentType$deleteCoordinationV1CollectionNamespacedLease>(params: Params$deleteCoordinationV1CollectionNamespacedLease<ResponseContentType>, option?: RequestOption): Promise<Response$deleteCoordinationV1CollectionNamespacedLease$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/coordination.k8s.io/v1/namespaces/\${params.parameter.namespace}/leases\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readCoordinationV1NamespacedLease = <ResponseContentType extends ResponseContentType$readCoordinationV1NamespacedLease>(params: Params$readCoordinationV1NamespacedLease<ResponseContentType>, option?: RequestOption): Promise<Response$readCoordinationV1NamespacedLease$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/coordination.k8s.io/v1/namespaces/\${params.parameter.namespace}/leases/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            exact: { value: params.parameter.exact, explode: false },
-            export: { value: params.parameter.export, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceCoordinationV1NamespacedLease = <ResponseContentType extends ResponseContentType$replaceCoordinationV1NamespacedLease>(params: Params$replaceCoordinationV1NamespacedLease<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceCoordinationV1NamespacedLease$Status$200 | Response$replaceCoordinationV1NamespacedLease$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/coordination.k8s.io/v1/namespaces/\${params.parameter.namespace}/leases/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteCoordinationV1NamespacedLease = <ResponseContentType extends ResponseContentType$deleteCoordinationV1NamespacedLease>(params: Params$deleteCoordinationV1NamespacedLease<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteCoordinationV1NamespacedLease$Status$200 | Response$deleteCoordinationV1NamespacedLease$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/coordination.k8s.io/v1/namespaces/\${params.parameter.namespace}/leases/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchCoordinationV1NamespacedLease = <RequestContentType extends RequestContentType$patchCoordinationV1NamespacedLease, ResponseContentType extends ResponseContentType$patchCoordinationV1NamespacedLease>(params: Params$patchCoordinationV1NamespacedLease<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchCoordinationV1NamespacedLease$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/coordination.k8s.io/v1/namespaces/\${params.parameter.namespace}/leases/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const watchCoordinationV1LeaseListForAllNamespaces = <ResponseContentType extends ResponseContentType$watchCoordinationV1LeaseListForAllNamespaces>(params: Params$watchCoordinationV1LeaseListForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoordinationV1LeaseListForAllNamespaces$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/coordination.k8s.io/v1/watch/leases\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchCoordinationV1NamespacedLeaseList = <ResponseContentType extends ResponseContentType$watchCoordinationV1NamespacedLeaseList>(params: Params$watchCoordinationV1NamespacedLeaseList<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoordinationV1NamespacedLeaseList$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/coordination.k8s.io/v1/watch/namespaces/\${params.parameter.namespace}/leases\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchCoordinationV1NamespacedLease = <ResponseContentType extends ResponseContentType$watchCoordinationV1NamespacedLease>(params: Params$watchCoordinationV1NamespacedLease<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoordinationV1NamespacedLease$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/coordination.k8s.io/v1/watch/namespaces/\${params.parameter.namespace}/leases/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const getCoordinationV1beta1APIResources = <ResponseContentType extends ResponseContentType$getCoordinationV1beta1APIResources>(params: Params$getCoordinationV1beta1APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getCoordinationV1beta1APIResources$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/coordination.k8s.io/v1beta1/\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const listCoordinationV1beta1LeaseForAllNamespaces = <ResponseContentType extends ResponseContentType$listCoordinationV1beta1LeaseForAllNamespaces>(params: Params$listCoordinationV1beta1LeaseForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$listCoordinationV1beta1LeaseForAllNamespaces$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/coordination.k8s.io/v1beta1/leases\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const listCoordinationV1beta1NamespacedLease = <ResponseContentType extends ResponseContentType$listCoordinationV1beta1NamespacedLease>(params: Params$listCoordinationV1beta1NamespacedLease<ResponseContentType>, option?: RequestOption): Promise<Response$listCoordinationV1beta1NamespacedLease$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/coordination.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/leases\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const createCoordinationV1beta1NamespacedLease = <ResponseContentType extends ResponseContentType$createCoordinationV1beta1NamespacedLease>(params: Params$createCoordinationV1beta1NamespacedLease<ResponseContentType>, option?: RequestOption): Promise<(Response$createCoordinationV1beta1NamespacedLease$Status$200 | Response$createCoordinationV1beta1NamespacedLease$Status$201 | Response$createCoordinationV1beta1NamespacedLease$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/coordination.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/leases\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteCoordinationV1beta1CollectionNamespacedLease = <ResponseContentType extends ResponseContentType$deleteCoordinationV1beta1CollectionNamespacedLease>(params: Params$deleteCoordinationV1beta1CollectionNamespacedLease<ResponseContentType>, option?: RequestOption): Promise<Response$deleteCoordinationV1beta1CollectionNamespacedLease$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/coordination.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/leases\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readCoordinationV1beta1NamespacedLease = <ResponseContentType extends ResponseContentType$readCoordinationV1beta1NamespacedLease>(params: Params$readCoordinationV1beta1NamespacedLease<ResponseContentType>, option?: RequestOption): Promise<Response$readCoordinationV1beta1NamespacedLease$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/coordination.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/leases/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            exact: { value: params.parameter.exact, explode: false },
-            export: { value: params.parameter.export, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceCoordinationV1beta1NamespacedLease = <ResponseContentType extends ResponseContentType$replaceCoordinationV1beta1NamespacedLease>(params: Params$replaceCoordinationV1beta1NamespacedLease<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceCoordinationV1beta1NamespacedLease$Status$200 | Response$replaceCoordinationV1beta1NamespacedLease$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/coordination.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/leases/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteCoordinationV1beta1NamespacedLease = <ResponseContentType extends ResponseContentType$deleteCoordinationV1beta1NamespacedLease>(params: Params$deleteCoordinationV1beta1NamespacedLease<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteCoordinationV1beta1NamespacedLease$Status$200 | Response$deleteCoordinationV1beta1NamespacedLease$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/coordination.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/leases/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchCoordinationV1beta1NamespacedLease = <RequestContentType extends RequestContentType$patchCoordinationV1beta1NamespacedLease, ResponseContentType extends ResponseContentType$patchCoordinationV1beta1NamespacedLease>(params: Params$patchCoordinationV1beta1NamespacedLease<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchCoordinationV1beta1NamespacedLease$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/coordination.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/leases/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const watchCoordinationV1beta1LeaseListForAllNamespaces = <ResponseContentType extends ResponseContentType$watchCoordinationV1beta1LeaseListForAllNamespaces>(params: Params$watchCoordinationV1beta1LeaseListForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoordinationV1beta1LeaseListForAllNamespaces$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/coordination.k8s.io/v1beta1/watch/leases\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchCoordinationV1beta1NamespacedLeaseList = <ResponseContentType extends ResponseContentType$watchCoordinationV1beta1NamespacedLeaseList>(params: Params$watchCoordinationV1beta1NamespacedLeaseList<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoordinationV1beta1NamespacedLeaseList$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/coordination.k8s.io/v1beta1/watch/namespaces/\${params.parameter.namespace}/leases\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchCoordinationV1beta1NamespacedLease = <ResponseContentType extends ResponseContentType$watchCoordinationV1beta1NamespacedLease>(params: Params$watchCoordinationV1beta1NamespacedLease<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoordinationV1beta1NamespacedLease$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/coordination.k8s.io/v1beta1/watch/namespaces/\${params.parameter.namespace}/leases/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const getDiscoveryAPIGroup = <ResponseContentType extends ResponseContentType$getDiscoveryAPIGroup>(params: Params$getDiscoveryAPIGroup<ResponseContentType>, option?: RequestOption): Promise<Response$getDiscoveryAPIGroup$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/discovery.k8s.io/\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const getDiscoveryV1beta1APIResources = <ResponseContentType extends ResponseContentType$getDiscoveryV1beta1APIResources>(params: Params$getDiscoveryV1beta1APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getDiscoveryV1beta1APIResources$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/discovery.k8s.io/v1beta1/\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const listDiscoveryV1beta1EndpointSliceForAllNamespaces = <ResponseContentType extends ResponseContentType$listDiscoveryV1beta1EndpointSliceForAllNamespaces>(params: Params$listDiscoveryV1beta1EndpointSliceForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$listDiscoveryV1beta1EndpointSliceForAllNamespaces$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/discovery.k8s.io/v1beta1/endpointslices\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const listDiscoveryV1beta1NamespacedEndpointSlice = <ResponseContentType extends ResponseContentType$listDiscoveryV1beta1NamespacedEndpointSlice>(params: Params$listDiscoveryV1beta1NamespacedEndpointSlice<ResponseContentType>, option?: RequestOption): Promise<Response$listDiscoveryV1beta1NamespacedEndpointSlice$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/discovery.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/endpointslices\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const createDiscoveryV1beta1NamespacedEndpointSlice = <ResponseContentType extends ResponseContentType$createDiscoveryV1beta1NamespacedEndpointSlice>(params: Params$createDiscoveryV1beta1NamespacedEndpointSlice<ResponseContentType>, option?: RequestOption): Promise<(Response$createDiscoveryV1beta1NamespacedEndpointSlice$Status$200 | Response$createDiscoveryV1beta1NamespacedEndpointSlice$Status$201 | Response$createDiscoveryV1beta1NamespacedEndpointSlice$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/discovery.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/endpointslices\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteDiscoveryV1beta1CollectionNamespacedEndpointSlice = <ResponseContentType extends ResponseContentType$deleteDiscoveryV1beta1CollectionNamespacedEndpointSlice>(params: Params$deleteDiscoveryV1beta1CollectionNamespacedEndpointSlice<ResponseContentType>, option?: RequestOption): Promise<Response$deleteDiscoveryV1beta1CollectionNamespacedEndpointSlice$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/discovery.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/endpointslices\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readDiscoveryV1beta1NamespacedEndpointSlice = <ResponseContentType extends ResponseContentType$readDiscoveryV1beta1NamespacedEndpointSlice>(params: Params$readDiscoveryV1beta1NamespacedEndpointSlice<ResponseContentType>, option?: RequestOption): Promise<Response$readDiscoveryV1beta1NamespacedEndpointSlice$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/discovery.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/endpointslices/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            exact: { value: params.parameter.exact, explode: false },
-            export: { value: params.parameter.export, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceDiscoveryV1beta1NamespacedEndpointSlice = <ResponseContentType extends ResponseContentType$replaceDiscoveryV1beta1NamespacedEndpointSlice>(params: Params$replaceDiscoveryV1beta1NamespacedEndpointSlice<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceDiscoveryV1beta1NamespacedEndpointSlice$Status$200 | Response$replaceDiscoveryV1beta1NamespacedEndpointSlice$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/discovery.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/endpointslices/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteDiscoveryV1beta1NamespacedEndpointSlice = <ResponseContentType extends ResponseContentType$deleteDiscoveryV1beta1NamespacedEndpointSlice>(params: Params$deleteDiscoveryV1beta1NamespacedEndpointSlice<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteDiscoveryV1beta1NamespacedEndpointSlice$Status$200 | Response$deleteDiscoveryV1beta1NamespacedEndpointSlice$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/discovery.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/endpointslices/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchDiscoveryV1beta1NamespacedEndpointSlice = <RequestContentType extends RequestContentType$patchDiscoveryV1beta1NamespacedEndpointSlice, ResponseContentType extends ResponseContentType$patchDiscoveryV1beta1NamespacedEndpointSlice>(params: Params$patchDiscoveryV1beta1NamespacedEndpointSlice<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchDiscoveryV1beta1NamespacedEndpointSlice$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/discovery.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/endpointslices/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const watchDiscoveryV1beta1EndpointSliceListForAllNamespaces = <ResponseContentType extends ResponseContentType$watchDiscoveryV1beta1EndpointSliceListForAllNamespaces>(params: Params$watchDiscoveryV1beta1EndpointSliceListForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$watchDiscoveryV1beta1EndpointSliceListForAllNamespaces$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/discovery.k8s.io/v1beta1/watch/endpointslices\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchDiscoveryV1beta1NamespacedEndpointSliceList = <ResponseContentType extends ResponseContentType$watchDiscoveryV1beta1NamespacedEndpointSliceList>(params: Params$watchDiscoveryV1beta1NamespacedEndpointSliceList<ResponseContentType>, option?: RequestOption): Promise<Response$watchDiscoveryV1beta1NamespacedEndpointSliceList$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/discovery.k8s.io/v1beta1/watch/namespaces/\${params.parameter.namespace}/endpointslices\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchDiscoveryV1beta1NamespacedEndpointSlice = <ResponseContentType extends ResponseContentType$watchDiscoveryV1beta1NamespacedEndpointSlice>(params: Params$watchDiscoveryV1beta1NamespacedEndpointSlice<ResponseContentType>, option?: RequestOption): Promise<Response$watchDiscoveryV1beta1NamespacedEndpointSlice$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/discovery.k8s.io/v1beta1/watch/namespaces/\${params.parameter.namespace}/endpointslices/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const getEventsAPIGroup = <ResponseContentType extends ResponseContentType$getEventsAPIGroup>(params: Params$getEventsAPIGroup<ResponseContentType>, option?: RequestOption): Promise<Response$getEventsAPIGroup$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/events.k8s.io/\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const getEventsV1beta1APIResources = <ResponseContentType extends ResponseContentType$getEventsV1beta1APIResources>(params: Params$getEventsV1beta1APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getEventsV1beta1APIResources$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/events.k8s.io/v1beta1/\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const listEventsV1beta1EventForAllNamespaces = <ResponseContentType extends ResponseContentType$listEventsV1beta1EventForAllNamespaces>(params: Params$listEventsV1beta1EventForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$listEventsV1beta1EventForAllNamespaces$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/events.k8s.io/v1beta1/events\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const listEventsV1beta1NamespacedEvent = <ResponseContentType extends ResponseContentType$listEventsV1beta1NamespacedEvent>(params: Params$listEventsV1beta1NamespacedEvent<ResponseContentType>, option?: RequestOption): Promise<Response$listEventsV1beta1NamespacedEvent$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/events.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/events\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const createEventsV1beta1NamespacedEvent = <ResponseContentType extends ResponseContentType$createEventsV1beta1NamespacedEvent>(params: Params$createEventsV1beta1NamespacedEvent<ResponseContentType>, option?: RequestOption): Promise<(Response$createEventsV1beta1NamespacedEvent$Status$200 | Response$createEventsV1beta1NamespacedEvent$Status$201 | Response$createEventsV1beta1NamespacedEvent$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/events.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/events\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteEventsV1beta1CollectionNamespacedEvent = <ResponseContentType extends ResponseContentType$deleteEventsV1beta1CollectionNamespacedEvent>(params: Params$deleteEventsV1beta1CollectionNamespacedEvent<ResponseContentType>, option?: RequestOption): Promise<Response$deleteEventsV1beta1CollectionNamespacedEvent$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/events.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/events\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readEventsV1beta1NamespacedEvent = <ResponseContentType extends ResponseContentType$readEventsV1beta1NamespacedEvent>(params: Params$readEventsV1beta1NamespacedEvent<ResponseContentType>, option?: RequestOption): Promise<Response$readEventsV1beta1NamespacedEvent$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/events.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/events/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            exact: { value: params.parameter.exact, explode: false },
-            export: { value: params.parameter.export, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceEventsV1beta1NamespacedEvent = <ResponseContentType extends ResponseContentType$replaceEventsV1beta1NamespacedEvent>(params: Params$replaceEventsV1beta1NamespacedEvent<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceEventsV1beta1NamespacedEvent$Status$200 | Response$replaceEventsV1beta1NamespacedEvent$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/events.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/events/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteEventsV1beta1NamespacedEvent = <ResponseContentType extends ResponseContentType$deleteEventsV1beta1NamespacedEvent>(params: Params$deleteEventsV1beta1NamespacedEvent<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteEventsV1beta1NamespacedEvent$Status$200 | Response$deleteEventsV1beta1NamespacedEvent$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/events.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/events/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchEventsV1beta1NamespacedEvent = <RequestContentType extends RequestContentType$patchEventsV1beta1NamespacedEvent, ResponseContentType extends ResponseContentType$patchEventsV1beta1NamespacedEvent>(params: Params$patchEventsV1beta1NamespacedEvent<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchEventsV1beta1NamespacedEvent$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/events.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/events/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const watchEventsV1beta1EventListForAllNamespaces = <ResponseContentType extends ResponseContentType$watchEventsV1beta1EventListForAllNamespaces>(params: Params$watchEventsV1beta1EventListForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$watchEventsV1beta1EventListForAllNamespaces$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/events.k8s.io/v1beta1/watch/events\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchEventsV1beta1NamespacedEventList = <ResponseContentType extends ResponseContentType$watchEventsV1beta1NamespacedEventList>(params: Params$watchEventsV1beta1NamespacedEventList<ResponseContentType>, option?: RequestOption): Promise<Response$watchEventsV1beta1NamespacedEventList$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/events.k8s.io/v1beta1/watch/namespaces/\${params.parameter.namespace}/events\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchEventsV1beta1NamespacedEvent = <ResponseContentType extends ResponseContentType$watchEventsV1beta1NamespacedEvent>(params: Params$watchEventsV1beta1NamespacedEvent<ResponseContentType>, option?: RequestOption): Promise<Response$watchEventsV1beta1NamespacedEvent$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/events.k8s.io/v1beta1/watch/namespaces/\${params.parameter.namespace}/events/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const getExtensionsAPIGroup = <ResponseContentType extends ResponseContentType$getExtensionsAPIGroup>(params: Params$getExtensionsAPIGroup<ResponseContentType>, option?: RequestOption): Promise<Response$getExtensionsAPIGroup$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/extensions/\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const getExtensionsV1beta1APIResources = <ResponseContentType extends ResponseContentType$getExtensionsV1beta1APIResources>(params: Params$getExtensionsV1beta1APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getExtensionsV1beta1APIResources$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/extensions/v1beta1/\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const listExtensionsV1beta1IngressForAllNamespaces = <ResponseContentType extends ResponseContentType$listExtensionsV1beta1IngressForAllNamespaces>(params: Params$listExtensionsV1beta1IngressForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$listExtensionsV1beta1IngressForAllNamespaces$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/extensions/v1beta1/ingresses\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const listExtensionsV1beta1NamespacedIngress = <ResponseContentType extends ResponseContentType$listExtensionsV1beta1NamespacedIngress>(params: Params$listExtensionsV1beta1NamespacedIngress<ResponseContentType>, option?: RequestOption): Promise<Response$listExtensionsV1beta1NamespacedIngress$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/extensions/v1beta1/namespaces/\${params.parameter.namespace}/ingresses\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const createExtensionsV1beta1NamespacedIngress = <ResponseContentType extends ResponseContentType$createExtensionsV1beta1NamespacedIngress>(params: Params$createExtensionsV1beta1NamespacedIngress<ResponseContentType>, option?: RequestOption): Promise<(Response$createExtensionsV1beta1NamespacedIngress$Status$200 | Response$createExtensionsV1beta1NamespacedIngress$Status$201 | Response$createExtensionsV1beta1NamespacedIngress$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/extensions/v1beta1/namespaces/\${params.parameter.namespace}/ingresses\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteExtensionsV1beta1CollectionNamespacedIngress = <ResponseContentType extends ResponseContentType$deleteExtensionsV1beta1CollectionNamespacedIngress>(params: Params$deleteExtensionsV1beta1CollectionNamespacedIngress<ResponseContentType>, option?: RequestOption): Promise<Response$deleteExtensionsV1beta1CollectionNamespacedIngress$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/extensions/v1beta1/namespaces/\${params.parameter.namespace}/ingresses\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readExtensionsV1beta1NamespacedIngress = <ResponseContentType extends ResponseContentType$readExtensionsV1beta1NamespacedIngress>(params: Params$readExtensionsV1beta1NamespacedIngress<ResponseContentType>, option?: RequestOption): Promise<Response$readExtensionsV1beta1NamespacedIngress$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/extensions/v1beta1/namespaces/\${params.parameter.namespace}/ingresses/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            exact: { value: params.parameter.exact, explode: false },
-            export: { value: params.parameter.export, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceExtensionsV1beta1NamespacedIngress = <ResponseContentType extends ResponseContentType$replaceExtensionsV1beta1NamespacedIngress>(params: Params$replaceExtensionsV1beta1NamespacedIngress<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceExtensionsV1beta1NamespacedIngress$Status$200 | Response$replaceExtensionsV1beta1NamespacedIngress$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/extensions/v1beta1/namespaces/\${params.parameter.namespace}/ingresses/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteExtensionsV1beta1NamespacedIngress = <ResponseContentType extends ResponseContentType$deleteExtensionsV1beta1NamespacedIngress>(params: Params$deleteExtensionsV1beta1NamespacedIngress<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteExtensionsV1beta1NamespacedIngress$Status$200 | Response$deleteExtensionsV1beta1NamespacedIngress$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/extensions/v1beta1/namespaces/\${params.parameter.namespace}/ingresses/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchExtensionsV1beta1NamespacedIngress = <RequestContentType extends RequestContentType$patchExtensionsV1beta1NamespacedIngress, ResponseContentType extends ResponseContentType$patchExtensionsV1beta1NamespacedIngress>(params: Params$patchExtensionsV1beta1NamespacedIngress<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchExtensionsV1beta1NamespacedIngress$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/extensions/v1beta1/namespaces/\${params.parameter.namespace}/ingresses/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readExtensionsV1beta1NamespacedIngressStatus = <ResponseContentType extends ResponseContentType$readExtensionsV1beta1NamespacedIngressStatus>(params: Params$readExtensionsV1beta1NamespacedIngressStatus<ResponseContentType>, option?: RequestOption): Promise<Response$readExtensionsV1beta1NamespacedIngressStatus$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/extensions/v1beta1/namespaces/\${params.parameter.namespace}/ingresses/\${params.parameter.name}/status\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceExtensionsV1beta1NamespacedIngressStatus = <ResponseContentType extends ResponseContentType$replaceExtensionsV1beta1NamespacedIngressStatus>(params: Params$replaceExtensionsV1beta1NamespacedIngressStatus<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceExtensionsV1beta1NamespacedIngressStatus$Status$200 | Response$replaceExtensionsV1beta1NamespacedIngressStatus$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/extensions/v1beta1/namespaces/\${params.parameter.namespace}/ingresses/\${params.parameter.name}/status\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchExtensionsV1beta1NamespacedIngressStatus = <RequestContentType extends RequestContentType$patchExtensionsV1beta1NamespacedIngressStatus, ResponseContentType extends ResponseContentType$patchExtensionsV1beta1NamespacedIngressStatus>(params: Params$patchExtensionsV1beta1NamespacedIngressStatus<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchExtensionsV1beta1NamespacedIngressStatus$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/extensions/v1beta1/namespaces/\${params.parameter.namespace}/ingresses/\${params.parameter.name}/status\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const watchExtensionsV1beta1IngressListForAllNamespaces = <ResponseContentType extends ResponseContentType$watchExtensionsV1beta1IngressListForAllNamespaces>(params: Params$watchExtensionsV1beta1IngressListForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$watchExtensionsV1beta1IngressListForAllNamespaces$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/extensions/v1beta1/watch/ingresses\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchExtensionsV1beta1NamespacedIngressList = <ResponseContentType extends ResponseContentType$watchExtensionsV1beta1NamespacedIngressList>(params: Params$watchExtensionsV1beta1NamespacedIngressList<ResponseContentType>, option?: RequestOption): Promise<Response$watchExtensionsV1beta1NamespacedIngressList$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/extensions/v1beta1/watch/namespaces/\${params.parameter.namespace}/ingresses\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchExtensionsV1beta1NamespacedIngress = <ResponseContentType extends ResponseContentType$watchExtensionsV1beta1NamespacedIngress>(params: Params$watchExtensionsV1beta1NamespacedIngress<ResponseContentType>, option?: RequestOption): Promise<Response$watchExtensionsV1beta1NamespacedIngress$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/extensions/v1beta1/watch/namespaces/\${params.parameter.namespace}/ingresses/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const getFlowcontrolApiserverAPIGroup = <ResponseContentType extends ResponseContentType$getFlowcontrolApiserverAPIGroup>(params: Params$getFlowcontrolApiserverAPIGroup<ResponseContentType>, option?: RequestOption): Promise<Response$getFlowcontrolApiserverAPIGroup$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/flowcontrol.apiserver.k8s.io/\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const getFlowcontrolApiserverV1alpha1APIResources = <ResponseContentType extends ResponseContentType$getFlowcontrolApiserverV1alpha1APIResources>(params: Params$getFlowcontrolApiserverV1alpha1APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getFlowcontrolApiserverV1alpha1APIResources$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/flowcontrol.apiserver.k8s.io/v1alpha1/\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const listFlowcontrolApiserverV1alpha1FlowSchema = <ResponseContentType extends ResponseContentType$listFlowcontrolApiserverV1alpha1FlowSchema>(params: Params$listFlowcontrolApiserverV1alpha1FlowSchema<ResponseContentType>, option?: RequestOption): Promise<Response$listFlowcontrolApiserverV1alpha1FlowSchema$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/flowcontrol.apiserver.k8s.io/v1alpha1/flowschemas\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const createFlowcontrolApiserverV1alpha1FlowSchema = <ResponseContentType extends ResponseContentType$createFlowcontrolApiserverV1alpha1FlowSchema>(params: Params$createFlowcontrolApiserverV1alpha1FlowSchema<ResponseContentType>, option?: RequestOption): Promise<(Response$createFlowcontrolApiserverV1alpha1FlowSchema$Status$200 | Response$createFlowcontrolApiserverV1alpha1FlowSchema$Status$201 | Response$createFlowcontrolApiserverV1alpha1FlowSchema$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/flowcontrol.apiserver.k8s.io/v1alpha1/flowschemas\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteFlowcontrolApiserverV1alpha1CollectionFlowSchema = <ResponseContentType extends ResponseContentType$deleteFlowcontrolApiserverV1alpha1CollectionFlowSchema>(params: Params$deleteFlowcontrolApiserverV1alpha1CollectionFlowSchema<ResponseContentType>, option?: RequestOption): Promise<Response$deleteFlowcontrolApiserverV1alpha1CollectionFlowSchema$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/flowcontrol.apiserver.k8s.io/v1alpha1/flowschemas\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readFlowcontrolApiserverV1alpha1FlowSchema = <ResponseContentType extends ResponseContentType$readFlowcontrolApiserverV1alpha1FlowSchema>(params: Params$readFlowcontrolApiserverV1alpha1FlowSchema<ResponseContentType>, option?: RequestOption): Promise<Response$readFlowcontrolApiserverV1alpha1FlowSchema$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/flowcontrol.apiserver.k8s.io/v1alpha1/flowschemas/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            exact: { value: params.parameter.exact, explode: false },
-            export: { value: params.parameter.export, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceFlowcontrolApiserverV1alpha1FlowSchema = <ResponseContentType extends ResponseContentType$replaceFlowcontrolApiserverV1alpha1FlowSchema>(params: Params$replaceFlowcontrolApiserverV1alpha1FlowSchema<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceFlowcontrolApiserverV1alpha1FlowSchema$Status$200 | Response$replaceFlowcontrolApiserverV1alpha1FlowSchema$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/flowcontrol.apiserver.k8s.io/v1alpha1/flowschemas/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteFlowcontrolApiserverV1alpha1FlowSchema = <ResponseContentType extends ResponseContentType$deleteFlowcontrolApiserverV1alpha1FlowSchema>(params: Params$deleteFlowcontrolApiserverV1alpha1FlowSchema<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteFlowcontrolApiserverV1alpha1FlowSchema$Status$200 | Response$deleteFlowcontrolApiserverV1alpha1FlowSchema$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/flowcontrol.apiserver.k8s.io/v1alpha1/flowschemas/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchFlowcontrolApiserverV1alpha1FlowSchema = <RequestContentType extends RequestContentType$patchFlowcontrolApiserverV1alpha1FlowSchema, ResponseContentType extends ResponseContentType$patchFlowcontrolApiserverV1alpha1FlowSchema>(params: Params$patchFlowcontrolApiserverV1alpha1FlowSchema<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchFlowcontrolApiserverV1alpha1FlowSchema$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/flowcontrol.apiserver.k8s.io/v1alpha1/flowschemas/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readFlowcontrolApiserverV1alpha1FlowSchemaStatus = <ResponseContentType extends ResponseContentType$readFlowcontrolApiserverV1alpha1FlowSchemaStatus>(params: Params$readFlowcontrolApiserverV1alpha1FlowSchemaStatus<ResponseContentType>, option?: RequestOption): Promise<Response$readFlowcontrolApiserverV1alpha1FlowSchemaStatus$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/flowcontrol.apiserver.k8s.io/v1alpha1/flowschemas/\${params.parameter.name}/status\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceFlowcontrolApiserverV1alpha1FlowSchemaStatus = <ResponseContentType extends ResponseContentType$replaceFlowcontrolApiserverV1alpha1FlowSchemaStatus>(params: Params$replaceFlowcontrolApiserverV1alpha1FlowSchemaStatus<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceFlowcontrolApiserverV1alpha1FlowSchemaStatus$Status$200 | Response$replaceFlowcontrolApiserverV1alpha1FlowSchemaStatus$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/flowcontrol.apiserver.k8s.io/v1alpha1/flowschemas/\${params.parameter.name}/status\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchFlowcontrolApiserverV1alpha1FlowSchemaStatus = <RequestContentType extends RequestContentType$patchFlowcontrolApiserverV1alpha1FlowSchemaStatus, ResponseContentType extends ResponseContentType$patchFlowcontrolApiserverV1alpha1FlowSchemaStatus>(params: Params$patchFlowcontrolApiserverV1alpha1FlowSchemaStatus<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchFlowcontrolApiserverV1alpha1FlowSchemaStatus$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/flowcontrol.apiserver.k8s.io/v1alpha1/flowschemas/\${params.parameter.name}/status\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const listFlowcontrolApiserverV1alpha1PriorityLevelConfiguration = <ResponseContentType extends ResponseContentType$listFlowcontrolApiserverV1alpha1PriorityLevelConfiguration>(params: Params$listFlowcontrolApiserverV1alpha1PriorityLevelConfiguration<ResponseContentType>, option?: RequestOption): Promise<Response$listFlowcontrolApiserverV1alpha1PriorityLevelConfiguration$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/flowcontrol.apiserver.k8s.io/v1alpha1/prioritylevelconfigurations\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const createFlowcontrolApiserverV1alpha1PriorityLevelConfiguration = <ResponseContentType extends ResponseContentType$createFlowcontrolApiserverV1alpha1PriorityLevelConfiguration>(params: Params$createFlowcontrolApiserverV1alpha1PriorityLevelConfiguration<ResponseContentType>, option?: RequestOption): Promise<(Response$createFlowcontrolApiserverV1alpha1PriorityLevelConfiguration$Status$200 | Response$createFlowcontrolApiserverV1alpha1PriorityLevelConfiguration$Status$201 | Response$createFlowcontrolApiserverV1alpha1PriorityLevelConfiguration$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/flowcontrol.apiserver.k8s.io/v1alpha1/prioritylevelconfigurations\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteFlowcontrolApiserverV1alpha1CollectionPriorityLevelConfiguration = <ResponseContentType extends ResponseContentType$deleteFlowcontrolApiserverV1alpha1CollectionPriorityLevelConfiguration>(params: Params$deleteFlowcontrolApiserverV1alpha1CollectionPriorityLevelConfiguration<ResponseContentType>, option?: RequestOption): Promise<Response$deleteFlowcontrolApiserverV1alpha1CollectionPriorityLevelConfiguration$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/flowcontrol.apiserver.k8s.io/v1alpha1/prioritylevelconfigurations\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readFlowcontrolApiserverV1alpha1PriorityLevelConfiguration = <ResponseContentType extends ResponseContentType$readFlowcontrolApiserverV1alpha1PriorityLevelConfiguration>(params: Params$readFlowcontrolApiserverV1alpha1PriorityLevelConfiguration<ResponseContentType>, option?: RequestOption): Promise<Response$readFlowcontrolApiserverV1alpha1PriorityLevelConfiguration$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/flowcontrol.apiserver.k8s.io/v1alpha1/prioritylevelconfigurations/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            exact: { value: params.parameter.exact, explode: false },
-            export: { value: params.parameter.export, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceFlowcontrolApiserverV1alpha1PriorityLevelConfiguration = <ResponseContentType extends ResponseContentType$replaceFlowcontrolApiserverV1alpha1PriorityLevelConfiguration>(params: Params$replaceFlowcontrolApiserverV1alpha1PriorityLevelConfiguration<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceFlowcontrolApiserverV1alpha1PriorityLevelConfiguration$Status$200 | Response$replaceFlowcontrolApiserverV1alpha1PriorityLevelConfiguration$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/flowcontrol.apiserver.k8s.io/v1alpha1/prioritylevelconfigurations/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteFlowcontrolApiserverV1alpha1PriorityLevelConfiguration = <ResponseContentType extends ResponseContentType$deleteFlowcontrolApiserverV1alpha1PriorityLevelConfiguration>(params: Params$deleteFlowcontrolApiserverV1alpha1PriorityLevelConfiguration<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteFlowcontrolApiserverV1alpha1PriorityLevelConfiguration$Status$200 | Response$deleteFlowcontrolApiserverV1alpha1PriorityLevelConfiguration$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/flowcontrol.apiserver.k8s.io/v1alpha1/prioritylevelconfigurations/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchFlowcontrolApiserverV1alpha1PriorityLevelConfiguration = <RequestContentType extends RequestContentType$patchFlowcontrolApiserverV1alpha1PriorityLevelConfiguration, ResponseContentType extends ResponseContentType$patchFlowcontrolApiserverV1alpha1PriorityLevelConfiguration>(params: Params$patchFlowcontrolApiserverV1alpha1PriorityLevelConfiguration<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchFlowcontrolApiserverV1alpha1PriorityLevelConfiguration$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/flowcontrol.apiserver.k8s.io/v1alpha1/prioritylevelconfigurations/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readFlowcontrolApiserverV1alpha1PriorityLevelConfigurationStatus = <ResponseContentType extends ResponseContentType$readFlowcontrolApiserverV1alpha1PriorityLevelConfigurationStatus>(params: Params$readFlowcontrolApiserverV1alpha1PriorityLevelConfigurationStatus<ResponseContentType>, option?: RequestOption): Promise<Response$readFlowcontrolApiserverV1alpha1PriorityLevelConfigurationStatus$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/flowcontrol.apiserver.k8s.io/v1alpha1/prioritylevelconfigurations/\${params.parameter.name}/status\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceFlowcontrolApiserverV1alpha1PriorityLevelConfigurationStatus = <ResponseContentType extends ResponseContentType$replaceFlowcontrolApiserverV1alpha1PriorityLevelConfigurationStatus>(params: Params$replaceFlowcontrolApiserverV1alpha1PriorityLevelConfigurationStatus<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceFlowcontrolApiserverV1alpha1PriorityLevelConfigurationStatus$Status$200 | Response$replaceFlowcontrolApiserverV1alpha1PriorityLevelConfigurationStatus$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/flowcontrol.apiserver.k8s.io/v1alpha1/prioritylevelconfigurations/\${params.parameter.name}/status\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchFlowcontrolApiserverV1alpha1PriorityLevelConfigurationStatus = <RequestContentType extends RequestContentType$patchFlowcontrolApiserverV1alpha1PriorityLevelConfigurationStatus, ResponseContentType extends ResponseContentType$patchFlowcontrolApiserverV1alpha1PriorityLevelConfigurationStatus>(params: Params$patchFlowcontrolApiserverV1alpha1PriorityLevelConfigurationStatus<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchFlowcontrolApiserverV1alpha1PriorityLevelConfigurationStatus$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/flowcontrol.apiserver.k8s.io/v1alpha1/prioritylevelconfigurations/\${params.parameter.name}/status\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const watchFlowcontrolApiserverV1alpha1FlowSchemaList = <ResponseContentType extends ResponseContentType$watchFlowcontrolApiserverV1alpha1FlowSchemaList>(params: Params$watchFlowcontrolApiserverV1alpha1FlowSchemaList<ResponseContentType>, option?: RequestOption): Promise<Response$watchFlowcontrolApiserverV1alpha1FlowSchemaList$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/flowcontrol.apiserver.k8s.io/v1alpha1/watch/flowschemas\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchFlowcontrolApiserverV1alpha1FlowSchema = <ResponseContentType extends ResponseContentType$watchFlowcontrolApiserverV1alpha1FlowSchema>(params: Params$watchFlowcontrolApiserverV1alpha1FlowSchema<ResponseContentType>, option?: RequestOption): Promise<Response$watchFlowcontrolApiserverV1alpha1FlowSchema$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/flowcontrol.apiserver.k8s.io/v1alpha1/watch/flowschemas/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchFlowcontrolApiserverV1alpha1PriorityLevelConfigurationList = <ResponseContentType extends ResponseContentType$watchFlowcontrolApiserverV1alpha1PriorityLevelConfigurationList>(params: Params$watchFlowcontrolApiserverV1alpha1PriorityLevelConfigurationList<ResponseContentType>, option?: RequestOption): Promise<Response$watchFlowcontrolApiserverV1alpha1PriorityLevelConfigurationList$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/flowcontrol.apiserver.k8s.io/v1alpha1/watch/prioritylevelconfigurations\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchFlowcontrolApiserverV1alpha1PriorityLevelConfiguration = <ResponseContentType extends ResponseContentType$watchFlowcontrolApiserverV1alpha1PriorityLevelConfiguration>(params: Params$watchFlowcontrolApiserverV1alpha1PriorityLevelConfiguration<ResponseContentType>, option?: RequestOption): Promise<Response$watchFlowcontrolApiserverV1alpha1PriorityLevelConfiguration$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/flowcontrol.apiserver.k8s.io/v1alpha1/watch/prioritylevelconfigurations/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const getNetworkingAPIGroup = <ResponseContentType extends ResponseContentType$getNetworkingAPIGroup>(params: Params$getNetworkingAPIGroup<ResponseContentType>, option?: RequestOption): Promise<Response$getNetworkingAPIGroup$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/networking.k8s.io/\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const getNetworkingV1APIResources = <ResponseContentType extends ResponseContentType$getNetworkingV1APIResources>(params: Params$getNetworkingV1APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getNetworkingV1APIResources$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/networking.k8s.io/v1/\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const listNetworkingV1NamespacedNetworkPolicy = <ResponseContentType extends ResponseContentType$listNetworkingV1NamespacedNetworkPolicy>(params: Params$listNetworkingV1NamespacedNetworkPolicy<ResponseContentType>, option?: RequestOption): Promise<Response$listNetworkingV1NamespacedNetworkPolicy$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/networking.k8s.io/v1/namespaces/\${params.parameter.namespace}/networkpolicies\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const createNetworkingV1NamespacedNetworkPolicy = <ResponseContentType extends ResponseContentType$createNetworkingV1NamespacedNetworkPolicy>(params: Params$createNetworkingV1NamespacedNetworkPolicy<ResponseContentType>, option?: RequestOption): Promise<(Response$createNetworkingV1NamespacedNetworkPolicy$Status$200 | Response$createNetworkingV1NamespacedNetworkPolicy$Status$201 | Response$createNetworkingV1NamespacedNetworkPolicy$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/networking.k8s.io/v1/namespaces/\${params.parameter.namespace}/networkpolicies\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteNetworkingV1CollectionNamespacedNetworkPolicy = <ResponseContentType extends ResponseContentType$deleteNetworkingV1CollectionNamespacedNetworkPolicy>(params: Params$deleteNetworkingV1CollectionNamespacedNetworkPolicy<ResponseContentType>, option?: RequestOption): Promise<Response$deleteNetworkingV1CollectionNamespacedNetworkPolicy$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/networking.k8s.io/v1/namespaces/\${params.parameter.namespace}/networkpolicies\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readNetworkingV1NamespacedNetworkPolicy = <ResponseContentType extends ResponseContentType$readNetworkingV1NamespacedNetworkPolicy>(params: Params$readNetworkingV1NamespacedNetworkPolicy<ResponseContentType>, option?: RequestOption): Promise<Response$readNetworkingV1NamespacedNetworkPolicy$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/networking.k8s.io/v1/namespaces/\${params.parameter.namespace}/networkpolicies/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            exact: { value: params.parameter.exact, explode: false },
-            export: { value: params.parameter.export, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceNetworkingV1NamespacedNetworkPolicy = <ResponseContentType extends ResponseContentType$replaceNetworkingV1NamespacedNetworkPolicy>(params: Params$replaceNetworkingV1NamespacedNetworkPolicy<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceNetworkingV1NamespacedNetworkPolicy$Status$200 | Response$replaceNetworkingV1NamespacedNetworkPolicy$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/networking.k8s.io/v1/namespaces/\${params.parameter.namespace}/networkpolicies/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteNetworkingV1NamespacedNetworkPolicy = <ResponseContentType extends ResponseContentType$deleteNetworkingV1NamespacedNetworkPolicy>(params: Params$deleteNetworkingV1NamespacedNetworkPolicy<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteNetworkingV1NamespacedNetworkPolicy$Status$200 | Response$deleteNetworkingV1NamespacedNetworkPolicy$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/networking.k8s.io/v1/namespaces/\${params.parameter.namespace}/networkpolicies/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchNetworkingV1NamespacedNetworkPolicy = <RequestContentType extends RequestContentType$patchNetworkingV1NamespacedNetworkPolicy, ResponseContentType extends ResponseContentType$patchNetworkingV1NamespacedNetworkPolicy>(params: Params$patchNetworkingV1NamespacedNetworkPolicy<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchNetworkingV1NamespacedNetworkPolicy$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/networking.k8s.io/v1/namespaces/\${params.parameter.namespace}/networkpolicies/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const listNetworkingV1NetworkPolicyForAllNamespaces = <ResponseContentType extends ResponseContentType$listNetworkingV1NetworkPolicyForAllNamespaces>(params: Params$listNetworkingV1NetworkPolicyForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$listNetworkingV1NetworkPolicyForAllNamespaces$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/networking.k8s.io/v1/networkpolicies\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchNetworkingV1NamespacedNetworkPolicyList = <ResponseContentType extends ResponseContentType$watchNetworkingV1NamespacedNetworkPolicyList>(params: Params$watchNetworkingV1NamespacedNetworkPolicyList<ResponseContentType>, option?: RequestOption): Promise<Response$watchNetworkingV1NamespacedNetworkPolicyList$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/networking.k8s.io/v1/watch/namespaces/\${params.parameter.namespace}/networkpolicies\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchNetworkingV1NamespacedNetworkPolicy = <ResponseContentType extends ResponseContentType$watchNetworkingV1NamespacedNetworkPolicy>(params: Params$watchNetworkingV1NamespacedNetworkPolicy<ResponseContentType>, option?: RequestOption): Promise<Response$watchNetworkingV1NamespacedNetworkPolicy$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/networking.k8s.io/v1/watch/namespaces/\${params.parameter.namespace}/networkpolicies/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchNetworkingV1NetworkPolicyListForAllNamespaces = <ResponseContentType extends ResponseContentType$watchNetworkingV1NetworkPolicyListForAllNamespaces>(params: Params$watchNetworkingV1NetworkPolicyListForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$watchNetworkingV1NetworkPolicyListForAllNamespaces$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/networking.k8s.io/v1/watch/networkpolicies\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const getNetworkingV1beta1APIResources = <ResponseContentType extends ResponseContentType$getNetworkingV1beta1APIResources>(params: Params$getNetworkingV1beta1APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getNetworkingV1beta1APIResources$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/networking.k8s.io/v1beta1/\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const listNetworkingV1beta1IngressClass = <ResponseContentType extends ResponseContentType$listNetworkingV1beta1IngressClass>(params: Params$listNetworkingV1beta1IngressClass<ResponseContentType>, option?: RequestOption): Promise<Response$listNetworkingV1beta1IngressClass$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/networking.k8s.io/v1beta1/ingressclasses\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const createNetworkingV1beta1IngressClass = <ResponseContentType extends ResponseContentType$createNetworkingV1beta1IngressClass>(params: Params$createNetworkingV1beta1IngressClass<ResponseContentType>, option?: RequestOption): Promise<(Response$createNetworkingV1beta1IngressClass$Status$200 | Response$createNetworkingV1beta1IngressClass$Status$201 | Response$createNetworkingV1beta1IngressClass$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/networking.k8s.io/v1beta1/ingressclasses\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteNetworkingV1beta1CollectionIngressClass = <ResponseContentType extends ResponseContentType$deleteNetworkingV1beta1CollectionIngressClass>(params: Params$deleteNetworkingV1beta1CollectionIngressClass<ResponseContentType>, option?: RequestOption): Promise<Response$deleteNetworkingV1beta1CollectionIngressClass$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/networking.k8s.io/v1beta1/ingressclasses\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readNetworkingV1beta1IngressClass = <ResponseContentType extends ResponseContentType$readNetworkingV1beta1IngressClass>(params: Params$readNetworkingV1beta1IngressClass<ResponseContentType>, option?: RequestOption): Promise<Response$readNetworkingV1beta1IngressClass$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/networking.k8s.io/v1beta1/ingressclasses/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            exact: { value: params.parameter.exact, explode: false },
-            export: { value: params.parameter.export, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceNetworkingV1beta1IngressClass = <ResponseContentType extends ResponseContentType$replaceNetworkingV1beta1IngressClass>(params: Params$replaceNetworkingV1beta1IngressClass<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceNetworkingV1beta1IngressClass$Status$200 | Response$replaceNetworkingV1beta1IngressClass$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/networking.k8s.io/v1beta1/ingressclasses/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteNetworkingV1beta1IngressClass = <ResponseContentType extends ResponseContentType$deleteNetworkingV1beta1IngressClass>(params: Params$deleteNetworkingV1beta1IngressClass<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteNetworkingV1beta1IngressClass$Status$200 | Response$deleteNetworkingV1beta1IngressClass$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/networking.k8s.io/v1beta1/ingressclasses/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchNetworkingV1beta1IngressClass = <RequestContentType extends RequestContentType$patchNetworkingV1beta1IngressClass, ResponseContentType extends ResponseContentType$patchNetworkingV1beta1IngressClass>(params: Params$patchNetworkingV1beta1IngressClass<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchNetworkingV1beta1IngressClass$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/networking.k8s.io/v1beta1/ingressclasses/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const listNetworkingV1beta1IngressForAllNamespaces = <ResponseContentType extends ResponseContentType$listNetworkingV1beta1IngressForAllNamespaces>(params: Params$listNetworkingV1beta1IngressForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$listNetworkingV1beta1IngressForAllNamespaces$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/networking.k8s.io/v1beta1/ingresses\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const listNetworkingV1beta1NamespacedIngress = <ResponseContentType extends ResponseContentType$listNetworkingV1beta1NamespacedIngress>(params: Params$listNetworkingV1beta1NamespacedIngress<ResponseContentType>, option?: RequestOption): Promise<Response$listNetworkingV1beta1NamespacedIngress$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/networking.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/ingresses\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const createNetworkingV1beta1NamespacedIngress = <ResponseContentType extends ResponseContentType$createNetworkingV1beta1NamespacedIngress>(params: Params$createNetworkingV1beta1NamespacedIngress<ResponseContentType>, option?: RequestOption): Promise<(Response$createNetworkingV1beta1NamespacedIngress$Status$200 | Response$createNetworkingV1beta1NamespacedIngress$Status$201 | Response$createNetworkingV1beta1NamespacedIngress$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/networking.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/ingresses\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteNetworkingV1beta1CollectionNamespacedIngress = <ResponseContentType extends ResponseContentType$deleteNetworkingV1beta1CollectionNamespacedIngress>(params: Params$deleteNetworkingV1beta1CollectionNamespacedIngress<ResponseContentType>, option?: RequestOption): Promise<Response$deleteNetworkingV1beta1CollectionNamespacedIngress$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/networking.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/ingresses\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readNetworkingV1beta1NamespacedIngress = <ResponseContentType extends ResponseContentType$readNetworkingV1beta1NamespacedIngress>(params: Params$readNetworkingV1beta1NamespacedIngress<ResponseContentType>, option?: RequestOption): Promise<Response$readNetworkingV1beta1NamespacedIngress$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/networking.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/ingresses/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            exact: { value: params.parameter.exact, explode: false },
-            export: { value: params.parameter.export, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceNetworkingV1beta1NamespacedIngress = <ResponseContentType extends ResponseContentType$replaceNetworkingV1beta1NamespacedIngress>(params: Params$replaceNetworkingV1beta1NamespacedIngress<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceNetworkingV1beta1NamespacedIngress$Status$200 | Response$replaceNetworkingV1beta1NamespacedIngress$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/networking.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/ingresses/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteNetworkingV1beta1NamespacedIngress = <ResponseContentType extends ResponseContentType$deleteNetworkingV1beta1NamespacedIngress>(params: Params$deleteNetworkingV1beta1NamespacedIngress<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteNetworkingV1beta1NamespacedIngress$Status$200 | Response$deleteNetworkingV1beta1NamespacedIngress$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/networking.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/ingresses/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchNetworkingV1beta1NamespacedIngress = <RequestContentType extends RequestContentType$patchNetworkingV1beta1NamespacedIngress, ResponseContentType extends ResponseContentType$patchNetworkingV1beta1NamespacedIngress>(params: Params$patchNetworkingV1beta1NamespacedIngress<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchNetworkingV1beta1NamespacedIngress$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/networking.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/ingresses/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readNetworkingV1beta1NamespacedIngressStatus = <ResponseContentType extends ResponseContentType$readNetworkingV1beta1NamespacedIngressStatus>(params: Params$readNetworkingV1beta1NamespacedIngressStatus<ResponseContentType>, option?: RequestOption): Promise<Response$readNetworkingV1beta1NamespacedIngressStatus$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/networking.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/ingresses/\${params.parameter.name}/status\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceNetworkingV1beta1NamespacedIngressStatus = <ResponseContentType extends ResponseContentType$replaceNetworkingV1beta1NamespacedIngressStatus>(params: Params$replaceNetworkingV1beta1NamespacedIngressStatus<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceNetworkingV1beta1NamespacedIngressStatus$Status$200 | Response$replaceNetworkingV1beta1NamespacedIngressStatus$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/networking.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/ingresses/\${params.parameter.name}/status\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchNetworkingV1beta1NamespacedIngressStatus = <RequestContentType extends RequestContentType$patchNetworkingV1beta1NamespacedIngressStatus, ResponseContentType extends ResponseContentType$patchNetworkingV1beta1NamespacedIngressStatus>(params: Params$patchNetworkingV1beta1NamespacedIngressStatus<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchNetworkingV1beta1NamespacedIngressStatus$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/networking.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/ingresses/\${params.parameter.name}/status\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const watchNetworkingV1beta1IngressClassList = <ResponseContentType extends ResponseContentType$watchNetworkingV1beta1IngressClassList>(params: Params$watchNetworkingV1beta1IngressClassList<ResponseContentType>, option?: RequestOption): Promise<Response$watchNetworkingV1beta1IngressClassList$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/networking.k8s.io/v1beta1/watch/ingressclasses\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchNetworkingV1beta1IngressClass = <ResponseContentType extends ResponseContentType$watchNetworkingV1beta1IngressClass>(params: Params$watchNetworkingV1beta1IngressClass<ResponseContentType>, option?: RequestOption): Promise<Response$watchNetworkingV1beta1IngressClass$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/networking.k8s.io/v1beta1/watch/ingressclasses/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchNetworkingV1beta1IngressListForAllNamespaces = <ResponseContentType extends ResponseContentType$watchNetworkingV1beta1IngressListForAllNamespaces>(params: Params$watchNetworkingV1beta1IngressListForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$watchNetworkingV1beta1IngressListForAllNamespaces$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/networking.k8s.io/v1beta1/watch/ingresses\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchNetworkingV1beta1NamespacedIngressList = <ResponseContentType extends ResponseContentType$watchNetworkingV1beta1NamespacedIngressList>(params: Params$watchNetworkingV1beta1NamespacedIngressList<ResponseContentType>, option?: RequestOption): Promise<Response$watchNetworkingV1beta1NamespacedIngressList$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/networking.k8s.io/v1beta1/watch/namespaces/\${params.parameter.namespace}/ingresses\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchNetworkingV1beta1NamespacedIngress = <ResponseContentType extends ResponseContentType$watchNetworkingV1beta1NamespacedIngress>(params: Params$watchNetworkingV1beta1NamespacedIngress<ResponseContentType>, option?: RequestOption): Promise<Response$watchNetworkingV1beta1NamespacedIngress$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/networking.k8s.io/v1beta1/watch/namespaces/\${params.parameter.namespace}/ingresses/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const getNodeAPIGroup = <ResponseContentType extends ResponseContentType$getNodeAPIGroup>(params: Params$getNodeAPIGroup<ResponseContentType>, option?: RequestOption): Promise<Response$getNodeAPIGroup$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/node.k8s.io/\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const getNodeV1alpha1APIResources = <ResponseContentType extends ResponseContentType$getNodeV1alpha1APIResources>(params: Params$getNodeV1alpha1APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getNodeV1alpha1APIResources$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/node.k8s.io/v1alpha1/\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const listNodeV1alpha1RuntimeClass = <ResponseContentType extends ResponseContentType$listNodeV1alpha1RuntimeClass>(params: Params$listNodeV1alpha1RuntimeClass<ResponseContentType>, option?: RequestOption): Promise<Response$listNodeV1alpha1RuntimeClass$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/node.k8s.io/v1alpha1/runtimeclasses\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const createNodeV1alpha1RuntimeClass = <ResponseContentType extends ResponseContentType$createNodeV1alpha1RuntimeClass>(params: Params$createNodeV1alpha1RuntimeClass<ResponseContentType>, option?: RequestOption): Promise<(Response$createNodeV1alpha1RuntimeClass$Status$200 | Response$createNodeV1alpha1RuntimeClass$Status$201 | Response$createNodeV1alpha1RuntimeClass$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/node.k8s.io/v1alpha1/runtimeclasses\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteNodeV1alpha1CollectionRuntimeClass = <ResponseContentType extends ResponseContentType$deleteNodeV1alpha1CollectionRuntimeClass>(params: Params$deleteNodeV1alpha1CollectionRuntimeClass<ResponseContentType>, option?: RequestOption): Promise<Response$deleteNodeV1alpha1CollectionRuntimeClass$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/node.k8s.io/v1alpha1/runtimeclasses\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readNodeV1alpha1RuntimeClass = <ResponseContentType extends ResponseContentType$readNodeV1alpha1RuntimeClass>(params: Params$readNodeV1alpha1RuntimeClass<ResponseContentType>, option?: RequestOption): Promise<Response$readNodeV1alpha1RuntimeClass$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/node.k8s.io/v1alpha1/runtimeclasses/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            exact: { value: params.parameter.exact, explode: false },
-            export: { value: params.parameter.export, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceNodeV1alpha1RuntimeClass = <ResponseContentType extends ResponseContentType$replaceNodeV1alpha1RuntimeClass>(params: Params$replaceNodeV1alpha1RuntimeClass<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceNodeV1alpha1RuntimeClass$Status$200 | Response$replaceNodeV1alpha1RuntimeClass$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/node.k8s.io/v1alpha1/runtimeclasses/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteNodeV1alpha1RuntimeClass = <ResponseContentType extends ResponseContentType$deleteNodeV1alpha1RuntimeClass>(params: Params$deleteNodeV1alpha1RuntimeClass<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteNodeV1alpha1RuntimeClass$Status$200 | Response$deleteNodeV1alpha1RuntimeClass$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/node.k8s.io/v1alpha1/runtimeclasses/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchNodeV1alpha1RuntimeClass = <RequestContentType extends RequestContentType$patchNodeV1alpha1RuntimeClass, ResponseContentType extends ResponseContentType$patchNodeV1alpha1RuntimeClass>(params: Params$patchNodeV1alpha1RuntimeClass<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchNodeV1alpha1RuntimeClass$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/node.k8s.io/v1alpha1/runtimeclasses/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const watchNodeV1alpha1RuntimeClassList = <ResponseContentType extends ResponseContentType$watchNodeV1alpha1RuntimeClassList>(params: Params$watchNodeV1alpha1RuntimeClassList<ResponseContentType>, option?: RequestOption): Promise<Response$watchNodeV1alpha1RuntimeClassList$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/node.k8s.io/v1alpha1/watch/runtimeclasses\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchNodeV1alpha1RuntimeClass = <ResponseContentType extends ResponseContentType$watchNodeV1alpha1RuntimeClass>(params: Params$watchNodeV1alpha1RuntimeClass<ResponseContentType>, option?: RequestOption): Promise<Response$watchNodeV1alpha1RuntimeClass$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/node.k8s.io/v1alpha1/watch/runtimeclasses/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const getNodeV1beta1APIResources = <ResponseContentType extends ResponseContentType$getNodeV1beta1APIResources>(params: Params$getNodeV1beta1APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getNodeV1beta1APIResources$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/node.k8s.io/v1beta1/\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const listNodeV1beta1RuntimeClass = <ResponseContentType extends ResponseContentType$listNodeV1beta1RuntimeClass>(params: Params$listNodeV1beta1RuntimeClass<ResponseContentType>, option?: RequestOption): Promise<Response$listNodeV1beta1RuntimeClass$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/node.k8s.io/v1beta1/runtimeclasses\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const createNodeV1beta1RuntimeClass = <ResponseContentType extends ResponseContentType$createNodeV1beta1RuntimeClass>(params: Params$createNodeV1beta1RuntimeClass<ResponseContentType>, option?: RequestOption): Promise<(Response$createNodeV1beta1RuntimeClass$Status$200 | Response$createNodeV1beta1RuntimeClass$Status$201 | Response$createNodeV1beta1RuntimeClass$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/node.k8s.io/v1beta1/runtimeclasses\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteNodeV1beta1CollectionRuntimeClass = <ResponseContentType extends ResponseContentType$deleteNodeV1beta1CollectionRuntimeClass>(params: Params$deleteNodeV1beta1CollectionRuntimeClass<ResponseContentType>, option?: RequestOption): Promise<Response$deleteNodeV1beta1CollectionRuntimeClass$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/node.k8s.io/v1beta1/runtimeclasses\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readNodeV1beta1RuntimeClass = <ResponseContentType extends ResponseContentType$readNodeV1beta1RuntimeClass>(params: Params$readNodeV1beta1RuntimeClass<ResponseContentType>, option?: RequestOption): Promise<Response$readNodeV1beta1RuntimeClass$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/node.k8s.io/v1beta1/runtimeclasses/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            exact: { value: params.parameter.exact, explode: false },
-            export: { value: params.parameter.export, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceNodeV1beta1RuntimeClass = <ResponseContentType extends ResponseContentType$replaceNodeV1beta1RuntimeClass>(params: Params$replaceNodeV1beta1RuntimeClass<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceNodeV1beta1RuntimeClass$Status$200 | Response$replaceNodeV1beta1RuntimeClass$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/node.k8s.io/v1beta1/runtimeclasses/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteNodeV1beta1RuntimeClass = <ResponseContentType extends ResponseContentType$deleteNodeV1beta1RuntimeClass>(params: Params$deleteNodeV1beta1RuntimeClass<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteNodeV1beta1RuntimeClass$Status$200 | Response$deleteNodeV1beta1RuntimeClass$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/node.k8s.io/v1beta1/runtimeclasses/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchNodeV1beta1RuntimeClass = <RequestContentType extends RequestContentType$patchNodeV1beta1RuntimeClass, ResponseContentType extends ResponseContentType$patchNodeV1beta1RuntimeClass>(params: Params$patchNodeV1beta1RuntimeClass<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchNodeV1beta1RuntimeClass$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/node.k8s.io/v1beta1/runtimeclasses/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const watchNodeV1beta1RuntimeClassList = <ResponseContentType extends ResponseContentType$watchNodeV1beta1RuntimeClassList>(params: Params$watchNodeV1beta1RuntimeClassList<ResponseContentType>, option?: RequestOption): Promise<Response$watchNodeV1beta1RuntimeClassList$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/node.k8s.io/v1beta1/watch/runtimeclasses\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchNodeV1beta1RuntimeClass = <ResponseContentType extends ResponseContentType$watchNodeV1beta1RuntimeClass>(params: Params$watchNodeV1beta1RuntimeClass<ResponseContentType>, option?: RequestOption): Promise<Response$watchNodeV1beta1RuntimeClass$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/node.k8s.io/v1beta1/watch/runtimeclasses/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const getPolicyAPIGroup = <ResponseContentType extends ResponseContentType$getPolicyAPIGroup>(params: Params$getPolicyAPIGroup<ResponseContentType>, option?: RequestOption): Promise<Response$getPolicyAPIGroup$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/policy/\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const getPolicyV1beta1APIResources = <ResponseContentType extends ResponseContentType$getPolicyV1beta1APIResources>(params: Params$getPolicyV1beta1APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getPolicyV1beta1APIResources$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/policy/v1beta1/\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const listPolicyV1beta1NamespacedPodDisruptionBudget = <ResponseContentType extends ResponseContentType$listPolicyV1beta1NamespacedPodDisruptionBudget>(params: Params$listPolicyV1beta1NamespacedPodDisruptionBudget<ResponseContentType>, option?: RequestOption): Promise<Response$listPolicyV1beta1NamespacedPodDisruptionBudget$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/policy/v1beta1/namespaces/\${params.parameter.namespace}/poddisruptionbudgets\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const createPolicyV1beta1NamespacedPodDisruptionBudget = <ResponseContentType extends ResponseContentType$createPolicyV1beta1NamespacedPodDisruptionBudget>(params: Params$createPolicyV1beta1NamespacedPodDisruptionBudget<ResponseContentType>, option?: RequestOption): Promise<(Response$createPolicyV1beta1NamespacedPodDisruptionBudget$Status$200 | Response$createPolicyV1beta1NamespacedPodDisruptionBudget$Status$201 | Response$createPolicyV1beta1NamespacedPodDisruptionBudget$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/policy/v1beta1/namespaces/\${params.parameter.namespace}/poddisruptionbudgets\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deletePolicyV1beta1CollectionNamespacedPodDisruptionBudget = <ResponseContentType extends ResponseContentType$deletePolicyV1beta1CollectionNamespacedPodDisruptionBudget>(params: Params$deletePolicyV1beta1CollectionNamespacedPodDisruptionBudget<ResponseContentType>, option?: RequestOption): Promise<Response$deletePolicyV1beta1CollectionNamespacedPodDisruptionBudget$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/policy/v1beta1/namespaces/\${params.parameter.namespace}/poddisruptionbudgets\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readPolicyV1beta1NamespacedPodDisruptionBudget = <ResponseContentType extends ResponseContentType$readPolicyV1beta1NamespacedPodDisruptionBudget>(params: Params$readPolicyV1beta1NamespacedPodDisruptionBudget<ResponseContentType>, option?: RequestOption): Promise<Response$readPolicyV1beta1NamespacedPodDisruptionBudget$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/policy/v1beta1/namespaces/\${params.parameter.namespace}/poddisruptionbudgets/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            exact: { value: params.parameter.exact, explode: false },
-            export: { value: params.parameter.export, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replacePolicyV1beta1NamespacedPodDisruptionBudget = <ResponseContentType extends ResponseContentType$replacePolicyV1beta1NamespacedPodDisruptionBudget>(params: Params$replacePolicyV1beta1NamespacedPodDisruptionBudget<ResponseContentType>, option?: RequestOption): Promise<(Response$replacePolicyV1beta1NamespacedPodDisruptionBudget$Status$200 | Response$replacePolicyV1beta1NamespacedPodDisruptionBudget$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/policy/v1beta1/namespaces/\${params.parameter.namespace}/poddisruptionbudgets/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deletePolicyV1beta1NamespacedPodDisruptionBudget = <ResponseContentType extends ResponseContentType$deletePolicyV1beta1NamespacedPodDisruptionBudget>(params: Params$deletePolicyV1beta1NamespacedPodDisruptionBudget<ResponseContentType>, option?: RequestOption): Promise<(Response$deletePolicyV1beta1NamespacedPodDisruptionBudget$Status$200 | Response$deletePolicyV1beta1NamespacedPodDisruptionBudget$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/policy/v1beta1/namespaces/\${params.parameter.namespace}/poddisruptionbudgets/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchPolicyV1beta1NamespacedPodDisruptionBudget = <RequestContentType extends RequestContentType$patchPolicyV1beta1NamespacedPodDisruptionBudget, ResponseContentType extends ResponseContentType$patchPolicyV1beta1NamespacedPodDisruptionBudget>(params: Params$patchPolicyV1beta1NamespacedPodDisruptionBudget<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchPolicyV1beta1NamespacedPodDisruptionBudget$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/policy/v1beta1/namespaces/\${params.parameter.namespace}/poddisruptionbudgets/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readPolicyV1beta1NamespacedPodDisruptionBudgetStatus = <ResponseContentType extends ResponseContentType$readPolicyV1beta1NamespacedPodDisruptionBudgetStatus>(params: Params$readPolicyV1beta1NamespacedPodDisruptionBudgetStatus<ResponseContentType>, option?: RequestOption): Promise<Response$readPolicyV1beta1NamespacedPodDisruptionBudgetStatus$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/policy/v1beta1/namespaces/\${params.parameter.namespace}/poddisruptionbudgets/\${params.parameter.name}/status\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replacePolicyV1beta1NamespacedPodDisruptionBudgetStatus = <ResponseContentType extends ResponseContentType$replacePolicyV1beta1NamespacedPodDisruptionBudgetStatus>(params: Params$replacePolicyV1beta1NamespacedPodDisruptionBudgetStatus<ResponseContentType>, option?: RequestOption): Promise<(Response$replacePolicyV1beta1NamespacedPodDisruptionBudgetStatus$Status$200 | Response$replacePolicyV1beta1NamespacedPodDisruptionBudgetStatus$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/policy/v1beta1/namespaces/\${params.parameter.namespace}/poddisruptionbudgets/\${params.parameter.name}/status\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchPolicyV1beta1NamespacedPodDisruptionBudgetStatus = <RequestContentType extends RequestContentType$patchPolicyV1beta1NamespacedPodDisruptionBudgetStatus, ResponseContentType extends ResponseContentType$patchPolicyV1beta1NamespacedPodDisruptionBudgetStatus>(params: Params$patchPolicyV1beta1NamespacedPodDisruptionBudgetStatus<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchPolicyV1beta1NamespacedPodDisruptionBudgetStatus$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/policy/v1beta1/namespaces/\${params.parameter.namespace}/poddisruptionbudgets/\${params.parameter.name}/status\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const listPolicyV1beta1PodDisruptionBudgetForAllNamespaces = <ResponseContentType extends ResponseContentType$listPolicyV1beta1PodDisruptionBudgetForAllNamespaces>(params: Params$listPolicyV1beta1PodDisruptionBudgetForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$listPolicyV1beta1PodDisruptionBudgetForAllNamespaces$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/policy/v1beta1/poddisruptionbudgets\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const listPolicyV1beta1PodSecurityPolicy = <ResponseContentType extends ResponseContentType$listPolicyV1beta1PodSecurityPolicy>(params: Params$listPolicyV1beta1PodSecurityPolicy<ResponseContentType>, option?: RequestOption): Promise<Response$listPolicyV1beta1PodSecurityPolicy$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/policy/v1beta1/podsecuritypolicies\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const createPolicyV1beta1PodSecurityPolicy = <ResponseContentType extends ResponseContentType$createPolicyV1beta1PodSecurityPolicy>(params: Params$createPolicyV1beta1PodSecurityPolicy<ResponseContentType>, option?: RequestOption): Promise<(Response$createPolicyV1beta1PodSecurityPolicy$Status$200 | Response$createPolicyV1beta1PodSecurityPolicy$Status$201 | Response$createPolicyV1beta1PodSecurityPolicy$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/policy/v1beta1/podsecuritypolicies\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deletePolicyV1beta1CollectionPodSecurityPolicy = <ResponseContentType extends ResponseContentType$deletePolicyV1beta1CollectionPodSecurityPolicy>(params: Params$deletePolicyV1beta1CollectionPodSecurityPolicy<ResponseContentType>, option?: RequestOption): Promise<Response$deletePolicyV1beta1CollectionPodSecurityPolicy$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/policy/v1beta1/podsecuritypolicies\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readPolicyV1beta1PodSecurityPolicy = <ResponseContentType extends ResponseContentType$readPolicyV1beta1PodSecurityPolicy>(params: Params$readPolicyV1beta1PodSecurityPolicy<ResponseContentType>, option?: RequestOption): Promise<Response$readPolicyV1beta1PodSecurityPolicy$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/policy/v1beta1/podsecuritypolicies/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            exact: { value: params.parameter.exact, explode: false },
-            export: { value: params.parameter.export, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replacePolicyV1beta1PodSecurityPolicy = <ResponseContentType extends ResponseContentType$replacePolicyV1beta1PodSecurityPolicy>(params: Params$replacePolicyV1beta1PodSecurityPolicy<ResponseContentType>, option?: RequestOption): Promise<(Response$replacePolicyV1beta1PodSecurityPolicy$Status$200 | Response$replacePolicyV1beta1PodSecurityPolicy$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/policy/v1beta1/podsecuritypolicies/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deletePolicyV1beta1PodSecurityPolicy = <ResponseContentType extends ResponseContentType$deletePolicyV1beta1PodSecurityPolicy>(params: Params$deletePolicyV1beta1PodSecurityPolicy<ResponseContentType>, option?: RequestOption): Promise<(Response$deletePolicyV1beta1PodSecurityPolicy$Status$200 | Response$deletePolicyV1beta1PodSecurityPolicy$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/policy/v1beta1/podsecuritypolicies/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchPolicyV1beta1PodSecurityPolicy = <RequestContentType extends RequestContentType$patchPolicyV1beta1PodSecurityPolicy, ResponseContentType extends ResponseContentType$patchPolicyV1beta1PodSecurityPolicy>(params: Params$patchPolicyV1beta1PodSecurityPolicy<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchPolicyV1beta1PodSecurityPolicy$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/policy/v1beta1/podsecuritypolicies/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const watchPolicyV1beta1NamespacedPodDisruptionBudgetList = <ResponseContentType extends ResponseContentType$watchPolicyV1beta1NamespacedPodDisruptionBudgetList>(params: Params$watchPolicyV1beta1NamespacedPodDisruptionBudgetList<ResponseContentType>, option?: RequestOption): Promise<Response$watchPolicyV1beta1NamespacedPodDisruptionBudgetList$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/policy/v1beta1/watch/namespaces/\${params.parameter.namespace}/poddisruptionbudgets\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchPolicyV1beta1NamespacedPodDisruptionBudget = <ResponseContentType extends ResponseContentType$watchPolicyV1beta1NamespacedPodDisruptionBudget>(params: Params$watchPolicyV1beta1NamespacedPodDisruptionBudget<ResponseContentType>, option?: RequestOption): Promise<Response$watchPolicyV1beta1NamespacedPodDisruptionBudget$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/policy/v1beta1/watch/namespaces/\${params.parameter.namespace}/poddisruptionbudgets/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchPolicyV1beta1PodDisruptionBudgetListForAllNamespaces = <ResponseContentType extends ResponseContentType$watchPolicyV1beta1PodDisruptionBudgetListForAllNamespaces>(params: Params$watchPolicyV1beta1PodDisruptionBudgetListForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$watchPolicyV1beta1PodDisruptionBudgetListForAllNamespaces$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/policy/v1beta1/watch/poddisruptionbudgets\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchPolicyV1beta1PodSecurityPolicyList = <ResponseContentType extends ResponseContentType$watchPolicyV1beta1PodSecurityPolicyList>(params: Params$watchPolicyV1beta1PodSecurityPolicyList<ResponseContentType>, option?: RequestOption): Promise<Response$watchPolicyV1beta1PodSecurityPolicyList$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/policy/v1beta1/watch/podsecuritypolicies\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchPolicyV1beta1PodSecurityPolicy = <ResponseContentType extends ResponseContentType$watchPolicyV1beta1PodSecurityPolicy>(params: Params$watchPolicyV1beta1PodSecurityPolicy<ResponseContentType>, option?: RequestOption): Promise<Response$watchPolicyV1beta1PodSecurityPolicy$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/policy/v1beta1/watch/podsecuritypolicies/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const getRbacAuthorizationAPIGroup = <ResponseContentType extends ResponseContentType$getRbacAuthorizationAPIGroup>(params: Params$getRbacAuthorizationAPIGroup<ResponseContentType>, option?: RequestOption): Promise<Response$getRbacAuthorizationAPIGroup$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const getRbacAuthorizationV1APIResources = <ResponseContentType extends ResponseContentType$getRbacAuthorizationV1APIResources>(params: Params$getRbacAuthorizationV1APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getRbacAuthorizationV1APIResources$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const listRbacAuthorizationV1ClusterRoleBinding = <ResponseContentType extends ResponseContentType$listRbacAuthorizationV1ClusterRoleBinding>(params: Params$listRbacAuthorizationV1ClusterRoleBinding<ResponseContentType>, option?: RequestOption): Promise<Response$listRbacAuthorizationV1ClusterRoleBinding$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/clusterrolebindings\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const createRbacAuthorizationV1ClusterRoleBinding = <ResponseContentType extends ResponseContentType$createRbacAuthorizationV1ClusterRoleBinding>(params: Params$createRbacAuthorizationV1ClusterRoleBinding<ResponseContentType>, option?: RequestOption): Promise<(Response$createRbacAuthorizationV1ClusterRoleBinding$Status$200 | Response$createRbacAuthorizationV1ClusterRoleBinding$Status$201 | Response$createRbacAuthorizationV1ClusterRoleBinding$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/clusterrolebindings\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteRbacAuthorizationV1CollectionClusterRoleBinding = <ResponseContentType extends ResponseContentType$deleteRbacAuthorizationV1CollectionClusterRoleBinding>(params: Params$deleteRbacAuthorizationV1CollectionClusterRoleBinding<ResponseContentType>, option?: RequestOption): Promise<Response$deleteRbacAuthorizationV1CollectionClusterRoleBinding$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/clusterrolebindings\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readRbacAuthorizationV1ClusterRoleBinding = <ResponseContentType extends ResponseContentType$readRbacAuthorizationV1ClusterRoleBinding>(params: Params$readRbacAuthorizationV1ClusterRoleBinding<ResponseContentType>, option?: RequestOption): Promise<Response$readRbacAuthorizationV1ClusterRoleBinding$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/clusterrolebindings/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceRbacAuthorizationV1ClusterRoleBinding = <ResponseContentType extends ResponseContentType$replaceRbacAuthorizationV1ClusterRoleBinding>(params: Params$replaceRbacAuthorizationV1ClusterRoleBinding<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceRbacAuthorizationV1ClusterRoleBinding$Status$200 | Response$replaceRbacAuthorizationV1ClusterRoleBinding$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/clusterrolebindings/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteRbacAuthorizationV1ClusterRoleBinding = <ResponseContentType extends ResponseContentType$deleteRbacAuthorizationV1ClusterRoleBinding>(params: Params$deleteRbacAuthorizationV1ClusterRoleBinding<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteRbacAuthorizationV1ClusterRoleBinding$Status$200 | Response$deleteRbacAuthorizationV1ClusterRoleBinding$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/clusterrolebindings/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchRbacAuthorizationV1ClusterRoleBinding = <RequestContentType extends RequestContentType$patchRbacAuthorizationV1ClusterRoleBinding, ResponseContentType extends ResponseContentType$patchRbacAuthorizationV1ClusterRoleBinding>(params: Params$patchRbacAuthorizationV1ClusterRoleBinding<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchRbacAuthorizationV1ClusterRoleBinding$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/clusterrolebindings/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const listRbacAuthorizationV1ClusterRole = <ResponseContentType extends ResponseContentType$listRbacAuthorizationV1ClusterRole>(params: Params$listRbacAuthorizationV1ClusterRole<ResponseContentType>, option?: RequestOption): Promise<Response$listRbacAuthorizationV1ClusterRole$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/clusterroles\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const createRbacAuthorizationV1ClusterRole = <ResponseContentType extends ResponseContentType$createRbacAuthorizationV1ClusterRole>(params: Params$createRbacAuthorizationV1ClusterRole<ResponseContentType>, option?: RequestOption): Promise<(Response$createRbacAuthorizationV1ClusterRole$Status$200 | Response$createRbacAuthorizationV1ClusterRole$Status$201 | Response$createRbacAuthorizationV1ClusterRole$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/clusterroles\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteRbacAuthorizationV1CollectionClusterRole = <ResponseContentType extends ResponseContentType$deleteRbacAuthorizationV1CollectionClusterRole>(params: Params$deleteRbacAuthorizationV1CollectionClusterRole<ResponseContentType>, option?: RequestOption): Promise<Response$deleteRbacAuthorizationV1CollectionClusterRole$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/clusterroles\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readRbacAuthorizationV1ClusterRole = <ResponseContentType extends ResponseContentType$readRbacAuthorizationV1ClusterRole>(params: Params$readRbacAuthorizationV1ClusterRole<ResponseContentType>, option?: RequestOption): Promise<Response$readRbacAuthorizationV1ClusterRole$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/clusterroles/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceRbacAuthorizationV1ClusterRole = <ResponseContentType extends ResponseContentType$replaceRbacAuthorizationV1ClusterRole>(params: Params$replaceRbacAuthorizationV1ClusterRole<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceRbacAuthorizationV1ClusterRole$Status$200 | Response$replaceRbacAuthorizationV1ClusterRole$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/clusterroles/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteRbacAuthorizationV1ClusterRole = <ResponseContentType extends ResponseContentType$deleteRbacAuthorizationV1ClusterRole>(params: Params$deleteRbacAuthorizationV1ClusterRole<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteRbacAuthorizationV1ClusterRole$Status$200 | Response$deleteRbacAuthorizationV1ClusterRole$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/clusterroles/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchRbacAuthorizationV1ClusterRole = <RequestContentType extends RequestContentType$patchRbacAuthorizationV1ClusterRole, ResponseContentType extends ResponseContentType$patchRbacAuthorizationV1ClusterRole>(params: Params$patchRbacAuthorizationV1ClusterRole<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchRbacAuthorizationV1ClusterRole$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/clusterroles/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const listRbacAuthorizationV1NamespacedRoleBinding = <ResponseContentType extends ResponseContentType$listRbacAuthorizationV1NamespacedRoleBinding>(params: Params$listRbacAuthorizationV1NamespacedRoleBinding<ResponseContentType>, option?: RequestOption): Promise<Response$listRbacAuthorizationV1NamespacedRoleBinding$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/namespaces/\${params.parameter.namespace}/rolebindings\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const createRbacAuthorizationV1NamespacedRoleBinding = <ResponseContentType extends ResponseContentType$createRbacAuthorizationV1NamespacedRoleBinding>(params: Params$createRbacAuthorizationV1NamespacedRoleBinding<ResponseContentType>, option?: RequestOption): Promise<(Response$createRbacAuthorizationV1NamespacedRoleBinding$Status$200 | Response$createRbacAuthorizationV1NamespacedRoleBinding$Status$201 | Response$createRbacAuthorizationV1NamespacedRoleBinding$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/namespaces/\${params.parameter.namespace}/rolebindings\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteRbacAuthorizationV1CollectionNamespacedRoleBinding = <ResponseContentType extends ResponseContentType$deleteRbacAuthorizationV1CollectionNamespacedRoleBinding>(params: Params$deleteRbacAuthorizationV1CollectionNamespacedRoleBinding<ResponseContentType>, option?: RequestOption): Promise<Response$deleteRbacAuthorizationV1CollectionNamespacedRoleBinding$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/namespaces/\${params.parameter.namespace}/rolebindings\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readRbacAuthorizationV1NamespacedRoleBinding = <ResponseContentType extends ResponseContentType$readRbacAuthorizationV1NamespacedRoleBinding>(params: Params$readRbacAuthorizationV1NamespacedRoleBinding<ResponseContentType>, option?: RequestOption): Promise<Response$readRbacAuthorizationV1NamespacedRoleBinding$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/namespaces/\${params.parameter.namespace}/rolebindings/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceRbacAuthorizationV1NamespacedRoleBinding = <ResponseContentType extends ResponseContentType$replaceRbacAuthorizationV1NamespacedRoleBinding>(params: Params$replaceRbacAuthorizationV1NamespacedRoleBinding<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceRbacAuthorizationV1NamespacedRoleBinding$Status$200 | Response$replaceRbacAuthorizationV1NamespacedRoleBinding$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/namespaces/\${params.parameter.namespace}/rolebindings/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteRbacAuthorizationV1NamespacedRoleBinding = <ResponseContentType extends ResponseContentType$deleteRbacAuthorizationV1NamespacedRoleBinding>(params: Params$deleteRbacAuthorizationV1NamespacedRoleBinding<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteRbacAuthorizationV1NamespacedRoleBinding$Status$200 | Response$deleteRbacAuthorizationV1NamespacedRoleBinding$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/namespaces/\${params.parameter.namespace}/rolebindings/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchRbacAuthorizationV1NamespacedRoleBinding = <RequestContentType extends RequestContentType$patchRbacAuthorizationV1NamespacedRoleBinding, ResponseContentType extends ResponseContentType$patchRbacAuthorizationV1NamespacedRoleBinding>(params: Params$patchRbacAuthorizationV1NamespacedRoleBinding<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchRbacAuthorizationV1NamespacedRoleBinding$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/namespaces/\${params.parameter.namespace}/rolebindings/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const listRbacAuthorizationV1NamespacedRole = <ResponseContentType extends ResponseContentType$listRbacAuthorizationV1NamespacedRole>(params: Params$listRbacAuthorizationV1NamespacedRole<ResponseContentType>, option?: RequestOption): Promise<Response$listRbacAuthorizationV1NamespacedRole$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/namespaces/\${params.parameter.namespace}/roles\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const createRbacAuthorizationV1NamespacedRole = <ResponseContentType extends ResponseContentType$createRbacAuthorizationV1NamespacedRole>(params: Params$createRbacAuthorizationV1NamespacedRole<ResponseContentType>, option?: RequestOption): Promise<(Response$createRbacAuthorizationV1NamespacedRole$Status$200 | Response$createRbacAuthorizationV1NamespacedRole$Status$201 | Response$createRbacAuthorizationV1NamespacedRole$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/namespaces/\${params.parameter.namespace}/roles\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteRbacAuthorizationV1CollectionNamespacedRole = <ResponseContentType extends ResponseContentType$deleteRbacAuthorizationV1CollectionNamespacedRole>(params: Params$deleteRbacAuthorizationV1CollectionNamespacedRole<ResponseContentType>, option?: RequestOption): Promise<Response$deleteRbacAuthorizationV1CollectionNamespacedRole$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/namespaces/\${params.parameter.namespace}/roles\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readRbacAuthorizationV1NamespacedRole = <ResponseContentType extends ResponseContentType$readRbacAuthorizationV1NamespacedRole>(params: Params$readRbacAuthorizationV1NamespacedRole<ResponseContentType>, option?: RequestOption): Promise<Response$readRbacAuthorizationV1NamespacedRole$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/namespaces/\${params.parameter.namespace}/roles/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceRbacAuthorizationV1NamespacedRole = <ResponseContentType extends ResponseContentType$replaceRbacAuthorizationV1NamespacedRole>(params: Params$replaceRbacAuthorizationV1NamespacedRole<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceRbacAuthorizationV1NamespacedRole$Status$200 | Response$replaceRbacAuthorizationV1NamespacedRole$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/namespaces/\${params.parameter.namespace}/roles/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteRbacAuthorizationV1NamespacedRole = <ResponseContentType extends ResponseContentType$deleteRbacAuthorizationV1NamespacedRole>(params: Params$deleteRbacAuthorizationV1NamespacedRole<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteRbacAuthorizationV1NamespacedRole$Status$200 | Response$deleteRbacAuthorizationV1NamespacedRole$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/namespaces/\${params.parameter.namespace}/roles/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchRbacAuthorizationV1NamespacedRole = <RequestContentType extends RequestContentType$patchRbacAuthorizationV1NamespacedRole, ResponseContentType extends ResponseContentType$patchRbacAuthorizationV1NamespacedRole>(params: Params$patchRbacAuthorizationV1NamespacedRole<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchRbacAuthorizationV1NamespacedRole$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/namespaces/\${params.parameter.namespace}/roles/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const listRbacAuthorizationV1RoleBindingForAllNamespaces = <ResponseContentType extends ResponseContentType$listRbacAuthorizationV1RoleBindingForAllNamespaces>(params: Params$listRbacAuthorizationV1RoleBindingForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$listRbacAuthorizationV1RoleBindingForAllNamespaces$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/rolebindings\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const listRbacAuthorizationV1RoleForAllNamespaces = <ResponseContentType extends ResponseContentType$listRbacAuthorizationV1RoleForAllNamespaces>(params: Params$listRbacAuthorizationV1RoleForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$listRbacAuthorizationV1RoleForAllNamespaces$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/roles\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchRbacAuthorizationV1ClusterRoleBindingList = <ResponseContentType extends ResponseContentType$watchRbacAuthorizationV1ClusterRoleBindingList>(params: Params$watchRbacAuthorizationV1ClusterRoleBindingList<ResponseContentType>, option?: RequestOption): Promise<Response$watchRbacAuthorizationV1ClusterRoleBindingList$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/watch/clusterrolebindings\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchRbacAuthorizationV1ClusterRoleBinding = <ResponseContentType extends ResponseContentType$watchRbacAuthorizationV1ClusterRoleBinding>(params: Params$watchRbacAuthorizationV1ClusterRoleBinding<ResponseContentType>, option?: RequestOption): Promise<Response$watchRbacAuthorizationV1ClusterRoleBinding$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/watch/clusterrolebindings/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchRbacAuthorizationV1ClusterRoleList = <ResponseContentType extends ResponseContentType$watchRbacAuthorizationV1ClusterRoleList>(params: Params$watchRbacAuthorizationV1ClusterRoleList<ResponseContentType>, option?: RequestOption): Promise<Response$watchRbacAuthorizationV1ClusterRoleList$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/watch/clusterroles\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchRbacAuthorizationV1ClusterRole = <ResponseContentType extends ResponseContentType$watchRbacAuthorizationV1ClusterRole>(params: Params$watchRbacAuthorizationV1ClusterRole<ResponseContentType>, option?: RequestOption): Promise<Response$watchRbacAuthorizationV1ClusterRole$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/watch/clusterroles/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchRbacAuthorizationV1NamespacedRoleBindingList = <ResponseContentType extends ResponseContentType$watchRbacAuthorizationV1NamespacedRoleBindingList>(params: Params$watchRbacAuthorizationV1NamespacedRoleBindingList<ResponseContentType>, option?: RequestOption): Promise<Response$watchRbacAuthorizationV1NamespacedRoleBindingList$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/watch/namespaces/\${params.parameter.namespace}/rolebindings\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchRbacAuthorizationV1NamespacedRoleBinding = <ResponseContentType extends ResponseContentType$watchRbacAuthorizationV1NamespacedRoleBinding>(params: Params$watchRbacAuthorizationV1NamespacedRoleBinding<ResponseContentType>, option?: RequestOption): Promise<Response$watchRbacAuthorizationV1NamespacedRoleBinding$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/watch/namespaces/\${params.parameter.namespace}/rolebindings/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchRbacAuthorizationV1NamespacedRoleList = <ResponseContentType extends ResponseContentType$watchRbacAuthorizationV1NamespacedRoleList>(params: Params$watchRbacAuthorizationV1NamespacedRoleList<ResponseContentType>, option?: RequestOption): Promise<Response$watchRbacAuthorizationV1NamespacedRoleList$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/watch/namespaces/\${params.parameter.namespace}/roles\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchRbacAuthorizationV1NamespacedRole = <ResponseContentType extends ResponseContentType$watchRbacAuthorizationV1NamespacedRole>(params: Params$watchRbacAuthorizationV1NamespacedRole<ResponseContentType>, option?: RequestOption): Promise<Response$watchRbacAuthorizationV1NamespacedRole$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/watch/namespaces/\${params.parameter.namespace}/roles/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchRbacAuthorizationV1RoleBindingListForAllNamespaces = <ResponseContentType extends ResponseContentType$watchRbacAuthorizationV1RoleBindingListForAllNamespaces>(params: Params$watchRbacAuthorizationV1RoleBindingListForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$watchRbacAuthorizationV1RoleBindingListForAllNamespaces$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/watch/rolebindings\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchRbacAuthorizationV1RoleListForAllNamespaces = <ResponseContentType extends ResponseContentType$watchRbacAuthorizationV1RoleListForAllNamespaces>(params: Params$watchRbacAuthorizationV1RoleListForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$watchRbacAuthorizationV1RoleListForAllNamespaces$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/watch/roles\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const getRbacAuthorizationV1alpha1APIResources = <ResponseContentType extends ResponseContentType$getRbacAuthorizationV1alpha1APIResources>(params: Params$getRbacAuthorizationV1alpha1APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getRbacAuthorizationV1alpha1APIResources$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const listRbacAuthorizationV1alpha1ClusterRoleBinding = <ResponseContentType extends ResponseContentType$listRbacAuthorizationV1alpha1ClusterRoleBinding>(params: Params$listRbacAuthorizationV1alpha1ClusterRoleBinding<ResponseContentType>, option?: RequestOption): Promise<Response$listRbacAuthorizationV1alpha1ClusterRoleBinding$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/clusterrolebindings\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const createRbacAuthorizationV1alpha1ClusterRoleBinding = <ResponseContentType extends ResponseContentType$createRbacAuthorizationV1alpha1ClusterRoleBinding>(params: Params$createRbacAuthorizationV1alpha1ClusterRoleBinding<ResponseContentType>, option?: RequestOption): Promise<(Response$createRbacAuthorizationV1alpha1ClusterRoleBinding$Status$200 | Response$createRbacAuthorizationV1alpha1ClusterRoleBinding$Status$201 | Response$createRbacAuthorizationV1alpha1ClusterRoleBinding$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/clusterrolebindings\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteRbacAuthorizationV1alpha1CollectionClusterRoleBinding = <ResponseContentType extends ResponseContentType$deleteRbacAuthorizationV1alpha1CollectionClusterRoleBinding>(params: Params$deleteRbacAuthorizationV1alpha1CollectionClusterRoleBinding<ResponseContentType>, option?: RequestOption): Promise<Response$deleteRbacAuthorizationV1alpha1CollectionClusterRoleBinding$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/clusterrolebindings\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readRbacAuthorizationV1alpha1ClusterRoleBinding = <ResponseContentType extends ResponseContentType$readRbacAuthorizationV1alpha1ClusterRoleBinding>(params: Params$readRbacAuthorizationV1alpha1ClusterRoleBinding<ResponseContentType>, option?: RequestOption): Promise<Response$readRbacAuthorizationV1alpha1ClusterRoleBinding$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/clusterrolebindings/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceRbacAuthorizationV1alpha1ClusterRoleBinding = <ResponseContentType extends ResponseContentType$replaceRbacAuthorizationV1alpha1ClusterRoleBinding>(params: Params$replaceRbacAuthorizationV1alpha1ClusterRoleBinding<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceRbacAuthorizationV1alpha1ClusterRoleBinding$Status$200 | Response$replaceRbacAuthorizationV1alpha1ClusterRoleBinding$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/clusterrolebindings/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteRbacAuthorizationV1alpha1ClusterRoleBinding = <ResponseContentType extends ResponseContentType$deleteRbacAuthorizationV1alpha1ClusterRoleBinding>(params: Params$deleteRbacAuthorizationV1alpha1ClusterRoleBinding<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteRbacAuthorizationV1alpha1ClusterRoleBinding$Status$200 | Response$deleteRbacAuthorizationV1alpha1ClusterRoleBinding$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/clusterrolebindings/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchRbacAuthorizationV1alpha1ClusterRoleBinding = <RequestContentType extends RequestContentType$patchRbacAuthorizationV1alpha1ClusterRoleBinding, ResponseContentType extends ResponseContentType$patchRbacAuthorizationV1alpha1ClusterRoleBinding>(params: Params$patchRbacAuthorizationV1alpha1ClusterRoleBinding<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchRbacAuthorizationV1alpha1ClusterRoleBinding$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/clusterrolebindings/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const listRbacAuthorizationV1alpha1ClusterRole = <ResponseContentType extends ResponseContentType$listRbacAuthorizationV1alpha1ClusterRole>(params: Params$listRbacAuthorizationV1alpha1ClusterRole<ResponseContentType>, option?: RequestOption): Promise<Response$listRbacAuthorizationV1alpha1ClusterRole$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/clusterroles\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const createRbacAuthorizationV1alpha1ClusterRole = <ResponseContentType extends ResponseContentType$createRbacAuthorizationV1alpha1ClusterRole>(params: Params$createRbacAuthorizationV1alpha1ClusterRole<ResponseContentType>, option?: RequestOption): Promise<(Response$createRbacAuthorizationV1alpha1ClusterRole$Status$200 | Response$createRbacAuthorizationV1alpha1ClusterRole$Status$201 | Response$createRbacAuthorizationV1alpha1ClusterRole$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/clusterroles\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteRbacAuthorizationV1alpha1CollectionClusterRole = <ResponseContentType extends ResponseContentType$deleteRbacAuthorizationV1alpha1CollectionClusterRole>(params: Params$deleteRbacAuthorizationV1alpha1CollectionClusterRole<ResponseContentType>, option?: RequestOption): Promise<Response$deleteRbacAuthorizationV1alpha1CollectionClusterRole$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/clusterroles\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readRbacAuthorizationV1alpha1ClusterRole = <ResponseContentType extends ResponseContentType$readRbacAuthorizationV1alpha1ClusterRole>(params: Params$readRbacAuthorizationV1alpha1ClusterRole<ResponseContentType>, option?: RequestOption): Promise<Response$readRbacAuthorizationV1alpha1ClusterRole$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/clusterroles/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceRbacAuthorizationV1alpha1ClusterRole = <ResponseContentType extends ResponseContentType$replaceRbacAuthorizationV1alpha1ClusterRole>(params: Params$replaceRbacAuthorizationV1alpha1ClusterRole<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceRbacAuthorizationV1alpha1ClusterRole$Status$200 | Response$replaceRbacAuthorizationV1alpha1ClusterRole$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/clusterroles/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteRbacAuthorizationV1alpha1ClusterRole = <ResponseContentType extends ResponseContentType$deleteRbacAuthorizationV1alpha1ClusterRole>(params: Params$deleteRbacAuthorizationV1alpha1ClusterRole<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteRbacAuthorizationV1alpha1ClusterRole$Status$200 | Response$deleteRbacAuthorizationV1alpha1ClusterRole$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/clusterroles/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchRbacAuthorizationV1alpha1ClusterRole = <RequestContentType extends RequestContentType$patchRbacAuthorizationV1alpha1ClusterRole, ResponseContentType extends ResponseContentType$patchRbacAuthorizationV1alpha1ClusterRole>(params: Params$patchRbacAuthorizationV1alpha1ClusterRole<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchRbacAuthorizationV1alpha1ClusterRole$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/clusterroles/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const listRbacAuthorizationV1alpha1NamespacedRoleBinding = <ResponseContentType extends ResponseContentType$listRbacAuthorizationV1alpha1NamespacedRoleBinding>(params: Params$listRbacAuthorizationV1alpha1NamespacedRoleBinding<ResponseContentType>, option?: RequestOption): Promise<Response$listRbacAuthorizationV1alpha1NamespacedRoleBinding$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/namespaces/\${params.parameter.namespace}/rolebindings\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const createRbacAuthorizationV1alpha1NamespacedRoleBinding = <ResponseContentType extends ResponseContentType$createRbacAuthorizationV1alpha1NamespacedRoleBinding>(params: Params$createRbacAuthorizationV1alpha1NamespacedRoleBinding<ResponseContentType>, option?: RequestOption): Promise<(Response$createRbacAuthorizationV1alpha1NamespacedRoleBinding$Status$200 | Response$createRbacAuthorizationV1alpha1NamespacedRoleBinding$Status$201 | Response$createRbacAuthorizationV1alpha1NamespacedRoleBinding$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/namespaces/\${params.parameter.namespace}/rolebindings\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteRbacAuthorizationV1alpha1CollectionNamespacedRoleBinding = <ResponseContentType extends ResponseContentType$deleteRbacAuthorizationV1alpha1CollectionNamespacedRoleBinding>(params: Params$deleteRbacAuthorizationV1alpha1CollectionNamespacedRoleBinding<ResponseContentType>, option?: RequestOption): Promise<Response$deleteRbacAuthorizationV1alpha1CollectionNamespacedRoleBinding$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/namespaces/\${params.parameter.namespace}/rolebindings\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readRbacAuthorizationV1alpha1NamespacedRoleBinding = <ResponseContentType extends ResponseContentType$readRbacAuthorizationV1alpha1NamespacedRoleBinding>(params: Params$readRbacAuthorizationV1alpha1NamespacedRoleBinding<ResponseContentType>, option?: RequestOption): Promise<Response$readRbacAuthorizationV1alpha1NamespacedRoleBinding$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/namespaces/\${params.parameter.namespace}/rolebindings/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceRbacAuthorizationV1alpha1NamespacedRoleBinding = <ResponseContentType extends ResponseContentType$replaceRbacAuthorizationV1alpha1NamespacedRoleBinding>(params: Params$replaceRbacAuthorizationV1alpha1NamespacedRoleBinding<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceRbacAuthorizationV1alpha1NamespacedRoleBinding$Status$200 | Response$replaceRbacAuthorizationV1alpha1NamespacedRoleBinding$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/namespaces/\${params.parameter.namespace}/rolebindings/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteRbacAuthorizationV1alpha1NamespacedRoleBinding = <ResponseContentType extends ResponseContentType$deleteRbacAuthorizationV1alpha1NamespacedRoleBinding>(params: Params$deleteRbacAuthorizationV1alpha1NamespacedRoleBinding<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteRbacAuthorizationV1alpha1NamespacedRoleBinding$Status$200 | Response$deleteRbacAuthorizationV1alpha1NamespacedRoleBinding$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/namespaces/\${params.parameter.namespace}/rolebindings/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchRbacAuthorizationV1alpha1NamespacedRoleBinding = <RequestContentType extends RequestContentType$patchRbacAuthorizationV1alpha1NamespacedRoleBinding, ResponseContentType extends ResponseContentType$patchRbacAuthorizationV1alpha1NamespacedRoleBinding>(params: Params$patchRbacAuthorizationV1alpha1NamespacedRoleBinding<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchRbacAuthorizationV1alpha1NamespacedRoleBinding$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/namespaces/\${params.parameter.namespace}/rolebindings/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const listRbacAuthorizationV1alpha1NamespacedRole = <ResponseContentType extends ResponseContentType$listRbacAuthorizationV1alpha1NamespacedRole>(params: Params$listRbacAuthorizationV1alpha1NamespacedRole<ResponseContentType>, option?: RequestOption): Promise<Response$listRbacAuthorizationV1alpha1NamespacedRole$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/namespaces/\${params.parameter.namespace}/roles\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const createRbacAuthorizationV1alpha1NamespacedRole = <ResponseContentType extends ResponseContentType$createRbacAuthorizationV1alpha1NamespacedRole>(params: Params$createRbacAuthorizationV1alpha1NamespacedRole<ResponseContentType>, option?: RequestOption): Promise<(Response$createRbacAuthorizationV1alpha1NamespacedRole$Status$200 | Response$createRbacAuthorizationV1alpha1NamespacedRole$Status$201 | Response$createRbacAuthorizationV1alpha1NamespacedRole$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/namespaces/\${params.parameter.namespace}/roles\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteRbacAuthorizationV1alpha1CollectionNamespacedRole = <ResponseContentType extends ResponseContentType$deleteRbacAuthorizationV1alpha1CollectionNamespacedRole>(params: Params$deleteRbacAuthorizationV1alpha1CollectionNamespacedRole<ResponseContentType>, option?: RequestOption): Promise<Response$deleteRbacAuthorizationV1alpha1CollectionNamespacedRole$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/namespaces/\${params.parameter.namespace}/roles\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readRbacAuthorizationV1alpha1NamespacedRole = <ResponseContentType extends ResponseContentType$readRbacAuthorizationV1alpha1NamespacedRole>(params: Params$readRbacAuthorizationV1alpha1NamespacedRole<ResponseContentType>, option?: RequestOption): Promise<Response$readRbacAuthorizationV1alpha1NamespacedRole$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/namespaces/\${params.parameter.namespace}/roles/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceRbacAuthorizationV1alpha1NamespacedRole = <ResponseContentType extends ResponseContentType$replaceRbacAuthorizationV1alpha1NamespacedRole>(params: Params$replaceRbacAuthorizationV1alpha1NamespacedRole<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceRbacAuthorizationV1alpha1NamespacedRole$Status$200 | Response$replaceRbacAuthorizationV1alpha1NamespacedRole$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/namespaces/\${params.parameter.namespace}/roles/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteRbacAuthorizationV1alpha1NamespacedRole = <ResponseContentType extends ResponseContentType$deleteRbacAuthorizationV1alpha1NamespacedRole>(params: Params$deleteRbacAuthorizationV1alpha1NamespacedRole<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteRbacAuthorizationV1alpha1NamespacedRole$Status$200 | Response$deleteRbacAuthorizationV1alpha1NamespacedRole$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/namespaces/\${params.parameter.namespace}/roles/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchRbacAuthorizationV1alpha1NamespacedRole = <RequestContentType extends RequestContentType$patchRbacAuthorizationV1alpha1NamespacedRole, ResponseContentType extends ResponseContentType$patchRbacAuthorizationV1alpha1NamespacedRole>(params: Params$patchRbacAuthorizationV1alpha1NamespacedRole<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchRbacAuthorizationV1alpha1NamespacedRole$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/namespaces/\${params.parameter.namespace}/roles/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const listRbacAuthorizationV1alpha1RoleBindingForAllNamespaces = <ResponseContentType extends ResponseContentType$listRbacAuthorizationV1alpha1RoleBindingForAllNamespaces>(params: Params$listRbacAuthorizationV1alpha1RoleBindingForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$listRbacAuthorizationV1alpha1RoleBindingForAllNamespaces$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/rolebindings\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const listRbacAuthorizationV1alpha1RoleForAllNamespaces = <ResponseContentType extends ResponseContentType$listRbacAuthorizationV1alpha1RoleForAllNamespaces>(params: Params$listRbacAuthorizationV1alpha1RoleForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$listRbacAuthorizationV1alpha1RoleForAllNamespaces$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/roles\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchRbacAuthorizationV1alpha1ClusterRoleBindingList = <ResponseContentType extends ResponseContentType$watchRbacAuthorizationV1alpha1ClusterRoleBindingList>(params: Params$watchRbacAuthorizationV1alpha1ClusterRoleBindingList<ResponseContentType>, option?: RequestOption): Promise<Response$watchRbacAuthorizationV1alpha1ClusterRoleBindingList$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/watch/clusterrolebindings\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchRbacAuthorizationV1alpha1ClusterRoleBinding = <ResponseContentType extends ResponseContentType$watchRbacAuthorizationV1alpha1ClusterRoleBinding>(params: Params$watchRbacAuthorizationV1alpha1ClusterRoleBinding<ResponseContentType>, option?: RequestOption): Promise<Response$watchRbacAuthorizationV1alpha1ClusterRoleBinding$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/watch/clusterrolebindings/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchRbacAuthorizationV1alpha1ClusterRoleList = <ResponseContentType extends ResponseContentType$watchRbacAuthorizationV1alpha1ClusterRoleList>(params: Params$watchRbacAuthorizationV1alpha1ClusterRoleList<ResponseContentType>, option?: RequestOption): Promise<Response$watchRbacAuthorizationV1alpha1ClusterRoleList$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/watch/clusterroles\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchRbacAuthorizationV1alpha1ClusterRole = <ResponseContentType extends ResponseContentType$watchRbacAuthorizationV1alpha1ClusterRole>(params: Params$watchRbacAuthorizationV1alpha1ClusterRole<ResponseContentType>, option?: RequestOption): Promise<Response$watchRbacAuthorizationV1alpha1ClusterRole$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/watch/clusterroles/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchRbacAuthorizationV1alpha1NamespacedRoleBindingList = <ResponseContentType extends ResponseContentType$watchRbacAuthorizationV1alpha1NamespacedRoleBindingList>(params: Params$watchRbacAuthorizationV1alpha1NamespacedRoleBindingList<ResponseContentType>, option?: RequestOption): Promise<Response$watchRbacAuthorizationV1alpha1NamespacedRoleBindingList$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/watch/namespaces/\${params.parameter.namespace}/rolebindings\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchRbacAuthorizationV1alpha1NamespacedRoleBinding = <ResponseContentType extends ResponseContentType$watchRbacAuthorizationV1alpha1NamespacedRoleBinding>(params: Params$watchRbacAuthorizationV1alpha1NamespacedRoleBinding<ResponseContentType>, option?: RequestOption): Promise<Response$watchRbacAuthorizationV1alpha1NamespacedRoleBinding$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/watch/namespaces/\${params.parameter.namespace}/rolebindings/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchRbacAuthorizationV1alpha1NamespacedRoleList = <ResponseContentType extends ResponseContentType$watchRbacAuthorizationV1alpha1NamespacedRoleList>(params: Params$watchRbacAuthorizationV1alpha1NamespacedRoleList<ResponseContentType>, option?: RequestOption): Promise<Response$watchRbacAuthorizationV1alpha1NamespacedRoleList$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/watch/namespaces/\${params.parameter.namespace}/roles\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchRbacAuthorizationV1alpha1NamespacedRole = <ResponseContentType extends ResponseContentType$watchRbacAuthorizationV1alpha1NamespacedRole>(params: Params$watchRbacAuthorizationV1alpha1NamespacedRole<ResponseContentType>, option?: RequestOption): Promise<Response$watchRbacAuthorizationV1alpha1NamespacedRole$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/watch/namespaces/\${params.parameter.namespace}/roles/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchRbacAuthorizationV1alpha1RoleBindingListForAllNamespaces = <ResponseContentType extends ResponseContentType$watchRbacAuthorizationV1alpha1RoleBindingListForAllNamespaces>(params: Params$watchRbacAuthorizationV1alpha1RoleBindingListForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$watchRbacAuthorizationV1alpha1RoleBindingListForAllNamespaces$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/watch/rolebindings\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchRbacAuthorizationV1alpha1RoleListForAllNamespaces = <ResponseContentType extends ResponseContentType$watchRbacAuthorizationV1alpha1RoleListForAllNamespaces>(params: Params$watchRbacAuthorizationV1alpha1RoleListForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$watchRbacAuthorizationV1alpha1RoleListForAllNamespaces$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/watch/roles\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const getRbacAuthorizationV1beta1APIResources = <ResponseContentType extends ResponseContentType$getRbacAuthorizationV1beta1APIResources>(params: Params$getRbacAuthorizationV1beta1APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getRbacAuthorizationV1beta1APIResources$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const listRbacAuthorizationV1beta1ClusterRoleBinding = <ResponseContentType extends ResponseContentType$listRbacAuthorizationV1beta1ClusterRoleBinding>(params: Params$listRbacAuthorizationV1beta1ClusterRoleBinding<ResponseContentType>, option?: RequestOption): Promise<Response$listRbacAuthorizationV1beta1ClusterRoleBinding$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/clusterrolebindings\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const createRbacAuthorizationV1beta1ClusterRoleBinding = <ResponseContentType extends ResponseContentType$createRbacAuthorizationV1beta1ClusterRoleBinding>(params: Params$createRbacAuthorizationV1beta1ClusterRoleBinding<ResponseContentType>, option?: RequestOption): Promise<(Response$createRbacAuthorizationV1beta1ClusterRoleBinding$Status$200 | Response$createRbacAuthorizationV1beta1ClusterRoleBinding$Status$201 | Response$createRbacAuthorizationV1beta1ClusterRoleBinding$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/clusterrolebindings\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteRbacAuthorizationV1beta1CollectionClusterRoleBinding = <ResponseContentType extends ResponseContentType$deleteRbacAuthorizationV1beta1CollectionClusterRoleBinding>(params: Params$deleteRbacAuthorizationV1beta1CollectionClusterRoleBinding<ResponseContentType>, option?: RequestOption): Promise<Response$deleteRbacAuthorizationV1beta1CollectionClusterRoleBinding$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/clusterrolebindings\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readRbacAuthorizationV1beta1ClusterRoleBinding = <ResponseContentType extends ResponseContentType$readRbacAuthorizationV1beta1ClusterRoleBinding>(params: Params$readRbacAuthorizationV1beta1ClusterRoleBinding<ResponseContentType>, option?: RequestOption): Promise<Response$readRbacAuthorizationV1beta1ClusterRoleBinding$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/clusterrolebindings/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceRbacAuthorizationV1beta1ClusterRoleBinding = <ResponseContentType extends ResponseContentType$replaceRbacAuthorizationV1beta1ClusterRoleBinding>(params: Params$replaceRbacAuthorizationV1beta1ClusterRoleBinding<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceRbacAuthorizationV1beta1ClusterRoleBinding$Status$200 | Response$replaceRbacAuthorizationV1beta1ClusterRoleBinding$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/clusterrolebindings/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteRbacAuthorizationV1beta1ClusterRoleBinding = <ResponseContentType extends ResponseContentType$deleteRbacAuthorizationV1beta1ClusterRoleBinding>(params: Params$deleteRbacAuthorizationV1beta1ClusterRoleBinding<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteRbacAuthorizationV1beta1ClusterRoleBinding$Status$200 | Response$deleteRbacAuthorizationV1beta1ClusterRoleBinding$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/clusterrolebindings/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchRbacAuthorizationV1beta1ClusterRoleBinding = <RequestContentType extends RequestContentType$patchRbacAuthorizationV1beta1ClusterRoleBinding, ResponseContentType extends ResponseContentType$patchRbacAuthorizationV1beta1ClusterRoleBinding>(params: Params$patchRbacAuthorizationV1beta1ClusterRoleBinding<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchRbacAuthorizationV1beta1ClusterRoleBinding$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/clusterrolebindings/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const listRbacAuthorizationV1beta1ClusterRole = <ResponseContentType extends ResponseContentType$listRbacAuthorizationV1beta1ClusterRole>(params: Params$listRbacAuthorizationV1beta1ClusterRole<ResponseContentType>, option?: RequestOption): Promise<Response$listRbacAuthorizationV1beta1ClusterRole$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/clusterroles\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const createRbacAuthorizationV1beta1ClusterRole = <ResponseContentType extends ResponseContentType$createRbacAuthorizationV1beta1ClusterRole>(params: Params$createRbacAuthorizationV1beta1ClusterRole<ResponseContentType>, option?: RequestOption): Promise<(Response$createRbacAuthorizationV1beta1ClusterRole$Status$200 | Response$createRbacAuthorizationV1beta1ClusterRole$Status$201 | Response$createRbacAuthorizationV1beta1ClusterRole$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/clusterroles\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteRbacAuthorizationV1beta1CollectionClusterRole = <ResponseContentType extends ResponseContentType$deleteRbacAuthorizationV1beta1CollectionClusterRole>(params: Params$deleteRbacAuthorizationV1beta1CollectionClusterRole<ResponseContentType>, option?: RequestOption): Promise<Response$deleteRbacAuthorizationV1beta1CollectionClusterRole$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/clusterroles\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readRbacAuthorizationV1beta1ClusterRole = <ResponseContentType extends ResponseContentType$readRbacAuthorizationV1beta1ClusterRole>(params: Params$readRbacAuthorizationV1beta1ClusterRole<ResponseContentType>, option?: RequestOption): Promise<Response$readRbacAuthorizationV1beta1ClusterRole$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/clusterroles/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceRbacAuthorizationV1beta1ClusterRole = <ResponseContentType extends ResponseContentType$replaceRbacAuthorizationV1beta1ClusterRole>(params: Params$replaceRbacAuthorizationV1beta1ClusterRole<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceRbacAuthorizationV1beta1ClusterRole$Status$200 | Response$replaceRbacAuthorizationV1beta1ClusterRole$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/clusterroles/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteRbacAuthorizationV1beta1ClusterRole = <ResponseContentType extends ResponseContentType$deleteRbacAuthorizationV1beta1ClusterRole>(params: Params$deleteRbacAuthorizationV1beta1ClusterRole<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteRbacAuthorizationV1beta1ClusterRole$Status$200 | Response$deleteRbacAuthorizationV1beta1ClusterRole$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/clusterroles/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchRbacAuthorizationV1beta1ClusterRole = <RequestContentType extends RequestContentType$patchRbacAuthorizationV1beta1ClusterRole, ResponseContentType extends ResponseContentType$patchRbacAuthorizationV1beta1ClusterRole>(params: Params$patchRbacAuthorizationV1beta1ClusterRole<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchRbacAuthorizationV1beta1ClusterRole$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/clusterroles/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const listRbacAuthorizationV1beta1NamespacedRoleBinding = <ResponseContentType extends ResponseContentType$listRbacAuthorizationV1beta1NamespacedRoleBinding>(params: Params$listRbacAuthorizationV1beta1NamespacedRoleBinding<ResponseContentType>, option?: RequestOption): Promise<Response$listRbacAuthorizationV1beta1NamespacedRoleBinding$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/rolebindings\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const createRbacAuthorizationV1beta1NamespacedRoleBinding = <ResponseContentType extends ResponseContentType$createRbacAuthorizationV1beta1NamespacedRoleBinding>(params: Params$createRbacAuthorizationV1beta1NamespacedRoleBinding<ResponseContentType>, option?: RequestOption): Promise<(Response$createRbacAuthorizationV1beta1NamespacedRoleBinding$Status$200 | Response$createRbacAuthorizationV1beta1NamespacedRoleBinding$Status$201 | Response$createRbacAuthorizationV1beta1NamespacedRoleBinding$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/rolebindings\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteRbacAuthorizationV1beta1CollectionNamespacedRoleBinding = <ResponseContentType extends ResponseContentType$deleteRbacAuthorizationV1beta1CollectionNamespacedRoleBinding>(params: Params$deleteRbacAuthorizationV1beta1CollectionNamespacedRoleBinding<ResponseContentType>, option?: RequestOption): Promise<Response$deleteRbacAuthorizationV1beta1CollectionNamespacedRoleBinding$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/rolebindings\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readRbacAuthorizationV1beta1NamespacedRoleBinding = <ResponseContentType extends ResponseContentType$readRbacAuthorizationV1beta1NamespacedRoleBinding>(params: Params$readRbacAuthorizationV1beta1NamespacedRoleBinding<ResponseContentType>, option?: RequestOption): Promise<Response$readRbacAuthorizationV1beta1NamespacedRoleBinding$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/rolebindings/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceRbacAuthorizationV1beta1NamespacedRoleBinding = <ResponseContentType extends ResponseContentType$replaceRbacAuthorizationV1beta1NamespacedRoleBinding>(params: Params$replaceRbacAuthorizationV1beta1NamespacedRoleBinding<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceRbacAuthorizationV1beta1NamespacedRoleBinding$Status$200 | Response$replaceRbacAuthorizationV1beta1NamespacedRoleBinding$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/rolebindings/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteRbacAuthorizationV1beta1NamespacedRoleBinding = <ResponseContentType extends ResponseContentType$deleteRbacAuthorizationV1beta1NamespacedRoleBinding>(params: Params$deleteRbacAuthorizationV1beta1NamespacedRoleBinding<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteRbacAuthorizationV1beta1NamespacedRoleBinding$Status$200 | Response$deleteRbacAuthorizationV1beta1NamespacedRoleBinding$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/rolebindings/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchRbacAuthorizationV1beta1NamespacedRoleBinding = <RequestContentType extends RequestContentType$patchRbacAuthorizationV1beta1NamespacedRoleBinding, ResponseContentType extends ResponseContentType$patchRbacAuthorizationV1beta1NamespacedRoleBinding>(params: Params$patchRbacAuthorizationV1beta1NamespacedRoleBinding<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchRbacAuthorizationV1beta1NamespacedRoleBinding$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/rolebindings/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const listRbacAuthorizationV1beta1NamespacedRole = <ResponseContentType extends ResponseContentType$listRbacAuthorizationV1beta1NamespacedRole>(params: Params$listRbacAuthorizationV1beta1NamespacedRole<ResponseContentType>, option?: RequestOption): Promise<Response$listRbacAuthorizationV1beta1NamespacedRole$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/roles\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const createRbacAuthorizationV1beta1NamespacedRole = <ResponseContentType extends ResponseContentType$createRbacAuthorizationV1beta1NamespacedRole>(params: Params$createRbacAuthorizationV1beta1NamespacedRole<ResponseContentType>, option?: RequestOption): Promise<(Response$createRbacAuthorizationV1beta1NamespacedRole$Status$200 | Response$createRbacAuthorizationV1beta1NamespacedRole$Status$201 | Response$createRbacAuthorizationV1beta1NamespacedRole$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/roles\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteRbacAuthorizationV1beta1CollectionNamespacedRole = <ResponseContentType extends ResponseContentType$deleteRbacAuthorizationV1beta1CollectionNamespacedRole>(params: Params$deleteRbacAuthorizationV1beta1CollectionNamespacedRole<ResponseContentType>, option?: RequestOption): Promise<Response$deleteRbacAuthorizationV1beta1CollectionNamespacedRole$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/roles\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readRbacAuthorizationV1beta1NamespacedRole = <ResponseContentType extends ResponseContentType$readRbacAuthorizationV1beta1NamespacedRole>(params: Params$readRbacAuthorizationV1beta1NamespacedRole<ResponseContentType>, option?: RequestOption): Promise<Response$readRbacAuthorizationV1beta1NamespacedRole$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/roles/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceRbacAuthorizationV1beta1NamespacedRole = <ResponseContentType extends ResponseContentType$replaceRbacAuthorizationV1beta1NamespacedRole>(params: Params$replaceRbacAuthorizationV1beta1NamespacedRole<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceRbacAuthorizationV1beta1NamespacedRole$Status$200 | Response$replaceRbacAuthorizationV1beta1NamespacedRole$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/roles/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteRbacAuthorizationV1beta1NamespacedRole = <ResponseContentType extends ResponseContentType$deleteRbacAuthorizationV1beta1NamespacedRole>(params: Params$deleteRbacAuthorizationV1beta1NamespacedRole<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteRbacAuthorizationV1beta1NamespacedRole$Status$200 | Response$deleteRbacAuthorizationV1beta1NamespacedRole$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/roles/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchRbacAuthorizationV1beta1NamespacedRole = <RequestContentType extends RequestContentType$patchRbacAuthorizationV1beta1NamespacedRole, ResponseContentType extends ResponseContentType$patchRbacAuthorizationV1beta1NamespacedRole>(params: Params$patchRbacAuthorizationV1beta1NamespacedRole<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchRbacAuthorizationV1beta1NamespacedRole$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/roles/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const listRbacAuthorizationV1beta1RoleBindingForAllNamespaces = <ResponseContentType extends ResponseContentType$listRbacAuthorizationV1beta1RoleBindingForAllNamespaces>(params: Params$listRbacAuthorizationV1beta1RoleBindingForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$listRbacAuthorizationV1beta1RoleBindingForAllNamespaces$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/rolebindings\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const listRbacAuthorizationV1beta1RoleForAllNamespaces = <ResponseContentType extends ResponseContentType$listRbacAuthorizationV1beta1RoleForAllNamespaces>(params: Params$listRbacAuthorizationV1beta1RoleForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$listRbacAuthorizationV1beta1RoleForAllNamespaces$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/roles\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchRbacAuthorizationV1beta1ClusterRoleBindingList = <ResponseContentType extends ResponseContentType$watchRbacAuthorizationV1beta1ClusterRoleBindingList>(params: Params$watchRbacAuthorizationV1beta1ClusterRoleBindingList<ResponseContentType>, option?: RequestOption): Promise<Response$watchRbacAuthorizationV1beta1ClusterRoleBindingList$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/watch/clusterrolebindings\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchRbacAuthorizationV1beta1ClusterRoleBinding = <ResponseContentType extends ResponseContentType$watchRbacAuthorizationV1beta1ClusterRoleBinding>(params: Params$watchRbacAuthorizationV1beta1ClusterRoleBinding<ResponseContentType>, option?: RequestOption): Promise<Response$watchRbacAuthorizationV1beta1ClusterRoleBinding$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/watch/clusterrolebindings/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchRbacAuthorizationV1beta1ClusterRoleList = <ResponseContentType extends ResponseContentType$watchRbacAuthorizationV1beta1ClusterRoleList>(params: Params$watchRbacAuthorizationV1beta1ClusterRoleList<ResponseContentType>, option?: RequestOption): Promise<Response$watchRbacAuthorizationV1beta1ClusterRoleList$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/watch/clusterroles\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchRbacAuthorizationV1beta1ClusterRole = <ResponseContentType extends ResponseContentType$watchRbacAuthorizationV1beta1ClusterRole>(params: Params$watchRbacAuthorizationV1beta1ClusterRole<ResponseContentType>, option?: RequestOption): Promise<Response$watchRbacAuthorizationV1beta1ClusterRole$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/watch/clusterroles/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchRbacAuthorizationV1beta1NamespacedRoleBindingList = <ResponseContentType extends ResponseContentType$watchRbacAuthorizationV1beta1NamespacedRoleBindingList>(params: Params$watchRbacAuthorizationV1beta1NamespacedRoleBindingList<ResponseContentType>, option?: RequestOption): Promise<Response$watchRbacAuthorizationV1beta1NamespacedRoleBindingList$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/watch/namespaces/\${params.parameter.namespace}/rolebindings\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchRbacAuthorizationV1beta1NamespacedRoleBinding = <ResponseContentType extends ResponseContentType$watchRbacAuthorizationV1beta1NamespacedRoleBinding>(params: Params$watchRbacAuthorizationV1beta1NamespacedRoleBinding<ResponseContentType>, option?: RequestOption): Promise<Response$watchRbacAuthorizationV1beta1NamespacedRoleBinding$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/watch/namespaces/\${params.parameter.namespace}/rolebindings/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchRbacAuthorizationV1beta1NamespacedRoleList = <ResponseContentType extends ResponseContentType$watchRbacAuthorizationV1beta1NamespacedRoleList>(params: Params$watchRbacAuthorizationV1beta1NamespacedRoleList<ResponseContentType>, option?: RequestOption): Promise<Response$watchRbacAuthorizationV1beta1NamespacedRoleList$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/watch/namespaces/\${params.parameter.namespace}/roles\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchRbacAuthorizationV1beta1NamespacedRole = <ResponseContentType extends ResponseContentType$watchRbacAuthorizationV1beta1NamespacedRole>(params: Params$watchRbacAuthorizationV1beta1NamespacedRole<ResponseContentType>, option?: RequestOption): Promise<Response$watchRbacAuthorizationV1beta1NamespacedRole$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/watch/namespaces/\${params.parameter.namespace}/roles/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchRbacAuthorizationV1beta1RoleBindingListForAllNamespaces = <ResponseContentType extends ResponseContentType$watchRbacAuthorizationV1beta1RoleBindingListForAllNamespaces>(params: Params$watchRbacAuthorizationV1beta1RoleBindingListForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$watchRbacAuthorizationV1beta1RoleBindingListForAllNamespaces$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/watch/rolebindings\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchRbacAuthorizationV1beta1RoleListForAllNamespaces = <ResponseContentType extends ResponseContentType$watchRbacAuthorizationV1beta1RoleListForAllNamespaces>(params: Params$watchRbacAuthorizationV1beta1RoleListForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$watchRbacAuthorizationV1beta1RoleListForAllNamespaces$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/watch/roles\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const getSchedulingAPIGroup = <ResponseContentType extends ResponseContentType$getSchedulingAPIGroup>(params: Params$getSchedulingAPIGroup<ResponseContentType>, option?: RequestOption): Promise<Response$getSchedulingAPIGroup$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/scheduling.k8s.io/\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const getSchedulingV1APIResources = <ResponseContentType extends ResponseContentType$getSchedulingV1APIResources>(params: Params$getSchedulingV1APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getSchedulingV1APIResources$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/scheduling.k8s.io/v1/\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const listSchedulingV1PriorityClass = <ResponseContentType extends ResponseContentType$listSchedulingV1PriorityClass>(params: Params$listSchedulingV1PriorityClass<ResponseContentType>, option?: RequestOption): Promise<Response$listSchedulingV1PriorityClass$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/scheduling.k8s.io/v1/priorityclasses\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const createSchedulingV1PriorityClass = <ResponseContentType extends ResponseContentType$createSchedulingV1PriorityClass>(params: Params$createSchedulingV1PriorityClass<ResponseContentType>, option?: RequestOption): Promise<(Response$createSchedulingV1PriorityClass$Status$200 | Response$createSchedulingV1PriorityClass$Status$201 | Response$createSchedulingV1PriorityClass$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/scheduling.k8s.io/v1/priorityclasses\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteSchedulingV1CollectionPriorityClass = <ResponseContentType extends ResponseContentType$deleteSchedulingV1CollectionPriorityClass>(params: Params$deleteSchedulingV1CollectionPriorityClass<ResponseContentType>, option?: RequestOption): Promise<Response$deleteSchedulingV1CollectionPriorityClass$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/scheduling.k8s.io/v1/priorityclasses\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readSchedulingV1PriorityClass = <ResponseContentType extends ResponseContentType$readSchedulingV1PriorityClass>(params: Params$readSchedulingV1PriorityClass<ResponseContentType>, option?: RequestOption): Promise<Response$readSchedulingV1PriorityClass$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/scheduling.k8s.io/v1/priorityclasses/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            exact: { value: params.parameter.exact, explode: false },
-            export: { value: params.parameter.export, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceSchedulingV1PriorityClass = <ResponseContentType extends ResponseContentType$replaceSchedulingV1PriorityClass>(params: Params$replaceSchedulingV1PriorityClass<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceSchedulingV1PriorityClass$Status$200 | Response$replaceSchedulingV1PriorityClass$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/scheduling.k8s.io/v1/priorityclasses/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteSchedulingV1PriorityClass = <ResponseContentType extends ResponseContentType$deleteSchedulingV1PriorityClass>(params: Params$deleteSchedulingV1PriorityClass<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteSchedulingV1PriorityClass$Status$200 | Response$deleteSchedulingV1PriorityClass$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/scheduling.k8s.io/v1/priorityclasses/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchSchedulingV1PriorityClass = <RequestContentType extends RequestContentType$patchSchedulingV1PriorityClass, ResponseContentType extends ResponseContentType$patchSchedulingV1PriorityClass>(params: Params$patchSchedulingV1PriorityClass<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchSchedulingV1PriorityClass$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/scheduling.k8s.io/v1/priorityclasses/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const watchSchedulingV1PriorityClassList = <ResponseContentType extends ResponseContentType$watchSchedulingV1PriorityClassList>(params: Params$watchSchedulingV1PriorityClassList<ResponseContentType>, option?: RequestOption): Promise<Response$watchSchedulingV1PriorityClassList$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/scheduling.k8s.io/v1/watch/priorityclasses\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchSchedulingV1PriorityClass = <ResponseContentType extends ResponseContentType$watchSchedulingV1PriorityClass>(params: Params$watchSchedulingV1PriorityClass<ResponseContentType>, option?: RequestOption): Promise<Response$watchSchedulingV1PriorityClass$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/scheduling.k8s.io/v1/watch/priorityclasses/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const getSchedulingV1alpha1APIResources = <ResponseContentType extends ResponseContentType$getSchedulingV1alpha1APIResources>(params: Params$getSchedulingV1alpha1APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getSchedulingV1alpha1APIResources$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/scheduling.k8s.io/v1alpha1/\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const listSchedulingV1alpha1PriorityClass = <ResponseContentType extends ResponseContentType$listSchedulingV1alpha1PriorityClass>(params: Params$listSchedulingV1alpha1PriorityClass<ResponseContentType>, option?: RequestOption): Promise<Response$listSchedulingV1alpha1PriorityClass$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/scheduling.k8s.io/v1alpha1/priorityclasses\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const createSchedulingV1alpha1PriorityClass = <ResponseContentType extends ResponseContentType$createSchedulingV1alpha1PriorityClass>(params: Params$createSchedulingV1alpha1PriorityClass<ResponseContentType>, option?: RequestOption): Promise<(Response$createSchedulingV1alpha1PriorityClass$Status$200 | Response$createSchedulingV1alpha1PriorityClass$Status$201 | Response$createSchedulingV1alpha1PriorityClass$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/scheduling.k8s.io/v1alpha1/priorityclasses\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteSchedulingV1alpha1CollectionPriorityClass = <ResponseContentType extends ResponseContentType$deleteSchedulingV1alpha1CollectionPriorityClass>(params: Params$deleteSchedulingV1alpha1CollectionPriorityClass<ResponseContentType>, option?: RequestOption): Promise<Response$deleteSchedulingV1alpha1CollectionPriorityClass$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/scheduling.k8s.io/v1alpha1/priorityclasses\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readSchedulingV1alpha1PriorityClass = <ResponseContentType extends ResponseContentType$readSchedulingV1alpha1PriorityClass>(params: Params$readSchedulingV1alpha1PriorityClass<ResponseContentType>, option?: RequestOption): Promise<Response$readSchedulingV1alpha1PriorityClass$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/scheduling.k8s.io/v1alpha1/priorityclasses/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            exact: { value: params.parameter.exact, explode: false },
-            export: { value: params.parameter.export, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceSchedulingV1alpha1PriorityClass = <ResponseContentType extends ResponseContentType$replaceSchedulingV1alpha1PriorityClass>(params: Params$replaceSchedulingV1alpha1PriorityClass<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceSchedulingV1alpha1PriorityClass$Status$200 | Response$replaceSchedulingV1alpha1PriorityClass$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/scheduling.k8s.io/v1alpha1/priorityclasses/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteSchedulingV1alpha1PriorityClass = <ResponseContentType extends ResponseContentType$deleteSchedulingV1alpha1PriorityClass>(params: Params$deleteSchedulingV1alpha1PriorityClass<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteSchedulingV1alpha1PriorityClass$Status$200 | Response$deleteSchedulingV1alpha1PriorityClass$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/scheduling.k8s.io/v1alpha1/priorityclasses/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchSchedulingV1alpha1PriorityClass = <RequestContentType extends RequestContentType$patchSchedulingV1alpha1PriorityClass, ResponseContentType extends ResponseContentType$patchSchedulingV1alpha1PriorityClass>(params: Params$patchSchedulingV1alpha1PriorityClass<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchSchedulingV1alpha1PriorityClass$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/scheduling.k8s.io/v1alpha1/priorityclasses/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const watchSchedulingV1alpha1PriorityClassList = <ResponseContentType extends ResponseContentType$watchSchedulingV1alpha1PriorityClassList>(params: Params$watchSchedulingV1alpha1PriorityClassList<ResponseContentType>, option?: RequestOption): Promise<Response$watchSchedulingV1alpha1PriorityClassList$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/scheduling.k8s.io/v1alpha1/watch/priorityclasses\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchSchedulingV1alpha1PriorityClass = <ResponseContentType extends ResponseContentType$watchSchedulingV1alpha1PriorityClass>(params: Params$watchSchedulingV1alpha1PriorityClass<ResponseContentType>, option?: RequestOption): Promise<Response$watchSchedulingV1alpha1PriorityClass$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/scheduling.k8s.io/v1alpha1/watch/priorityclasses/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const getSchedulingV1beta1APIResources = <ResponseContentType extends ResponseContentType$getSchedulingV1beta1APIResources>(params: Params$getSchedulingV1beta1APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getSchedulingV1beta1APIResources$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/scheduling.k8s.io/v1beta1/\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const listSchedulingV1beta1PriorityClass = <ResponseContentType extends ResponseContentType$listSchedulingV1beta1PriorityClass>(params: Params$listSchedulingV1beta1PriorityClass<ResponseContentType>, option?: RequestOption): Promise<Response$listSchedulingV1beta1PriorityClass$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/scheduling.k8s.io/v1beta1/priorityclasses\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const createSchedulingV1beta1PriorityClass = <ResponseContentType extends ResponseContentType$createSchedulingV1beta1PriorityClass>(params: Params$createSchedulingV1beta1PriorityClass<ResponseContentType>, option?: RequestOption): Promise<(Response$createSchedulingV1beta1PriorityClass$Status$200 | Response$createSchedulingV1beta1PriorityClass$Status$201 | Response$createSchedulingV1beta1PriorityClass$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/scheduling.k8s.io/v1beta1/priorityclasses\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteSchedulingV1beta1CollectionPriorityClass = <ResponseContentType extends ResponseContentType$deleteSchedulingV1beta1CollectionPriorityClass>(params: Params$deleteSchedulingV1beta1CollectionPriorityClass<ResponseContentType>, option?: RequestOption): Promise<Response$deleteSchedulingV1beta1CollectionPriorityClass$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/scheduling.k8s.io/v1beta1/priorityclasses\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readSchedulingV1beta1PriorityClass = <ResponseContentType extends ResponseContentType$readSchedulingV1beta1PriorityClass>(params: Params$readSchedulingV1beta1PriorityClass<ResponseContentType>, option?: RequestOption): Promise<Response$readSchedulingV1beta1PriorityClass$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/scheduling.k8s.io/v1beta1/priorityclasses/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            exact: { value: params.parameter.exact, explode: false },
-            export: { value: params.parameter.export, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceSchedulingV1beta1PriorityClass = <ResponseContentType extends ResponseContentType$replaceSchedulingV1beta1PriorityClass>(params: Params$replaceSchedulingV1beta1PriorityClass<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceSchedulingV1beta1PriorityClass$Status$200 | Response$replaceSchedulingV1beta1PriorityClass$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/scheduling.k8s.io/v1beta1/priorityclasses/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteSchedulingV1beta1PriorityClass = <ResponseContentType extends ResponseContentType$deleteSchedulingV1beta1PriorityClass>(params: Params$deleteSchedulingV1beta1PriorityClass<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteSchedulingV1beta1PriorityClass$Status$200 | Response$deleteSchedulingV1beta1PriorityClass$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/scheduling.k8s.io/v1beta1/priorityclasses/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchSchedulingV1beta1PriorityClass = <RequestContentType extends RequestContentType$patchSchedulingV1beta1PriorityClass, ResponseContentType extends ResponseContentType$patchSchedulingV1beta1PriorityClass>(params: Params$patchSchedulingV1beta1PriorityClass<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchSchedulingV1beta1PriorityClass$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/scheduling.k8s.io/v1beta1/priorityclasses/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const watchSchedulingV1beta1PriorityClassList = <ResponseContentType extends ResponseContentType$watchSchedulingV1beta1PriorityClassList>(params: Params$watchSchedulingV1beta1PriorityClassList<ResponseContentType>, option?: RequestOption): Promise<Response$watchSchedulingV1beta1PriorityClassList$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/scheduling.k8s.io/v1beta1/watch/priorityclasses\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchSchedulingV1beta1PriorityClass = <ResponseContentType extends ResponseContentType$watchSchedulingV1beta1PriorityClass>(params: Params$watchSchedulingV1beta1PriorityClass<ResponseContentType>, option?: RequestOption): Promise<Response$watchSchedulingV1beta1PriorityClass$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/scheduling.k8s.io/v1beta1/watch/priorityclasses/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const getSettingsAPIGroup = <ResponseContentType extends ResponseContentType$getSettingsAPIGroup>(params: Params$getSettingsAPIGroup<ResponseContentType>, option?: RequestOption): Promise<Response$getSettingsAPIGroup$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/settings.k8s.io/\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const getSettingsV1alpha1APIResources = <ResponseContentType extends ResponseContentType$getSettingsV1alpha1APIResources>(params: Params$getSettingsV1alpha1APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getSettingsV1alpha1APIResources$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/settings.k8s.io/v1alpha1/\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const listSettingsV1alpha1NamespacedPodPreset = <ResponseContentType extends ResponseContentType$listSettingsV1alpha1NamespacedPodPreset>(params: Params$listSettingsV1alpha1NamespacedPodPreset<ResponseContentType>, option?: RequestOption): Promise<Response$listSettingsV1alpha1NamespacedPodPreset$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/settings.k8s.io/v1alpha1/namespaces/\${params.parameter.namespace}/podpresets\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const createSettingsV1alpha1NamespacedPodPreset = <ResponseContentType extends ResponseContentType$createSettingsV1alpha1NamespacedPodPreset>(params: Params$createSettingsV1alpha1NamespacedPodPreset<ResponseContentType>, option?: RequestOption): Promise<(Response$createSettingsV1alpha1NamespacedPodPreset$Status$200 | Response$createSettingsV1alpha1NamespacedPodPreset$Status$201 | Response$createSettingsV1alpha1NamespacedPodPreset$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/settings.k8s.io/v1alpha1/namespaces/\${params.parameter.namespace}/podpresets\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteSettingsV1alpha1CollectionNamespacedPodPreset = <ResponseContentType extends ResponseContentType$deleteSettingsV1alpha1CollectionNamespacedPodPreset>(params: Params$deleteSettingsV1alpha1CollectionNamespacedPodPreset<ResponseContentType>, option?: RequestOption): Promise<Response$deleteSettingsV1alpha1CollectionNamespacedPodPreset$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/settings.k8s.io/v1alpha1/namespaces/\${params.parameter.namespace}/podpresets\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readSettingsV1alpha1NamespacedPodPreset = <ResponseContentType extends ResponseContentType$readSettingsV1alpha1NamespacedPodPreset>(params: Params$readSettingsV1alpha1NamespacedPodPreset<ResponseContentType>, option?: RequestOption): Promise<Response$readSettingsV1alpha1NamespacedPodPreset$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/settings.k8s.io/v1alpha1/namespaces/\${params.parameter.namespace}/podpresets/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            exact: { value: params.parameter.exact, explode: false },
-            export: { value: params.parameter.export, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceSettingsV1alpha1NamespacedPodPreset = <ResponseContentType extends ResponseContentType$replaceSettingsV1alpha1NamespacedPodPreset>(params: Params$replaceSettingsV1alpha1NamespacedPodPreset<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceSettingsV1alpha1NamespacedPodPreset$Status$200 | Response$replaceSettingsV1alpha1NamespacedPodPreset$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/settings.k8s.io/v1alpha1/namespaces/\${params.parameter.namespace}/podpresets/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteSettingsV1alpha1NamespacedPodPreset = <ResponseContentType extends ResponseContentType$deleteSettingsV1alpha1NamespacedPodPreset>(params: Params$deleteSettingsV1alpha1NamespacedPodPreset<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteSettingsV1alpha1NamespacedPodPreset$Status$200 | Response$deleteSettingsV1alpha1NamespacedPodPreset$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/settings.k8s.io/v1alpha1/namespaces/\${params.parameter.namespace}/podpresets/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchSettingsV1alpha1NamespacedPodPreset = <RequestContentType extends RequestContentType$patchSettingsV1alpha1NamespacedPodPreset, ResponseContentType extends ResponseContentType$patchSettingsV1alpha1NamespacedPodPreset>(params: Params$patchSettingsV1alpha1NamespacedPodPreset<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchSettingsV1alpha1NamespacedPodPreset$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/settings.k8s.io/v1alpha1/namespaces/\${params.parameter.namespace}/podpresets/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const listSettingsV1alpha1PodPresetForAllNamespaces = <ResponseContentType extends ResponseContentType$listSettingsV1alpha1PodPresetForAllNamespaces>(params: Params$listSettingsV1alpha1PodPresetForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$listSettingsV1alpha1PodPresetForAllNamespaces$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/settings.k8s.io/v1alpha1/podpresets\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchSettingsV1alpha1NamespacedPodPresetList = <ResponseContentType extends ResponseContentType$watchSettingsV1alpha1NamespacedPodPresetList>(params: Params$watchSettingsV1alpha1NamespacedPodPresetList<ResponseContentType>, option?: RequestOption): Promise<Response$watchSettingsV1alpha1NamespacedPodPresetList$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/settings.k8s.io/v1alpha1/watch/namespaces/\${params.parameter.namespace}/podpresets\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchSettingsV1alpha1NamespacedPodPreset = <ResponseContentType extends ResponseContentType$watchSettingsV1alpha1NamespacedPodPreset>(params: Params$watchSettingsV1alpha1NamespacedPodPreset<ResponseContentType>, option?: RequestOption): Promise<Response$watchSettingsV1alpha1NamespacedPodPreset$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/settings.k8s.io/v1alpha1/watch/namespaces/\${params.parameter.namespace}/podpresets/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchSettingsV1alpha1PodPresetListForAllNamespaces = <ResponseContentType extends ResponseContentType$watchSettingsV1alpha1PodPresetListForAllNamespaces>(params: Params$watchSettingsV1alpha1PodPresetListForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$watchSettingsV1alpha1PodPresetListForAllNamespaces$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/settings.k8s.io/v1alpha1/watch/podpresets\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const getStorageAPIGroup = <ResponseContentType extends ResponseContentType$getStorageAPIGroup>(params: Params$getStorageAPIGroup<ResponseContentType>, option?: RequestOption): Promise<Response$getStorageAPIGroup$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const getStorageV1APIResources = <ResponseContentType extends ResponseContentType$getStorageV1APIResources>(params: Params$getStorageV1APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getStorageV1APIResources$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1/\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const listStorageV1CSIDriver = <ResponseContentType extends ResponseContentType$listStorageV1CSIDriver>(params: Params$listStorageV1CSIDriver<ResponseContentType>, option?: RequestOption): Promise<Response$listStorageV1CSIDriver$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1/csidrivers\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const createStorageV1CSIDriver = <ResponseContentType extends ResponseContentType$createStorageV1CSIDriver>(params: Params$createStorageV1CSIDriver<ResponseContentType>, option?: RequestOption): Promise<(Response$createStorageV1CSIDriver$Status$200 | Response$createStorageV1CSIDriver$Status$201 | Response$createStorageV1CSIDriver$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1/csidrivers\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteStorageV1CollectionCSIDriver = <ResponseContentType extends ResponseContentType$deleteStorageV1CollectionCSIDriver>(params: Params$deleteStorageV1CollectionCSIDriver<ResponseContentType>, option?: RequestOption): Promise<Response$deleteStorageV1CollectionCSIDriver$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1/csidrivers\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readStorageV1CSIDriver = <ResponseContentType extends ResponseContentType$readStorageV1CSIDriver>(params: Params$readStorageV1CSIDriver<ResponseContentType>, option?: RequestOption): Promise<Response$readStorageV1CSIDriver$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1/csidrivers/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            exact: { value: params.parameter.exact, explode: false },
-            export: { value: params.parameter.export, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceStorageV1CSIDriver = <ResponseContentType extends ResponseContentType$replaceStorageV1CSIDriver>(params: Params$replaceStorageV1CSIDriver<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceStorageV1CSIDriver$Status$200 | Response$replaceStorageV1CSIDriver$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1/csidrivers/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteStorageV1CSIDriver = <ResponseContentType extends ResponseContentType$deleteStorageV1CSIDriver>(params: Params$deleteStorageV1CSIDriver<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteStorageV1CSIDriver$Status$200 | Response$deleteStorageV1CSIDriver$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1/csidrivers/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchStorageV1CSIDriver = <RequestContentType extends RequestContentType$patchStorageV1CSIDriver, ResponseContentType extends ResponseContentType$patchStorageV1CSIDriver>(params: Params$patchStorageV1CSIDriver<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchStorageV1CSIDriver$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1/csidrivers/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const listStorageV1CSINode = <ResponseContentType extends ResponseContentType$listStorageV1CSINode>(params: Params$listStorageV1CSINode<ResponseContentType>, option?: RequestOption): Promise<Response$listStorageV1CSINode$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1/csinodes\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const createStorageV1CSINode = <ResponseContentType extends ResponseContentType$createStorageV1CSINode>(params: Params$createStorageV1CSINode<ResponseContentType>, option?: RequestOption): Promise<(Response$createStorageV1CSINode$Status$200 | Response$createStorageV1CSINode$Status$201 | Response$createStorageV1CSINode$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1/csinodes\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteStorageV1CollectionCSINode = <ResponseContentType extends ResponseContentType$deleteStorageV1CollectionCSINode>(params: Params$deleteStorageV1CollectionCSINode<ResponseContentType>, option?: RequestOption): Promise<Response$deleteStorageV1CollectionCSINode$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1/csinodes\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readStorageV1CSINode = <ResponseContentType extends ResponseContentType$readStorageV1CSINode>(params: Params$readStorageV1CSINode<ResponseContentType>, option?: RequestOption): Promise<Response$readStorageV1CSINode$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1/csinodes/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            exact: { value: params.parameter.exact, explode: false },
-            export: { value: params.parameter.export, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceStorageV1CSINode = <ResponseContentType extends ResponseContentType$replaceStorageV1CSINode>(params: Params$replaceStorageV1CSINode<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceStorageV1CSINode$Status$200 | Response$replaceStorageV1CSINode$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1/csinodes/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteStorageV1CSINode = <ResponseContentType extends ResponseContentType$deleteStorageV1CSINode>(params: Params$deleteStorageV1CSINode<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteStorageV1CSINode$Status$200 | Response$deleteStorageV1CSINode$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1/csinodes/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchStorageV1CSINode = <RequestContentType extends RequestContentType$patchStorageV1CSINode, ResponseContentType extends ResponseContentType$patchStorageV1CSINode>(params: Params$patchStorageV1CSINode<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchStorageV1CSINode$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1/csinodes/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const listStorageV1StorageClass = <ResponseContentType extends ResponseContentType$listStorageV1StorageClass>(params: Params$listStorageV1StorageClass<ResponseContentType>, option?: RequestOption): Promise<Response$listStorageV1StorageClass$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1/storageclasses\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const createStorageV1StorageClass = <ResponseContentType extends ResponseContentType$createStorageV1StorageClass>(params: Params$createStorageV1StorageClass<ResponseContentType>, option?: RequestOption): Promise<(Response$createStorageV1StorageClass$Status$200 | Response$createStorageV1StorageClass$Status$201 | Response$createStorageV1StorageClass$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1/storageclasses\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteStorageV1CollectionStorageClass = <ResponseContentType extends ResponseContentType$deleteStorageV1CollectionStorageClass>(params: Params$deleteStorageV1CollectionStorageClass<ResponseContentType>, option?: RequestOption): Promise<Response$deleteStorageV1CollectionStorageClass$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1/storageclasses\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readStorageV1StorageClass = <ResponseContentType extends ResponseContentType$readStorageV1StorageClass>(params: Params$readStorageV1StorageClass<ResponseContentType>, option?: RequestOption): Promise<Response$readStorageV1StorageClass$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1/storageclasses/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            exact: { value: params.parameter.exact, explode: false },
-            export: { value: params.parameter.export, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceStorageV1StorageClass = <ResponseContentType extends ResponseContentType$replaceStorageV1StorageClass>(params: Params$replaceStorageV1StorageClass<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceStorageV1StorageClass$Status$200 | Response$replaceStorageV1StorageClass$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1/storageclasses/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteStorageV1StorageClass = <ResponseContentType extends ResponseContentType$deleteStorageV1StorageClass>(params: Params$deleteStorageV1StorageClass<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteStorageV1StorageClass$Status$200 | Response$deleteStorageV1StorageClass$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1/storageclasses/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchStorageV1StorageClass = <RequestContentType extends RequestContentType$patchStorageV1StorageClass, ResponseContentType extends ResponseContentType$patchStorageV1StorageClass>(params: Params$patchStorageV1StorageClass<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchStorageV1StorageClass$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1/storageclasses/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const listStorageV1VolumeAttachment = <ResponseContentType extends ResponseContentType$listStorageV1VolumeAttachment>(params: Params$listStorageV1VolumeAttachment<ResponseContentType>, option?: RequestOption): Promise<Response$listStorageV1VolumeAttachment$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1/volumeattachments\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const createStorageV1VolumeAttachment = <ResponseContentType extends ResponseContentType$createStorageV1VolumeAttachment>(params: Params$createStorageV1VolumeAttachment<ResponseContentType>, option?: RequestOption): Promise<(Response$createStorageV1VolumeAttachment$Status$200 | Response$createStorageV1VolumeAttachment$Status$201 | Response$createStorageV1VolumeAttachment$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1/volumeattachments\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteStorageV1CollectionVolumeAttachment = <ResponseContentType extends ResponseContentType$deleteStorageV1CollectionVolumeAttachment>(params: Params$deleteStorageV1CollectionVolumeAttachment<ResponseContentType>, option?: RequestOption): Promise<Response$deleteStorageV1CollectionVolumeAttachment$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1/volumeattachments\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readStorageV1VolumeAttachment = <ResponseContentType extends ResponseContentType$readStorageV1VolumeAttachment>(params: Params$readStorageV1VolumeAttachment<ResponseContentType>, option?: RequestOption): Promise<Response$readStorageV1VolumeAttachment$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1/volumeattachments/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            exact: { value: params.parameter.exact, explode: false },
-            export: { value: params.parameter.export, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceStorageV1VolumeAttachment = <ResponseContentType extends ResponseContentType$replaceStorageV1VolumeAttachment>(params: Params$replaceStorageV1VolumeAttachment<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceStorageV1VolumeAttachment$Status$200 | Response$replaceStorageV1VolumeAttachment$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1/volumeattachments/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteStorageV1VolumeAttachment = <ResponseContentType extends ResponseContentType$deleteStorageV1VolumeAttachment>(params: Params$deleteStorageV1VolumeAttachment<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteStorageV1VolumeAttachment$Status$200 | Response$deleteStorageV1VolumeAttachment$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1/volumeattachments/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchStorageV1VolumeAttachment = <RequestContentType extends RequestContentType$patchStorageV1VolumeAttachment, ResponseContentType extends ResponseContentType$patchStorageV1VolumeAttachment>(params: Params$patchStorageV1VolumeAttachment<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchStorageV1VolumeAttachment$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1/volumeattachments/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readStorageV1VolumeAttachmentStatus = <ResponseContentType extends ResponseContentType$readStorageV1VolumeAttachmentStatus>(params: Params$readStorageV1VolumeAttachmentStatus<ResponseContentType>, option?: RequestOption): Promise<Response$readStorageV1VolumeAttachmentStatus$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1/volumeattachments/\${params.parameter.name}/status\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceStorageV1VolumeAttachmentStatus = <ResponseContentType extends ResponseContentType$replaceStorageV1VolumeAttachmentStatus>(params: Params$replaceStorageV1VolumeAttachmentStatus<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceStorageV1VolumeAttachmentStatus$Status$200 | Response$replaceStorageV1VolumeAttachmentStatus$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1/volumeattachments/\${params.parameter.name}/status\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchStorageV1VolumeAttachmentStatus = <RequestContentType extends RequestContentType$patchStorageV1VolumeAttachmentStatus, ResponseContentType extends ResponseContentType$patchStorageV1VolumeAttachmentStatus>(params: Params$patchStorageV1VolumeAttachmentStatus<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchStorageV1VolumeAttachmentStatus$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1/volumeattachments/\${params.parameter.name}/status\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const watchStorageV1CSIDriverList = <ResponseContentType extends ResponseContentType$watchStorageV1CSIDriverList>(params: Params$watchStorageV1CSIDriverList<ResponseContentType>, option?: RequestOption): Promise<Response$watchStorageV1CSIDriverList$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1/watch/csidrivers\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchStorageV1CSIDriver = <ResponseContentType extends ResponseContentType$watchStorageV1CSIDriver>(params: Params$watchStorageV1CSIDriver<ResponseContentType>, option?: RequestOption): Promise<Response$watchStorageV1CSIDriver$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1/watch/csidrivers/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchStorageV1CSINodeList = <ResponseContentType extends ResponseContentType$watchStorageV1CSINodeList>(params: Params$watchStorageV1CSINodeList<ResponseContentType>, option?: RequestOption): Promise<Response$watchStorageV1CSINodeList$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1/watch/csinodes\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchStorageV1CSINode = <ResponseContentType extends ResponseContentType$watchStorageV1CSINode>(params: Params$watchStorageV1CSINode<ResponseContentType>, option?: RequestOption): Promise<Response$watchStorageV1CSINode$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1/watch/csinodes/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchStorageV1StorageClassList = <ResponseContentType extends ResponseContentType$watchStorageV1StorageClassList>(params: Params$watchStorageV1StorageClassList<ResponseContentType>, option?: RequestOption): Promise<Response$watchStorageV1StorageClassList$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1/watch/storageclasses\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchStorageV1StorageClass = <ResponseContentType extends ResponseContentType$watchStorageV1StorageClass>(params: Params$watchStorageV1StorageClass<ResponseContentType>, option?: RequestOption): Promise<Response$watchStorageV1StorageClass$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1/watch/storageclasses/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchStorageV1VolumeAttachmentList = <ResponseContentType extends ResponseContentType$watchStorageV1VolumeAttachmentList>(params: Params$watchStorageV1VolumeAttachmentList<ResponseContentType>, option?: RequestOption): Promise<Response$watchStorageV1VolumeAttachmentList$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1/watch/volumeattachments\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchStorageV1VolumeAttachment = <ResponseContentType extends ResponseContentType$watchStorageV1VolumeAttachment>(params: Params$watchStorageV1VolumeAttachment<ResponseContentType>, option?: RequestOption): Promise<Response$watchStorageV1VolumeAttachment$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1/watch/volumeattachments/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const getStorageV1alpha1APIResources = <ResponseContentType extends ResponseContentType$getStorageV1alpha1APIResources>(params: Params$getStorageV1alpha1APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getStorageV1alpha1APIResources$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1alpha1/\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const listStorageV1alpha1VolumeAttachment = <ResponseContentType extends ResponseContentType$listStorageV1alpha1VolumeAttachment>(params: Params$listStorageV1alpha1VolumeAttachment<ResponseContentType>, option?: RequestOption): Promise<Response$listStorageV1alpha1VolumeAttachment$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1alpha1/volumeattachments\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const createStorageV1alpha1VolumeAttachment = <ResponseContentType extends ResponseContentType$createStorageV1alpha1VolumeAttachment>(params: Params$createStorageV1alpha1VolumeAttachment<ResponseContentType>, option?: RequestOption): Promise<(Response$createStorageV1alpha1VolumeAttachment$Status$200 | Response$createStorageV1alpha1VolumeAttachment$Status$201 | Response$createStorageV1alpha1VolumeAttachment$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1alpha1/volumeattachments\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteStorageV1alpha1CollectionVolumeAttachment = <ResponseContentType extends ResponseContentType$deleteStorageV1alpha1CollectionVolumeAttachment>(params: Params$deleteStorageV1alpha1CollectionVolumeAttachment<ResponseContentType>, option?: RequestOption): Promise<Response$deleteStorageV1alpha1CollectionVolumeAttachment$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1alpha1/volumeattachments\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readStorageV1alpha1VolumeAttachment = <ResponseContentType extends ResponseContentType$readStorageV1alpha1VolumeAttachment>(params: Params$readStorageV1alpha1VolumeAttachment<ResponseContentType>, option?: RequestOption): Promise<Response$readStorageV1alpha1VolumeAttachment$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1alpha1/volumeattachments/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            exact: { value: params.parameter.exact, explode: false },
-            export: { value: params.parameter.export, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceStorageV1alpha1VolumeAttachment = <ResponseContentType extends ResponseContentType$replaceStorageV1alpha1VolumeAttachment>(params: Params$replaceStorageV1alpha1VolumeAttachment<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceStorageV1alpha1VolumeAttachment$Status$200 | Response$replaceStorageV1alpha1VolumeAttachment$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1alpha1/volumeattachments/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteStorageV1alpha1VolumeAttachment = <ResponseContentType extends ResponseContentType$deleteStorageV1alpha1VolumeAttachment>(params: Params$deleteStorageV1alpha1VolumeAttachment<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteStorageV1alpha1VolumeAttachment$Status$200 | Response$deleteStorageV1alpha1VolumeAttachment$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1alpha1/volumeattachments/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchStorageV1alpha1VolumeAttachment = <RequestContentType extends RequestContentType$patchStorageV1alpha1VolumeAttachment, ResponseContentType extends ResponseContentType$patchStorageV1alpha1VolumeAttachment>(params: Params$patchStorageV1alpha1VolumeAttachment<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchStorageV1alpha1VolumeAttachment$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1alpha1/volumeattachments/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const watchStorageV1alpha1VolumeAttachmentList = <ResponseContentType extends ResponseContentType$watchStorageV1alpha1VolumeAttachmentList>(params: Params$watchStorageV1alpha1VolumeAttachmentList<ResponseContentType>, option?: RequestOption): Promise<Response$watchStorageV1alpha1VolumeAttachmentList$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1alpha1/watch/volumeattachments\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchStorageV1alpha1VolumeAttachment = <ResponseContentType extends ResponseContentType$watchStorageV1alpha1VolumeAttachment>(params: Params$watchStorageV1alpha1VolumeAttachment<ResponseContentType>, option?: RequestOption): Promise<Response$watchStorageV1alpha1VolumeAttachment$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1alpha1/watch/volumeattachments/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const getStorageV1beta1APIResources = <ResponseContentType extends ResponseContentType$getStorageV1beta1APIResources>(params: Params$getStorageV1beta1APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getStorageV1beta1APIResources$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1beta1/\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const listStorageV1beta1CSIDriver = <ResponseContentType extends ResponseContentType$listStorageV1beta1CSIDriver>(params: Params$listStorageV1beta1CSIDriver<ResponseContentType>, option?: RequestOption): Promise<Response$listStorageV1beta1CSIDriver$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1beta1/csidrivers\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const createStorageV1beta1CSIDriver = <ResponseContentType extends ResponseContentType$createStorageV1beta1CSIDriver>(params: Params$createStorageV1beta1CSIDriver<ResponseContentType>, option?: RequestOption): Promise<(Response$createStorageV1beta1CSIDriver$Status$200 | Response$createStorageV1beta1CSIDriver$Status$201 | Response$createStorageV1beta1CSIDriver$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1beta1/csidrivers\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteStorageV1beta1CollectionCSIDriver = <ResponseContentType extends ResponseContentType$deleteStorageV1beta1CollectionCSIDriver>(params: Params$deleteStorageV1beta1CollectionCSIDriver<ResponseContentType>, option?: RequestOption): Promise<Response$deleteStorageV1beta1CollectionCSIDriver$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1beta1/csidrivers\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readStorageV1beta1CSIDriver = <ResponseContentType extends ResponseContentType$readStorageV1beta1CSIDriver>(params: Params$readStorageV1beta1CSIDriver<ResponseContentType>, option?: RequestOption): Promise<Response$readStorageV1beta1CSIDriver$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1beta1/csidrivers/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            exact: { value: params.parameter.exact, explode: false },
-            export: { value: params.parameter.export, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceStorageV1beta1CSIDriver = <ResponseContentType extends ResponseContentType$replaceStorageV1beta1CSIDriver>(params: Params$replaceStorageV1beta1CSIDriver<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceStorageV1beta1CSIDriver$Status$200 | Response$replaceStorageV1beta1CSIDriver$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1beta1/csidrivers/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteStorageV1beta1CSIDriver = <ResponseContentType extends ResponseContentType$deleteStorageV1beta1CSIDriver>(params: Params$deleteStorageV1beta1CSIDriver<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteStorageV1beta1CSIDriver$Status$200 | Response$deleteStorageV1beta1CSIDriver$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1beta1/csidrivers/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchStorageV1beta1CSIDriver = <RequestContentType extends RequestContentType$patchStorageV1beta1CSIDriver, ResponseContentType extends ResponseContentType$patchStorageV1beta1CSIDriver>(params: Params$patchStorageV1beta1CSIDriver<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchStorageV1beta1CSIDriver$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1beta1/csidrivers/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const listStorageV1beta1CSINode = <ResponseContentType extends ResponseContentType$listStorageV1beta1CSINode>(params: Params$listStorageV1beta1CSINode<ResponseContentType>, option?: RequestOption): Promise<Response$listStorageV1beta1CSINode$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1beta1/csinodes\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const createStorageV1beta1CSINode = <ResponseContentType extends ResponseContentType$createStorageV1beta1CSINode>(params: Params$createStorageV1beta1CSINode<ResponseContentType>, option?: RequestOption): Promise<(Response$createStorageV1beta1CSINode$Status$200 | Response$createStorageV1beta1CSINode$Status$201 | Response$createStorageV1beta1CSINode$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1beta1/csinodes\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteStorageV1beta1CollectionCSINode = <ResponseContentType extends ResponseContentType$deleteStorageV1beta1CollectionCSINode>(params: Params$deleteStorageV1beta1CollectionCSINode<ResponseContentType>, option?: RequestOption): Promise<Response$deleteStorageV1beta1CollectionCSINode$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1beta1/csinodes\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readStorageV1beta1CSINode = <ResponseContentType extends ResponseContentType$readStorageV1beta1CSINode>(params: Params$readStorageV1beta1CSINode<ResponseContentType>, option?: RequestOption): Promise<Response$readStorageV1beta1CSINode$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1beta1/csinodes/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            exact: { value: params.parameter.exact, explode: false },
-            export: { value: params.parameter.export, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceStorageV1beta1CSINode = <ResponseContentType extends ResponseContentType$replaceStorageV1beta1CSINode>(params: Params$replaceStorageV1beta1CSINode<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceStorageV1beta1CSINode$Status$200 | Response$replaceStorageV1beta1CSINode$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1beta1/csinodes/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteStorageV1beta1CSINode = <ResponseContentType extends ResponseContentType$deleteStorageV1beta1CSINode>(params: Params$deleteStorageV1beta1CSINode<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteStorageV1beta1CSINode$Status$200 | Response$deleteStorageV1beta1CSINode$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1beta1/csinodes/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchStorageV1beta1CSINode = <RequestContentType extends RequestContentType$patchStorageV1beta1CSINode, ResponseContentType extends ResponseContentType$patchStorageV1beta1CSINode>(params: Params$patchStorageV1beta1CSINode<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchStorageV1beta1CSINode$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1beta1/csinodes/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const listStorageV1beta1StorageClass = <ResponseContentType extends ResponseContentType$listStorageV1beta1StorageClass>(params: Params$listStorageV1beta1StorageClass<ResponseContentType>, option?: RequestOption): Promise<Response$listStorageV1beta1StorageClass$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1beta1/storageclasses\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const createStorageV1beta1StorageClass = <ResponseContentType extends ResponseContentType$createStorageV1beta1StorageClass>(params: Params$createStorageV1beta1StorageClass<ResponseContentType>, option?: RequestOption): Promise<(Response$createStorageV1beta1StorageClass$Status$200 | Response$createStorageV1beta1StorageClass$Status$201 | Response$createStorageV1beta1StorageClass$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1beta1/storageclasses\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteStorageV1beta1CollectionStorageClass = <ResponseContentType extends ResponseContentType$deleteStorageV1beta1CollectionStorageClass>(params: Params$deleteStorageV1beta1CollectionStorageClass<ResponseContentType>, option?: RequestOption): Promise<Response$deleteStorageV1beta1CollectionStorageClass$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1beta1/storageclasses\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readStorageV1beta1StorageClass = <ResponseContentType extends ResponseContentType$readStorageV1beta1StorageClass>(params: Params$readStorageV1beta1StorageClass<ResponseContentType>, option?: RequestOption): Promise<Response$readStorageV1beta1StorageClass$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1beta1/storageclasses/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            exact: { value: params.parameter.exact, explode: false },
-            export: { value: params.parameter.export, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceStorageV1beta1StorageClass = <ResponseContentType extends ResponseContentType$replaceStorageV1beta1StorageClass>(params: Params$replaceStorageV1beta1StorageClass<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceStorageV1beta1StorageClass$Status$200 | Response$replaceStorageV1beta1StorageClass$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1beta1/storageclasses/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteStorageV1beta1StorageClass = <ResponseContentType extends ResponseContentType$deleteStorageV1beta1StorageClass>(params: Params$deleteStorageV1beta1StorageClass<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteStorageV1beta1StorageClass$Status$200 | Response$deleteStorageV1beta1StorageClass$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1beta1/storageclasses/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchStorageV1beta1StorageClass = <RequestContentType extends RequestContentType$patchStorageV1beta1StorageClass, ResponseContentType extends ResponseContentType$patchStorageV1beta1StorageClass>(params: Params$patchStorageV1beta1StorageClass<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchStorageV1beta1StorageClass$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1beta1/storageclasses/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const listStorageV1beta1VolumeAttachment = <ResponseContentType extends ResponseContentType$listStorageV1beta1VolumeAttachment>(params: Params$listStorageV1beta1VolumeAttachment<ResponseContentType>, option?: RequestOption): Promise<Response$listStorageV1beta1VolumeAttachment$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1beta1/volumeattachments\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const createStorageV1beta1VolumeAttachment = <ResponseContentType extends ResponseContentType$createStorageV1beta1VolumeAttachment>(params: Params$createStorageV1beta1VolumeAttachment<ResponseContentType>, option?: RequestOption): Promise<(Response$createStorageV1beta1VolumeAttachment$Status$200 | Response$createStorageV1beta1VolumeAttachment$Status$201 | Response$createStorageV1beta1VolumeAttachment$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1beta1/volumeattachments\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteStorageV1beta1CollectionVolumeAttachment = <ResponseContentType extends ResponseContentType$deleteStorageV1beta1CollectionVolumeAttachment>(params: Params$deleteStorageV1beta1CollectionVolumeAttachment<ResponseContentType>, option?: RequestOption): Promise<Response$deleteStorageV1beta1CollectionVolumeAttachment$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1beta1/volumeattachments\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const readStorageV1beta1VolumeAttachment = <ResponseContentType extends ResponseContentType$readStorageV1beta1VolumeAttachment>(params: Params$readStorageV1beta1VolumeAttachment<ResponseContentType>, option?: RequestOption): Promise<Response$readStorageV1beta1VolumeAttachment$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1beta1/volumeattachments/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            exact: { value: params.parameter.exact, explode: false },
-            export: { value: params.parameter.export, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const replaceStorageV1beta1VolumeAttachment = <ResponseContentType extends ResponseContentType$replaceStorageV1beta1VolumeAttachment>(params: Params$replaceStorageV1beta1VolumeAttachment<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceStorageV1beta1VolumeAttachment$Status$200 | Response$replaceStorageV1beta1VolumeAttachment$Status$201)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1beta1/volumeattachments/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false }
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
-    };
-    const deleteStorageV1beta1VolumeAttachment = <ResponseContentType extends ResponseContentType$deleteStorageV1beta1VolumeAttachment>(params: Params$deleteStorageV1beta1VolumeAttachment<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteStorageV1beta1VolumeAttachment$Status$200 | Response$deleteStorageV1beta1VolumeAttachment$Status$202)[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1beta1/volumeattachments/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": "*/*",
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
-            orphanDependents: { value: params.parameter.orphanDependents, explode: false },
-            propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
-        };
-        return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
-    };
-    const patchStorageV1beta1VolumeAttachment = <RequestContentType extends RequestContentType$patchStorageV1beta1VolumeAttachment, ResponseContentType extends ResponseContentType$patchStorageV1beta1VolumeAttachment>(params: Params$patchStorageV1beta1VolumeAttachment<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchStorageV1beta1VolumeAttachment$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1beta1/volumeattachments/\${params.parameter.name}\`;
-        const headers = {
-            "Content-Type": params.headers["Content-Type"],
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            pretty: { value: params.parameter.pretty, explode: false },
-            dryRun: { value: params.parameter.dryRun, explode: false },
-            fieldManager: { value: params.parameter.fieldManager, explode: false },
-            force: { value: params.parameter.force, explode: false }
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
-    };
-    const watchStorageV1beta1CSIDriverList = <ResponseContentType extends ResponseContentType$watchStorageV1beta1CSIDriverList>(params: Params$watchStorageV1beta1CSIDriverList<ResponseContentType>, option?: RequestOption): Promise<Response$watchStorageV1beta1CSIDriverList$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1beta1/watch/csidrivers\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchStorageV1beta1CSIDriver = <ResponseContentType extends ResponseContentType$watchStorageV1beta1CSIDriver>(params: Params$watchStorageV1beta1CSIDriver<ResponseContentType>, option?: RequestOption): Promise<Response$watchStorageV1beta1CSIDriver$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1beta1/watch/csidrivers/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchStorageV1beta1CSINodeList = <ResponseContentType extends ResponseContentType$watchStorageV1beta1CSINodeList>(params: Params$watchStorageV1beta1CSINodeList<ResponseContentType>, option?: RequestOption): Promise<Response$watchStorageV1beta1CSINodeList$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1beta1/watch/csinodes\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchStorageV1beta1CSINode = <ResponseContentType extends ResponseContentType$watchStorageV1beta1CSINode>(params: Params$watchStorageV1beta1CSINode<ResponseContentType>, option?: RequestOption): Promise<Response$watchStorageV1beta1CSINode$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1beta1/watch/csinodes/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchStorageV1beta1StorageClassList = <ResponseContentType extends ResponseContentType$watchStorageV1beta1StorageClassList>(params: Params$watchStorageV1beta1StorageClassList<ResponseContentType>, option?: RequestOption): Promise<Response$watchStorageV1beta1StorageClassList$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1beta1/watch/storageclasses\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchStorageV1beta1StorageClass = <ResponseContentType extends ResponseContentType$watchStorageV1beta1StorageClass>(params: Params$watchStorageV1beta1StorageClass<ResponseContentType>, option?: RequestOption): Promise<Response$watchStorageV1beta1StorageClass$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1beta1/watch/storageclasses/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchStorageV1beta1VolumeAttachmentList = <ResponseContentType extends ResponseContentType$watchStorageV1beta1VolumeAttachmentList>(params: Params$watchStorageV1beta1VolumeAttachmentList<ResponseContentType>, option?: RequestOption): Promise<Response$watchStorageV1beta1VolumeAttachmentList$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1beta1/watch/volumeattachments\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const watchStorageV1beta1VolumeAttachment = <ResponseContentType extends ResponseContentType$watchStorageV1beta1VolumeAttachment>(params: Params$watchStorageV1beta1VolumeAttachment<ResponseContentType>, option?: RequestOption): Promise<Response$watchStorageV1beta1VolumeAttachment$Status$200[ResponseContentType]> => {
-        const url = baseUrl + \`/apis/storage.k8s.io/v1beta1/watch/volumeattachments/\${params.parameter.name}\`;
-        const headers = {
-            Accept: params.headers.Accept
-        };
-        const queryParameters: QueryParameters = {
-            allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
-            continue: { value: params.parameter.continue, explode: false },
-            fieldSelector: { value: params.parameter.fieldSelector, explode: false },
-            labelSelector: { value: params.parameter.labelSelector, explode: false },
-            limit: { value: params.parameter.limit, explode: false },
-            pretty: { value: params.parameter.pretty, explode: false },
-            resourceVersion: { value: params.parameter.resourceVersion, explode: false },
-            timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
-            watch: { value: params.parameter.watch, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const logFileListHandler = (option?: RequestOption): Promise<void> => {
-        const url = baseUrl + \`/logs/\`;
-        const headers = {};
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const logFileHandler = (params: Params$logFileHandler, option?: RequestOption): Promise<void> => {
-        const url = baseUrl + \`/logs/\${params.parameter.logpath}\`;
-        const headers = {};
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const getCodeVersion = (option?: RequestOption): Promise<Response$getCodeVersion$Status$200["application/json"]> => {
-        const url = baseUrl + \`/version/\`;
-        const headers = {
-            Accept: "application/json"
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
+    return {
+        /** get available API versions */
+        getCoreAPIVersions: <ResponseContentType extends ResponseContentType$getCoreAPIVersions>(params: Params$getCoreAPIVersions<ResponseContentType>, option?: RequestOption): Promise<Response$getCoreAPIVersions$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        /** get available resources */
+        getCoreV1APIResources: <ResponseContentType extends ResponseContentType$getCoreV1APIResources>(params: Params$getCoreV1APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getCoreV1APIResources$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        /** list objects of kind ComponentStatus */
+        listCoreV1ComponentStatus: <ResponseContentType extends ResponseContentType$listCoreV1ComponentStatus>(params: Params$listCoreV1ComponentStatus<ResponseContentType>, option?: RequestOption): Promise<Response$listCoreV1ComponentStatus$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/componentstatuses\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** read the specified ComponentStatus */
+        readCoreV1ComponentStatus: <ResponseContentType extends ResponseContentType$readCoreV1ComponentStatus>(params: Params$readCoreV1ComponentStatus<ResponseContentType>, option?: RequestOption): Promise<Response$readCoreV1ComponentStatus$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/componentstatuses/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** list or watch objects of kind ConfigMap */
+        listCoreV1ConfigMapForAllNamespaces: <ResponseContentType extends ResponseContentType$listCoreV1ConfigMapForAllNamespaces>(params: Params$listCoreV1ConfigMapForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$listCoreV1ConfigMapForAllNamespaces$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/configmaps\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** list or watch objects of kind Endpoints */
+        listCoreV1EndpointsForAllNamespaces: <ResponseContentType extends ResponseContentType$listCoreV1EndpointsForAllNamespaces>(params: Params$listCoreV1EndpointsForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$listCoreV1EndpointsForAllNamespaces$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/endpoints\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** list or watch objects of kind Event */
+        listCoreV1EventForAllNamespaces: <ResponseContentType extends ResponseContentType$listCoreV1EventForAllNamespaces>(params: Params$listCoreV1EventForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$listCoreV1EventForAllNamespaces$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/events\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** list or watch objects of kind LimitRange */
+        listCoreV1LimitRangeForAllNamespaces: <ResponseContentType extends ResponseContentType$listCoreV1LimitRangeForAllNamespaces>(params: Params$listCoreV1LimitRangeForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$listCoreV1LimitRangeForAllNamespaces$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/limitranges\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** list or watch objects of kind Namespace */
+        listCoreV1Namespace: <ResponseContentType extends ResponseContentType$listCoreV1Namespace>(params: Params$listCoreV1Namespace<ResponseContentType>, option?: RequestOption): Promise<Response$listCoreV1Namespace$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** create a Namespace */
+        createCoreV1Namespace: <ResponseContentType extends ResponseContentType$createCoreV1Namespace>(params: Params$createCoreV1Namespace<ResponseContentType>, option?: RequestOption): Promise<(Response$createCoreV1Namespace$Status$200 | Response$createCoreV1Namespace$Status$201 | Response$createCoreV1Namespace$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** create a Binding */
+        createCoreV1NamespacedBinding: <ResponseContentType extends ResponseContentType$createCoreV1NamespacedBinding>(params: Params$createCoreV1NamespacedBinding<ResponseContentType>, option?: RequestOption): Promise<(Response$createCoreV1NamespacedBinding$Status$200 | Response$createCoreV1NamespacedBinding$Status$201 | Response$createCoreV1NamespacedBinding$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/bindings\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** list or watch objects of kind ConfigMap */
+        listCoreV1NamespacedConfigMap: <ResponseContentType extends ResponseContentType$listCoreV1NamespacedConfigMap>(params: Params$listCoreV1NamespacedConfigMap<ResponseContentType>, option?: RequestOption): Promise<Response$listCoreV1NamespacedConfigMap$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/configmaps\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** create a ConfigMap */
+        createCoreV1NamespacedConfigMap: <ResponseContentType extends ResponseContentType$createCoreV1NamespacedConfigMap>(params: Params$createCoreV1NamespacedConfigMap<ResponseContentType>, option?: RequestOption): Promise<(Response$createCoreV1NamespacedConfigMap$Status$200 | Response$createCoreV1NamespacedConfigMap$Status$201 | Response$createCoreV1NamespacedConfigMap$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/configmaps\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete collection of ConfigMap */
+        deleteCoreV1CollectionNamespacedConfigMap: <ResponseContentType extends ResponseContentType$deleteCoreV1CollectionNamespacedConfigMap>(params: Params$deleteCoreV1CollectionNamespacedConfigMap<ResponseContentType>, option?: RequestOption): Promise<Response$deleteCoreV1CollectionNamespacedConfigMap$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/configmaps\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read the specified ConfigMap */
+        readCoreV1NamespacedConfigMap: <ResponseContentType extends ResponseContentType$readCoreV1NamespacedConfigMap>(params: Params$readCoreV1NamespacedConfigMap<ResponseContentType>, option?: RequestOption): Promise<Response$readCoreV1NamespacedConfigMap$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/configmaps/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                exact: { value: params.parameter.exact, explode: false },
+                export: { value: params.parameter.export, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace the specified ConfigMap */
+        replaceCoreV1NamespacedConfigMap: <ResponseContentType extends ResponseContentType$replaceCoreV1NamespacedConfigMap>(params: Params$replaceCoreV1NamespacedConfigMap<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceCoreV1NamespacedConfigMap$Status$200 | Response$replaceCoreV1NamespacedConfigMap$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/configmaps/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete a ConfigMap */
+        deleteCoreV1NamespacedConfigMap: <ResponseContentType extends ResponseContentType$deleteCoreV1NamespacedConfigMap>(params: Params$deleteCoreV1NamespacedConfigMap<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteCoreV1NamespacedConfigMap$Status$200 | Response$deleteCoreV1NamespacedConfigMap$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/configmaps/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update the specified ConfigMap */
+        patchCoreV1NamespacedConfigMap: <RequestContentType extends RequestContentType$patchCoreV1NamespacedConfigMap, ResponseContentType extends ResponseContentType$patchCoreV1NamespacedConfigMap>(params: Params$patchCoreV1NamespacedConfigMap<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchCoreV1NamespacedConfigMap$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/configmaps/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** list or watch objects of kind Endpoints */
+        listCoreV1NamespacedEndpoints: <ResponseContentType extends ResponseContentType$listCoreV1NamespacedEndpoints>(params: Params$listCoreV1NamespacedEndpoints<ResponseContentType>, option?: RequestOption): Promise<Response$listCoreV1NamespacedEndpoints$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/endpoints\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** create Endpoints */
+        createCoreV1NamespacedEndpoints: <ResponseContentType extends ResponseContentType$createCoreV1NamespacedEndpoints>(params: Params$createCoreV1NamespacedEndpoints<ResponseContentType>, option?: RequestOption): Promise<(Response$createCoreV1NamespacedEndpoints$Status$200 | Response$createCoreV1NamespacedEndpoints$Status$201 | Response$createCoreV1NamespacedEndpoints$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/endpoints\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete collection of Endpoints */
+        deleteCoreV1CollectionNamespacedEndpoints: <ResponseContentType extends ResponseContentType$deleteCoreV1CollectionNamespacedEndpoints>(params: Params$deleteCoreV1CollectionNamespacedEndpoints<ResponseContentType>, option?: RequestOption): Promise<Response$deleteCoreV1CollectionNamespacedEndpoints$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/endpoints\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read the specified Endpoints */
+        readCoreV1NamespacedEndpoints: <ResponseContentType extends ResponseContentType$readCoreV1NamespacedEndpoints>(params: Params$readCoreV1NamespacedEndpoints<ResponseContentType>, option?: RequestOption): Promise<Response$readCoreV1NamespacedEndpoints$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/endpoints/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                exact: { value: params.parameter.exact, explode: false },
+                export: { value: params.parameter.export, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace the specified Endpoints */
+        replaceCoreV1NamespacedEndpoints: <ResponseContentType extends ResponseContentType$replaceCoreV1NamespacedEndpoints>(params: Params$replaceCoreV1NamespacedEndpoints<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceCoreV1NamespacedEndpoints$Status$200 | Response$replaceCoreV1NamespacedEndpoints$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/endpoints/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete Endpoints */
+        deleteCoreV1NamespacedEndpoints: <ResponseContentType extends ResponseContentType$deleteCoreV1NamespacedEndpoints>(params: Params$deleteCoreV1NamespacedEndpoints<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteCoreV1NamespacedEndpoints$Status$200 | Response$deleteCoreV1NamespacedEndpoints$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/endpoints/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update the specified Endpoints */
+        patchCoreV1NamespacedEndpoints: <RequestContentType extends RequestContentType$patchCoreV1NamespacedEndpoints, ResponseContentType extends ResponseContentType$patchCoreV1NamespacedEndpoints>(params: Params$patchCoreV1NamespacedEndpoints<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchCoreV1NamespacedEndpoints$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/endpoints/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** list or watch objects of kind Event */
+        listCoreV1NamespacedEvent: <ResponseContentType extends ResponseContentType$listCoreV1NamespacedEvent>(params: Params$listCoreV1NamespacedEvent<ResponseContentType>, option?: RequestOption): Promise<Response$listCoreV1NamespacedEvent$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/events\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** create an Event */
+        createCoreV1NamespacedEvent: <ResponseContentType extends ResponseContentType$createCoreV1NamespacedEvent>(params: Params$createCoreV1NamespacedEvent<ResponseContentType>, option?: RequestOption): Promise<(Response$createCoreV1NamespacedEvent$Status$200 | Response$createCoreV1NamespacedEvent$Status$201 | Response$createCoreV1NamespacedEvent$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/events\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete collection of Event */
+        deleteCoreV1CollectionNamespacedEvent: <ResponseContentType extends ResponseContentType$deleteCoreV1CollectionNamespacedEvent>(params: Params$deleteCoreV1CollectionNamespacedEvent<ResponseContentType>, option?: RequestOption): Promise<Response$deleteCoreV1CollectionNamespacedEvent$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/events\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read the specified Event */
+        readCoreV1NamespacedEvent: <ResponseContentType extends ResponseContentType$readCoreV1NamespacedEvent>(params: Params$readCoreV1NamespacedEvent<ResponseContentType>, option?: RequestOption): Promise<Response$readCoreV1NamespacedEvent$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/events/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                exact: { value: params.parameter.exact, explode: false },
+                export: { value: params.parameter.export, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace the specified Event */
+        replaceCoreV1NamespacedEvent: <ResponseContentType extends ResponseContentType$replaceCoreV1NamespacedEvent>(params: Params$replaceCoreV1NamespacedEvent<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceCoreV1NamespacedEvent$Status$200 | Response$replaceCoreV1NamespacedEvent$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/events/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete an Event */
+        deleteCoreV1NamespacedEvent: <ResponseContentType extends ResponseContentType$deleteCoreV1NamespacedEvent>(params: Params$deleteCoreV1NamespacedEvent<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteCoreV1NamespacedEvent$Status$200 | Response$deleteCoreV1NamespacedEvent$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/events/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update the specified Event */
+        patchCoreV1NamespacedEvent: <RequestContentType extends RequestContentType$patchCoreV1NamespacedEvent, ResponseContentType extends ResponseContentType$patchCoreV1NamespacedEvent>(params: Params$patchCoreV1NamespacedEvent<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchCoreV1NamespacedEvent$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/events/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** list or watch objects of kind LimitRange */
+        listCoreV1NamespacedLimitRange: <ResponseContentType extends ResponseContentType$listCoreV1NamespacedLimitRange>(params: Params$listCoreV1NamespacedLimitRange<ResponseContentType>, option?: RequestOption): Promise<Response$listCoreV1NamespacedLimitRange$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/limitranges\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** create a LimitRange */
+        createCoreV1NamespacedLimitRange: <ResponseContentType extends ResponseContentType$createCoreV1NamespacedLimitRange>(params: Params$createCoreV1NamespacedLimitRange<ResponseContentType>, option?: RequestOption): Promise<(Response$createCoreV1NamespacedLimitRange$Status$200 | Response$createCoreV1NamespacedLimitRange$Status$201 | Response$createCoreV1NamespacedLimitRange$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/limitranges\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete collection of LimitRange */
+        deleteCoreV1CollectionNamespacedLimitRange: <ResponseContentType extends ResponseContentType$deleteCoreV1CollectionNamespacedLimitRange>(params: Params$deleteCoreV1CollectionNamespacedLimitRange<ResponseContentType>, option?: RequestOption): Promise<Response$deleteCoreV1CollectionNamespacedLimitRange$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/limitranges\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read the specified LimitRange */
+        readCoreV1NamespacedLimitRange: <ResponseContentType extends ResponseContentType$readCoreV1NamespacedLimitRange>(params: Params$readCoreV1NamespacedLimitRange<ResponseContentType>, option?: RequestOption): Promise<Response$readCoreV1NamespacedLimitRange$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/limitranges/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                exact: { value: params.parameter.exact, explode: false },
+                export: { value: params.parameter.export, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace the specified LimitRange */
+        replaceCoreV1NamespacedLimitRange: <ResponseContentType extends ResponseContentType$replaceCoreV1NamespacedLimitRange>(params: Params$replaceCoreV1NamespacedLimitRange<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceCoreV1NamespacedLimitRange$Status$200 | Response$replaceCoreV1NamespacedLimitRange$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/limitranges/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete a LimitRange */
+        deleteCoreV1NamespacedLimitRange: <ResponseContentType extends ResponseContentType$deleteCoreV1NamespacedLimitRange>(params: Params$deleteCoreV1NamespacedLimitRange<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteCoreV1NamespacedLimitRange$Status$200 | Response$deleteCoreV1NamespacedLimitRange$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/limitranges/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update the specified LimitRange */
+        patchCoreV1NamespacedLimitRange: <RequestContentType extends RequestContentType$patchCoreV1NamespacedLimitRange, ResponseContentType extends ResponseContentType$patchCoreV1NamespacedLimitRange>(params: Params$patchCoreV1NamespacedLimitRange<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchCoreV1NamespacedLimitRange$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/limitranges/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** list or watch objects of kind PersistentVolumeClaim */
+        listCoreV1NamespacedPersistentVolumeClaim: <ResponseContentType extends ResponseContentType$listCoreV1NamespacedPersistentVolumeClaim>(params: Params$listCoreV1NamespacedPersistentVolumeClaim<ResponseContentType>, option?: RequestOption): Promise<Response$listCoreV1NamespacedPersistentVolumeClaim$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/persistentvolumeclaims\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** create a PersistentVolumeClaim */
+        createCoreV1NamespacedPersistentVolumeClaim: <ResponseContentType extends ResponseContentType$createCoreV1NamespacedPersistentVolumeClaim>(params: Params$createCoreV1NamespacedPersistentVolumeClaim<ResponseContentType>, option?: RequestOption): Promise<(Response$createCoreV1NamespacedPersistentVolumeClaim$Status$200 | Response$createCoreV1NamespacedPersistentVolumeClaim$Status$201 | Response$createCoreV1NamespacedPersistentVolumeClaim$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/persistentvolumeclaims\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete collection of PersistentVolumeClaim */
+        deleteCoreV1CollectionNamespacedPersistentVolumeClaim: <ResponseContentType extends ResponseContentType$deleteCoreV1CollectionNamespacedPersistentVolumeClaim>(params: Params$deleteCoreV1CollectionNamespacedPersistentVolumeClaim<ResponseContentType>, option?: RequestOption): Promise<Response$deleteCoreV1CollectionNamespacedPersistentVolumeClaim$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/persistentvolumeclaims\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read the specified PersistentVolumeClaim */
+        readCoreV1NamespacedPersistentVolumeClaim: <ResponseContentType extends ResponseContentType$readCoreV1NamespacedPersistentVolumeClaim>(params: Params$readCoreV1NamespacedPersistentVolumeClaim<ResponseContentType>, option?: RequestOption): Promise<Response$readCoreV1NamespacedPersistentVolumeClaim$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/persistentvolumeclaims/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                exact: { value: params.parameter.exact, explode: false },
+                export: { value: params.parameter.export, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace the specified PersistentVolumeClaim */
+        replaceCoreV1NamespacedPersistentVolumeClaim: <ResponseContentType extends ResponseContentType$replaceCoreV1NamespacedPersistentVolumeClaim>(params: Params$replaceCoreV1NamespacedPersistentVolumeClaim<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceCoreV1NamespacedPersistentVolumeClaim$Status$200 | Response$replaceCoreV1NamespacedPersistentVolumeClaim$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/persistentvolumeclaims/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete a PersistentVolumeClaim */
+        deleteCoreV1NamespacedPersistentVolumeClaim: <ResponseContentType extends ResponseContentType$deleteCoreV1NamespacedPersistentVolumeClaim>(params: Params$deleteCoreV1NamespacedPersistentVolumeClaim<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteCoreV1NamespacedPersistentVolumeClaim$Status$200 | Response$deleteCoreV1NamespacedPersistentVolumeClaim$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/persistentvolumeclaims/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update the specified PersistentVolumeClaim */
+        patchCoreV1NamespacedPersistentVolumeClaim: <RequestContentType extends RequestContentType$patchCoreV1NamespacedPersistentVolumeClaim, ResponseContentType extends ResponseContentType$patchCoreV1NamespacedPersistentVolumeClaim>(params: Params$patchCoreV1NamespacedPersistentVolumeClaim<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchCoreV1NamespacedPersistentVolumeClaim$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/persistentvolumeclaims/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read status of the specified PersistentVolumeClaim */
+        readCoreV1NamespacedPersistentVolumeClaimStatus: <ResponseContentType extends ResponseContentType$readCoreV1NamespacedPersistentVolumeClaimStatus>(params: Params$readCoreV1NamespacedPersistentVolumeClaimStatus<ResponseContentType>, option?: RequestOption): Promise<Response$readCoreV1NamespacedPersistentVolumeClaimStatus$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/persistentvolumeclaims/\${params.parameter.name}/status\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace status of the specified PersistentVolumeClaim */
+        replaceCoreV1NamespacedPersistentVolumeClaimStatus: <ResponseContentType extends ResponseContentType$replaceCoreV1NamespacedPersistentVolumeClaimStatus>(params: Params$replaceCoreV1NamespacedPersistentVolumeClaimStatus<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceCoreV1NamespacedPersistentVolumeClaimStatus$Status$200 | Response$replaceCoreV1NamespacedPersistentVolumeClaimStatus$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/persistentvolumeclaims/\${params.parameter.name}/status\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update status of the specified PersistentVolumeClaim */
+        patchCoreV1NamespacedPersistentVolumeClaimStatus: <RequestContentType extends RequestContentType$patchCoreV1NamespacedPersistentVolumeClaimStatus, ResponseContentType extends ResponseContentType$patchCoreV1NamespacedPersistentVolumeClaimStatus>(params: Params$patchCoreV1NamespacedPersistentVolumeClaimStatus<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchCoreV1NamespacedPersistentVolumeClaimStatus$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/persistentvolumeclaims/\${params.parameter.name}/status\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** list or watch objects of kind Pod */
+        listCoreV1NamespacedPod: <ResponseContentType extends ResponseContentType$listCoreV1NamespacedPod>(params: Params$listCoreV1NamespacedPod<ResponseContentType>, option?: RequestOption): Promise<Response$listCoreV1NamespacedPod$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/pods\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** create a Pod */
+        createCoreV1NamespacedPod: <ResponseContentType extends ResponseContentType$createCoreV1NamespacedPod>(params: Params$createCoreV1NamespacedPod<ResponseContentType>, option?: RequestOption): Promise<(Response$createCoreV1NamespacedPod$Status$200 | Response$createCoreV1NamespacedPod$Status$201 | Response$createCoreV1NamespacedPod$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/pods\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete collection of Pod */
+        deleteCoreV1CollectionNamespacedPod: <ResponseContentType extends ResponseContentType$deleteCoreV1CollectionNamespacedPod>(params: Params$deleteCoreV1CollectionNamespacedPod<ResponseContentType>, option?: RequestOption): Promise<Response$deleteCoreV1CollectionNamespacedPod$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/pods\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read the specified Pod */
+        readCoreV1NamespacedPod: <ResponseContentType extends ResponseContentType$readCoreV1NamespacedPod>(params: Params$readCoreV1NamespacedPod<ResponseContentType>, option?: RequestOption): Promise<Response$readCoreV1NamespacedPod$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/pods/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                exact: { value: params.parameter.exact, explode: false },
+                export: { value: params.parameter.export, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace the specified Pod */
+        replaceCoreV1NamespacedPod: <ResponseContentType extends ResponseContentType$replaceCoreV1NamespacedPod>(params: Params$replaceCoreV1NamespacedPod<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceCoreV1NamespacedPod$Status$200 | Response$replaceCoreV1NamespacedPod$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/pods/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete a Pod */
+        deleteCoreV1NamespacedPod: <ResponseContentType extends ResponseContentType$deleteCoreV1NamespacedPod>(params: Params$deleteCoreV1NamespacedPod<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteCoreV1NamespacedPod$Status$200 | Response$deleteCoreV1NamespacedPod$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/pods/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update the specified Pod */
+        patchCoreV1NamespacedPod: <RequestContentType extends RequestContentType$patchCoreV1NamespacedPod, ResponseContentType extends ResponseContentType$patchCoreV1NamespacedPod>(params: Params$patchCoreV1NamespacedPod<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchCoreV1NamespacedPod$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/pods/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** connect GET requests to attach of Pod */
+        connectCoreV1GetNamespacedPodAttach: (params: Params$connectCoreV1GetNamespacedPodAttach, option?: RequestOption): Promise<Response$connectCoreV1GetNamespacedPodAttach$Status$200["*/*"]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/pods/\${params.parameter.name}/attach\`;
+            const headers = {
+                Accept: "*/*"
+            };
+            const queryParameters: QueryParameters = {
+                container: { value: params.parameter.container, explode: false },
+                stderr: { value: params.parameter.stderr, explode: false },
+                stdin: { value: params.parameter.stdin, explode: false },
+                stdout: { value: params.parameter.stdout, explode: false },
+                tty: { value: params.parameter.tty, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** connect POST requests to attach of Pod */
+        connectCoreV1PostNamespacedPodAttach: (params: Params$connectCoreV1PostNamespacedPodAttach, option?: RequestOption): Promise<Response$connectCoreV1PostNamespacedPodAttach$Status$200["*/*"]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/pods/\${params.parameter.name}/attach\`;
+            const headers = {
+                Accept: "*/*"
+            };
+            const queryParameters: QueryParameters = {
+                container: { value: params.parameter.container, explode: false },
+                stderr: { value: params.parameter.stderr, explode: false },
+                stdin: { value: params.parameter.stdin, explode: false },
+                stdout: { value: params.parameter.stdout, explode: false },
+                tty: { value: params.parameter.tty, explode: false }
+            };
+            return apiClient.request("POST", url, headers, undefined, queryParameters, option);
+        },
+        /** create binding of a Pod */
+        createCoreV1NamespacedPodBinding: <ResponseContentType extends ResponseContentType$createCoreV1NamespacedPodBinding>(params: Params$createCoreV1NamespacedPodBinding<ResponseContentType>, option?: RequestOption): Promise<(Response$createCoreV1NamespacedPodBinding$Status$200 | Response$createCoreV1NamespacedPodBinding$Status$201 | Response$createCoreV1NamespacedPodBinding$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/pods/\${params.parameter.name}/binding\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** create eviction of a Pod */
+        createCoreV1NamespacedPodEviction: <ResponseContentType extends ResponseContentType$createCoreV1NamespacedPodEviction>(params: Params$createCoreV1NamespacedPodEviction<ResponseContentType>, option?: RequestOption): Promise<(Response$createCoreV1NamespacedPodEviction$Status$200 | Response$createCoreV1NamespacedPodEviction$Status$201 | Response$createCoreV1NamespacedPodEviction$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/pods/\${params.parameter.name}/eviction\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** connect GET requests to exec of Pod */
+        connectCoreV1GetNamespacedPodExec: (params: Params$connectCoreV1GetNamespacedPodExec, option?: RequestOption): Promise<Response$connectCoreV1GetNamespacedPodExec$Status$200["*/*"]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/pods/\${params.parameter.name}/exec\`;
+            const headers = {
+                Accept: "*/*"
+            };
+            const queryParameters: QueryParameters = {
+                command: { value: params.parameter.command, explode: false },
+                container: { value: params.parameter.container, explode: false },
+                stderr: { value: params.parameter.stderr, explode: false },
+                stdin: { value: params.parameter.stdin, explode: false },
+                stdout: { value: params.parameter.stdout, explode: false },
+                tty: { value: params.parameter.tty, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** connect POST requests to exec of Pod */
+        connectCoreV1PostNamespacedPodExec: (params: Params$connectCoreV1PostNamespacedPodExec, option?: RequestOption): Promise<Response$connectCoreV1PostNamespacedPodExec$Status$200["*/*"]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/pods/\${params.parameter.name}/exec\`;
+            const headers = {
+                Accept: "*/*"
+            };
+            const queryParameters: QueryParameters = {
+                command: { value: params.parameter.command, explode: false },
+                container: { value: params.parameter.container, explode: false },
+                stderr: { value: params.parameter.stderr, explode: false },
+                stdin: { value: params.parameter.stdin, explode: false },
+                stdout: { value: params.parameter.stdout, explode: false },
+                tty: { value: params.parameter.tty, explode: false }
+            };
+            return apiClient.request("POST", url, headers, undefined, queryParameters, option);
+        },
+        /** read log of the specified Pod */
+        readCoreV1NamespacedPodLog: <ResponseContentType extends ResponseContentType$readCoreV1NamespacedPodLog>(params: Params$readCoreV1NamespacedPodLog<ResponseContentType>, option?: RequestOption): Promise<Response$readCoreV1NamespacedPodLog$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/pods/\${params.parameter.name}/log\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                container: { value: params.parameter.container, explode: false },
+                follow: { value: params.parameter.follow, explode: false },
+                insecureSkipTLSVerifyBackend: { value: params.parameter.insecureSkipTLSVerifyBackend, explode: false },
+                limitBytes: { value: params.parameter.limitBytes, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                previous: { value: params.parameter.previous, explode: false },
+                sinceSeconds: { value: params.parameter.sinceSeconds, explode: false },
+                tailLines: { value: params.parameter.tailLines, explode: false },
+                timestamps: { value: params.parameter.timestamps, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** connect GET requests to portforward of Pod */
+        connectCoreV1GetNamespacedPodPortforward: (params: Params$connectCoreV1GetNamespacedPodPortforward, option?: RequestOption): Promise<Response$connectCoreV1GetNamespacedPodPortforward$Status$200["*/*"]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/pods/\${params.parameter.name}/portforward\`;
+            const headers = {
+                Accept: "*/*"
+            };
+            const queryParameters: QueryParameters = {
+                ports: { value: params.parameter.ports, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** connect POST requests to portforward of Pod */
+        connectCoreV1PostNamespacedPodPortforward: (params: Params$connectCoreV1PostNamespacedPodPortforward, option?: RequestOption): Promise<Response$connectCoreV1PostNamespacedPodPortforward$Status$200["*/*"]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/pods/\${params.parameter.name}/portforward\`;
+            const headers = {
+                Accept: "*/*"
+            };
+            const queryParameters: QueryParameters = {
+                ports: { value: params.parameter.ports, explode: false }
+            };
+            return apiClient.request("POST", url, headers, undefined, queryParameters, option);
+        },
+        /** connect GET requests to proxy of Pod */
+        connectCoreV1GetNamespacedPodProxy: (params: Params$connectCoreV1GetNamespacedPodProxy, option?: RequestOption): Promise<Response$connectCoreV1GetNamespacedPodProxy$Status$200["*/*"]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/pods/\${params.parameter.name}/proxy\`;
+            const headers = {
+                Accept: "*/*"
+            };
+            const queryParameters: QueryParameters = {
+                path: { value: params.parameter.path, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** connect PUT requests to proxy of Pod */
+        connectCoreV1PutNamespacedPodProxy: (params: Params$connectCoreV1PutNamespacedPodProxy, option?: RequestOption): Promise<Response$connectCoreV1PutNamespacedPodProxy$Status$200["*/*"]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/pods/\${params.parameter.name}/proxy\`;
+            const headers = {
+                Accept: "*/*"
+            };
+            const queryParameters: QueryParameters = {
+                path: { value: params.parameter.path, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, undefined, queryParameters, option);
+        },
+        /** connect POST requests to proxy of Pod */
+        connectCoreV1PostNamespacedPodProxy: (params: Params$connectCoreV1PostNamespacedPodProxy, option?: RequestOption): Promise<Response$connectCoreV1PostNamespacedPodProxy$Status$200["*/*"]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/pods/\${params.parameter.name}/proxy\`;
+            const headers = {
+                Accept: "*/*"
+            };
+            const queryParameters: QueryParameters = {
+                path: { value: params.parameter.path, explode: false }
+            };
+            return apiClient.request("POST", url, headers, undefined, queryParameters, option);
+        },
+        /** connect DELETE requests to proxy of Pod */
+        connectCoreV1DeleteNamespacedPodProxy: (params: Params$connectCoreV1DeleteNamespacedPodProxy, option?: RequestOption): Promise<Response$connectCoreV1DeleteNamespacedPodProxy$Status$200["*/*"]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/pods/\${params.parameter.name}/proxy\`;
+            const headers = {
+                Accept: "*/*"
+            };
+            const queryParameters: QueryParameters = {
+                path: { value: params.parameter.path, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, undefined, queryParameters, option);
+        },
+        /** connect OPTIONS requests to proxy of Pod */
+        connectCoreV1OptionsNamespacedPodProxy: (params: Params$connectCoreV1OptionsNamespacedPodProxy, option?: RequestOption): Promise<Response$connectCoreV1OptionsNamespacedPodProxy$Status$200["*/*"]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/pods/\${params.parameter.name}/proxy\`;
+            const headers = {
+                Accept: "*/*"
+            };
+            const queryParameters: QueryParameters = {
+                path: { value: params.parameter.path, explode: false }
+            };
+            return apiClient.request("OPTIONS", url, headers, undefined, queryParameters, option);
+        },
+        /** connect HEAD requests to proxy of Pod */
+        connectCoreV1HeadNamespacedPodProxy: (params: Params$connectCoreV1HeadNamespacedPodProxy, option?: RequestOption): Promise<Response$connectCoreV1HeadNamespacedPodProxy$Status$200["*/*"]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/pods/\${params.parameter.name}/proxy\`;
+            const headers = {
+                Accept: "*/*"
+            };
+            const queryParameters: QueryParameters = {
+                path: { value: params.parameter.path, explode: false }
+            };
+            return apiClient.request("HEAD", url, headers, undefined, queryParameters, option);
+        },
+        /** connect PATCH requests to proxy of Pod */
+        connectCoreV1PatchNamespacedPodProxy: (params: Params$connectCoreV1PatchNamespacedPodProxy, option?: RequestOption): Promise<Response$connectCoreV1PatchNamespacedPodProxy$Status$200["*/*"]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/pods/\${params.parameter.name}/proxy\`;
+            const headers = {
+                Accept: "*/*"
+            };
+            const queryParameters: QueryParameters = {
+                path: { value: params.parameter.path, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, undefined, queryParameters, option);
+        },
+        /** connect GET requests to proxy of Pod */
+        connectCoreV1GetNamespacedPodProxyWithPath: (params: Params$connectCoreV1GetNamespacedPodProxyWithPath, option?: RequestOption): Promise<Response$connectCoreV1GetNamespacedPodProxyWithPath$Status$200["*/*"]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/pods/\${params.parameter.name}/proxy/\${params.parameter.path}\`;
+            const headers = {
+                Accept: "*/*"
+            };
+            const queryParameters: QueryParameters = {
+                path: { value: params.parameter.path, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** connect PUT requests to proxy of Pod */
+        connectCoreV1PutNamespacedPodProxyWithPath: (params: Params$connectCoreV1PutNamespacedPodProxyWithPath, option?: RequestOption): Promise<Response$connectCoreV1PutNamespacedPodProxyWithPath$Status$200["*/*"]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/pods/\${params.parameter.name}/proxy/\${params.parameter.path}\`;
+            const headers = {
+                Accept: "*/*"
+            };
+            const queryParameters: QueryParameters = {
+                path: { value: params.parameter.path, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, undefined, queryParameters, option);
+        },
+        /** connect POST requests to proxy of Pod */
+        connectCoreV1PostNamespacedPodProxyWithPath: (params: Params$connectCoreV1PostNamespacedPodProxyWithPath, option?: RequestOption): Promise<Response$connectCoreV1PostNamespacedPodProxyWithPath$Status$200["*/*"]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/pods/\${params.parameter.name}/proxy/\${params.parameter.path}\`;
+            const headers = {
+                Accept: "*/*"
+            };
+            const queryParameters: QueryParameters = {
+                path: { value: params.parameter.path, explode: false }
+            };
+            return apiClient.request("POST", url, headers, undefined, queryParameters, option);
+        },
+        /** connect DELETE requests to proxy of Pod */
+        connectCoreV1DeleteNamespacedPodProxyWithPath: (params: Params$connectCoreV1DeleteNamespacedPodProxyWithPath, option?: RequestOption): Promise<Response$connectCoreV1DeleteNamespacedPodProxyWithPath$Status$200["*/*"]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/pods/\${params.parameter.name}/proxy/\${params.parameter.path}\`;
+            const headers = {
+                Accept: "*/*"
+            };
+            const queryParameters: QueryParameters = {
+                path: { value: params.parameter.path, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, undefined, queryParameters, option);
+        },
+        /** connect OPTIONS requests to proxy of Pod */
+        connectCoreV1OptionsNamespacedPodProxyWithPath: (params: Params$connectCoreV1OptionsNamespacedPodProxyWithPath, option?: RequestOption): Promise<Response$connectCoreV1OptionsNamespacedPodProxyWithPath$Status$200["*/*"]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/pods/\${params.parameter.name}/proxy/\${params.parameter.path}\`;
+            const headers = {
+                Accept: "*/*"
+            };
+            const queryParameters: QueryParameters = {
+                path: { value: params.parameter.path, explode: false }
+            };
+            return apiClient.request("OPTIONS", url, headers, undefined, queryParameters, option);
+        },
+        /** connect HEAD requests to proxy of Pod */
+        connectCoreV1HeadNamespacedPodProxyWithPath: (params: Params$connectCoreV1HeadNamespacedPodProxyWithPath, option?: RequestOption): Promise<Response$connectCoreV1HeadNamespacedPodProxyWithPath$Status$200["*/*"]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/pods/\${params.parameter.name}/proxy/\${params.parameter.path}\`;
+            const headers = {
+                Accept: "*/*"
+            };
+            const queryParameters: QueryParameters = {
+                path: { value: params.parameter.path, explode: false }
+            };
+            return apiClient.request("HEAD", url, headers, undefined, queryParameters, option);
+        },
+        /** connect PATCH requests to proxy of Pod */
+        connectCoreV1PatchNamespacedPodProxyWithPath: (params: Params$connectCoreV1PatchNamespacedPodProxyWithPath, option?: RequestOption): Promise<Response$connectCoreV1PatchNamespacedPodProxyWithPath$Status$200["*/*"]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/pods/\${params.parameter.name}/proxy/\${params.parameter.path}\`;
+            const headers = {
+                Accept: "*/*"
+            };
+            const queryParameters: QueryParameters = {
+                path: { value: params.parameter.path, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, undefined, queryParameters, option);
+        },
+        /** read status of the specified Pod */
+        readCoreV1NamespacedPodStatus: <ResponseContentType extends ResponseContentType$readCoreV1NamespacedPodStatus>(params: Params$readCoreV1NamespacedPodStatus<ResponseContentType>, option?: RequestOption): Promise<Response$readCoreV1NamespacedPodStatus$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/pods/\${params.parameter.name}/status\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace status of the specified Pod */
+        replaceCoreV1NamespacedPodStatus: <ResponseContentType extends ResponseContentType$replaceCoreV1NamespacedPodStatus>(params: Params$replaceCoreV1NamespacedPodStatus<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceCoreV1NamespacedPodStatus$Status$200 | Response$replaceCoreV1NamespacedPodStatus$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/pods/\${params.parameter.name}/status\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update status of the specified Pod */
+        patchCoreV1NamespacedPodStatus: <RequestContentType extends RequestContentType$patchCoreV1NamespacedPodStatus, ResponseContentType extends ResponseContentType$patchCoreV1NamespacedPodStatus>(params: Params$patchCoreV1NamespacedPodStatus<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchCoreV1NamespacedPodStatus$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/pods/\${params.parameter.name}/status\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** list or watch objects of kind PodTemplate */
+        listCoreV1NamespacedPodTemplate: <ResponseContentType extends ResponseContentType$listCoreV1NamespacedPodTemplate>(params: Params$listCoreV1NamespacedPodTemplate<ResponseContentType>, option?: RequestOption): Promise<Response$listCoreV1NamespacedPodTemplate$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/podtemplates\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** create a PodTemplate */
+        createCoreV1NamespacedPodTemplate: <ResponseContentType extends ResponseContentType$createCoreV1NamespacedPodTemplate>(params: Params$createCoreV1NamespacedPodTemplate<ResponseContentType>, option?: RequestOption): Promise<(Response$createCoreV1NamespacedPodTemplate$Status$200 | Response$createCoreV1NamespacedPodTemplate$Status$201 | Response$createCoreV1NamespacedPodTemplate$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/podtemplates\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete collection of PodTemplate */
+        deleteCoreV1CollectionNamespacedPodTemplate: <ResponseContentType extends ResponseContentType$deleteCoreV1CollectionNamespacedPodTemplate>(params: Params$deleteCoreV1CollectionNamespacedPodTemplate<ResponseContentType>, option?: RequestOption): Promise<Response$deleteCoreV1CollectionNamespacedPodTemplate$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/podtemplates\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read the specified PodTemplate */
+        readCoreV1NamespacedPodTemplate: <ResponseContentType extends ResponseContentType$readCoreV1NamespacedPodTemplate>(params: Params$readCoreV1NamespacedPodTemplate<ResponseContentType>, option?: RequestOption): Promise<Response$readCoreV1NamespacedPodTemplate$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/podtemplates/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                exact: { value: params.parameter.exact, explode: false },
+                export: { value: params.parameter.export, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace the specified PodTemplate */
+        replaceCoreV1NamespacedPodTemplate: <ResponseContentType extends ResponseContentType$replaceCoreV1NamespacedPodTemplate>(params: Params$replaceCoreV1NamespacedPodTemplate<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceCoreV1NamespacedPodTemplate$Status$200 | Response$replaceCoreV1NamespacedPodTemplate$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/podtemplates/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete a PodTemplate */
+        deleteCoreV1NamespacedPodTemplate: <ResponseContentType extends ResponseContentType$deleteCoreV1NamespacedPodTemplate>(params: Params$deleteCoreV1NamespacedPodTemplate<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteCoreV1NamespacedPodTemplate$Status$200 | Response$deleteCoreV1NamespacedPodTemplate$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/podtemplates/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update the specified PodTemplate */
+        patchCoreV1NamespacedPodTemplate: <RequestContentType extends RequestContentType$patchCoreV1NamespacedPodTemplate, ResponseContentType extends ResponseContentType$patchCoreV1NamespacedPodTemplate>(params: Params$patchCoreV1NamespacedPodTemplate<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchCoreV1NamespacedPodTemplate$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/podtemplates/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** list or watch objects of kind ReplicationController */
+        listCoreV1NamespacedReplicationController: <ResponseContentType extends ResponseContentType$listCoreV1NamespacedReplicationController>(params: Params$listCoreV1NamespacedReplicationController<ResponseContentType>, option?: RequestOption): Promise<Response$listCoreV1NamespacedReplicationController$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/replicationcontrollers\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** create a ReplicationController */
+        createCoreV1NamespacedReplicationController: <ResponseContentType extends ResponseContentType$createCoreV1NamespacedReplicationController>(params: Params$createCoreV1NamespacedReplicationController<ResponseContentType>, option?: RequestOption): Promise<(Response$createCoreV1NamespacedReplicationController$Status$200 | Response$createCoreV1NamespacedReplicationController$Status$201 | Response$createCoreV1NamespacedReplicationController$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/replicationcontrollers\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete collection of ReplicationController */
+        deleteCoreV1CollectionNamespacedReplicationController: <ResponseContentType extends ResponseContentType$deleteCoreV1CollectionNamespacedReplicationController>(params: Params$deleteCoreV1CollectionNamespacedReplicationController<ResponseContentType>, option?: RequestOption): Promise<Response$deleteCoreV1CollectionNamespacedReplicationController$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/replicationcontrollers\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read the specified ReplicationController */
+        readCoreV1NamespacedReplicationController: <ResponseContentType extends ResponseContentType$readCoreV1NamespacedReplicationController>(params: Params$readCoreV1NamespacedReplicationController<ResponseContentType>, option?: RequestOption): Promise<Response$readCoreV1NamespacedReplicationController$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/replicationcontrollers/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                exact: { value: params.parameter.exact, explode: false },
+                export: { value: params.parameter.export, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace the specified ReplicationController */
+        replaceCoreV1NamespacedReplicationController: <ResponseContentType extends ResponseContentType$replaceCoreV1NamespacedReplicationController>(params: Params$replaceCoreV1NamespacedReplicationController<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceCoreV1NamespacedReplicationController$Status$200 | Response$replaceCoreV1NamespacedReplicationController$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/replicationcontrollers/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete a ReplicationController */
+        deleteCoreV1NamespacedReplicationController: <ResponseContentType extends ResponseContentType$deleteCoreV1NamespacedReplicationController>(params: Params$deleteCoreV1NamespacedReplicationController<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteCoreV1NamespacedReplicationController$Status$200 | Response$deleteCoreV1NamespacedReplicationController$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/replicationcontrollers/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update the specified ReplicationController */
+        patchCoreV1NamespacedReplicationController: <RequestContentType extends RequestContentType$patchCoreV1NamespacedReplicationController, ResponseContentType extends ResponseContentType$patchCoreV1NamespacedReplicationController>(params: Params$patchCoreV1NamespacedReplicationController<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchCoreV1NamespacedReplicationController$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/replicationcontrollers/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read scale of the specified ReplicationController */
+        readCoreV1NamespacedReplicationControllerScale: <ResponseContentType extends ResponseContentType$readCoreV1NamespacedReplicationControllerScale>(params: Params$readCoreV1NamespacedReplicationControllerScale<ResponseContentType>, option?: RequestOption): Promise<Response$readCoreV1NamespacedReplicationControllerScale$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/replicationcontrollers/\${params.parameter.name}/scale\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace scale of the specified ReplicationController */
+        replaceCoreV1NamespacedReplicationControllerScale: <ResponseContentType extends ResponseContentType$replaceCoreV1NamespacedReplicationControllerScale>(params: Params$replaceCoreV1NamespacedReplicationControllerScale<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceCoreV1NamespacedReplicationControllerScale$Status$200 | Response$replaceCoreV1NamespacedReplicationControllerScale$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/replicationcontrollers/\${params.parameter.name}/scale\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update scale of the specified ReplicationController */
+        patchCoreV1NamespacedReplicationControllerScale: <RequestContentType extends RequestContentType$patchCoreV1NamespacedReplicationControllerScale, ResponseContentType extends ResponseContentType$patchCoreV1NamespacedReplicationControllerScale>(params: Params$patchCoreV1NamespacedReplicationControllerScale<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchCoreV1NamespacedReplicationControllerScale$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/replicationcontrollers/\${params.parameter.name}/scale\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read status of the specified ReplicationController */
+        readCoreV1NamespacedReplicationControllerStatus: <ResponseContentType extends ResponseContentType$readCoreV1NamespacedReplicationControllerStatus>(params: Params$readCoreV1NamespacedReplicationControllerStatus<ResponseContentType>, option?: RequestOption): Promise<Response$readCoreV1NamespacedReplicationControllerStatus$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/replicationcontrollers/\${params.parameter.name}/status\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace status of the specified ReplicationController */
+        replaceCoreV1NamespacedReplicationControllerStatus: <ResponseContentType extends ResponseContentType$replaceCoreV1NamespacedReplicationControllerStatus>(params: Params$replaceCoreV1NamespacedReplicationControllerStatus<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceCoreV1NamespacedReplicationControllerStatus$Status$200 | Response$replaceCoreV1NamespacedReplicationControllerStatus$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/replicationcontrollers/\${params.parameter.name}/status\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update status of the specified ReplicationController */
+        patchCoreV1NamespacedReplicationControllerStatus: <RequestContentType extends RequestContentType$patchCoreV1NamespacedReplicationControllerStatus, ResponseContentType extends ResponseContentType$patchCoreV1NamespacedReplicationControllerStatus>(params: Params$patchCoreV1NamespacedReplicationControllerStatus<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchCoreV1NamespacedReplicationControllerStatus$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/replicationcontrollers/\${params.parameter.name}/status\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** list or watch objects of kind ResourceQuota */
+        listCoreV1NamespacedResourceQuota: <ResponseContentType extends ResponseContentType$listCoreV1NamespacedResourceQuota>(params: Params$listCoreV1NamespacedResourceQuota<ResponseContentType>, option?: RequestOption): Promise<Response$listCoreV1NamespacedResourceQuota$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/resourcequotas\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** create a ResourceQuota */
+        createCoreV1NamespacedResourceQuota: <ResponseContentType extends ResponseContentType$createCoreV1NamespacedResourceQuota>(params: Params$createCoreV1NamespacedResourceQuota<ResponseContentType>, option?: RequestOption): Promise<(Response$createCoreV1NamespacedResourceQuota$Status$200 | Response$createCoreV1NamespacedResourceQuota$Status$201 | Response$createCoreV1NamespacedResourceQuota$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/resourcequotas\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete collection of ResourceQuota */
+        deleteCoreV1CollectionNamespacedResourceQuota: <ResponseContentType extends ResponseContentType$deleteCoreV1CollectionNamespacedResourceQuota>(params: Params$deleteCoreV1CollectionNamespacedResourceQuota<ResponseContentType>, option?: RequestOption): Promise<Response$deleteCoreV1CollectionNamespacedResourceQuota$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/resourcequotas\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read the specified ResourceQuota */
+        readCoreV1NamespacedResourceQuota: <ResponseContentType extends ResponseContentType$readCoreV1NamespacedResourceQuota>(params: Params$readCoreV1NamespacedResourceQuota<ResponseContentType>, option?: RequestOption): Promise<Response$readCoreV1NamespacedResourceQuota$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/resourcequotas/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                exact: { value: params.parameter.exact, explode: false },
+                export: { value: params.parameter.export, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace the specified ResourceQuota */
+        replaceCoreV1NamespacedResourceQuota: <ResponseContentType extends ResponseContentType$replaceCoreV1NamespacedResourceQuota>(params: Params$replaceCoreV1NamespacedResourceQuota<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceCoreV1NamespacedResourceQuota$Status$200 | Response$replaceCoreV1NamespacedResourceQuota$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/resourcequotas/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete a ResourceQuota */
+        deleteCoreV1NamespacedResourceQuota: <ResponseContentType extends ResponseContentType$deleteCoreV1NamespacedResourceQuota>(params: Params$deleteCoreV1NamespacedResourceQuota<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteCoreV1NamespacedResourceQuota$Status$200 | Response$deleteCoreV1NamespacedResourceQuota$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/resourcequotas/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update the specified ResourceQuota */
+        patchCoreV1NamespacedResourceQuota: <RequestContentType extends RequestContentType$patchCoreV1NamespacedResourceQuota, ResponseContentType extends ResponseContentType$patchCoreV1NamespacedResourceQuota>(params: Params$patchCoreV1NamespacedResourceQuota<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchCoreV1NamespacedResourceQuota$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/resourcequotas/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read status of the specified ResourceQuota */
+        readCoreV1NamespacedResourceQuotaStatus: <ResponseContentType extends ResponseContentType$readCoreV1NamespacedResourceQuotaStatus>(params: Params$readCoreV1NamespacedResourceQuotaStatus<ResponseContentType>, option?: RequestOption): Promise<Response$readCoreV1NamespacedResourceQuotaStatus$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/resourcequotas/\${params.parameter.name}/status\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace status of the specified ResourceQuota */
+        replaceCoreV1NamespacedResourceQuotaStatus: <ResponseContentType extends ResponseContentType$replaceCoreV1NamespacedResourceQuotaStatus>(params: Params$replaceCoreV1NamespacedResourceQuotaStatus<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceCoreV1NamespacedResourceQuotaStatus$Status$200 | Response$replaceCoreV1NamespacedResourceQuotaStatus$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/resourcequotas/\${params.parameter.name}/status\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update status of the specified ResourceQuota */
+        patchCoreV1NamespacedResourceQuotaStatus: <RequestContentType extends RequestContentType$patchCoreV1NamespacedResourceQuotaStatus, ResponseContentType extends ResponseContentType$patchCoreV1NamespacedResourceQuotaStatus>(params: Params$patchCoreV1NamespacedResourceQuotaStatus<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchCoreV1NamespacedResourceQuotaStatus$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/resourcequotas/\${params.parameter.name}/status\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** list or watch objects of kind Secret */
+        listCoreV1NamespacedSecret: <ResponseContentType extends ResponseContentType$listCoreV1NamespacedSecret>(params: Params$listCoreV1NamespacedSecret<ResponseContentType>, option?: RequestOption): Promise<Response$listCoreV1NamespacedSecret$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/secrets\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** create a Secret */
+        createCoreV1NamespacedSecret: <ResponseContentType extends ResponseContentType$createCoreV1NamespacedSecret>(params: Params$createCoreV1NamespacedSecret<ResponseContentType>, option?: RequestOption): Promise<(Response$createCoreV1NamespacedSecret$Status$200 | Response$createCoreV1NamespacedSecret$Status$201 | Response$createCoreV1NamespacedSecret$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/secrets\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete collection of Secret */
+        deleteCoreV1CollectionNamespacedSecret: <ResponseContentType extends ResponseContentType$deleteCoreV1CollectionNamespacedSecret>(params: Params$deleteCoreV1CollectionNamespacedSecret<ResponseContentType>, option?: RequestOption): Promise<Response$deleteCoreV1CollectionNamespacedSecret$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/secrets\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read the specified Secret */
+        readCoreV1NamespacedSecret: <ResponseContentType extends ResponseContentType$readCoreV1NamespacedSecret>(params: Params$readCoreV1NamespacedSecret<ResponseContentType>, option?: RequestOption): Promise<Response$readCoreV1NamespacedSecret$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/secrets/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                exact: { value: params.parameter.exact, explode: false },
+                export: { value: params.parameter.export, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace the specified Secret */
+        replaceCoreV1NamespacedSecret: <ResponseContentType extends ResponseContentType$replaceCoreV1NamespacedSecret>(params: Params$replaceCoreV1NamespacedSecret<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceCoreV1NamespacedSecret$Status$200 | Response$replaceCoreV1NamespacedSecret$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/secrets/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete a Secret */
+        deleteCoreV1NamespacedSecret: <ResponseContentType extends ResponseContentType$deleteCoreV1NamespacedSecret>(params: Params$deleteCoreV1NamespacedSecret<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteCoreV1NamespacedSecret$Status$200 | Response$deleteCoreV1NamespacedSecret$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/secrets/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update the specified Secret */
+        patchCoreV1NamespacedSecret: <RequestContentType extends RequestContentType$patchCoreV1NamespacedSecret, ResponseContentType extends ResponseContentType$patchCoreV1NamespacedSecret>(params: Params$patchCoreV1NamespacedSecret<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchCoreV1NamespacedSecret$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/secrets/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** list or watch objects of kind ServiceAccount */
+        listCoreV1NamespacedServiceAccount: <ResponseContentType extends ResponseContentType$listCoreV1NamespacedServiceAccount>(params: Params$listCoreV1NamespacedServiceAccount<ResponseContentType>, option?: RequestOption): Promise<Response$listCoreV1NamespacedServiceAccount$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/serviceaccounts\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** create a ServiceAccount */
+        createCoreV1NamespacedServiceAccount: <ResponseContentType extends ResponseContentType$createCoreV1NamespacedServiceAccount>(params: Params$createCoreV1NamespacedServiceAccount<ResponseContentType>, option?: RequestOption): Promise<(Response$createCoreV1NamespacedServiceAccount$Status$200 | Response$createCoreV1NamespacedServiceAccount$Status$201 | Response$createCoreV1NamespacedServiceAccount$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/serviceaccounts\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete collection of ServiceAccount */
+        deleteCoreV1CollectionNamespacedServiceAccount: <ResponseContentType extends ResponseContentType$deleteCoreV1CollectionNamespacedServiceAccount>(params: Params$deleteCoreV1CollectionNamespacedServiceAccount<ResponseContentType>, option?: RequestOption): Promise<Response$deleteCoreV1CollectionNamespacedServiceAccount$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/serviceaccounts\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read the specified ServiceAccount */
+        readCoreV1NamespacedServiceAccount: <ResponseContentType extends ResponseContentType$readCoreV1NamespacedServiceAccount>(params: Params$readCoreV1NamespacedServiceAccount<ResponseContentType>, option?: RequestOption): Promise<Response$readCoreV1NamespacedServiceAccount$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/serviceaccounts/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                exact: { value: params.parameter.exact, explode: false },
+                export: { value: params.parameter.export, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace the specified ServiceAccount */
+        replaceCoreV1NamespacedServiceAccount: <ResponseContentType extends ResponseContentType$replaceCoreV1NamespacedServiceAccount>(params: Params$replaceCoreV1NamespacedServiceAccount<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceCoreV1NamespacedServiceAccount$Status$200 | Response$replaceCoreV1NamespacedServiceAccount$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/serviceaccounts/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete a ServiceAccount */
+        deleteCoreV1NamespacedServiceAccount: <ResponseContentType extends ResponseContentType$deleteCoreV1NamespacedServiceAccount>(params: Params$deleteCoreV1NamespacedServiceAccount<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteCoreV1NamespacedServiceAccount$Status$200 | Response$deleteCoreV1NamespacedServiceAccount$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/serviceaccounts/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update the specified ServiceAccount */
+        patchCoreV1NamespacedServiceAccount: <RequestContentType extends RequestContentType$patchCoreV1NamespacedServiceAccount, ResponseContentType extends ResponseContentType$patchCoreV1NamespacedServiceAccount>(params: Params$patchCoreV1NamespacedServiceAccount<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchCoreV1NamespacedServiceAccount$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/serviceaccounts/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** create token of a ServiceAccount */
+        createCoreV1NamespacedServiceAccountToken: <ResponseContentType extends ResponseContentType$createCoreV1NamespacedServiceAccountToken>(params: Params$createCoreV1NamespacedServiceAccountToken<ResponseContentType>, option?: RequestOption): Promise<(Response$createCoreV1NamespacedServiceAccountToken$Status$200 | Response$createCoreV1NamespacedServiceAccountToken$Status$201 | Response$createCoreV1NamespacedServiceAccountToken$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/serviceaccounts/\${params.parameter.name}/token\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** list or watch objects of kind Service */
+        listCoreV1NamespacedService: <ResponseContentType extends ResponseContentType$listCoreV1NamespacedService>(params: Params$listCoreV1NamespacedService<ResponseContentType>, option?: RequestOption): Promise<Response$listCoreV1NamespacedService$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/services\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** create a Service */
+        createCoreV1NamespacedService: <ResponseContentType extends ResponseContentType$createCoreV1NamespacedService>(params: Params$createCoreV1NamespacedService<ResponseContentType>, option?: RequestOption): Promise<(Response$createCoreV1NamespacedService$Status$200 | Response$createCoreV1NamespacedService$Status$201 | Response$createCoreV1NamespacedService$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/services\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read the specified Service */
+        readCoreV1NamespacedService: <ResponseContentType extends ResponseContentType$readCoreV1NamespacedService>(params: Params$readCoreV1NamespacedService<ResponseContentType>, option?: RequestOption): Promise<Response$readCoreV1NamespacedService$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/services/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                exact: { value: params.parameter.exact, explode: false },
+                export: { value: params.parameter.export, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace the specified Service */
+        replaceCoreV1NamespacedService: <ResponseContentType extends ResponseContentType$replaceCoreV1NamespacedService>(params: Params$replaceCoreV1NamespacedService<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceCoreV1NamespacedService$Status$200 | Response$replaceCoreV1NamespacedService$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/services/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete a Service */
+        deleteCoreV1NamespacedService: <ResponseContentType extends ResponseContentType$deleteCoreV1NamespacedService>(params: Params$deleteCoreV1NamespacedService<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteCoreV1NamespacedService$Status$200 | Response$deleteCoreV1NamespacedService$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/services/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update the specified Service */
+        patchCoreV1NamespacedService: <RequestContentType extends RequestContentType$patchCoreV1NamespacedService, ResponseContentType extends ResponseContentType$patchCoreV1NamespacedService>(params: Params$patchCoreV1NamespacedService<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchCoreV1NamespacedService$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/services/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** connect GET requests to proxy of Service */
+        connectCoreV1GetNamespacedServiceProxy: (params: Params$connectCoreV1GetNamespacedServiceProxy, option?: RequestOption): Promise<Response$connectCoreV1GetNamespacedServiceProxy$Status$200["*/*"]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/services/\${params.parameter.name}/proxy\`;
+            const headers = {
+                Accept: "*/*"
+            };
+            const queryParameters: QueryParameters = {
+                path: { value: params.parameter.path, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** connect PUT requests to proxy of Service */
+        connectCoreV1PutNamespacedServiceProxy: (params: Params$connectCoreV1PutNamespacedServiceProxy, option?: RequestOption): Promise<Response$connectCoreV1PutNamespacedServiceProxy$Status$200["*/*"]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/services/\${params.parameter.name}/proxy\`;
+            const headers = {
+                Accept: "*/*"
+            };
+            const queryParameters: QueryParameters = {
+                path: { value: params.parameter.path, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, undefined, queryParameters, option);
+        },
+        /** connect POST requests to proxy of Service */
+        connectCoreV1PostNamespacedServiceProxy: (params: Params$connectCoreV1PostNamespacedServiceProxy, option?: RequestOption): Promise<Response$connectCoreV1PostNamespacedServiceProxy$Status$200["*/*"]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/services/\${params.parameter.name}/proxy\`;
+            const headers = {
+                Accept: "*/*"
+            };
+            const queryParameters: QueryParameters = {
+                path: { value: params.parameter.path, explode: false }
+            };
+            return apiClient.request("POST", url, headers, undefined, queryParameters, option);
+        },
+        /** connect DELETE requests to proxy of Service */
+        connectCoreV1DeleteNamespacedServiceProxy: (params: Params$connectCoreV1DeleteNamespacedServiceProxy, option?: RequestOption): Promise<Response$connectCoreV1DeleteNamespacedServiceProxy$Status$200["*/*"]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/services/\${params.parameter.name}/proxy\`;
+            const headers = {
+                Accept: "*/*"
+            };
+            const queryParameters: QueryParameters = {
+                path: { value: params.parameter.path, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, undefined, queryParameters, option);
+        },
+        /** connect OPTIONS requests to proxy of Service */
+        connectCoreV1OptionsNamespacedServiceProxy: (params: Params$connectCoreV1OptionsNamespacedServiceProxy, option?: RequestOption): Promise<Response$connectCoreV1OptionsNamespacedServiceProxy$Status$200["*/*"]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/services/\${params.parameter.name}/proxy\`;
+            const headers = {
+                Accept: "*/*"
+            };
+            const queryParameters: QueryParameters = {
+                path: { value: params.parameter.path, explode: false }
+            };
+            return apiClient.request("OPTIONS", url, headers, undefined, queryParameters, option);
+        },
+        /** connect HEAD requests to proxy of Service */
+        connectCoreV1HeadNamespacedServiceProxy: (params: Params$connectCoreV1HeadNamespacedServiceProxy, option?: RequestOption): Promise<Response$connectCoreV1HeadNamespacedServiceProxy$Status$200["*/*"]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/services/\${params.parameter.name}/proxy\`;
+            const headers = {
+                Accept: "*/*"
+            };
+            const queryParameters: QueryParameters = {
+                path: { value: params.parameter.path, explode: false }
+            };
+            return apiClient.request("HEAD", url, headers, undefined, queryParameters, option);
+        },
+        /** connect PATCH requests to proxy of Service */
+        connectCoreV1PatchNamespacedServiceProxy: (params: Params$connectCoreV1PatchNamespacedServiceProxy, option?: RequestOption): Promise<Response$connectCoreV1PatchNamespacedServiceProxy$Status$200["*/*"]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/services/\${params.parameter.name}/proxy\`;
+            const headers = {
+                Accept: "*/*"
+            };
+            const queryParameters: QueryParameters = {
+                path: { value: params.parameter.path, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, undefined, queryParameters, option);
+        },
+        /** connect GET requests to proxy of Service */
+        connectCoreV1GetNamespacedServiceProxyWithPath: (params: Params$connectCoreV1GetNamespacedServiceProxyWithPath, option?: RequestOption): Promise<Response$connectCoreV1GetNamespacedServiceProxyWithPath$Status$200["*/*"]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/services/\${params.parameter.name}/proxy/\${params.parameter.path}\`;
+            const headers = {
+                Accept: "*/*"
+            };
+            const queryParameters: QueryParameters = {
+                path: { value: params.parameter.path, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** connect PUT requests to proxy of Service */
+        connectCoreV1PutNamespacedServiceProxyWithPath: (params: Params$connectCoreV1PutNamespacedServiceProxyWithPath, option?: RequestOption): Promise<Response$connectCoreV1PutNamespacedServiceProxyWithPath$Status$200["*/*"]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/services/\${params.parameter.name}/proxy/\${params.parameter.path}\`;
+            const headers = {
+                Accept: "*/*"
+            };
+            const queryParameters: QueryParameters = {
+                path: { value: params.parameter.path, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, undefined, queryParameters, option);
+        },
+        /** connect POST requests to proxy of Service */
+        connectCoreV1PostNamespacedServiceProxyWithPath: (params: Params$connectCoreV1PostNamespacedServiceProxyWithPath, option?: RequestOption): Promise<Response$connectCoreV1PostNamespacedServiceProxyWithPath$Status$200["*/*"]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/services/\${params.parameter.name}/proxy/\${params.parameter.path}\`;
+            const headers = {
+                Accept: "*/*"
+            };
+            const queryParameters: QueryParameters = {
+                path: { value: params.parameter.path, explode: false }
+            };
+            return apiClient.request("POST", url, headers, undefined, queryParameters, option);
+        },
+        /** connect DELETE requests to proxy of Service */
+        connectCoreV1DeleteNamespacedServiceProxyWithPath: (params: Params$connectCoreV1DeleteNamespacedServiceProxyWithPath, option?: RequestOption): Promise<Response$connectCoreV1DeleteNamespacedServiceProxyWithPath$Status$200["*/*"]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/services/\${params.parameter.name}/proxy/\${params.parameter.path}\`;
+            const headers = {
+                Accept: "*/*"
+            };
+            const queryParameters: QueryParameters = {
+                path: { value: params.parameter.path, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, undefined, queryParameters, option);
+        },
+        /** connect OPTIONS requests to proxy of Service */
+        connectCoreV1OptionsNamespacedServiceProxyWithPath: (params: Params$connectCoreV1OptionsNamespacedServiceProxyWithPath, option?: RequestOption): Promise<Response$connectCoreV1OptionsNamespacedServiceProxyWithPath$Status$200["*/*"]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/services/\${params.parameter.name}/proxy/\${params.parameter.path}\`;
+            const headers = {
+                Accept: "*/*"
+            };
+            const queryParameters: QueryParameters = {
+                path: { value: params.parameter.path, explode: false }
+            };
+            return apiClient.request("OPTIONS", url, headers, undefined, queryParameters, option);
+        },
+        /** connect HEAD requests to proxy of Service */
+        connectCoreV1HeadNamespacedServiceProxyWithPath: (params: Params$connectCoreV1HeadNamespacedServiceProxyWithPath, option?: RequestOption): Promise<Response$connectCoreV1HeadNamespacedServiceProxyWithPath$Status$200["*/*"]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/services/\${params.parameter.name}/proxy/\${params.parameter.path}\`;
+            const headers = {
+                Accept: "*/*"
+            };
+            const queryParameters: QueryParameters = {
+                path: { value: params.parameter.path, explode: false }
+            };
+            return apiClient.request("HEAD", url, headers, undefined, queryParameters, option);
+        },
+        /** connect PATCH requests to proxy of Service */
+        connectCoreV1PatchNamespacedServiceProxyWithPath: (params: Params$connectCoreV1PatchNamespacedServiceProxyWithPath, option?: RequestOption): Promise<Response$connectCoreV1PatchNamespacedServiceProxyWithPath$Status$200["*/*"]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/services/\${params.parameter.name}/proxy/\${params.parameter.path}\`;
+            const headers = {
+                Accept: "*/*"
+            };
+            const queryParameters: QueryParameters = {
+                path: { value: params.parameter.path, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, undefined, queryParameters, option);
+        },
+        /** read status of the specified Service */
+        readCoreV1NamespacedServiceStatus: <ResponseContentType extends ResponseContentType$readCoreV1NamespacedServiceStatus>(params: Params$readCoreV1NamespacedServiceStatus<ResponseContentType>, option?: RequestOption): Promise<Response$readCoreV1NamespacedServiceStatus$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/services/\${params.parameter.name}/status\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace status of the specified Service */
+        replaceCoreV1NamespacedServiceStatus: <ResponseContentType extends ResponseContentType$replaceCoreV1NamespacedServiceStatus>(params: Params$replaceCoreV1NamespacedServiceStatus<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceCoreV1NamespacedServiceStatus$Status$200 | Response$replaceCoreV1NamespacedServiceStatus$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/services/\${params.parameter.name}/status\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update status of the specified Service */
+        patchCoreV1NamespacedServiceStatus: <RequestContentType extends RequestContentType$patchCoreV1NamespacedServiceStatus, ResponseContentType extends ResponseContentType$patchCoreV1NamespacedServiceStatus>(params: Params$patchCoreV1NamespacedServiceStatus<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchCoreV1NamespacedServiceStatus$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.namespace}/services/\${params.parameter.name}/status\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read the specified Namespace */
+        readCoreV1Namespace: <ResponseContentType extends ResponseContentType$readCoreV1Namespace>(params: Params$readCoreV1Namespace<ResponseContentType>, option?: RequestOption): Promise<Response$readCoreV1Namespace$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                exact: { value: params.parameter.exact, explode: false },
+                export: { value: params.parameter.export, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace the specified Namespace */
+        replaceCoreV1Namespace: <ResponseContentType extends ResponseContentType$replaceCoreV1Namespace>(params: Params$replaceCoreV1Namespace<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceCoreV1Namespace$Status$200 | Response$replaceCoreV1Namespace$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete a Namespace */
+        deleteCoreV1Namespace: <ResponseContentType extends ResponseContentType$deleteCoreV1Namespace>(params: Params$deleteCoreV1Namespace<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteCoreV1Namespace$Status$200 | Response$deleteCoreV1Namespace$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update the specified Namespace */
+        patchCoreV1Namespace: <RequestContentType extends RequestContentType$patchCoreV1Namespace, ResponseContentType extends ResponseContentType$patchCoreV1Namespace>(params: Params$patchCoreV1Namespace<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchCoreV1Namespace$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** replace finalize of the specified Namespace */
+        replaceCoreV1NamespaceFinalize: <ResponseContentType extends ResponseContentType$replaceCoreV1NamespaceFinalize>(params: Params$replaceCoreV1NamespaceFinalize<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceCoreV1NamespaceFinalize$Status$200 | Response$replaceCoreV1NamespaceFinalize$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.name}/finalize\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read status of the specified Namespace */
+        readCoreV1NamespaceStatus: <ResponseContentType extends ResponseContentType$readCoreV1NamespaceStatus>(params: Params$readCoreV1NamespaceStatus<ResponseContentType>, option?: RequestOption): Promise<Response$readCoreV1NamespaceStatus$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.name}/status\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace status of the specified Namespace */
+        replaceCoreV1NamespaceStatus: <ResponseContentType extends ResponseContentType$replaceCoreV1NamespaceStatus>(params: Params$replaceCoreV1NamespaceStatus<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceCoreV1NamespaceStatus$Status$200 | Response$replaceCoreV1NamespaceStatus$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.name}/status\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update status of the specified Namespace */
+        patchCoreV1NamespaceStatus: <RequestContentType extends RequestContentType$patchCoreV1NamespaceStatus, ResponseContentType extends ResponseContentType$patchCoreV1NamespaceStatus>(params: Params$patchCoreV1NamespaceStatus<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchCoreV1NamespaceStatus$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/namespaces/\${params.parameter.name}/status\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** list or watch objects of kind Node */
+        listCoreV1Node: <ResponseContentType extends ResponseContentType$listCoreV1Node>(params: Params$listCoreV1Node<ResponseContentType>, option?: RequestOption): Promise<Response$listCoreV1Node$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/nodes\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** create a Node */
+        createCoreV1Node: <ResponseContentType extends ResponseContentType$createCoreV1Node>(params: Params$createCoreV1Node<ResponseContentType>, option?: RequestOption): Promise<(Response$createCoreV1Node$Status$200 | Response$createCoreV1Node$Status$201 | Response$createCoreV1Node$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/nodes\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete collection of Node */
+        deleteCoreV1CollectionNode: <ResponseContentType extends ResponseContentType$deleteCoreV1CollectionNode>(params: Params$deleteCoreV1CollectionNode<ResponseContentType>, option?: RequestOption): Promise<Response$deleteCoreV1CollectionNode$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/nodes\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read the specified Node */
+        readCoreV1Node: <ResponseContentType extends ResponseContentType$readCoreV1Node>(params: Params$readCoreV1Node<ResponseContentType>, option?: RequestOption): Promise<Response$readCoreV1Node$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/nodes/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                exact: { value: params.parameter.exact, explode: false },
+                export: { value: params.parameter.export, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace the specified Node */
+        replaceCoreV1Node: <ResponseContentType extends ResponseContentType$replaceCoreV1Node>(params: Params$replaceCoreV1Node<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceCoreV1Node$Status$200 | Response$replaceCoreV1Node$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/nodes/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete a Node */
+        deleteCoreV1Node: <ResponseContentType extends ResponseContentType$deleteCoreV1Node>(params: Params$deleteCoreV1Node<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteCoreV1Node$Status$200 | Response$deleteCoreV1Node$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/nodes/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update the specified Node */
+        patchCoreV1Node: <RequestContentType extends RequestContentType$patchCoreV1Node, ResponseContentType extends ResponseContentType$patchCoreV1Node>(params: Params$patchCoreV1Node<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchCoreV1Node$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/nodes/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** connect GET requests to proxy of Node */
+        connectCoreV1GetNodeProxy: (params: Params$connectCoreV1GetNodeProxy, option?: RequestOption): Promise<Response$connectCoreV1GetNodeProxy$Status$200["*/*"]> => {
+            const url = baseUrl + \`/api/v1/nodes/\${params.parameter.name}/proxy\`;
+            const headers = {
+                Accept: "*/*"
+            };
+            const queryParameters: QueryParameters = {
+                path: { value: params.parameter.path, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** connect PUT requests to proxy of Node */
+        connectCoreV1PutNodeProxy: (params: Params$connectCoreV1PutNodeProxy, option?: RequestOption): Promise<Response$connectCoreV1PutNodeProxy$Status$200["*/*"]> => {
+            const url = baseUrl + \`/api/v1/nodes/\${params.parameter.name}/proxy\`;
+            const headers = {
+                Accept: "*/*"
+            };
+            const queryParameters: QueryParameters = {
+                path: { value: params.parameter.path, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, undefined, queryParameters, option);
+        },
+        /** connect POST requests to proxy of Node */
+        connectCoreV1PostNodeProxy: (params: Params$connectCoreV1PostNodeProxy, option?: RequestOption): Promise<Response$connectCoreV1PostNodeProxy$Status$200["*/*"]> => {
+            const url = baseUrl + \`/api/v1/nodes/\${params.parameter.name}/proxy\`;
+            const headers = {
+                Accept: "*/*"
+            };
+            const queryParameters: QueryParameters = {
+                path: { value: params.parameter.path, explode: false }
+            };
+            return apiClient.request("POST", url, headers, undefined, queryParameters, option);
+        },
+        /** connect DELETE requests to proxy of Node */
+        connectCoreV1DeleteNodeProxy: (params: Params$connectCoreV1DeleteNodeProxy, option?: RequestOption): Promise<Response$connectCoreV1DeleteNodeProxy$Status$200["*/*"]> => {
+            const url = baseUrl + \`/api/v1/nodes/\${params.parameter.name}/proxy\`;
+            const headers = {
+                Accept: "*/*"
+            };
+            const queryParameters: QueryParameters = {
+                path: { value: params.parameter.path, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, undefined, queryParameters, option);
+        },
+        /** connect OPTIONS requests to proxy of Node */
+        connectCoreV1OptionsNodeProxy: (params: Params$connectCoreV1OptionsNodeProxy, option?: RequestOption): Promise<Response$connectCoreV1OptionsNodeProxy$Status$200["*/*"]> => {
+            const url = baseUrl + \`/api/v1/nodes/\${params.parameter.name}/proxy\`;
+            const headers = {
+                Accept: "*/*"
+            };
+            const queryParameters: QueryParameters = {
+                path: { value: params.parameter.path, explode: false }
+            };
+            return apiClient.request("OPTIONS", url, headers, undefined, queryParameters, option);
+        },
+        /** connect HEAD requests to proxy of Node */
+        connectCoreV1HeadNodeProxy: (params: Params$connectCoreV1HeadNodeProxy, option?: RequestOption): Promise<Response$connectCoreV1HeadNodeProxy$Status$200["*/*"]> => {
+            const url = baseUrl + \`/api/v1/nodes/\${params.parameter.name}/proxy\`;
+            const headers = {
+                Accept: "*/*"
+            };
+            const queryParameters: QueryParameters = {
+                path: { value: params.parameter.path, explode: false }
+            };
+            return apiClient.request("HEAD", url, headers, undefined, queryParameters, option);
+        },
+        /** connect PATCH requests to proxy of Node */
+        connectCoreV1PatchNodeProxy: (params: Params$connectCoreV1PatchNodeProxy, option?: RequestOption): Promise<Response$connectCoreV1PatchNodeProxy$Status$200["*/*"]> => {
+            const url = baseUrl + \`/api/v1/nodes/\${params.parameter.name}/proxy\`;
+            const headers = {
+                Accept: "*/*"
+            };
+            const queryParameters: QueryParameters = {
+                path: { value: params.parameter.path, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, undefined, queryParameters, option);
+        },
+        /** connect GET requests to proxy of Node */
+        connectCoreV1GetNodeProxyWithPath: (params: Params$connectCoreV1GetNodeProxyWithPath, option?: RequestOption): Promise<Response$connectCoreV1GetNodeProxyWithPath$Status$200["*/*"]> => {
+            const url = baseUrl + \`/api/v1/nodes/\${params.parameter.name}/proxy/\${params.parameter.path}\`;
+            const headers = {
+                Accept: "*/*"
+            };
+            const queryParameters: QueryParameters = {
+                path: { value: params.parameter.path, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** connect PUT requests to proxy of Node */
+        connectCoreV1PutNodeProxyWithPath: (params: Params$connectCoreV1PutNodeProxyWithPath, option?: RequestOption): Promise<Response$connectCoreV1PutNodeProxyWithPath$Status$200["*/*"]> => {
+            const url = baseUrl + \`/api/v1/nodes/\${params.parameter.name}/proxy/\${params.parameter.path}\`;
+            const headers = {
+                Accept: "*/*"
+            };
+            const queryParameters: QueryParameters = {
+                path: { value: params.parameter.path, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, undefined, queryParameters, option);
+        },
+        /** connect POST requests to proxy of Node */
+        connectCoreV1PostNodeProxyWithPath: (params: Params$connectCoreV1PostNodeProxyWithPath, option?: RequestOption): Promise<Response$connectCoreV1PostNodeProxyWithPath$Status$200["*/*"]> => {
+            const url = baseUrl + \`/api/v1/nodes/\${params.parameter.name}/proxy/\${params.parameter.path}\`;
+            const headers = {
+                Accept: "*/*"
+            };
+            const queryParameters: QueryParameters = {
+                path: { value: params.parameter.path, explode: false }
+            };
+            return apiClient.request("POST", url, headers, undefined, queryParameters, option);
+        },
+        /** connect DELETE requests to proxy of Node */
+        connectCoreV1DeleteNodeProxyWithPath: (params: Params$connectCoreV1DeleteNodeProxyWithPath, option?: RequestOption): Promise<Response$connectCoreV1DeleteNodeProxyWithPath$Status$200["*/*"]> => {
+            const url = baseUrl + \`/api/v1/nodes/\${params.parameter.name}/proxy/\${params.parameter.path}\`;
+            const headers = {
+                Accept: "*/*"
+            };
+            const queryParameters: QueryParameters = {
+                path: { value: params.parameter.path, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, undefined, queryParameters, option);
+        },
+        /** connect OPTIONS requests to proxy of Node */
+        connectCoreV1OptionsNodeProxyWithPath: (params: Params$connectCoreV1OptionsNodeProxyWithPath, option?: RequestOption): Promise<Response$connectCoreV1OptionsNodeProxyWithPath$Status$200["*/*"]> => {
+            const url = baseUrl + \`/api/v1/nodes/\${params.parameter.name}/proxy/\${params.parameter.path}\`;
+            const headers = {
+                Accept: "*/*"
+            };
+            const queryParameters: QueryParameters = {
+                path: { value: params.parameter.path, explode: false }
+            };
+            return apiClient.request("OPTIONS", url, headers, undefined, queryParameters, option);
+        },
+        /** connect HEAD requests to proxy of Node */
+        connectCoreV1HeadNodeProxyWithPath: (params: Params$connectCoreV1HeadNodeProxyWithPath, option?: RequestOption): Promise<Response$connectCoreV1HeadNodeProxyWithPath$Status$200["*/*"]> => {
+            const url = baseUrl + \`/api/v1/nodes/\${params.parameter.name}/proxy/\${params.parameter.path}\`;
+            const headers = {
+                Accept: "*/*"
+            };
+            const queryParameters: QueryParameters = {
+                path: { value: params.parameter.path, explode: false }
+            };
+            return apiClient.request("HEAD", url, headers, undefined, queryParameters, option);
+        },
+        /** connect PATCH requests to proxy of Node */
+        connectCoreV1PatchNodeProxyWithPath: (params: Params$connectCoreV1PatchNodeProxyWithPath, option?: RequestOption): Promise<Response$connectCoreV1PatchNodeProxyWithPath$Status$200["*/*"]> => {
+            const url = baseUrl + \`/api/v1/nodes/\${params.parameter.name}/proxy/\${params.parameter.path}\`;
+            const headers = {
+                Accept: "*/*"
+            };
+            const queryParameters: QueryParameters = {
+                path: { value: params.parameter.path, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, undefined, queryParameters, option);
+        },
+        /** read status of the specified Node */
+        readCoreV1NodeStatus: <ResponseContentType extends ResponseContentType$readCoreV1NodeStatus>(params: Params$readCoreV1NodeStatus<ResponseContentType>, option?: RequestOption): Promise<Response$readCoreV1NodeStatus$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/nodes/\${params.parameter.name}/status\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace status of the specified Node */
+        replaceCoreV1NodeStatus: <ResponseContentType extends ResponseContentType$replaceCoreV1NodeStatus>(params: Params$replaceCoreV1NodeStatus<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceCoreV1NodeStatus$Status$200 | Response$replaceCoreV1NodeStatus$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/nodes/\${params.parameter.name}/status\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update status of the specified Node */
+        patchCoreV1NodeStatus: <RequestContentType extends RequestContentType$patchCoreV1NodeStatus, ResponseContentType extends ResponseContentType$patchCoreV1NodeStatus>(params: Params$patchCoreV1NodeStatus<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchCoreV1NodeStatus$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/nodes/\${params.parameter.name}/status\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** list or watch objects of kind PersistentVolumeClaim */
+        listCoreV1PersistentVolumeClaimForAllNamespaces: <ResponseContentType extends ResponseContentType$listCoreV1PersistentVolumeClaimForAllNamespaces>(params: Params$listCoreV1PersistentVolumeClaimForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$listCoreV1PersistentVolumeClaimForAllNamespaces$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/persistentvolumeclaims\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** list or watch objects of kind PersistentVolume */
+        listCoreV1PersistentVolume: <ResponseContentType extends ResponseContentType$listCoreV1PersistentVolume>(params: Params$listCoreV1PersistentVolume<ResponseContentType>, option?: RequestOption): Promise<Response$listCoreV1PersistentVolume$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/persistentvolumes\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** create a PersistentVolume */
+        createCoreV1PersistentVolume: <ResponseContentType extends ResponseContentType$createCoreV1PersistentVolume>(params: Params$createCoreV1PersistentVolume<ResponseContentType>, option?: RequestOption): Promise<(Response$createCoreV1PersistentVolume$Status$200 | Response$createCoreV1PersistentVolume$Status$201 | Response$createCoreV1PersistentVolume$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/persistentvolumes\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete collection of PersistentVolume */
+        deleteCoreV1CollectionPersistentVolume: <ResponseContentType extends ResponseContentType$deleteCoreV1CollectionPersistentVolume>(params: Params$deleteCoreV1CollectionPersistentVolume<ResponseContentType>, option?: RequestOption): Promise<Response$deleteCoreV1CollectionPersistentVolume$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/persistentvolumes\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read the specified PersistentVolume */
+        readCoreV1PersistentVolume: <ResponseContentType extends ResponseContentType$readCoreV1PersistentVolume>(params: Params$readCoreV1PersistentVolume<ResponseContentType>, option?: RequestOption): Promise<Response$readCoreV1PersistentVolume$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/persistentvolumes/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                exact: { value: params.parameter.exact, explode: false },
+                export: { value: params.parameter.export, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace the specified PersistentVolume */
+        replaceCoreV1PersistentVolume: <ResponseContentType extends ResponseContentType$replaceCoreV1PersistentVolume>(params: Params$replaceCoreV1PersistentVolume<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceCoreV1PersistentVolume$Status$200 | Response$replaceCoreV1PersistentVolume$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/persistentvolumes/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete a PersistentVolume */
+        deleteCoreV1PersistentVolume: <ResponseContentType extends ResponseContentType$deleteCoreV1PersistentVolume>(params: Params$deleteCoreV1PersistentVolume<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteCoreV1PersistentVolume$Status$200 | Response$deleteCoreV1PersistentVolume$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/persistentvolumes/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update the specified PersistentVolume */
+        patchCoreV1PersistentVolume: <RequestContentType extends RequestContentType$patchCoreV1PersistentVolume, ResponseContentType extends ResponseContentType$patchCoreV1PersistentVolume>(params: Params$patchCoreV1PersistentVolume<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchCoreV1PersistentVolume$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/persistentvolumes/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read status of the specified PersistentVolume */
+        readCoreV1PersistentVolumeStatus: <ResponseContentType extends ResponseContentType$readCoreV1PersistentVolumeStatus>(params: Params$readCoreV1PersistentVolumeStatus<ResponseContentType>, option?: RequestOption): Promise<Response$readCoreV1PersistentVolumeStatus$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/persistentvolumes/\${params.parameter.name}/status\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace status of the specified PersistentVolume */
+        replaceCoreV1PersistentVolumeStatus: <ResponseContentType extends ResponseContentType$replaceCoreV1PersistentVolumeStatus>(params: Params$replaceCoreV1PersistentVolumeStatus<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceCoreV1PersistentVolumeStatus$Status$200 | Response$replaceCoreV1PersistentVolumeStatus$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/persistentvolumes/\${params.parameter.name}/status\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update status of the specified PersistentVolume */
+        patchCoreV1PersistentVolumeStatus: <RequestContentType extends RequestContentType$patchCoreV1PersistentVolumeStatus, ResponseContentType extends ResponseContentType$patchCoreV1PersistentVolumeStatus>(params: Params$patchCoreV1PersistentVolumeStatus<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchCoreV1PersistentVolumeStatus$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/persistentvolumes/\${params.parameter.name}/status\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** list or watch objects of kind Pod */
+        listCoreV1PodForAllNamespaces: <ResponseContentType extends ResponseContentType$listCoreV1PodForAllNamespaces>(params: Params$listCoreV1PodForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$listCoreV1PodForAllNamespaces$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/pods\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** list or watch objects of kind PodTemplate */
+        listCoreV1PodTemplateForAllNamespaces: <ResponseContentType extends ResponseContentType$listCoreV1PodTemplateForAllNamespaces>(params: Params$listCoreV1PodTemplateForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$listCoreV1PodTemplateForAllNamespaces$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/podtemplates\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** list or watch objects of kind ReplicationController */
+        listCoreV1ReplicationControllerForAllNamespaces: <ResponseContentType extends ResponseContentType$listCoreV1ReplicationControllerForAllNamespaces>(params: Params$listCoreV1ReplicationControllerForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$listCoreV1ReplicationControllerForAllNamespaces$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/replicationcontrollers\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** list or watch objects of kind ResourceQuota */
+        listCoreV1ResourceQuotaForAllNamespaces: <ResponseContentType extends ResponseContentType$listCoreV1ResourceQuotaForAllNamespaces>(params: Params$listCoreV1ResourceQuotaForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$listCoreV1ResourceQuotaForAllNamespaces$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/resourcequotas\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** list or watch objects of kind Secret */
+        listCoreV1SecretForAllNamespaces: <ResponseContentType extends ResponseContentType$listCoreV1SecretForAllNamespaces>(params: Params$listCoreV1SecretForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$listCoreV1SecretForAllNamespaces$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/secrets\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** list or watch objects of kind ServiceAccount */
+        listCoreV1ServiceAccountForAllNamespaces: <ResponseContentType extends ResponseContentType$listCoreV1ServiceAccountForAllNamespaces>(params: Params$listCoreV1ServiceAccountForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$listCoreV1ServiceAccountForAllNamespaces$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/serviceaccounts\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** list or watch objects of kind Service */
+        listCoreV1ServiceForAllNamespaces: <ResponseContentType extends ResponseContentType$listCoreV1ServiceForAllNamespaces>(params: Params$listCoreV1ServiceForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$listCoreV1ServiceForAllNamespaces$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/services\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of ConfigMap. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchCoreV1ConfigMapListForAllNamespaces: <ResponseContentType extends ResponseContentType$watchCoreV1ConfigMapListForAllNamespaces>(params: Params$watchCoreV1ConfigMapListForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1ConfigMapListForAllNamespaces$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/watch/configmaps\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of Endpoints. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchCoreV1EndpointsListForAllNamespaces: <ResponseContentType extends ResponseContentType$watchCoreV1EndpointsListForAllNamespaces>(params: Params$watchCoreV1EndpointsListForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1EndpointsListForAllNamespaces$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/watch/endpoints\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of Event. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchCoreV1EventListForAllNamespaces: <ResponseContentType extends ResponseContentType$watchCoreV1EventListForAllNamespaces>(params: Params$watchCoreV1EventListForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1EventListForAllNamespaces$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/watch/events\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of LimitRange. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchCoreV1LimitRangeListForAllNamespaces: <ResponseContentType extends ResponseContentType$watchCoreV1LimitRangeListForAllNamespaces>(params: Params$watchCoreV1LimitRangeListForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1LimitRangeListForAllNamespaces$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/watch/limitranges\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of Namespace. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchCoreV1NamespaceList: <ResponseContentType extends ResponseContentType$watchCoreV1NamespaceList>(params: Params$watchCoreV1NamespaceList<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1NamespaceList$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/watch/namespaces\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of ConfigMap. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchCoreV1NamespacedConfigMapList: <ResponseContentType extends ResponseContentType$watchCoreV1NamespacedConfigMapList>(params: Params$watchCoreV1NamespacedConfigMapList<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1NamespacedConfigMapList$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/watch/namespaces/\${params.parameter.namespace}/configmaps\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** 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. */
+        watchCoreV1NamespacedConfigMap: <ResponseContentType extends ResponseContentType$watchCoreV1NamespacedConfigMap>(params: Params$watchCoreV1NamespacedConfigMap<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1NamespacedConfigMap$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/watch/namespaces/\${params.parameter.namespace}/configmaps/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of Endpoints. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchCoreV1NamespacedEndpointsList: <ResponseContentType extends ResponseContentType$watchCoreV1NamespacedEndpointsList>(params: Params$watchCoreV1NamespacedEndpointsList<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1NamespacedEndpointsList$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/watch/namespaces/\${params.parameter.namespace}/endpoints\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** 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. */
+        watchCoreV1NamespacedEndpoints: <ResponseContentType extends ResponseContentType$watchCoreV1NamespacedEndpoints>(params: Params$watchCoreV1NamespacedEndpoints<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1NamespacedEndpoints$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/watch/namespaces/\${params.parameter.namespace}/endpoints/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of Event. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchCoreV1NamespacedEventList: <ResponseContentType extends ResponseContentType$watchCoreV1NamespacedEventList>(params: Params$watchCoreV1NamespacedEventList<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1NamespacedEventList$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/watch/namespaces/\${params.parameter.namespace}/events\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** 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. */
+        watchCoreV1NamespacedEvent: <ResponseContentType extends ResponseContentType$watchCoreV1NamespacedEvent>(params: Params$watchCoreV1NamespacedEvent<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1NamespacedEvent$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/watch/namespaces/\${params.parameter.namespace}/events/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of LimitRange. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchCoreV1NamespacedLimitRangeList: <ResponseContentType extends ResponseContentType$watchCoreV1NamespacedLimitRangeList>(params: Params$watchCoreV1NamespacedLimitRangeList<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1NamespacedLimitRangeList$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/watch/namespaces/\${params.parameter.namespace}/limitranges\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** 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. */
+        watchCoreV1NamespacedLimitRange: <ResponseContentType extends ResponseContentType$watchCoreV1NamespacedLimitRange>(params: Params$watchCoreV1NamespacedLimitRange<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1NamespacedLimitRange$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/watch/namespaces/\${params.parameter.namespace}/limitranges/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of PersistentVolumeClaim. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchCoreV1NamespacedPersistentVolumeClaimList: <ResponseContentType extends ResponseContentType$watchCoreV1NamespacedPersistentVolumeClaimList>(params: Params$watchCoreV1NamespacedPersistentVolumeClaimList<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1NamespacedPersistentVolumeClaimList$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/watch/namespaces/\${params.parameter.namespace}/persistentvolumeclaims\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** 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. */
+        watchCoreV1NamespacedPersistentVolumeClaim: <ResponseContentType extends ResponseContentType$watchCoreV1NamespacedPersistentVolumeClaim>(params: Params$watchCoreV1NamespacedPersistentVolumeClaim<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1NamespacedPersistentVolumeClaim$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/watch/namespaces/\${params.parameter.namespace}/persistentvolumeclaims/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of Pod. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchCoreV1NamespacedPodList: <ResponseContentType extends ResponseContentType$watchCoreV1NamespacedPodList>(params: Params$watchCoreV1NamespacedPodList<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1NamespacedPodList$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/watch/namespaces/\${params.parameter.namespace}/pods\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** 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. */
+        watchCoreV1NamespacedPod: <ResponseContentType extends ResponseContentType$watchCoreV1NamespacedPod>(params: Params$watchCoreV1NamespacedPod<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1NamespacedPod$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/watch/namespaces/\${params.parameter.namespace}/pods/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of PodTemplate. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchCoreV1NamespacedPodTemplateList: <ResponseContentType extends ResponseContentType$watchCoreV1NamespacedPodTemplateList>(params: Params$watchCoreV1NamespacedPodTemplateList<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1NamespacedPodTemplateList$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/watch/namespaces/\${params.parameter.namespace}/podtemplates\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** 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. */
+        watchCoreV1NamespacedPodTemplate: <ResponseContentType extends ResponseContentType$watchCoreV1NamespacedPodTemplate>(params: Params$watchCoreV1NamespacedPodTemplate<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1NamespacedPodTemplate$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/watch/namespaces/\${params.parameter.namespace}/podtemplates/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of ReplicationController. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchCoreV1NamespacedReplicationControllerList: <ResponseContentType extends ResponseContentType$watchCoreV1NamespacedReplicationControllerList>(params: Params$watchCoreV1NamespacedReplicationControllerList<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1NamespacedReplicationControllerList$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/watch/namespaces/\${params.parameter.namespace}/replicationcontrollers\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** 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. */
+        watchCoreV1NamespacedReplicationController: <ResponseContentType extends ResponseContentType$watchCoreV1NamespacedReplicationController>(params: Params$watchCoreV1NamespacedReplicationController<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1NamespacedReplicationController$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/watch/namespaces/\${params.parameter.namespace}/replicationcontrollers/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of ResourceQuota. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchCoreV1NamespacedResourceQuotaList: <ResponseContentType extends ResponseContentType$watchCoreV1NamespacedResourceQuotaList>(params: Params$watchCoreV1NamespacedResourceQuotaList<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1NamespacedResourceQuotaList$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/watch/namespaces/\${params.parameter.namespace}/resourcequotas\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** 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. */
+        watchCoreV1NamespacedResourceQuota: <ResponseContentType extends ResponseContentType$watchCoreV1NamespacedResourceQuota>(params: Params$watchCoreV1NamespacedResourceQuota<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1NamespacedResourceQuota$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/watch/namespaces/\${params.parameter.namespace}/resourcequotas/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of Secret. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchCoreV1NamespacedSecretList: <ResponseContentType extends ResponseContentType$watchCoreV1NamespacedSecretList>(params: Params$watchCoreV1NamespacedSecretList<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1NamespacedSecretList$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/watch/namespaces/\${params.parameter.namespace}/secrets\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** 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. */
+        watchCoreV1NamespacedSecret: <ResponseContentType extends ResponseContentType$watchCoreV1NamespacedSecret>(params: Params$watchCoreV1NamespacedSecret<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1NamespacedSecret$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/watch/namespaces/\${params.parameter.namespace}/secrets/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of ServiceAccount. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchCoreV1NamespacedServiceAccountList: <ResponseContentType extends ResponseContentType$watchCoreV1NamespacedServiceAccountList>(params: Params$watchCoreV1NamespacedServiceAccountList<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1NamespacedServiceAccountList$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/watch/namespaces/\${params.parameter.namespace}/serviceaccounts\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** 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. */
+        watchCoreV1NamespacedServiceAccount: <ResponseContentType extends ResponseContentType$watchCoreV1NamespacedServiceAccount>(params: Params$watchCoreV1NamespacedServiceAccount<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1NamespacedServiceAccount$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/watch/namespaces/\${params.parameter.namespace}/serviceaccounts/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of Service. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchCoreV1NamespacedServiceList: <ResponseContentType extends ResponseContentType$watchCoreV1NamespacedServiceList>(params: Params$watchCoreV1NamespacedServiceList<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1NamespacedServiceList$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/watch/namespaces/\${params.parameter.namespace}/services\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** 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. */
+        watchCoreV1NamespacedService: <ResponseContentType extends ResponseContentType$watchCoreV1NamespacedService>(params: Params$watchCoreV1NamespacedService<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1NamespacedService$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/watch/namespaces/\${params.parameter.namespace}/services/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** 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. */
+        watchCoreV1Namespace: <ResponseContentType extends ResponseContentType$watchCoreV1Namespace>(params: Params$watchCoreV1Namespace<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1Namespace$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/watch/namespaces/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of Node. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchCoreV1NodeList: <ResponseContentType extends ResponseContentType$watchCoreV1NodeList>(params: Params$watchCoreV1NodeList<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1NodeList$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/watch/nodes\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** 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. */
+        watchCoreV1Node: <ResponseContentType extends ResponseContentType$watchCoreV1Node>(params: Params$watchCoreV1Node<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1Node$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/watch/nodes/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of PersistentVolumeClaim. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchCoreV1PersistentVolumeClaimListForAllNamespaces: <ResponseContentType extends ResponseContentType$watchCoreV1PersistentVolumeClaimListForAllNamespaces>(params: Params$watchCoreV1PersistentVolumeClaimListForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1PersistentVolumeClaimListForAllNamespaces$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/watch/persistentvolumeclaims\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of PersistentVolume. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchCoreV1PersistentVolumeList: <ResponseContentType extends ResponseContentType$watchCoreV1PersistentVolumeList>(params: Params$watchCoreV1PersistentVolumeList<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1PersistentVolumeList$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/watch/persistentvolumes\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** 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. */
+        watchCoreV1PersistentVolume: <ResponseContentType extends ResponseContentType$watchCoreV1PersistentVolume>(params: Params$watchCoreV1PersistentVolume<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1PersistentVolume$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/watch/persistentvolumes/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of Pod. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchCoreV1PodListForAllNamespaces: <ResponseContentType extends ResponseContentType$watchCoreV1PodListForAllNamespaces>(params: Params$watchCoreV1PodListForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1PodListForAllNamespaces$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/watch/pods\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of PodTemplate. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchCoreV1PodTemplateListForAllNamespaces: <ResponseContentType extends ResponseContentType$watchCoreV1PodTemplateListForAllNamespaces>(params: Params$watchCoreV1PodTemplateListForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1PodTemplateListForAllNamespaces$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/watch/podtemplates\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of ReplicationController. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchCoreV1ReplicationControllerListForAllNamespaces: <ResponseContentType extends ResponseContentType$watchCoreV1ReplicationControllerListForAllNamespaces>(params: Params$watchCoreV1ReplicationControllerListForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1ReplicationControllerListForAllNamespaces$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/watch/replicationcontrollers\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of ResourceQuota. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchCoreV1ResourceQuotaListForAllNamespaces: <ResponseContentType extends ResponseContentType$watchCoreV1ResourceQuotaListForAllNamespaces>(params: Params$watchCoreV1ResourceQuotaListForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1ResourceQuotaListForAllNamespaces$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/watch/resourcequotas\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of Secret. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchCoreV1SecretListForAllNamespaces: <ResponseContentType extends ResponseContentType$watchCoreV1SecretListForAllNamespaces>(params: Params$watchCoreV1SecretListForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1SecretListForAllNamespaces$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/watch/secrets\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of ServiceAccount. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchCoreV1ServiceAccountListForAllNamespaces: <ResponseContentType extends ResponseContentType$watchCoreV1ServiceAccountListForAllNamespaces>(params: Params$watchCoreV1ServiceAccountListForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1ServiceAccountListForAllNamespaces$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/watch/serviceaccounts\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of Service. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchCoreV1ServiceListForAllNamespaces: <ResponseContentType extends ResponseContentType$watchCoreV1ServiceListForAllNamespaces>(params: Params$watchCoreV1ServiceListForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoreV1ServiceListForAllNamespaces$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/api/v1/watch/services\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** get available API versions */
+        getAPIVersions: <ResponseContentType extends ResponseContentType$getAPIVersions>(params: Params$getAPIVersions<ResponseContentType>, option?: RequestOption): Promise<Response$getAPIVersions$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        /** get information of a group */
+        getAdmissionregistrationAPIGroup: <ResponseContentType extends ResponseContentType$getAdmissionregistrationAPIGroup>(params: Params$getAdmissionregistrationAPIGroup<ResponseContentType>, option?: RequestOption): Promise<Response$getAdmissionregistrationAPIGroup$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/admissionregistration.k8s.io/\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        /** get available resources */
+        getAdmissionregistrationV1APIResources: <ResponseContentType extends ResponseContentType$getAdmissionregistrationV1APIResources>(params: Params$getAdmissionregistrationV1APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getAdmissionregistrationV1APIResources$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/admissionregistration.k8s.io/v1/\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        /** list or watch objects of kind MutatingWebhookConfiguration */
+        listAdmissionregistrationV1MutatingWebhookConfiguration: <ResponseContentType extends ResponseContentType$listAdmissionregistrationV1MutatingWebhookConfiguration>(params: Params$listAdmissionregistrationV1MutatingWebhookConfiguration<ResponseContentType>, option?: RequestOption): Promise<Response$listAdmissionregistrationV1MutatingWebhookConfiguration$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/admissionregistration.k8s.io/v1/mutatingwebhookconfigurations\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** create a MutatingWebhookConfiguration */
+        createAdmissionregistrationV1MutatingWebhookConfiguration: <ResponseContentType extends ResponseContentType$createAdmissionregistrationV1MutatingWebhookConfiguration>(params: Params$createAdmissionregistrationV1MutatingWebhookConfiguration<ResponseContentType>, option?: RequestOption): Promise<(Response$createAdmissionregistrationV1MutatingWebhookConfiguration$Status$200 | Response$createAdmissionregistrationV1MutatingWebhookConfiguration$Status$201 | Response$createAdmissionregistrationV1MutatingWebhookConfiguration$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/admissionregistration.k8s.io/v1/mutatingwebhookconfigurations\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete collection of MutatingWebhookConfiguration */
+        deleteAdmissionregistrationV1CollectionMutatingWebhookConfiguration: <ResponseContentType extends ResponseContentType$deleteAdmissionregistrationV1CollectionMutatingWebhookConfiguration>(params: Params$deleteAdmissionregistrationV1CollectionMutatingWebhookConfiguration<ResponseContentType>, option?: RequestOption): Promise<Response$deleteAdmissionregistrationV1CollectionMutatingWebhookConfiguration$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/admissionregistration.k8s.io/v1/mutatingwebhookconfigurations\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read the specified MutatingWebhookConfiguration */
+        readAdmissionregistrationV1MutatingWebhookConfiguration: <ResponseContentType extends ResponseContentType$readAdmissionregistrationV1MutatingWebhookConfiguration>(params: Params$readAdmissionregistrationV1MutatingWebhookConfiguration<ResponseContentType>, option?: RequestOption): Promise<Response$readAdmissionregistrationV1MutatingWebhookConfiguration$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/admissionregistration.k8s.io/v1/mutatingwebhookconfigurations/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                exact: { value: params.parameter.exact, explode: false },
+                export: { value: params.parameter.export, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace the specified MutatingWebhookConfiguration */
+        replaceAdmissionregistrationV1MutatingWebhookConfiguration: <ResponseContentType extends ResponseContentType$replaceAdmissionregistrationV1MutatingWebhookConfiguration>(params: Params$replaceAdmissionregistrationV1MutatingWebhookConfiguration<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceAdmissionregistrationV1MutatingWebhookConfiguration$Status$200 | Response$replaceAdmissionregistrationV1MutatingWebhookConfiguration$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/admissionregistration.k8s.io/v1/mutatingwebhookconfigurations/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete a MutatingWebhookConfiguration */
+        deleteAdmissionregistrationV1MutatingWebhookConfiguration: <ResponseContentType extends ResponseContentType$deleteAdmissionregistrationV1MutatingWebhookConfiguration>(params: Params$deleteAdmissionregistrationV1MutatingWebhookConfiguration<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteAdmissionregistrationV1MutatingWebhookConfiguration$Status$200 | Response$deleteAdmissionregistrationV1MutatingWebhookConfiguration$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/admissionregistration.k8s.io/v1/mutatingwebhookconfigurations/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update the specified MutatingWebhookConfiguration */
+        patchAdmissionregistrationV1MutatingWebhookConfiguration: <RequestContentType extends RequestContentType$patchAdmissionregistrationV1MutatingWebhookConfiguration, ResponseContentType extends ResponseContentType$patchAdmissionregistrationV1MutatingWebhookConfiguration>(params: Params$patchAdmissionregistrationV1MutatingWebhookConfiguration<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchAdmissionregistrationV1MutatingWebhookConfiguration$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/admissionregistration.k8s.io/v1/mutatingwebhookconfigurations/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** list or watch objects of kind ValidatingWebhookConfiguration */
+        listAdmissionregistrationV1ValidatingWebhookConfiguration: <ResponseContentType extends ResponseContentType$listAdmissionregistrationV1ValidatingWebhookConfiguration>(params: Params$listAdmissionregistrationV1ValidatingWebhookConfiguration<ResponseContentType>, option?: RequestOption): Promise<Response$listAdmissionregistrationV1ValidatingWebhookConfiguration$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/admissionregistration.k8s.io/v1/validatingwebhookconfigurations\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** create a ValidatingWebhookConfiguration */
+        createAdmissionregistrationV1ValidatingWebhookConfiguration: <ResponseContentType extends ResponseContentType$createAdmissionregistrationV1ValidatingWebhookConfiguration>(params: Params$createAdmissionregistrationV1ValidatingWebhookConfiguration<ResponseContentType>, option?: RequestOption): Promise<(Response$createAdmissionregistrationV1ValidatingWebhookConfiguration$Status$200 | Response$createAdmissionregistrationV1ValidatingWebhookConfiguration$Status$201 | Response$createAdmissionregistrationV1ValidatingWebhookConfiguration$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/admissionregistration.k8s.io/v1/validatingwebhookconfigurations\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete collection of ValidatingWebhookConfiguration */
+        deleteAdmissionregistrationV1CollectionValidatingWebhookConfiguration: <ResponseContentType extends ResponseContentType$deleteAdmissionregistrationV1CollectionValidatingWebhookConfiguration>(params: Params$deleteAdmissionregistrationV1CollectionValidatingWebhookConfiguration<ResponseContentType>, option?: RequestOption): Promise<Response$deleteAdmissionregistrationV1CollectionValidatingWebhookConfiguration$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/admissionregistration.k8s.io/v1/validatingwebhookconfigurations\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read the specified ValidatingWebhookConfiguration */
+        readAdmissionregistrationV1ValidatingWebhookConfiguration: <ResponseContentType extends ResponseContentType$readAdmissionregistrationV1ValidatingWebhookConfiguration>(params: Params$readAdmissionregistrationV1ValidatingWebhookConfiguration<ResponseContentType>, option?: RequestOption): Promise<Response$readAdmissionregistrationV1ValidatingWebhookConfiguration$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/admissionregistration.k8s.io/v1/validatingwebhookconfigurations/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                exact: { value: params.parameter.exact, explode: false },
+                export: { value: params.parameter.export, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace the specified ValidatingWebhookConfiguration */
+        replaceAdmissionregistrationV1ValidatingWebhookConfiguration: <ResponseContentType extends ResponseContentType$replaceAdmissionregistrationV1ValidatingWebhookConfiguration>(params: Params$replaceAdmissionregistrationV1ValidatingWebhookConfiguration<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceAdmissionregistrationV1ValidatingWebhookConfiguration$Status$200 | Response$replaceAdmissionregistrationV1ValidatingWebhookConfiguration$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/admissionregistration.k8s.io/v1/validatingwebhookconfigurations/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete a ValidatingWebhookConfiguration */
+        deleteAdmissionregistrationV1ValidatingWebhookConfiguration: <ResponseContentType extends ResponseContentType$deleteAdmissionregistrationV1ValidatingWebhookConfiguration>(params: Params$deleteAdmissionregistrationV1ValidatingWebhookConfiguration<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteAdmissionregistrationV1ValidatingWebhookConfiguration$Status$200 | Response$deleteAdmissionregistrationV1ValidatingWebhookConfiguration$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/admissionregistration.k8s.io/v1/validatingwebhookconfigurations/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update the specified ValidatingWebhookConfiguration */
+        patchAdmissionregistrationV1ValidatingWebhookConfiguration: <RequestContentType extends RequestContentType$patchAdmissionregistrationV1ValidatingWebhookConfiguration, ResponseContentType extends ResponseContentType$patchAdmissionregistrationV1ValidatingWebhookConfiguration>(params: Params$patchAdmissionregistrationV1ValidatingWebhookConfiguration<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchAdmissionregistrationV1ValidatingWebhookConfiguration$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/admissionregistration.k8s.io/v1/validatingwebhookconfigurations/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** watch individual changes to a list of MutatingWebhookConfiguration. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchAdmissionregistrationV1MutatingWebhookConfigurationList: <ResponseContentType extends ResponseContentType$watchAdmissionregistrationV1MutatingWebhookConfigurationList>(params: Params$watchAdmissionregistrationV1MutatingWebhookConfigurationList<ResponseContentType>, option?: RequestOption): Promise<Response$watchAdmissionregistrationV1MutatingWebhookConfigurationList$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/admissionregistration.k8s.io/v1/watch/mutatingwebhookconfigurations\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch changes to an object of kind MutatingWebhookConfiguration. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. */
+        watchAdmissionregistrationV1MutatingWebhookConfiguration: <ResponseContentType extends ResponseContentType$watchAdmissionregistrationV1MutatingWebhookConfiguration>(params: Params$watchAdmissionregistrationV1MutatingWebhookConfiguration<ResponseContentType>, option?: RequestOption): Promise<Response$watchAdmissionregistrationV1MutatingWebhookConfiguration$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/admissionregistration.k8s.io/v1/watch/mutatingwebhookconfigurations/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of ValidatingWebhookConfiguration. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchAdmissionregistrationV1ValidatingWebhookConfigurationList: <ResponseContentType extends ResponseContentType$watchAdmissionregistrationV1ValidatingWebhookConfigurationList>(params: Params$watchAdmissionregistrationV1ValidatingWebhookConfigurationList<ResponseContentType>, option?: RequestOption): Promise<Response$watchAdmissionregistrationV1ValidatingWebhookConfigurationList$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/admissionregistration.k8s.io/v1/watch/validatingwebhookconfigurations\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch changes to an object of kind ValidatingWebhookConfiguration. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. */
+        watchAdmissionregistrationV1ValidatingWebhookConfiguration: <ResponseContentType extends ResponseContentType$watchAdmissionregistrationV1ValidatingWebhookConfiguration>(params: Params$watchAdmissionregistrationV1ValidatingWebhookConfiguration<ResponseContentType>, option?: RequestOption): Promise<Response$watchAdmissionregistrationV1ValidatingWebhookConfiguration$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/admissionregistration.k8s.io/v1/watch/validatingwebhookconfigurations/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** get available resources */
+        getAdmissionregistrationV1beta1APIResources: <ResponseContentType extends ResponseContentType$getAdmissionregistrationV1beta1APIResources>(params: Params$getAdmissionregistrationV1beta1APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getAdmissionregistrationV1beta1APIResources$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/admissionregistration.k8s.io/v1beta1/\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        /** list or watch objects of kind MutatingWebhookConfiguration */
+        listAdmissionregistrationV1beta1MutatingWebhookConfiguration: <ResponseContentType extends ResponseContentType$listAdmissionregistrationV1beta1MutatingWebhookConfiguration>(params: Params$listAdmissionregistrationV1beta1MutatingWebhookConfiguration<ResponseContentType>, option?: RequestOption): Promise<Response$listAdmissionregistrationV1beta1MutatingWebhookConfiguration$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/admissionregistration.k8s.io/v1beta1/mutatingwebhookconfigurations\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** create a MutatingWebhookConfiguration */
+        createAdmissionregistrationV1beta1MutatingWebhookConfiguration: <ResponseContentType extends ResponseContentType$createAdmissionregistrationV1beta1MutatingWebhookConfiguration>(params: Params$createAdmissionregistrationV1beta1MutatingWebhookConfiguration<ResponseContentType>, option?: RequestOption): Promise<(Response$createAdmissionregistrationV1beta1MutatingWebhookConfiguration$Status$200 | Response$createAdmissionregistrationV1beta1MutatingWebhookConfiguration$Status$201 | Response$createAdmissionregistrationV1beta1MutatingWebhookConfiguration$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/admissionregistration.k8s.io/v1beta1/mutatingwebhookconfigurations\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete collection of MutatingWebhookConfiguration */
+        deleteAdmissionregistrationV1beta1CollectionMutatingWebhookConfiguration: <ResponseContentType extends ResponseContentType$deleteAdmissionregistrationV1beta1CollectionMutatingWebhookConfiguration>(params: Params$deleteAdmissionregistrationV1beta1CollectionMutatingWebhookConfiguration<ResponseContentType>, option?: RequestOption): Promise<Response$deleteAdmissionregistrationV1beta1CollectionMutatingWebhookConfiguration$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/admissionregistration.k8s.io/v1beta1/mutatingwebhookconfigurations\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read the specified MutatingWebhookConfiguration */
+        readAdmissionregistrationV1beta1MutatingWebhookConfiguration: <ResponseContentType extends ResponseContentType$readAdmissionregistrationV1beta1MutatingWebhookConfiguration>(params: Params$readAdmissionregistrationV1beta1MutatingWebhookConfiguration<ResponseContentType>, option?: RequestOption): Promise<Response$readAdmissionregistrationV1beta1MutatingWebhookConfiguration$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/admissionregistration.k8s.io/v1beta1/mutatingwebhookconfigurations/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                exact: { value: params.parameter.exact, explode: false },
+                export: { value: params.parameter.export, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace the specified MutatingWebhookConfiguration */
+        replaceAdmissionregistrationV1beta1MutatingWebhookConfiguration: <ResponseContentType extends ResponseContentType$replaceAdmissionregistrationV1beta1MutatingWebhookConfiguration>(params: Params$replaceAdmissionregistrationV1beta1MutatingWebhookConfiguration<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceAdmissionregistrationV1beta1MutatingWebhookConfiguration$Status$200 | Response$replaceAdmissionregistrationV1beta1MutatingWebhookConfiguration$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/admissionregistration.k8s.io/v1beta1/mutatingwebhookconfigurations/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete a MutatingWebhookConfiguration */
+        deleteAdmissionregistrationV1beta1MutatingWebhookConfiguration: <ResponseContentType extends ResponseContentType$deleteAdmissionregistrationV1beta1MutatingWebhookConfiguration>(params: Params$deleteAdmissionregistrationV1beta1MutatingWebhookConfiguration<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteAdmissionregistrationV1beta1MutatingWebhookConfiguration$Status$200 | Response$deleteAdmissionregistrationV1beta1MutatingWebhookConfiguration$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/admissionregistration.k8s.io/v1beta1/mutatingwebhookconfigurations/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update the specified MutatingWebhookConfiguration */
+        patchAdmissionregistrationV1beta1MutatingWebhookConfiguration: <RequestContentType extends RequestContentType$patchAdmissionregistrationV1beta1MutatingWebhookConfiguration, ResponseContentType extends ResponseContentType$patchAdmissionregistrationV1beta1MutatingWebhookConfiguration>(params: Params$patchAdmissionregistrationV1beta1MutatingWebhookConfiguration<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchAdmissionregistrationV1beta1MutatingWebhookConfiguration$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/admissionregistration.k8s.io/v1beta1/mutatingwebhookconfigurations/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** list or watch objects of kind ValidatingWebhookConfiguration */
+        listAdmissionregistrationV1beta1ValidatingWebhookConfiguration: <ResponseContentType extends ResponseContentType$listAdmissionregistrationV1beta1ValidatingWebhookConfiguration>(params: Params$listAdmissionregistrationV1beta1ValidatingWebhookConfiguration<ResponseContentType>, option?: RequestOption): Promise<Response$listAdmissionregistrationV1beta1ValidatingWebhookConfiguration$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/admissionregistration.k8s.io/v1beta1/validatingwebhookconfigurations\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** create a ValidatingWebhookConfiguration */
+        createAdmissionregistrationV1beta1ValidatingWebhookConfiguration: <ResponseContentType extends ResponseContentType$createAdmissionregistrationV1beta1ValidatingWebhookConfiguration>(params: Params$createAdmissionregistrationV1beta1ValidatingWebhookConfiguration<ResponseContentType>, option?: RequestOption): Promise<(Response$createAdmissionregistrationV1beta1ValidatingWebhookConfiguration$Status$200 | Response$createAdmissionregistrationV1beta1ValidatingWebhookConfiguration$Status$201 | Response$createAdmissionregistrationV1beta1ValidatingWebhookConfiguration$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/admissionregistration.k8s.io/v1beta1/validatingwebhookconfigurations\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete collection of ValidatingWebhookConfiguration */
+        deleteAdmissionregistrationV1beta1CollectionValidatingWebhookConfiguration: <ResponseContentType extends ResponseContentType$deleteAdmissionregistrationV1beta1CollectionValidatingWebhookConfiguration>(params: Params$deleteAdmissionregistrationV1beta1CollectionValidatingWebhookConfiguration<ResponseContentType>, option?: RequestOption): Promise<Response$deleteAdmissionregistrationV1beta1CollectionValidatingWebhookConfiguration$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/admissionregistration.k8s.io/v1beta1/validatingwebhookconfigurations\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read the specified ValidatingWebhookConfiguration */
+        readAdmissionregistrationV1beta1ValidatingWebhookConfiguration: <ResponseContentType extends ResponseContentType$readAdmissionregistrationV1beta1ValidatingWebhookConfiguration>(params: Params$readAdmissionregistrationV1beta1ValidatingWebhookConfiguration<ResponseContentType>, option?: RequestOption): Promise<Response$readAdmissionregistrationV1beta1ValidatingWebhookConfiguration$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/admissionregistration.k8s.io/v1beta1/validatingwebhookconfigurations/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                exact: { value: params.parameter.exact, explode: false },
+                export: { value: params.parameter.export, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace the specified ValidatingWebhookConfiguration */
+        replaceAdmissionregistrationV1beta1ValidatingWebhookConfiguration: <ResponseContentType extends ResponseContentType$replaceAdmissionregistrationV1beta1ValidatingWebhookConfiguration>(params: Params$replaceAdmissionregistrationV1beta1ValidatingWebhookConfiguration<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceAdmissionregistrationV1beta1ValidatingWebhookConfiguration$Status$200 | Response$replaceAdmissionregistrationV1beta1ValidatingWebhookConfiguration$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/admissionregistration.k8s.io/v1beta1/validatingwebhookconfigurations/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete a ValidatingWebhookConfiguration */
+        deleteAdmissionregistrationV1beta1ValidatingWebhookConfiguration: <ResponseContentType extends ResponseContentType$deleteAdmissionregistrationV1beta1ValidatingWebhookConfiguration>(params: Params$deleteAdmissionregistrationV1beta1ValidatingWebhookConfiguration<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteAdmissionregistrationV1beta1ValidatingWebhookConfiguration$Status$200 | Response$deleteAdmissionregistrationV1beta1ValidatingWebhookConfiguration$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/admissionregistration.k8s.io/v1beta1/validatingwebhookconfigurations/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update the specified ValidatingWebhookConfiguration */
+        patchAdmissionregistrationV1beta1ValidatingWebhookConfiguration: <RequestContentType extends RequestContentType$patchAdmissionregistrationV1beta1ValidatingWebhookConfiguration, ResponseContentType extends ResponseContentType$patchAdmissionregistrationV1beta1ValidatingWebhookConfiguration>(params: Params$patchAdmissionregistrationV1beta1ValidatingWebhookConfiguration<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchAdmissionregistrationV1beta1ValidatingWebhookConfiguration$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/admissionregistration.k8s.io/v1beta1/validatingwebhookconfigurations/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** watch individual changes to a list of MutatingWebhookConfiguration. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchAdmissionregistrationV1beta1MutatingWebhookConfigurationList: <ResponseContentType extends ResponseContentType$watchAdmissionregistrationV1beta1MutatingWebhookConfigurationList>(params: Params$watchAdmissionregistrationV1beta1MutatingWebhookConfigurationList<ResponseContentType>, option?: RequestOption): Promise<Response$watchAdmissionregistrationV1beta1MutatingWebhookConfigurationList$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/admissionregistration.k8s.io/v1beta1/watch/mutatingwebhookconfigurations\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch changes to an object of kind MutatingWebhookConfiguration. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. */
+        watchAdmissionregistrationV1beta1MutatingWebhookConfiguration: <ResponseContentType extends ResponseContentType$watchAdmissionregistrationV1beta1MutatingWebhookConfiguration>(params: Params$watchAdmissionregistrationV1beta1MutatingWebhookConfiguration<ResponseContentType>, option?: RequestOption): Promise<Response$watchAdmissionregistrationV1beta1MutatingWebhookConfiguration$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/admissionregistration.k8s.io/v1beta1/watch/mutatingwebhookconfigurations/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of ValidatingWebhookConfiguration. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchAdmissionregistrationV1beta1ValidatingWebhookConfigurationList: <ResponseContentType extends ResponseContentType$watchAdmissionregistrationV1beta1ValidatingWebhookConfigurationList>(params: Params$watchAdmissionregistrationV1beta1ValidatingWebhookConfigurationList<ResponseContentType>, option?: RequestOption): Promise<Response$watchAdmissionregistrationV1beta1ValidatingWebhookConfigurationList$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/admissionregistration.k8s.io/v1beta1/watch/validatingwebhookconfigurations\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch changes to an object of kind ValidatingWebhookConfiguration. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. */
+        watchAdmissionregistrationV1beta1ValidatingWebhookConfiguration: <ResponseContentType extends ResponseContentType$watchAdmissionregistrationV1beta1ValidatingWebhookConfiguration>(params: Params$watchAdmissionregistrationV1beta1ValidatingWebhookConfiguration<ResponseContentType>, option?: RequestOption): Promise<Response$watchAdmissionregistrationV1beta1ValidatingWebhookConfiguration$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/admissionregistration.k8s.io/v1beta1/watch/validatingwebhookconfigurations/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** get information of a group */
+        getApiextensionsAPIGroup: <ResponseContentType extends ResponseContentType$getApiextensionsAPIGroup>(params: Params$getApiextensionsAPIGroup<ResponseContentType>, option?: RequestOption): Promise<Response$getApiextensionsAPIGroup$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apiextensions.k8s.io/\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        /** get available resources */
+        getApiextensionsV1APIResources: <ResponseContentType extends ResponseContentType$getApiextensionsV1APIResources>(params: Params$getApiextensionsV1APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getApiextensionsV1APIResources$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apiextensions.k8s.io/v1/\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        /** list or watch objects of kind CustomResourceDefinition */
+        listApiextensionsV1CustomResourceDefinition: <ResponseContentType extends ResponseContentType$listApiextensionsV1CustomResourceDefinition>(params: Params$listApiextensionsV1CustomResourceDefinition<ResponseContentType>, option?: RequestOption): Promise<Response$listApiextensionsV1CustomResourceDefinition$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apiextensions.k8s.io/v1/customresourcedefinitions\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** create a CustomResourceDefinition */
+        createApiextensionsV1CustomResourceDefinition: <ResponseContentType extends ResponseContentType$createApiextensionsV1CustomResourceDefinition>(params: Params$createApiextensionsV1CustomResourceDefinition<ResponseContentType>, option?: RequestOption): Promise<(Response$createApiextensionsV1CustomResourceDefinition$Status$200 | Response$createApiextensionsV1CustomResourceDefinition$Status$201 | Response$createApiextensionsV1CustomResourceDefinition$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apiextensions.k8s.io/v1/customresourcedefinitions\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete collection of CustomResourceDefinition */
+        deleteApiextensionsV1CollectionCustomResourceDefinition: <ResponseContentType extends ResponseContentType$deleteApiextensionsV1CollectionCustomResourceDefinition>(params: Params$deleteApiextensionsV1CollectionCustomResourceDefinition<ResponseContentType>, option?: RequestOption): Promise<Response$deleteApiextensionsV1CollectionCustomResourceDefinition$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apiextensions.k8s.io/v1/customresourcedefinitions\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read the specified CustomResourceDefinition */
+        readApiextensionsV1CustomResourceDefinition: <ResponseContentType extends ResponseContentType$readApiextensionsV1CustomResourceDefinition>(params: Params$readApiextensionsV1CustomResourceDefinition<ResponseContentType>, option?: RequestOption): Promise<Response$readApiextensionsV1CustomResourceDefinition$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apiextensions.k8s.io/v1/customresourcedefinitions/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                exact: { value: params.parameter.exact, explode: false },
+                export: { value: params.parameter.export, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace the specified CustomResourceDefinition */
+        replaceApiextensionsV1CustomResourceDefinition: <ResponseContentType extends ResponseContentType$replaceApiextensionsV1CustomResourceDefinition>(params: Params$replaceApiextensionsV1CustomResourceDefinition<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceApiextensionsV1CustomResourceDefinition$Status$200 | Response$replaceApiextensionsV1CustomResourceDefinition$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apiextensions.k8s.io/v1/customresourcedefinitions/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete a CustomResourceDefinition */
+        deleteApiextensionsV1CustomResourceDefinition: <ResponseContentType extends ResponseContentType$deleteApiextensionsV1CustomResourceDefinition>(params: Params$deleteApiextensionsV1CustomResourceDefinition<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteApiextensionsV1CustomResourceDefinition$Status$200 | Response$deleteApiextensionsV1CustomResourceDefinition$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apiextensions.k8s.io/v1/customresourcedefinitions/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update the specified CustomResourceDefinition */
+        patchApiextensionsV1CustomResourceDefinition: <RequestContentType extends RequestContentType$patchApiextensionsV1CustomResourceDefinition, ResponseContentType extends ResponseContentType$patchApiextensionsV1CustomResourceDefinition>(params: Params$patchApiextensionsV1CustomResourceDefinition<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchApiextensionsV1CustomResourceDefinition$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apiextensions.k8s.io/v1/customresourcedefinitions/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read status of the specified CustomResourceDefinition */
+        readApiextensionsV1CustomResourceDefinitionStatus: <ResponseContentType extends ResponseContentType$readApiextensionsV1CustomResourceDefinitionStatus>(params: Params$readApiextensionsV1CustomResourceDefinitionStatus<ResponseContentType>, option?: RequestOption): Promise<Response$readApiextensionsV1CustomResourceDefinitionStatus$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apiextensions.k8s.io/v1/customresourcedefinitions/\${params.parameter.name}/status\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace status of the specified CustomResourceDefinition */
+        replaceApiextensionsV1CustomResourceDefinitionStatus: <ResponseContentType extends ResponseContentType$replaceApiextensionsV1CustomResourceDefinitionStatus>(params: Params$replaceApiextensionsV1CustomResourceDefinitionStatus<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceApiextensionsV1CustomResourceDefinitionStatus$Status$200 | Response$replaceApiextensionsV1CustomResourceDefinitionStatus$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apiextensions.k8s.io/v1/customresourcedefinitions/\${params.parameter.name}/status\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update status of the specified CustomResourceDefinition */
+        patchApiextensionsV1CustomResourceDefinitionStatus: <RequestContentType extends RequestContentType$patchApiextensionsV1CustomResourceDefinitionStatus, ResponseContentType extends ResponseContentType$patchApiextensionsV1CustomResourceDefinitionStatus>(params: Params$patchApiextensionsV1CustomResourceDefinitionStatus<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchApiextensionsV1CustomResourceDefinitionStatus$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apiextensions.k8s.io/v1/customresourcedefinitions/\${params.parameter.name}/status\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** watch individual changes to a list of CustomResourceDefinition. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchApiextensionsV1CustomResourceDefinitionList: <ResponseContentType extends ResponseContentType$watchApiextensionsV1CustomResourceDefinitionList>(params: Params$watchApiextensionsV1CustomResourceDefinitionList<ResponseContentType>, option?: RequestOption): Promise<Response$watchApiextensionsV1CustomResourceDefinitionList$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apiextensions.k8s.io/v1/watch/customresourcedefinitions\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch changes to an object of kind CustomResourceDefinition. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. */
+        watchApiextensionsV1CustomResourceDefinition: <ResponseContentType extends ResponseContentType$watchApiextensionsV1CustomResourceDefinition>(params: Params$watchApiextensionsV1CustomResourceDefinition<ResponseContentType>, option?: RequestOption): Promise<Response$watchApiextensionsV1CustomResourceDefinition$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apiextensions.k8s.io/v1/watch/customresourcedefinitions/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** get available resources */
+        getApiextensionsV1beta1APIResources: <ResponseContentType extends ResponseContentType$getApiextensionsV1beta1APIResources>(params: Params$getApiextensionsV1beta1APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getApiextensionsV1beta1APIResources$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apiextensions.k8s.io/v1beta1/\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        /** list or watch objects of kind CustomResourceDefinition */
+        listApiextensionsV1beta1CustomResourceDefinition: <ResponseContentType extends ResponseContentType$listApiextensionsV1beta1CustomResourceDefinition>(params: Params$listApiextensionsV1beta1CustomResourceDefinition<ResponseContentType>, option?: RequestOption): Promise<Response$listApiextensionsV1beta1CustomResourceDefinition$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apiextensions.k8s.io/v1beta1/customresourcedefinitions\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** create a CustomResourceDefinition */
+        createApiextensionsV1beta1CustomResourceDefinition: <ResponseContentType extends ResponseContentType$createApiextensionsV1beta1CustomResourceDefinition>(params: Params$createApiextensionsV1beta1CustomResourceDefinition<ResponseContentType>, option?: RequestOption): Promise<(Response$createApiextensionsV1beta1CustomResourceDefinition$Status$200 | Response$createApiextensionsV1beta1CustomResourceDefinition$Status$201 | Response$createApiextensionsV1beta1CustomResourceDefinition$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apiextensions.k8s.io/v1beta1/customresourcedefinitions\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete collection of CustomResourceDefinition */
+        deleteApiextensionsV1beta1CollectionCustomResourceDefinition: <ResponseContentType extends ResponseContentType$deleteApiextensionsV1beta1CollectionCustomResourceDefinition>(params: Params$deleteApiextensionsV1beta1CollectionCustomResourceDefinition<ResponseContentType>, option?: RequestOption): Promise<Response$deleteApiextensionsV1beta1CollectionCustomResourceDefinition$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apiextensions.k8s.io/v1beta1/customresourcedefinitions\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read the specified CustomResourceDefinition */
+        readApiextensionsV1beta1CustomResourceDefinition: <ResponseContentType extends ResponseContentType$readApiextensionsV1beta1CustomResourceDefinition>(params: Params$readApiextensionsV1beta1CustomResourceDefinition<ResponseContentType>, option?: RequestOption): Promise<Response$readApiextensionsV1beta1CustomResourceDefinition$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apiextensions.k8s.io/v1beta1/customresourcedefinitions/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                exact: { value: params.parameter.exact, explode: false },
+                export: { value: params.parameter.export, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace the specified CustomResourceDefinition */
+        replaceApiextensionsV1beta1CustomResourceDefinition: <ResponseContentType extends ResponseContentType$replaceApiextensionsV1beta1CustomResourceDefinition>(params: Params$replaceApiextensionsV1beta1CustomResourceDefinition<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceApiextensionsV1beta1CustomResourceDefinition$Status$200 | Response$replaceApiextensionsV1beta1CustomResourceDefinition$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apiextensions.k8s.io/v1beta1/customresourcedefinitions/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete a CustomResourceDefinition */
+        deleteApiextensionsV1beta1CustomResourceDefinition: <ResponseContentType extends ResponseContentType$deleteApiextensionsV1beta1CustomResourceDefinition>(params: Params$deleteApiextensionsV1beta1CustomResourceDefinition<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteApiextensionsV1beta1CustomResourceDefinition$Status$200 | Response$deleteApiextensionsV1beta1CustomResourceDefinition$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apiextensions.k8s.io/v1beta1/customresourcedefinitions/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update the specified CustomResourceDefinition */
+        patchApiextensionsV1beta1CustomResourceDefinition: <RequestContentType extends RequestContentType$patchApiextensionsV1beta1CustomResourceDefinition, ResponseContentType extends ResponseContentType$patchApiextensionsV1beta1CustomResourceDefinition>(params: Params$patchApiextensionsV1beta1CustomResourceDefinition<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchApiextensionsV1beta1CustomResourceDefinition$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apiextensions.k8s.io/v1beta1/customresourcedefinitions/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read status of the specified CustomResourceDefinition */
+        readApiextensionsV1beta1CustomResourceDefinitionStatus: <ResponseContentType extends ResponseContentType$readApiextensionsV1beta1CustomResourceDefinitionStatus>(params: Params$readApiextensionsV1beta1CustomResourceDefinitionStatus<ResponseContentType>, option?: RequestOption): Promise<Response$readApiextensionsV1beta1CustomResourceDefinitionStatus$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apiextensions.k8s.io/v1beta1/customresourcedefinitions/\${params.parameter.name}/status\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace status of the specified CustomResourceDefinition */
+        replaceApiextensionsV1beta1CustomResourceDefinitionStatus: <ResponseContentType extends ResponseContentType$replaceApiextensionsV1beta1CustomResourceDefinitionStatus>(params: Params$replaceApiextensionsV1beta1CustomResourceDefinitionStatus<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceApiextensionsV1beta1CustomResourceDefinitionStatus$Status$200 | Response$replaceApiextensionsV1beta1CustomResourceDefinitionStatus$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apiextensions.k8s.io/v1beta1/customresourcedefinitions/\${params.parameter.name}/status\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update status of the specified CustomResourceDefinition */
+        patchApiextensionsV1beta1CustomResourceDefinitionStatus: <RequestContentType extends RequestContentType$patchApiextensionsV1beta1CustomResourceDefinitionStatus, ResponseContentType extends ResponseContentType$patchApiextensionsV1beta1CustomResourceDefinitionStatus>(params: Params$patchApiextensionsV1beta1CustomResourceDefinitionStatus<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchApiextensionsV1beta1CustomResourceDefinitionStatus$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apiextensions.k8s.io/v1beta1/customresourcedefinitions/\${params.parameter.name}/status\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** watch individual changes to a list of CustomResourceDefinition. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchApiextensionsV1beta1CustomResourceDefinitionList: <ResponseContentType extends ResponseContentType$watchApiextensionsV1beta1CustomResourceDefinitionList>(params: Params$watchApiextensionsV1beta1CustomResourceDefinitionList<ResponseContentType>, option?: RequestOption): Promise<Response$watchApiextensionsV1beta1CustomResourceDefinitionList$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apiextensions.k8s.io/v1beta1/watch/customresourcedefinitions\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch changes to an object of kind CustomResourceDefinition. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. */
+        watchApiextensionsV1beta1CustomResourceDefinition: <ResponseContentType extends ResponseContentType$watchApiextensionsV1beta1CustomResourceDefinition>(params: Params$watchApiextensionsV1beta1CustomResourceDefinition<ResponseContentType>, option?: RequestOption): Promise<Response$watchApiextensionsV1beta1CustomResourceDefinition$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apiextensions.k8s.io/v1beta1/watch/customresourcedefinitions/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** get information of a group */
+        getApiregistrationAPIGroup: <ResponseContentType extends ResponseContentType$getApiregistrationAPIGroup>(params: Params$getApiregistrationAPIGroup<ResponseContentType>, option?: RequestOption): Promise<Response$getApiregistrationAPIGroup$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apiregistration.k8s.io/\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        /** get available resources */
+        getApiregistrationV1APIResources: <ResponseContentType extends ResponseContentType$getApiregistrationV1APIResources>(params: Params$getApiregistrationV1APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getApiregistrationV1APIResources$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apiregistration.k8s.io/v1/\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        /** list or watch objects of kind APIService */
+        listApiregistrationV1APIService: <ResponseContentType extends ResponseContentType$listApiregistrationV1APIService>(params: Params$listApiregistrationV1APIService<ResponseContentType>, option?: RequestOption): Promise<Response$listApiregistrationV1APIService$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apiregistration.k8s.io/v1/apiservices\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** create an APIService */
+        createApiregistrationV1APIService: <ResponseContentType extends ResponseContentType$createApiregistrationV1APIService>(params: Params$createApiregistrationV1APIService<ResponseContentType>, option?: RequestOption): Promise<(Response$createApiregistrationV1APIService$Status$200 | Response$createApiregistrationV1APIService$Status$201 | Response$createApiregistrationV1APIService$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apiregistration.k8s.io/v1/apiservices\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete collection of APIService */
+        deleteApiregistrationV1CollectionAPIService: <ResponseContentType extends ResponseContentType$deleteApiregistrationV1CollectionAPIService>(params: Params$deleteApiregistrationV1CollectionAPIService<ResponseContentType>, option?: RequestOption): Promise<Response$deleteApiregistrationV1CollectionAPIService$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apiregistration.k8s.io/v1/apiservices\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read the specified APIService */
+        readApiregistrationV1APIService: <ResponseContentType extends ResponseContentType$readApiregistrationV1APIService>(params: Params$readApiregistrationV1APIService<ResponseContentType>, option?: RequestOption): Promise<Response$readApiregistrationV1APIService$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apiregistration.k8s.io/v1/apiservices/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                exact: { value: params.parameter.exact, explode: false },
+                export: { value: params.parameter.export, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace the specified APIService */
+        replaceApiregistrationV1APIService: <ResponseContentType extends ResponseContentType$replaceApiregistrationV1APIService>(params: Params$replaceApiregistrationV1APIService<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceApiregistrationV1APIService$Status$200 | Response$replaceApiregistrationV1APIService$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apiregistration.k8s.io/v1/apiservices/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete an APIService */
+        deleteApiregistrationV1APIService: <ResponseContentType extends ResponseContentType$deleteApiregistrationV1APIService>(params: Params$deleteApiregistrationV1APIService<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteApiregistrationV1APIService$Status$200 | Response$deleteApiregistrationV1APIService$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apiregistration.k8s.io/v1/apiservices/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update the specified APIService */
+        patchApiregistrationV1APIService: <RequestContentType extends RequestContentType$patchApiregistrationV1APIService, ResponseContentType extends ResponseContentType$patchApiregistrationV1APIService>(params: Params$patchApiregistrationV1APIService<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchApiregistrationV1APIService$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apiregistration.k8s.io/v1/apiservices/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read status of the specified APIService */
+        readApiregistrationV1APIServiceStatus: <ResponseContentType extends ResponseContentType$readApiregistrationV1APIServiceStatus>(params: Params$readApiregistrationV1APIServiceStatus<ResponseContentType>, option?: RequestOption): Promise<Response$readApiregistrationV1APIServiceStatus$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apiregistration.k8s.io/v1/apiservices/\${params.parameter.name}/status\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace status of the specified APIService */
+        replaceApiregistrationV1APIServiceStatus: <ResponseContentType extends ResponseContentType$replaceApiregistrationV1APIServiceStatus>(params: Params$replaceApiregistrationV1APIServiceStatus<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceApiregistrationV1APIServiceStatus$Status$200 | Response$replaceApiregistrationV1APIServiceStatus$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apiregistration.k8s.io/v1/apiservices/\${params.parameter.name}/status\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update status of the specified APIService */
+        patchApiregistrationV1APIServiceStatus: <RequestContentType extends RequestContentType$patchApiregistrationV1APIServiceStatus, ResponseContentType extends ResponseContentType$patchApiregistrationV1APIServiceStatus>(params: Params$patchApiregistrationV1APIServiceStatus<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchApiregistrationV1APIServiceStatus$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apiregistration.k8s.io/v1/apiservices/\${params.parameter.name}/status\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** watch individual changes to a list of APIService. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchApiregistrationV1APIServiceList: <ResponseContentType extends ResponseContentType$watchApiregistrationV1APIServiceList>(params: Params$watchApiregistrationV1APIServiceList<ResponseContentType>, option?: RequestOption): Promise<Response$watchApiregistrationV1APIServiceList$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apiregistration.k8s.io/v1/watch/apiservices\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch changes to an object of kind APIService. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. */
+        watchApiregistrationV1APIService: <ResponseContentType extends ResponseContentType$watchApiregistrationV1APIService>(params: Params$watchApiregistrationV1APIService<ResponseContentType>, option?: RequestOption): Promise<Response$watchApiregistrationV1APIService$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apiregistration.k8s.io/v1/watch/apiservices/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** get available resources */
+        getApiregistrationV1beta1APIResources: <ResponseContentType extends ResponseContentType$getApiregistrationV1beta1APIResources>(params: Params$getApiregistrationV1beta1APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getApiregistrationV1beta1APIResources$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apiregistration.k8s.io/v1beta1/\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        /** list or watch objects of kind APIService */
+        listApiregistrationV1beta1APIService: <ResponseContentType extends ResponseContentType$listApiregistrationV1beta1APIService>(params: Params$listApiregistrationV1beta1APIService<ResponseContentType>, option?: RequestOption): Promise<Response$listApiregistrationV1beta1APIService$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apiregistration.k8s.io/v1beta1/apiservices\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** create an APIService */
+        createApiregistrationV1beta1APIService: <ResponseContentType extends ResponseContentType$createApiregistrationV1beta1APIService>(params: Params$createApiregistrationV1beta1APIService<ResponseContentType>, option?: RequestOption): Promise<(Response$createApiregistrationV1beta1APIService$Status$200 | Response$createApiregistrationV1beta1APIService$Status$201 | Response$createApiregistrationV1beta1APIService$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apiregistration.k8s.io/v1beta1/apiservices\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete collection of APIService */
+        deleteApiregistrationV1beta1CollectionAPIService: <ResponseContentType extends ResponseContentType$deleteApiregistrationV1beta1CollectionAPIService>(params: Params$deleteApiregistrationV1beta1CollectionAPIService<ResponseContentType>, option?: RequestOption): Promise<Response$deleteApiregistrationV1beta1CollectionAPIService$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apiregistration.k8s.io/v1beta1/apiservices\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read the specified APIService */
+        readApiregistrationV1beta1APIService: <ResponseContentType extends ResponseContentType$readApiregistrationV1beta1APIService>(params: Params$readApiregistrationV1beta1APIService<ResponseContentType>, option?: RequestOption): Promise<Response$readApiregistrationV1beta1APIService$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apiregistration.k8s.io/v1beta1/apiservices/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                exact: { value: params.parameter.exact, explode: false },
+                export: { value: params.parameter.export, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace the specified APIService */
+        replaceApiregistrationV1beta1APIService: <ResponseContentType extends ResponseContentType$replaceApiregistrationV1beta1APIService>(params: Params$replaceApiregistrationV1beta1APIService<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceApiregistrationV1beta1APIService$Status$200 | Response$replaceApiregistrationV1beta1APIService$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apiregistration.k8s.io/v1beta1/apiservices/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete an APIService */
+        deleteApiregistrationV1beta1APIService: <ResponseContentType extends ResponseContentType$deleteApiregistrationV1beta1APIService>(params: Params$deleteApiregistrationV1beta1APIService<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteApiregistrationV1beta1APIService$Status$200 | Response$deleteApiregistrationV1beta1APIService$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apiregistration.k8s.io/v1beta1/apiservices/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update the specified APIService */
+        patchApiregistrationV1beta1APIService: <RequestContentType extends RequestContentType$patchApiregistrationV1beta1APIService, ResponseContentType extends ResponseContentType$patchApiregistrationV1beta1APIService>(params: Params$patchApiregistrationV1beta1APIService<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchApiregistrationV1beta1APIService$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apiregistration.k8s.io/v1beta1/apiservices/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read status of the specified APIService */
+        readApiregistrationV1beta1APIServiceStatus: <ResponseContentType extends ResponseContentType$readApiregistrationV1beta1APIServiceStatus>(params: Params$readApiregistrationV1beta1APIServiceStatus<ResponseContentType>, option?: RequestOption): Promise<Response$readApiregistrationV1beta1APIServiceStatus$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apiregistration.k8s.io/v1beta1/apiservices/\${params.parameter.name}/status\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace status of the specified APIService */
+        replaceApiregistrationV1beta1APIServiceStatus: <ResponseContentType extends ResponseContentType$replaceApiregistrationV1beta1APIServiceStatus>(params: Params$replaceApiregistrationV1beta1APIServiceStatus<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceApiregistrationV1beta1APIServiceStatus$Status$200 | Response$replaceApiregistrationV1beta1APIServiceStatus$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apiregistration.k8s.io/v1beta1/apiservices/\${params.parameter.name}/status\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update status of the specified APIService */
+        patchApiregistrationV1beta1APIServiceStatus: <RequestContentType extends RequestContentType$patchApiregistrationV1beta1APIServiceStatus, ResponseContentType extends ResponseContentType$patchApiregistrationV1beta1APIServiceStatus>(params: Params$patchApiregistrationV1beta1APIServiceStatus<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchApiregistrationV1beta1APIServiceStatus$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apiregistration.k8s.io/v1beta1/apiservices/\${params.parameter.name}/status\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** watch individual changes to a list of APIService. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchApiregistrationV1beta1APIServiceList: <ResponseContentType extends ResponseContentType$watchApiregistrationV1beta1APIServiceList>(params: Params$watchApiregistrationV1beta1APIServiceList<ResponseContentType>, option?: RequestOption): Promise<Response$watchApiregistrationV1beta1APIServiceList$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apiregistration.k8s.io/v1beta1/watch/apiservices\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch changes to an object of kind APIService. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. */
+        watchApiregistrationV1beta1APIService: <ResponseContentType extends ResponseContentType$watchApiregistrationV1beta1APIService>(params: Params$watchApiregistrationV1beta1APIService<ResponseContentType>, option?: RequestOption): Promise<Response$watchApiregistrationV1beta1APIService$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apiregistration.k8s.io/v1beta1/watch/apiservices/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** get information of a group */
+        getAppsAPIGroup: <ResponseContentType extends ResponseContentType$getAppsAPIGroup>(params: Params$getAppsAPIGroup<ResponseContentType>, option?: RequestOption): Promise<Response$getAppsAPIGroup$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apps/\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        /** get available resources */
+        getAppsV1APIResources: <ResponseContentType extends ResponseContentType$getAppsV1APIResources>(params: Params$getAppsV1APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getAppsV1APIResources$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apps/v1/\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        /** list or watch objects of kind ControllerRevision */
+        listAppsV1ControllerRevisionForAllNamespaces: <ResponseContentType extends ResponseContentType$listAppsV1ControllerRevisionForAllNamespaces>(params: Params$listAppsV1ControllerRevisionForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$listAppsV1ControllerRevisionForAllNamespaces$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apps/v1/controllerrevisions\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** list or watch objects of kind DaemonSet */
+        listAppsV1DaemonSetForAllNamespaces: <ResponseContentType extends ResponseContentType$listAppsV1DaemonSetForAllNamespaces>(params: Params$listAppsV1DaemonSetForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$listAppsV1DaemonSetForAllNamespaces$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apps/v1/daemonsets\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** list or watch objects of kind Deployment */
+        listAppsV1DeploymentForAllNamespaces: <ResponseContentType extends ResponseContentType$listAppsV1DeploymentForAllNamespaces>(params: Params$listAppsV1DeploymentForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$listAppsV1DeploymentForAllNamespaces$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apps/v1/deployments\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** list or watch objects of kind ControllerRevision */
+        listAppsV1NamespacedControllerRevision: <ResponseContentType extends ResponseContentType$listAppsV1NamespacedControllerRevision>(params: Params$listAppsV1NamespacedControllerRevision<ResponseContentType>, option?: RequestOption): Promise<Response$listAppsV1NamespacedControllerRevision$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/controllerrevisions\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** create a ControllerRevision */
+        createAppsV1NamespacedControllerRevision: <ResponseContentType extends ResponseContentType$createAppsV1NamespacedControllerRevision>(params: Params$createAppsV1NamespacedControllerRevision<ResponseContentType>, option?: RequestOption): Promise<(Response$createAppsV1NamespacedControllerRevision$Status$200 | Response$createAppsV1NamespacedControllerRevision$Status$201 | Response$createAppsV1NamespacedControllerRevision$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/controllerrevisions\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete collection of ControllerRevision */
+        deleteAppsV1CollectionNamespacedControllerRevision: <ResponseContentType extends ResponseContentType$deleteAppsV1CollectionNamespacedControllerRevision>(params: Params$deleteAppsV1CollectionNamespacedControllerRevision<ResponseContentType>, option?: RequestOption): Promise<Response$deleteAppsV1CollectionNamespacedControllerRevision$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/controllerrevisions\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read the specified ControllerRevision */
+        readAppsV1NamespacedControllerRevision: <ResponseContentType extends ResponseContentType$readAppsV1NamespacedControllerRevision>(params: Params$readAppsV1NamespacedControllerRevision<ResponseContentType>, option?: RequestOption): Promise<Response$readAppsV1NamespacedControllerRevision$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/controllerrevisions/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                exact: { value: params.parameter.exact, explode: false },
+                export: { value: params.parameter.export, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace the specified ControllerRevision */
+        replaceAppsV1NamespacedControllerRevision: <ResponseContentType extends ResponseContentType$replaceAppsV1NamespacedControllerRevision>(params: Params$replaceAppsV1NamespacedControllerRevision<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceAppsV1NamespacedControllerRevision$Status$200 | Response$replaceAppsV1NamespacedControllerRevision$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/controllerrevisions/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete a ControllerRevision */
+        deleteAppsV1NamespacedControllerRevision: <ResponseContentType extends ResponseContentType$deleteAppsV1NamespacedControllerRevision>(params: Params$deleteAppsV1NamespacedControllerRevision<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteAppsV1NamespacedControllerRevision$Status$200 | Response$deleteAppsV1NamespacedControllerRevision$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/controllerrevisions/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update the specified ControllerRevision */
+        patchAppsV1NamespacedControllerRevision: <RequestContentType extends RequestContentType$patchAppsV1NamespacedControllerRevision, ResponseContentType extends ResponseContentType$patchAppsV1NamespacedControllerRevision>(params: Params$patchAppsV1NamespacedControllerRevision<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchAppsV1NamespacedControllerRevision$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/controllerrevisions/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** list or watch objects of kind DaemonSet */
+        listAppsV1NamespacedDaemonSet: <ResponseContentType extends ResponseContentType$listAppsV1NamespacedDaemonSet>(params: Params$listAppsV1NamespacedDaemonSet<ResponseContentType>, option?: RequestOption): Promise<Response$listAppsV1NamespacedDaemonSet$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/daemonsets\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** create a DaemonSet */
+        createAppsV1NamespacedDaemonSet: <ResponseContentType extends ResponseContentType$createAppsV1NamespacedDaemonSet>(params: Params$createAppsV1NamespacedDaemonSet<ResponseContentType>, option?: RequestOption): Promise<(Response$createAppsV1NamespacedDaemonSet$Status$200 | Response$createAppsV1NamespacedDaemonSet$Status$201 | Response$createAppsV1NamespacedDaemonSet$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/daemonsets\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete collection of DaemonSet */
+        deleteAppsV1CollectionNamespacedDaemonSet: <ResponseContentType extends ResponseContentType$deleteAppsV1CollectionNamespacedDaemonSet>(params: Params$deleteAppsV1CollectionNamespacedDaemonSet<ResponseContentType>, option?: RequestOption): Promise<Response$deleteAppsV1CollectionNamespacedDaemonSet$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/daemonsets\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read the specified DaemonSet */
+        readAppsV1NamespacedDaemonSet: <ResponseContentType extends ResponseContentType$readAppsV1NamespacedDaemonSet>(params: Params$readAppsV1NamespacedDaemonSet<ResponseContentType>, option?: RequestOption): Promise<Response$readAppsV1NamespacedDaemonSet$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/daemonsets/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                exact: { value: params.parameter.exact, explode: false },
+                export: { value: params.parameter.export, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace the specified DaemonSet */
+        replaceAppsV1NamespacedDaemonSet: <ResponseContentType extends ResponseContentType$replaceAppsV1NamespacedDaemonSet>(params: Params$replaceAppsV1NamespacedDaemonSet<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceAppsV1NamespacedDaemonSet$Status$200 | Response$replaceAppsV1NamespacedDaemonSet$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/daemonsets/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete a DaemonSet */
+        deleteAppsV1NamespacedDaemonSet: <ResponseContentType extends ResponseContentType$deleteAppsV1NamespacedDaemonSet>(params: Params$deleteAppsV1NamespacedDaemonSet<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteAppsV1NamespacedDaemonSet$Status$200 | Response$deleteAppsV1NamespacedDaemonSet$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/daemonsets/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update the specified DaemonSet */
+        patchAppsV1NamespacedDaemonSet: <RequestContentType extends RequestContentType$patchAppsV1NamespacedDaemonSet, ResponseContentType extends ResponseContentType$patchAppsV1NamespacedDaemonSet>(params: Params$patchAppsV1NamespacedDaemonSet<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchAppsV1NamespacedDaemonSet$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/daemonsets/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read status of the specified DaemonSet */
+        readAppsV1NamespacedDaemonSetStatus: <ResponseContentType extends ResponseContentType$readAppsV1NamespacedDaemonSetStatus>(params: Params$readAppsV1NamespacedDaemonSetStatus<ResponseContentType>, option?: RequestOption): Promise<Response$readAppsV1NamespacedDaemonSetStatus$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/daemonsets/\${params.parameter.name}/status\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace status of the specified DaemonSet */
+        replaceAppsV1NamespacedDaemonSetStatus: <ResponseContentType extends ResponseContentType$replaceAppsV1NamespacedDaemonSetStatus>(params: Params$replaceAppsV1NamespacedDaemonSetStatus<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceAppsV1NamespacedDaemonSetStatus$Status$200 | Response$replaceAppsV1NamespacedDaemonSetStatus$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/daemonsets/\${params.parameter.name}/status\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update status of the specified DaemonSet */
+        patchAppsV1NamespacedDaemonSetStatus: <RequestContentType extends RequestContentType$patchAppsV1NamespacedDaemonSetStatus, ResponseContentType extends ResponseContentType$patchAppsV1NamespacedDaemonSetStatus>(params: Params$patchAppsV1NamespacedDaemonSetStatus<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchAppsV1NamespacedDaemonSetStatus$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/daemonsets/\${params.parameter.name}/status\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** list or watch objects of kind Deployment */
+        listAppsV1NamespacedDeployment: <ResponseContentType extends ResponseContentType$listAppsV1NamespacedDeployment>(params: Params$listAppsV1NamespacedDeployment<ResponseContentType>, option?: RequestOption): Promise<Response$listAppsV1NamespacedDeployment$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/deployments\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** create a Deployment */
+        createAppsV1NamespacedDeployment: <ResponseContentType extends ResponseContentType$createAppsV1NamespacedDeployment>(params: Params$createAppsV1NamespacedDeployment<ResponseContentType>, option?: RequestOption): Promise<(Response$createAppsV1NamespacedDeployment$Status$200 | Response$createAppsV1NamespacedDeployment$Status$201 | Response$createAppsV1NamespacedDeployment$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/deployments\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete collection of Deployment */
+        deleteAppsV1CollectionNamespacedDeployment: <ResponseContentType extends ResponseContentType$deleteAppsV1CollectionNamespacedDeployment>(params: Params$deleteAppsV1CollectionNamespacedDeployment<ResponseContentType>, option?: RequestOption): Promise<Response$deleteAppsV1CollectionNamespacedDeployment$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/deployments\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read the specified Deployment */
+        readAppsV1NamespacedDeployment: <ResponseContentType extends ResponseContentType$readAppsV1NamespacedDeployment>(params: Params$readAppsV1NamespacedDeployment<ResponseContentType>, option?: RequestOption): Promise<Response$readAppsV1NamespacedDeployment$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/deployments/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                exact: { value: params.parameter.exact, explode: false },
+                export: { value: params.parameter.export, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace the specified Deployment */
+        replaceAppsV1NamespacedDeployment: <ResponseContentType extends ResponseContentType$replaceAppsV1NamespacedDeployment>(params: Params$replaceAppsV1NamespacedDeployment<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceAppsV1NamespacedDeployment$Status$200 | Response$replaceAppsV1NamespacedDeployment$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/deployments/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete a Deployment */
+        deleteAppsV1NamespacedDeployment: <ResponseContentType extends ResponseContentType$deleteAppsV1NamespacedDeployment>(params: Params$deleteAppsV1NamespacedDeployment<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteAppsV1NamespacedDeployment$Status$200 | Response$deleteAppsV1NamespacedDeployment$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/deployments/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update the specified Deployment */
+        patchAppsV1NamespacedDeployment: <RequestContentType extends RequestContentType$patchAppsV1NamespacedDeployment, ResponseContentType extends ResponseContentType$patchAppsV1NamespacedDeployment>(params: Params$patchAppsV1NamespacedDeployment<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchAppsV1NamespacedDeployment$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/deployments/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read scale of the specified Deployment */
+        readAppsV1NamespacedDeploymentScale: <ResponseContentType extends ResponseContentType$readAppsV1NamespacedDeploymentScale>(params: Params$readAppsV1NamespacedDeploymentScale<ResponseContentType>, option?: RequestOption): Promise<Response$readAppsV1NamespacedDeploymentScale$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/deployments/\${params.parameter.name}/scale\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace scale of the specified Deployment */
+        replaceAppsV1NamespacedDeploymentScale: <ResponseContentType extends ResponseContentType$replaceAppsV1NamespacedDeploymentScale>(params: Params$replaceAppsV1NamespacedDeploymentScale<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceAppsV1NamespacedDeploymentScale$Status$200 | Response$replaceAppsV1NamespacedDeploymentScale$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/deployments/\${params.parameter.name}/scale\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update scale of the specified Deployment */
+        patchAppsV1NamespacedDeploymentScale: <RequestContentType extends RequestContentType$patchAppsV1NamespacedDeploymentScale, ResponseContentType extends ResponseContentType$patchAppsV1NamespacedDeploymentScale>(params: Params$patchAppsV1NamespacedDeploymentScale<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchAppsV1NamespacedDeploymentScale$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/deployments/\${params.parameter.name}/scale\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read status of the specified Deployment */
+        readAppsV1NamespacedDeploymentStatus: <ResponseContentType extends ResponseContentType$readAppsV1NamespacedDeploymentStatus>(params: Params$readAppsV1NamespacedDeploymentStatus<ResponseContentType>, option?: RequestOption): Promise<Response$readAppsV1NamespacedDeploymentStatus$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/deployments/\${params.parameter.name}/status\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace status of the specified Deployment */
+        replaceAppsV1NamespacedDeploymentStatus: <ResponseContentType extends ResponseContentType$replaceAppsV1NamespacedDeploymentStatus>(params: Params$replaceAppsV1NamespacedDeploymentStatus<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceAppsV1NamespacedDeploymentStatus$Status$200 | Response$replaceAppsV1NamespacedDeploymentStatus$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/deployments/\${params.parameter.name}/status\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update status of the specified Deployment */
+        patchAppsV1NamespacedDeploymentStatus: <RequestContentType extends RequestContentType$patchAppsV1NamespacedDeploymentStatus, ResponseContentType extends ResponseContentType$patchAppsV1NamespacedDeploymentStatus>(params: Params$patchAppsV1NamespacedDeploymentStatus<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchAppsV1NamespacedDeploymentStatus$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/deployments/\${params.parameter.name}/status\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** list or watch objects of kind ReplicaSet */
+        listAppsV1NamespacedReplicaSet: <ResponseContentType extends ResponseContentType$listAppsV1NamespacedReplicaSet>(params: Params$listAppsV1NamespacedReplicaSet<ResponseContentType>, option?: RequestOption): Promise<Response$listAppsV1NamespacedReplicaSet$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/replicasets\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** create a ReplicaSet */
+        createAppsV1NamespacedReplicaSet: <ResponseContentType extends ResponseContentType$createAppsV1NamespacedReplicaSet>(params: Params$createAppsV1NamespacedReplicaSet<ResponseContentType>, option?: RequestOption): Promise<(Response$createAppsV1NamespacedReplicaSet$Status$200 | Response$createAppsV1NamespacedReplicaSet$Status$201 | Response$createAppsV1NamespacedReplicaSet$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/replicasets\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete collection of ReplicaSet */
+        deleteAppsV1CollectionNamespacedReplicaSet: <ResponseContentType extends ResponseContentType$deleteAppsV1CollectionNamespacedReplicaSet>(params: Params$deleteAppsV1CollectionNamespacedReplicaSet<ResponseContentType>, option?: RequestOption): Promise<Response$deleteAppsV1CollectionNamespacedReplicaSet$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/replicasets\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read the specified ReplicaSet */
+        readAppsV1NamespacedReplicaSet: <ResponseContentType extends ResponseContentType$readAppsV1NamespacedReplicaSet>(params: Params$readAppsV1NamespacedReplicaSet<ResponseContentType>, option?: RequestOption): Promise<Response$readAppsV1NamespacedReplicaSet$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/replicasets/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                exact: { value: params.parameter.exact, explode: false },
+                export: { value: params.parameter.export, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace the specified ReplicaSet */
+        replaceAppsV1NamespacedReplicaSet: <ResponseContentType extends ResponseContentType$replaceAppsV1NamespacedReplicaSet>(params: Params$replaceAppsV1NamespacedReplicaSet<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceAppsV1NamespacedReplicaSet$Status$200 | Response$replaceAppsV1NamespacedReplicaSet$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/replicasets/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete a ReplicaSet */
+        deleteAppsV1NamespacedReplicaSet: <ResponseContentType extends ResponseContentType$deleteAppsV1NamespacedReplicaSet>(params: Params$deleteAppsV1NamespacedReplicaSet<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteAppsV1NamespacedReplicaSet$Status$200 | Response$deleteAppsV1NamespacedReplicaSet$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/replicasets/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update the specified ReplicaSet */
+        patchAppsV1NamespacedReplicaSet: <RequestContentType extends RequestContentType$patchAppsV1NamespacedReplicaSet, ResponseContentType extends ResponseContentType$patchAppsV1NamespacedReplicaSet>(params: Params$patchAppsV1NamespacedReplicaSet<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchAppsV1NamespacedReplicaSet$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/replicasets/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read scale of the specified ReplicaSet */
+        readAppsV1NamespacedReplicaSetScale: <ResponseContentType extends ResponseContentType$readAppsV1NamespacedReplicaSetScale>(params: Params$readAppsV1NamespacedReplicaSetScale<ResponseContentType>, option?: RequestOption): Promise<Response$readAppsV1NamespacedReplicaSetScale$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/replicasets/\${params.parameter.name}/scale\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace scale of the specified ReplicaSet */
+        replaceAppsV1NamespacedReplicaSetScale: <ResponseContentType extends ResponseContentType$replaceAppsV1NamespacedReplicaSetScale>(params: Params$replaceAppsV1NamespacedReplicaSetScale<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceAppsV1NamespacedReplicaSetScale$Status$200 | Response$replaceAppsV1NamespacedReplicaSetScale$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/replicasets/\${params.parameter.name}/scale\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update scale of the specified ReplicaSet */
+        patchAppsV1NamespacedReplicaSetScale: <RequestContentType extends RequestContentType$patchAppsV1NamespacedReplicaSetScale, ResponseContentType extends ResponseContentType$patchAppsV1NamespacedReplicaSetScale>(params: Params$patchAppsV1NamespacedReplicaSetScale<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchAppsV1NamespacedReplicaSetScale$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/replicasets/\${params.parameter.name}/scale\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read status of the specified ReplicaSet */
+        readAppsV1NamespacedReplicaSetStatus: <ResponseContentType extends ResponseContentType$readAppsV1NamespacedReplicaSetStatus>(params: Params$readAppsV1NamespacedReplicaSetStatus<ResponseContentType>, option?: RequestOption): Promise<Response$readAppsV1NamespacedReplicaSetStatus$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/replicasets/\${params.parameter.name}/status\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace status of the specified ReplicaSet */
+        replaceAppsV1NamespacedReplicaSetStatus: <ResponseContentType extends ResponseContentType$replaceAppsV1NamespacedReplicaSetStatus>(params: Params$replaceAppsV1NamespacedReplicaSetStatus<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceAppsV1NamespacedReplicaSetStatus$Status$200 | Response$replaceAppsV1NamespacedReplicaSetStatus$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/replicasets/\${params.parameter.name}/status\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update status of the specified ReplicaSet */
+        patchAppsV1NamespacedReplicaSetStatus: <RequestContentType extends RequestContentType$patchAppsV1NamespacedReplicaSetStatus, ResponseContentType extends ResponseContentType$patchAppsV1NamespacedReplicaSetStatus>(params: Params$patchAppsV1NamespacedReplicaSetStatus<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchAppsV1NamespacedReplicaSetStatus$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/replicasets/\${params.parameter.name}/status\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** list or watch objects of kind StatefulSet */
+        listAppsV1NamespacedStatefulSet: <ResponseContentType extends ResponseContentType$listAppsV1NamespacedStatefulSet>(params: Params$listAppsV1NamespacedStatefulSet<ResponseContentType>, option?: RequestOption): Promise<Response$listAppsV1NamespacedStatefulSet$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/statefulsets\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** create a StatefulSet */
+        createAppsV1NamespacedStatefulSet: <ResponseContentType extends ResponseContentType$createAppsV1NamespacedStatefulSet>(params: Params$createAppsV1NamespacedStatefulSet<ResponseContentType>, option?: RequestOption): Promise<(Response$createAppsV1NamespacedStatefulSet$Status$200 | Response$createAppsV1NamespacedStatefulSet$Status$201 | Response$createAppsV1NamespacedStatefulSet$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/statefulsets\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete collection of StatefulSet */
+        deleteAppsV1CollectionNamespacedStatefulSet: <ResponseContentType extends ResponseContentType$deleteAppsV1CollectionNamespacedStatefulSet>(params: Params$deleteAppsV1CollectionNamespacedStatefulSet<ResponseContentType>, option?: RequestOption): Promise<Response$deleteAppsV1CollectionNamespacedStatefulSet$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/statefulsets\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read the specified StatefulSet */
+        readAppsV1NamespacedStatefulSet: <ResponseContentType extends ResponseContentType$readAppsV1NamespacedStatefulSet>(params: Params$readAppsV1NamespacedStatefulSet<ResponseContentType>, option?: RequestOption): Promise<Response$readAppsV1NamespacedStatefulSet$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/statefulsets/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                exact: { value: params.parameter.exact, explode: false },
+                export: { value: params.parameter.export, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace the specified StatefulSet */
+        replaceAppsV1NamespacedStatefulSet: <ResponseContentType extends ResponseContentType$replaceAppsV1NamespacedStatefulSet>(params: Params$replaceAppsV1NamespacedStatefulSet<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceAppsV1NamespacedStatefulSet$Status$200 | Response$replaceAppsV1NamespacedStatefulSet$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/statefulsets/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete a StatefulSet */
+        deleteAppsV1NamespacedStatefulSet: <ResponseContentType extends ResponseContentType$deleteAppsV1NamespacedStatefulSet>(params: Params$deleteAppsV1NamespacedStatefulSet<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteAppsV1NamespacedStatefulSet$Status$200 | Response$deleteAppsV1NamespacedStatefulSet$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/statefulsets/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update the specified StatefulSet */
+        patchAppsV1NamespacedStatefulSet: <RequestContentType extends RequestContentType$patchAppsV1NamespacedStatefulSet, ResponseContentType extends ResponseContentType$patchAppsV1NamespacedStatefulSet>(params: Params$patchAppsV1NamespacedStatefulSet<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchAppsV1NamespacedStatefulSet$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/statefulsets/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read scale of the specified StatefulSet */
+        readAppsV1NamespacedStatefulSetScale: <ResponseContentType extends ResponseContentType$readAppsV1NamespacedStatefulSetScale>(params: Params$readAppsV1NamespacedStatefulSetScale<ResponseContentType>, option?: RequestOption): Promise<Response$readAppsV1NamespacedStatefulSetScale$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/statefulsets/\${params.parameter.name}/scale\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace scale of the specified StatefulSet */
+        replaceAppsV1NamespacedStatefulSetScale: <ResponseContentType extends ResponseContentType$replaceAppsV1NamespacedStatefulSetScale>(params: Params$replaceAppsV1NamespacedStatefulSetScale<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceAppsV1NamespacedStatefulSetScale$Status$200 | Response$replaceAppsV1NamespacedStatefulSetScale$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/statefulsets/\${params.parameter.name}/scale\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update scale of the specified StatefulSet */
+        patchAppsV1NamespacedStatefulSetScale: <RequestContentType extends RequestContentType$patchAppsV1NamespacedStatefulSetScale, ResponseContentType extends ResponseContentType$patchAppsV1NamespacedStatefulSetScale>(params: Params$patchAppsV1NamespacedStatefulSetScale<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchAppsV1NamespacedStatefulSetScale$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/statefulsets/\${params.parameter.name}/scale\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read status of the specified StatefulSet */
+        readAppsV1NamespacedStatefulSetStatus: <ResponseContentType extends ResponseContentType$readAppsV1NamespacedStatefulSetStatus>(params: Params$readAppsV1NamespacedStatefulSetStatus<ResponseContentType>, option?: RequestOption): Promise<Response$readAppsV1NamespacedStatefulSetStatus$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/statefulsets/\${params.parameter.name}/status\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace status of the specified StatefulSet */
+        replaceAppsV1NamespacedStatefulSetStatus: <ResponseContentType extends ResponseContentType$replaceAppsV1NamespacedStatefulSetStatus>(params: Params$replaceAppsV1NamespacedStatefulSetStatus<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceAppsV1NamespacedStatefulSetStatus$Status$200 | Response$replaceAppsV1NamespacedStatefulSetStatus$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/statefulsets/\${params.parameter.name}/status\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update status of the specified StatefulSet */
+        patchAppsV1NamespacedStatefulSetStatus: <RequestContentType extends RequestContentType$patchAppsV1NamespacedStatefulSetStatus, ResponseContentType extends ResponseContentType$patchAppsV1NamespacedStatefulSetStatus>(params: Params$patchAppsV1NamespacedStatefulSetStatus<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchAppsV1NamespacedStatefulSetStatus$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apps/v1/namespaces/\${params.parameter.namespace}/statefulsets/\${params.parameter.name}/status\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** list or watch objects of kind ReplicaSet */
+        listAppsV1ReplicaSetForAllNamespaces: <ResponseContentType extends ResponseContentType$listAppsV1ReplicaSetForAllNamespaces>(params: Params$listAppsV1ReplicaSetForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$listAppsV1ReplicaSetForAllNamespaces$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apps/v1/replicasets\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** list or watch objects of kind StatefulSet */
+        listAppsV1StatefulSetForAllNamespaces: <ResponseContentType extends ResponseContentType$listAppsV1StatefulSetForAllNamespaces>(params: Params$listAppsV1StatefulSetForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$listAppsV1StatefulSetForAllNamespaces$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apps/v1/statefulsets\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of ControllerRevision. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchAppsV1ControllerRevisionListForAllNamespaces: <ResponseContentType extends ResponseContentType$watchAppsV1ControllerRevisionListForAllNamespaces>(params: Params$watchAppsV1ControllerRevisionListForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$watchAppsV1ControllerRevisionListForAllNamespaces$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apps/v1/watch/controllerrevisions\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of DaemonSet. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchAppsV1DaemonSetListForAllNamespaces: <ResponseContentType extends ResponseContentType$watchAppsV1DaemonSetListForAllNamespaces>(params: Params$watchAppsV1DaemonSetListForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$watchAppsV1DaemonSetListForAllNamespaces$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apps/v1/watch/daemonsets\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of Deployment. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchAppsV1DeploymentListForAllNamespaces: <ResponseContentType extends ResponseContentType$watchAppsV1DeploymentListForAllNamespaces>(params: Params$watchAppsV1DeploymentListForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$watchAppsV1DeploymentListForAllNamespaces$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apps/v1/watch/deployments\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of ControllerRevision. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchAppsV1NamespacedControllerRevisionList: <ResponseContentType extends ResponseContentType$watchAppsV1NamespacedControllerRevisionList>(params: Params$watchAppsV1NamespacedControllerRevisionList<ResponseContentType>, option?: RequestOption): Promise<Response$watchAppsV1NamespacedControllerRevisionList$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apps/v1/watch/namespaces/\${params.parameter.namespace}/controllerrevisions\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch changes to an object of kind ControllerRevision. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. */
+        watchAppsV1NamespacedControllerRevision: <ResponseContentType extends ResponseContentType$watchAppsV1NamespacedControllerRevision>(params: Params$watchAppsV1NamespacedControllerRevision<ResponseContentType>, option?: RequestOption): Promise<Response$watchAppsV1NamespacedControllerRevision$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apps/v1/watch/namespaces/\${params.parameter.namespace}/controllerrevisions/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of DaemonSet. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchAppsV1NamespacedDaemonSetList: <ResponseContentType extends ResponseContentType$watchAppsV1NamespacedDaemonSetList>(params: Params$watchAppsV1NamespacedDaemonSetList<ResponseContentType>, option?: RequestOption): Promise<Response$watchAppsV1NamespacedDaemonSetList$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apps/v1/watch/namespaces/\${params.parameter.namespace}/daemonsets\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch changes to an object of kind DaemonSet. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. */
+        watchAppsV1NamespacedDaemonSet: <ResponseContentType extends ResponseContentType$watchAppsV1NamespacedDaemonSet>(params: Params$watchAppsV1NamespacedDaemonSet<ResponseContentType>, option?: RequestOption): Promise<Response$watchAppsV1NamespacedDaemonSet$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apps/v1/watch/namespaces/\${params.parameter.namespace}/daemonsets/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of Deployment. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchAppsV1NamespacedDeploymentList: <ResponseContentType extends ResponseContentType$watchAppsV1NamespacedDeploymentList>(params: Params$watchAppsV1NamespacedDeploymentList<ResponseContentType>, option?: RequestOption): Promise<Response$watchAppsV1NamespacedDeploymentList$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apps/v1/watch/namespaces/\${params.parameter.namespace}/deployments\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch changes to an object of kind Deployment. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. */
+        watchAppsV1NamespacedDeployment: <ResponseContentType extends ResponseContentType$watchAppsV1NamespacedDeployment>(params: Params$watchAppsV1NamespacedDeployment<ResponseContentType>, option?: RequestOption): Promise<Response$watchAppsV1NamespacedDeployment$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apps/v1/watch/namespaces/\${params.parameter.namespace}/deployments/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of ReplicaSet. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchAppsV1NamespacedReplicaSetList: <ResponseContentType extends ResponseContentType$watchAppsV1NamespacedReplicaSetList>(params: Params$watchAppsV1NamespacedReplicaSetList<ResponseContentType>, option?: RequestOption): Promise<Response$watchAppsV1NamespacedReplicaSetList$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apps/v1/watch/namespaces/\${params.parameter.namespace}/replicasets\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch changes to an object of kind ReplicaSet. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. */
+        watchAppsV1NamespacedReplicaSet: <ResponseContentType extends ResponseContentType$watchAppsV1NamespacedReplicaSet>(params: Params$watchAppsV1NamespacedReplicaSet<ResponseContentType>, option?: RequestOption): Promise<Response$watchAppsV1NamespacedReplicaSet$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apps/v1/watch/namespaces/\${params.parameter.namespace}/replicasets/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of StatefulSet. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchAppsV1NamespacedStatefulSetList: <ResponseContentType extends ResponseContentType$watchAppsV1NamespacedStatefulSetList>(params: Params$watchAppsV1NamespacedStatefulSetList<ResponseContentType>, option?: RequestOption): Promise<Response$watchAppsV1NamespacedStatefulSetList$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apps/v1/watch/namespaces/\${params.parameter.namespace}/statefulsets\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch changes to an object of kind StatefulSet. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. */
+        watchAppsV1NamespacedStatefulSet: <ResponseContentType extends ResponseContentType$watchAppsV1NamespacedStatefulSet>(params: Params$watchAppsV1NamespacedStatefulSet<ResponseContentType>, option?: RequestOption): Promise<Response$watchAppsV1NamespacedStatefulSet$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apps/v1/watch/namespaces/\${params.parameter.namespace}/statefulsets/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of ReplicaSet. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchAppsV1ReplicaSetListForAllNamespaces: <ResponseContentType extends ResponseContentType$watchAppsV1ReplicaSetListForAllNamespaces>(params: Params$watchAppsV1ReplicaSetListForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$watchAppsV1ReplicaSetListForAllNamespaces$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apps/v1/watch/replicasets\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of StatefulSet. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchAppsV1StatefulSetListForAllNamespaces: <ResponseContentType extends ResponseContentType$watchAppsV1StatefulSetListForAllNamespaces>(params: Params$watchAppsV1StatefulSetListForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$watchAppsV1StatefulSetListForAllNamespaces$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/apps/v1/watch/statefulsets\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** get information of a group */
+        getAuditregistrationAPIGroup: <ResponseContentType extends ResponseContentType$getAuditregistrationAPIGroup>(params: Params$getAuditregistrationAPIGroup<ResponseContentType>, option?: RequestOption): Promise<Response$getAuditregistrationAPIGroup$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/auditregistration.k8s.io/\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        /** get available resources */
+        getAuditregistrationV1alpha1APIResources: <ResponseContentType extends ResponseContentType$getAuditregistrationV1alpha1APIResources>(params: Params$getAuditregistrationV1alpha1APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getAuditregistrationV1alpha1APIResources$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/auditregistration.k8s.io/v1alpha1/\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        /** list or watch objects of kind AuditSink */
+        listAuditregistrationV1alpha1AuditSink: <ResponseContentType extends ResponseContentType$listAuditregistrationV1alpha1AuditSink>(params: Params$listAuditregistrationV1alpha1AuditSink<ResponseContentType>, option?: RequestOption): Promise<Response$listAuditregistrationV1alpha1AuditSink$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/auditregistration.k8s.io/v1alpha1/auditsinks\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** create an AuditSink */
+        createAuditregistrationV1alpha1AuditSink: <ResponseContentType extends ResponseContentType$createAuditregistrationV1alpha1AuditSink>(params: Params$createAuditregistrationV1alpha1AuditSink<ResponseContentType>, option?: RequestOption): Promise<(Response$createAuditregistrationV1alpha1AuditSink$Status$200 | Response$createAuditregistrationV1alpha1AuditSink$Status$201 | Response$createAuditregistrationV1alpha1AuditSink$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/auditregistration.k8s.io/v1alpha1/auditsinks\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete collection of AuditSink */
+        deleteAuditregistrationV1alpha1CollectionAuditSink: <ResponseContentType extends ResponseContentType$deleteAuditregistrationV1alpha1CollectionAuditSink>(params: Params$deleteAuditregistrationV1alpha1CollectionAuditSink<ResponseContentType>, option?: RequestOption): Promise<Response$deleteAuditregistrationV1alpha1CollectionAuditSink$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/auditregistration.k8s.io/v1alpha1/auditsinks\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read the specified AuditSink */
+        readAuditregistrationV1alpha1AuditSink: <ResponseContentType extends ResponseContentType$readAuditregistrationV1alpha1AuditSink>(params: Params$readAuditregistrationV1alpha1AuditSink<ResponseContentType>, option?: RequestOption): Promise<Response$readAuditregistrationV1alpha1AuditSink$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/auditregistration.k8s.io/v1alpha1/auditsinks/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                exact: { value: params.parameter.exact, explode: false },
+                export: { value: params.parameter.export, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace the specified AuditSink */
+        replaceAuditregistrationV1alpha1AuditSink: <ResponseContentType extends ResponseContentType$replaceAuditregistrationV1alpha1AuditSink>(params: Params$replaceAuditregistrationV1alpha1AuditSink<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceAuditregistrationV1alpha1AuditSink$Status$200 | Response$replaceAuditregistrationV1alpha1AuditSink$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/auditregistration.k8s.io/v1alpha1/auditsinks/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete an AuditSink */
+        deleteAuditregistrationV1alpha1AuditSink: <ResponseContentType extends ResponseContentType$deleteAuditregistrationV1alpha1AuditSink>(params: Params$deleteAuditregistrationV1alpha1AuditSink<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteAuditregistrationV1alpha1AuditSink$Status$200 | Response$deleteAuditregistrationV1alpha1AuditSink$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/auditregistration.k8s.io/v1alpha1/auditsinks/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update the specified AuditSink */
+        patchAuditregistrationV1alpha1AuditSink: <RequestContentType extends RequestContentType$patchAuditregistrationV1alpha1AuditSink, ResponseContentType extends ResponseContentType$patchAuditregistrationV1alpha1AuditSink>(params: Params$patchAuditregistrationV1alpha1AuditSink<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchAuditregistrationV1alpha1AuditSink$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/auditregistration.k8s.io/v1alpha1/auditsinks/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** watch individual changes to a list of AuditSink. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchAuditregistrationV1alpha1AuditSinkList: <ResponseContentType extends ResponseContentType$watchAuditregistrationV1alpha1AuditSinkList>(params: Params$watchAuditregistrationV1alpha1AuditSinkList<ResponseContentType>, option?: RequestOption): Promise<Response$watchAuditregistrationV1alpha1AuditSinkList$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/auditregistration.k8s.io/v1alpha1/watch/auditsinks\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch changes to an object of kind AuditSink. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. */
+        watchAuditregistrationV1alpha1AuditSink: <ResponseContentType extends ResponseContentType$watchAuditregistrationV1alpha1AuditSink>(params: Params$watchAuditregistrationV1alpha1AuditSink<ResponseContentType>, option?: RequestOption): Promise<Response$watchAuditregistrationV1alpha1AuditSink$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/auditregistration.k8s.io/v1alpha1/watch/auditsinks/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** get information of a group */
+        getAuthenticationAPIGroup: <ResponseContentType extends ResponseContentType$getAuthenticationAPIGroup>(params: Params$getAuthenticationAPIGroup<ResponseContentType>, option?: RequestOption): Promise<Response$getAuthenticationAPIGroup$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/authentication.k8s.io/\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        /** get available resources */
+        getAuthenticationV1APIResources: <ResponseContentType extends ResponseContentType$getAuthenticationV1APIResources>(params: Params$getAuthenticationV1APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getAuthenticationV1APIResources$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/authentication.k8s.io/v1/\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        /** create a TokenReview */
+        createAuthenticationV1TokenReview: <ResponseContentType extends ResponseContentType$createAuthenticationV1TokenReview>(params: Params$createAuthenticationV1TokenReview<ResponseContentType>, option?: RequestOption): Promise<(Response$createAuthenticationV1TokenReview$Status$200 | Response$createAuthenticationV1TokenReview$Status$201 | Response$createAuthenticationV1TokenReview$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/authentication.k8s.io/v1/tokenreviews\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** get available resources */
+        getAuthenticationV1beta1APIResources: <ResponseContentType extends ResponseContentType$getAuthenticationV1beta1APIResources>(params: Params$getAuthenticationV1beta1APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getAuthenticationV1beta1APIResources$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/authentication.k8s.io/v1beta1/\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        /** create a TokenReview */
+        createAuthenticationV1beta1TokenReview: <ResponseContentType extends ResponseContentType$createAuthenticationV1beta1TokenReview>(params: Params$createAuthenticationV1beta1TokenReview<ResponseContentType>, option?: RequestOption): Promise<(Response$createAuthenticationV1beta1TokenReview$Status$200 | Response$createAuthenticationV1beta1TokenReview$Status$201 | Response$createAuthenticationV1beta1TokenReview$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/authentication.k8s.io/v1beta1/tokenreviews\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** get information of a group */
+        getAuthorizationAPIGroup: <ResponseContentType extends ResponseContentType$getAuthorizationAPIGroup>(params: Params$getAuthorizationAPIGroup<ResponseContentType>, option?: RequestOption): Promise<Response$getAuthorizationAPIGroup$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/authorization.k8s.io/\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        /** get available resources */
+        getAuthorizationV1APIResources: <ResponseContentType extends ResponseContentType$getAuthorizationV1APIResources>(params: Params$getAuthorizationV1APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getAuthorizationV1APIResources$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/authorization.k8s.io/v1/\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        /** create a LocalSubjectAccessReview */
+        createAuthorizationV1NamespacedLocalSubjectAccessReview: <ResponseContentType extends ResponseContentType$createAuthorizationV1NamespacedLocalSubjectAccessReview>(params: Params$createAuthorizationV1NamespacedLocalSubjectAccessReview<ResponseContentType>, option?: RequestOption): Promise<(Response$createAuthorizationV1NamespacedLocalSubjectAccessReview$Status$200 | Response$createAuthorizationV1NamespacedLocalSubjectAccessReview$Status$201 | Response$createAuthorizationV1NamespacedLocalSubjectAccessReview$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/authorization.k8s.io/v1/namespaces/\${params.parameter.namespace}/localsubjectaccessreviews\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** create a SelfSubjectAccessReview */
+        createAuthorizationV1SelfSubjectAccessReview: <ResponseContentType extends ResponseContentType$createAuthorizationV1SelfSubjectAccessReview>(params: Params$createAuthorizationV1SelfSubjectAccessReview<ResponseContentType>, option?: RequestOption): Promise<(Response$createAuthorizationV1SelfSubjectAccessReview$Status$200 | Response$createAuthorizationV1SelfSubjectAccessReview$Status$201 | Response$createAuthorizationV1SelfSubjectAccessReview$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/authorization.k8s.io/v1/selfsubjectaccessreviews\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** create a SelfSubjectRulesReview */
+        createAuthorizationV1SelfSubjectRulesReview: <ResponseContentType extends ResponseContentType$createAuthorizationV1SelfSubjectRulesReview>(params: Params$createAuthorizationV1SelfSubjectRulesReview<ResponseContentType>, option?: RequestOption): Promise<(Response$createAuthorizationV1SelfSubjectRulesReview$Status$200 | Response$createAuthorizationV1SelfSubjectRulesReview$Status$201 | Response$createAuthorizationV1SelfSubjectRulesReview$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/authorization.k8s.io/v1/selfsubjectrulesreviews\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** create a SubjectAccessReview */
+        createAuthorizationV1SubjectAccessReview: <ResponseContentType extends ResponseContentType$createAuthorizationV1SubjectAccessReview>(params: Params$createAuthorizationV1SubjectAccessReview<ResponseContentType>, option?: RequestOption): Promise<(Response$createAuthorizationV1SubjectAccessReview$Status$200 | Response$createAuthorizationV1SubjectAccessReview$Status$201 | Response$createAuthorizationV1SubjectAccessReview$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/authorization.k8s.io/v1/subjectaccessreviews\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** get available resources */
+        getAuthorizationV1beta1APIResources: <ResponseContentType extends ResponseContentType$getAuthorizationV1beta1APIResources>(params: Params$getAuthorizationV1beta1APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getAuthorizationV1beta1APIResources$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/authorization.k8s.io/v1beta1/\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        /** create a LocalSubjectAccessReview */
+        createAuthorizationV1beta1NamespacedLocalSubjectAccessReview: <ResponseContentType extends ResponseContentType$createAuthorizationV1beta1NamespacedLocalSubjectAccessReview>(params: Params$createAuthorizationV1beta1NamespacedLocalSubjectAccessReview<ResponseContentType>, option?: RequestOption): Promise<(Response$createAuthorizationV1beta1NamespacedLocalSubjectAccessReview$Status$200 | Response$createAuthorizationV1beta1NamespacedLocalSubjectAccessReview$Status$201 | Response$createAuthorizationV1beta1NamespacedLocalSubjectAccessReview$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/authorization.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/localsubjectaccessreviews\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** create a SelfSubjectAccessReview */
+        createAuthorizationV1beta1SelfSubjectAccessReview: <ResponseContentType extends ResponseContentType$createAuthorizationV1beta1SelfSubjectAccessReview>(params: Params$createAuthorizationV1beta1SelfSubjectAccessReview<ResponseContentType>, option?: RequestOption): Promise<(Response$createAuthorizationV1beta1SelfSubjectAccessReview$Status$200 | Response$createAuthorizationV1beta1SelfSubjectAccessReview$Status$201 | Response$createAuthorizationV1beta1SelfSubjectAccessReview$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/authorization.k8s.io/v1beta1/selfsubjectaccessreviews\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** create a SelfSubjectRulesReview */
+        createAuthorizationV1beta1SelfSubjectRulesReview: <ResponseContentType extends ResponseContentType$createAuthorizationV1beta1SelfSubjectRulesReview>(params: Params$createAuthorizationV1beta1SelfSubjectRulesReview<ResponseContentType>, option?: RequestOption): Promise<(Response$createAuthorizationV1beta1SelfSubjectRulesReview$Status$200 | Response$createAuthorizationV1beta1SelfSubjectRulesReview$Status$201 | Response$createAuthorizationV1beta1SelfSubjectRulesReview$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/authorization.k8s.io/v1beta1/selfsubjectrulesreviews\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** create a SubjectAccessReview */
+        createAuthorizationV1beta1SubjectAccessReview: <ResponseContentType extends ResponseContentType$createAuthorizationV1beta1SubjectAccessReview>(params: Params$createAuthorizationV1beta1SubjectAccessReview<ResponseContentType>, option?: RequestOption): Promise<(Response$createAuthorizationV1beta1SubjectAccessReview$Status$200 | Response$createAuthorizationV1beta1SubjectAccessReview$Status$201 | Response$createAuthorizationV1beta1SubjectAccessReview$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/authorization.k8s.io/v1beta1/subjectaccessreviews\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** get information of a group */
+        getAutoscalingAPIGroup: <ResponseContentType extends ResponseContentType$getAutoscalingAPIGroup>(params: Params$getAutoscalingAPIGroup<ResponseContentType>, option?: RequestOption): Promise<Response$getAutoscalingAPIGroup$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/autoscaling/\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        /** get available resources */
+        getAutoscalingV1APIResources: <ResponseContentType extends ResponseContentType$getAutoscalingV1APIResources>(params: Params$getAutoscalingV1APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getAutoscalingV1APIResources$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/autoscaling/v1/\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        /** list or watch objects of kind HorizontalPodAutoscaler */
+        listAutoscalingV1HorizontalPodAutoscalerForAllNamespaces: <ResponseContentType extends ResponseContentType$listAutoscalingV1HorizontalPodAutoscalerForAllNamespaces>(params: Params$listAutoscalingV1HorizontalPodAutoscalerForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$listAutoscalingV1HorizontalPodAutoscalerForAllNamespaces$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/autoscaling/v1/horizontalpodautoscalers\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** list or watch objects of kind HorizontalPodAutoscaler */
+        listAutoscalingV1NamespacedHorizontalPodAutoscaler: <ResponseContentType extends ResponseContentType$listAutoscalingV1NamespacedHorizontalPodAutoscaler>(params: Params$listAutoscalingV1NamespacedHorizontalPodAutoscaler<ResponseContentType>, option?: RequestOption): Promise<Response$listAutoscalingV1NamespacedHorizontalPodAutoscaler$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/autoscaling/v1/namespaces/\${params.parameter.namespace}/horizontalpodautoscalers\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** create a HorizontalPodAutoscaler */
+        createAutoscalingV1NamespacedHorizontalPodAutoscaler: <ResponseContentType extends ResponseContentType$createAutoscalingV1NamespacedHorizontalPodAutoscaler>(params: Params$createAutoscalingV1NamespacedHorizontalPodAutoscaler<ResponseContentType>, option?: RequestOption): Promise<(Response$createAutoscalingV1NamespacedHorizontalPodAutoscaler$Status$200 | Response$createAutoscalingV1NamespacedHorizontalPodAutoscaler$Status$201 | Response$createAutoscalingV1NamespacedHorizontalPodAutoscaler$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/autoscaling/v1/namespaces/\${params.parameter.namespace}/horizontalpodautoscalers\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete collection of HorizontalPodAutoscaler */
+        deleteAutoscalingV1CollectionNamespacedHorizontalPodAutoscaler: <ResponseContentType extends ResponseContentType$deleteAutoscalingV1CollectionNamespacedHorizontalPodAutoscaler>(params: Params$deleteAutoscalingV1CollectionNamespacedHorizontalPodAutoscaler<ResponseContentType>, option?: RequestOption): Promise<Response$deleteAutoscalingV1CollectionNamespacedHorizontalPodAutoscaler$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/autoscaling/v1/namespaces/\${params.parameter.namespace}/horizontalpodautoscalers\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read the specified HorizontalPodAutoscaler */
+        readAutoscalingV1NamespacedHorizontalPodAutoscaler: <ResponseContentType extends ResponseContentType$readAutoscalingV1NamespacedHorizontalPodAutoscaler>(params: Params$readAutoscalingV1NamespacedHorizontalPodAutoscaler<ResponseContentType>, option?: RequestOption): Promise<Response$readAutoscalingV1NamespacedHorizontalPodAutoscaler$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/autoscaling/v1/namespaces/\${params.parameter.namespace}/horizontalpodautoscalers/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                exact: { value: params.parameter.exact, explode: false },
+                export: { value: params.parameter.export, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace the specified HorizontalPodAutoscaler */
+        replaceAutoscalingV1NamespacedHorizontalPodAutoscaler: <ResponseContentType extends ResponseContentType$replaceAutoscalingV1NamespacedHorizontalPodAutoscaler>(params: Params$replaceAutoscalingV1NamespacedHorizontalPodAutoscaler<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceAutoscalingV1NamespacedHorizontalPodAutoscaler$Status$200 | Response$replaceAutoscalingV1NamespacedHorizontalPodAutoscaler$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/autoscaling/v1/namespaces/\${params.parameter.namespace}/horizontalpodautoscalers/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete a HorizontalPodAutoscaler */
+        deleteAutoscalingV1NamespacedHorizontalPodAutoscaler: <ResponseContentType extends ResponseContentType$deleteAutoscalingV1NamespacedHorizontalPodAutoscaler>(params: Params$deleteAutoscalingV1NamespacedHorizontalPodAutoscaler<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteAutoscalingV1NamespacedHorizontalPodAutoscaler$Status$200 | Response$deleteAutoscalingV1NamespacedHorizontalPodAutoscaler$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/autoscaling/v1/namespaces/\${params.parameter.namespace}/horizontalpodautoscalers/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update the specified HorizontalPodAutoscaler */
+        patchAutoscalingV1NamespacedHorizontalPodAutoscaler: <RequestContentType extends RequestContentType$patchAutoscalingV1NamespacedHorizontalPodAutoscaler, ResponseContentType extends ResponseContentType$patchAutoscalingV1NamespacedHorizontalPodAutoscaler>(params: Params$patchAutoscalingV1NamespacedHorizontalPodAutoscaler<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchAutoscalingV1NamespacedHorizontalPodAutoscaler$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/autoscaling/v1/namespaces/\${params.parameter.namespace}/horizontalpodautoscalers/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read status of the specified HorizontalPodAutoscaler */
+        readAutoscalingV1NamespacedHorizontalPodAutoscalerStatus: <ResponseContentType extends ResponseContentType$readAutoscalingV1NamespacedHorizontalPodAutoscalerStatus>(params: Params$readAutoscalingV1NamespacedHorizontalPodAutoscalerStatus<ResponseContentType>, option?: RequestOption): Promise<Response$readAutoscalingV1NamespacedHorizontalPodAutoscalerStatus$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/autoscaling/v1/namespaces/\${params.parameter.namespace}/horizontalpodautoscalers/\${params.parameter.name}/status\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace status of the specified HorizontalPodAutoscaler */
+        replaceAutoscalingV1NamespacedHorizontalPodAutoscalerStatus: <ResponseContentType extends ResponseContentType$replaceAutoscalingV1NamespacedHorizontalPodAutoscalerStatus>(params: Params$replaceAutoscalingV1NamespacedHorizontalPodAutoscalerStatus<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceAutoscalingV1NamespacedHorizontalPodAutoscalerStatus$Status$200 | Response$replaceAutoscalingV1NamespacedHorizontalPodAutoscalerStatus$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/autoscaling/v1/namespaces/\${params.parameter.namespace}/horizontalpodautoscalers/\${params.parameter.name}/status\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update status of the specified HorizontalPodAutoscaler */
+        patchAutoscalingV1NamespacedHorizontalPodAutoscalerStatus: <RequestContentType extends RequestContentType$patchAutoscalingV1NamespacedHorizontalPodAutoscalerStatus, ResponseContentType extends ResponseContentType$patchAutoscalingV1NamespacedHorizontalPodAutoscalerStatus>(params: Params$patchAutoscalingV1NamespacedHorizontalPodAutoscalerStatus<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchAutoscalingV1NamespacedHorizontalPodAutoscalerStatus$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/autoscaling/v1/namespaces/\${params.parameter.namespace}/horizontalpodautoscalers/\${params.parameter.name}/status\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** watch individual changes to a list of HorizontalPodAutoscaler. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchAutoscalingV1HorizontalPodAutoscalerListForAllNamespaces: <ResponseContentType extends ResponseContentType$watchAutoscalingV1HorizontalPodAutoscalerListForAllNamespaces>(params: Params$watchAutoscalingV1HorizontalPodAutoscalerListForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$watchAutoscalingV1HorizontalPodAutoscalerListForAllNamespaces$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/autoscaling/v1/watch/horizontalpodautoscalers\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of HorizontalPodAutoscaler. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchAutoscalingV1NamespacedHorizontalPodAutoscalerList: <ResponseContentType extends ResponseContentType$watchAutoscalingV1NamespacedHorizontalPodAutoscalerList>(params: Params$watchAutoscalingV1NamespacedHorizontalPodAutoscalerList<ResponseContentType>, option?: RequestOption): Promise<Response$watchAutoscalingV1NamespacedHorizontalPodAutoscalerList$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/autoscaling/v1/watch/namespaces/\${params.parameter.namespace}/horizontalpodautoscalers\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch changes to an object of kind HorizontalPodAutoscaler. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. */
+        watchAutoscalingV1NamespacedHorizontalPodAutoscaler: <ResponseContentType extends ResponseContentType$watchAutoscalingV1NamespacedHorizontalPodAutoscaler>(params: Params$watchAutoscalingV1NamespacedHorizontalPodAutoscaler<ResponseContentType>, option?: RequestOption): Promise<Response$watchAutoscalingV1NamespacedHorizontalPodAutoscaler$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/autoscaling/v1/watch/namespaces/\${params.parameter.namespace}/horizontalpodautoscalers/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** get available resources */
+        getAutoscalingV2beta1APIResources: <ResponseContentType extends ResponseContentType$getAutoscalingV2beta1APIResources>(params: Params$getAutoscalingV2beta1APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getAutoscalingV2beta1APIResources$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/autoscaling/v2beta1/\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        /** list or watch objects of kind HorizontalPodAutoscaler */
+        listAutoscalingV2beta1HorizontalPodAutoscalerForAllNamespaces: <ResponseContentType extends ResponseContentType$listAutoscalingV2beta1HorizontalPodAutoscalerForAllNamespaces>(params: Params$listAutoscalingV2beta1HorizontalPodAutoscalerForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$listAutoscalingV2beta1HorizontalPodAutoscalerForAllNamespaces$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/autoscaling/v2beta1/horizontalpodautoscalers\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** list or watch objects of kind HorizontalPodAutoscaler */
+        listAutoscalingV2beta1NamespacedHorizontalPodAutoscaler: <ResponseContentType extends ResponseContentType$listAutoscalingV2beta1NamespacedHorizontalPodAutoscaler>(params: Params$listAutoscalingV2beta1NamespacedHorizontalPodAutoscaler<ResponseContentType>, option?: RequestOption): Promise<Response$listAutoscalingV2beta1NamespacedHorizontalPodAutoscaler$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/autoscaling/v2beta1/namespaces/\${params.parameter.namespace}/horizontalpodautoscalers\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** create a HorizontalPodAutoscaler */
+        createAutoscalingV2beta1NamespacedHorizontalPodAutoscaler: <ResponseContentType extends ResponseContentType$createAutoscalingV2beta1NamespacedHorizontalPodAutoscaler>(params: Params$createAutoscalingV2beta1NamespacedHorizontalPodAutoscaler<ResponseContentType>, option?: RequestOption): Promise<(Response$createAutoscalingV2beta1NamespacedHorizontalPodAutoscaler$Status$200 | Response$createAutoscalingV2beta1NamespacedHorizontalPodAutoscaler$Status$201 | Response$createAutoscalingV2beta1NamespacedHorizontalPodAutoscaler$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/autoscaling/v2beta1/namespaces/\${params.parameter.namespace}/horizontalpodautoscalers\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete collection of HorizontalPodAutoscaler */
+        deleteAutoscalingV2beta1CollectionNamespacedHorizontalPodAutoscaler: <ResponseContentType extends ResponseContentType$deleteAutoscalingV2beta1CollectionNamespacedHorizontalPodAutoscaler>(params: Params$deleteAutoscalingV2beta1CollectionNamespacedHorizontalPodAutoscaler<ResponseContentType>, option?: RequestOption): Promise<Response$deleteAutoscalingV2beta1CollectionNamespacedHorizontalPodAutoscaler$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/autoscaling/v2beta1/namespaces/\${params.parameter.namespace}/horizontalpodautoscalers\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read the specified HorizontalPodAutoscaler */
+        readAutoscalingV2beta1NamespacedHorizontalPodAutoscaler: <ResponseContentType extends ResponseContentType$readAutoscalingV2beta1NamespacedHorizontalPodAutoscaler>(params: Params$readAutoscalingV2beta1NamespacedHorizontalPodAutoscaler<ResponseContentType>, option?: RequestOption): Promise<Response$readAutoscalingV2beta1NamespacedHorizontalPodAutoscaler$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/autoscaling/v2beta1/namespaces/\${params.parameter.namespace}/horizontalpodautoscalers/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                exact: { value: params.parameter.exact, explode: false },
+                export: { value: params.parameter.export, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace the specified HorizontalPodAutoscaler */
+        replaceAutoscalingV2beta1NamespacedHorizontalPodAutoscaler: <ResponseContentType extends ResponseContentType$replaceAutoscalingV2beta1NamespacedHorizontalPodAutoscaler>(params: Params$replaceAutoscalingV2beta1NamespacedHorizontalPodAutoscaler<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceAutoscalingV2beta1NamespacedHorizontalPodAutoscaler$Status$200 | Response$replaceAutoscalingV2beta1NamespacedHorizontalPodAutoscaler$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/autoscaling/v2beta1/namespaces/\${params.parameter.namespace}/horizontalpodautoscalers/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete a HorizontalPodAutoscaler */
+        deleteAutoscalingV2beta1NamespacedHorizontalPodAutoscaler: <ResponseContentType extends ResponseContentType$deleteAutoscalingV2beta1NamespacedHorizontalPodAutoscaler>(params: Params$deleteAutoscalingV2beta1NamespacedHorizontalPodAutoscaler<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteAutoscalingV2beta1NamespacedHorizontalPodAutoscaler$Status$200 | Response$deleteAutoscalingV2beta1NamespacedHorizontalPodAutoscaler$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/autoscaling/v2beta1/namespaces/\${params.parameter.namespace}/horizontalpodautoscalers/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update the specified HorizontalPodAutoscaler */
+        patchAutoscalingV2beta1NamespacedHorizontalPodAutoscaler: <RequestContentType extends RequestContentType$patchAutoscalingV2beta1NamespacedHorizontalPodAutoscaler, ResponseContentType extends ResponseContentType$patchAutoscalingV2beta1NamespacedHorizontalPodAutoscaler>(params: Params$patchAutoscalingV2beta1NamespacedHorizontalPodAutoscaler<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchAutoscalingV2beta1NamespacedHorizontalPodAutoscaler$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/autoscaling/v2beta1/namespaces/\${params.parameter.namespace}/horizontalpodautoscalers/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read status of the specified HorizontalPodAutoscaler */
+        readAutoscalingV2beta1NamespacedHorizontalPodAutoscalerStatus: <ResponseContentType extends ResponseContentType$readAutoscalingV2beta1NamespacedHorizontalPodAutoscalerStatus>(params: Params$readAutoscalingV2beta1NamespacedHorizontalPodAutoscalerStatus<ResponseContentType>, option?: RequestOption): Promise<Response$readAutoscalingV2beta1NamespacedHorizontalPodAutoscalerStatus$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/autoscaling/v2beta1/namespaces/\${params.parameter.namespace}/horizontalpodautoscalers/\${params.parameter.name}/status\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace status of the specified HorizontalPodAutoscaler */
+        replaceAutoscalingV2beta1NamespacedHorizontalPodAutoscalerStatus: <ResponseContentType extends ResponseContentType$replaceAutoscalingV2beta1NamespacedHorizontalPodAutoscalerStatus>(params: Params$replaceAutoscalingV2beta1NamespacedHorizontalPodAutoscalerStatus<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceAutoscalingV2beta1NamespacedHorizontalPodAutoscalerStatus$Status$200 | Response$replaceAutoscalingV2beta1NamespacedHorizontalPodAutoscalerStatus$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/autoscaling/v2beta1/namespaces/\${params.parameter.namespace}/horizontalpodautoscalers/\${params.parameter.name}/status\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update status of the specified HorizontalPodAutoscaler */
+        patchAutoscalingV2beta1NamespacedHorizontalPodAutoscalerStatus: <RequestContentType extends RequestContentType$patchAutoscalingV2beta1NamespacedHorizontalPodAutoscalerStatus, ResponseContentType extends ResponseContentType$patchAutoscalingV2beta1NamespacedHorizontalPodAutoscalerStatus>(params: Params$patchAutoscalingV2beta1NamespacedHorizontalPodAutoscalerStatus<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchAutoscalingV2beta1NamespacedHorizontalPodAutoscalerStatus$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/autoscaling/v2beta1/namespaces/\${params.parameter.namespace}/horizontalpodautoscalers/\${params.parameter.name}/status\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** watch individual changes to a list of HorizontalPodAutoscaler. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchAutoscalingV2beta1HorizontalPodAutoscalerListForAllNamespaces: <ResponseContentType extends ResponseContentType$watchAutoscalingV2beta1HorizontalPodAutoscalerListForAllNamespaces>(params: Params$watchAutoscalingV2beta1HorizontalPodAutoscalerListForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$watchAutoscalingV2beta1HorizontalPodAutoscalerListForAllNamespaces$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/autoscaling/v2beta1/watch/horizontalpodautoscalers\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of HorizontalPodAutoscaler. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchAutoscalingV2beta1NamespacedHorizontalPodAutoscalerList: <ResponseContentType extends ResponseContentType$watchAutoscalingV2beta1NamespacedHorizontalPodAutoscalerList>(params: Params$watchAutoscalingV2beta1NamespacedHorizontalPodAutoscalerList<ResponseContentType>, option?: RequestOption): Promise<Response$watchAutoscalingV2beta1NamespacedHorizontalPodAutoscalerList$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/autoscaling/v2beta1/watch/namespaces/\${params.parameter.namespace}/horizontalpodautoscalers\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch changes to an object of kind HorizontalPodAutoscaler. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. */
+        watchAutoscalingV2beta1NamespacedHorizontalPodAutoscaler: <ResponseContentType extends ResponseContentType$watchAutoscalingV2beta1NamespacedHorizontalPodAutoscaler>(params: Params$watchAutoscalingV2beta1NamespacedHorizontalPodAutoscaler<ResponseContentType>, option?: RequestOption): Promise<Response$watchAutoscalingV2beta1NamespacedHorizontalPodAutoscaler$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/autoscaling/v2beta1/watch/namespaces/\${params.parameter.namespace}/horizontalpodautoscalers/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** get available resources */
+        getAutoscalingV2beta2APIResources: <ResponseContentType extends ResponseContentType$getAutoscalingV2beta2APIResources>(params: Params$getAutoscalingV2beta2APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getAutoscalingV2beta2APIResources$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/autoscaling/v2beta2/\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        /** list or watch objects of kind HorizontalPodAutoscaler */
+        listAutoscalingV2beta2HorizontalPodAutoscalerForAllNamespaces: <ResponseContentType extends ResponseContentType$listAutoscalingV2beta2HorizontalPodAutoscalerForAllNamespaces>(params: Params$listAutoscalingV2beta2HorizontalPodAutoscalerForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$listAutoscalingV2beta2HorizontalPodAutoscalerForAllNamespaces$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/autoscaling/v2beta2/horizontalpodautoscalers\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** list or watch objects of kind HorizontalPodAutoscaler */
+        listAutoscalingV2beta2NamespacedHorizontalPodAutoscaler: <ResponseContentType extends ResponseContentType$listAutoscalingV2beta2NamespacedHorizontalPodAutoscaler>(params: Params$listAutoscalingV2beta2NamespacedHorizontalPodAutoscaler<ResponseContentType>, option?: RequestOption): Promise<Response$listAutoscalingV2beta2NamespacedHorizontalPodAutoscaler$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/autoscaling/v2beta2/namespaces/\${params.parameter.namespace}/horizontalpodautoscalers\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** create a HorizontalPodAutoscaler */
+        createAutoscalingV2beta2NamespacedHorizontalPodAutoscaler: <ResponseContentType extends ResponseContentType$createAutoscalingV2beta2NamespacedHorizontalPodAutoscaler>(params: Params$createAutoscalingV2beta2NamespacedHorizontalPodAutoscaler<ResponseContentType>, option?: RequestOption): Promise<(Response$createAutoscalingV2beta2NamespacedHorizontalPodAutoscaler$Status$200 | Response$createAutoscalingV2beta2NamespacedHorizontalPodAutoscaler$Status$201 | Response$createAutoscalingV2beta2NamespacedHorizontalPodAutoscaler$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/autoscaling/v2beta2/namespaces/\${params.parameter.namespace}/horizontalpodautoscalers\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete collection of HorizontalPodAutoscaler */
+        deleteAutoscalingV2beta2CollectionNamespacedHorizontalPodAutoscaler: <ResponseContentType extends ResponseContentType$deleteAutoscalingV2beta2CollectionNamespacedHorizontalPodAutoscaler>(params: Params$deleteAutoscalingV2beta2CollectionNamespacedHorizontalPodAutoscaler<ResponseContentType>, option?: RequestOption): Promise<Response$deleteAutoscalingV2beta2CollectionNamespacedHorizontalPodAutoscaler$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/autoscaling/v2beta2/namespaces/\${params.parameter.namespace}/horizontalpodautoscalers\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read the specified HorizontalPodAutoscaler */
+        readAutoscalingV2beta2NamespacedHorizontalPodAutoscaler: <ResponseContentType extends ResponseContentType$readAutoscalingV2beta2NamespacedHorizontalPodAutoscaler>(params: Params$readAutoscalingV2beta2NamespacedHorizontalPodAutoscaler<ResponseContentType>, option?: RequestOption): Promise<Response$readAutoscalingV2beta2NamespacedHorizontalPodAutoscaler$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/autoscaling/v2beta2/namespaces/\${params.parameter.namespace}/horizontalpodautoscalers/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                exact: { value: params.parameter.exact, explode: false },
+                export: { value: params.parameter.export, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace the specified HorizontalPodAutoscaler */
+        replaceAutoscalingV2beta2NamespacedHorizontalPodAutoscaler: <ResponseContentType extends ResponseContentType$replaceAutoscalingV2beta2NamespacedHorizontalPodAutoscaler>(params: Params$replaceAutoscalingV2beta2NamespacedHorizontalPodAutoscaler<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceAutoscalingV2beta2NamespacedHorizontalPodAutoscaler$Status$200 | Response$replaceAutoscalingV2beta2NamespacedHorizontalPodAutoscaler$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/autoscaling/v2beta2/namespaces/\${params.parameter.namespace}/horizontalpodautoscalers/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete a HorizontalPodAutoscaler */
+        deleteAutoscalingV2beta2NamespacedHorizontalPodAutoscaler: <ResponseContentType extends ResponseContentType$deleteAutoscalingV2beta2NamespacedHorizontalPodAutoscaler>(params: Params$deleteAutoscalingV2beta2NamespacedHorizontalPodAutoscaler<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteAutoscalingV2beta2NamespacedHorizontalPodAutoscaler$Status$200 | Response$deleteAutoscalingV2beta2NamespacedHorizontalPodAutoscaler$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/autoscaling/v2beta2/namespaces/\${params.parameter.namespace}/horizontalpodautoscalers/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update the specified HorizontalPodAutoscaler */
+        patchAutoscalingV2beta2NamespacedHorizontalPodAutoscaler: <RequestContentType extends RequestContentType$patchAutoscalingV2beta2NamespacedHorizontalPodAutoscaler, ResponseContentType extends ResponseContentType$patchAutoscalingV2beta2NamespacedHorizontalPodAutoscaler>(params: Params$patchAutoscalingV2beta2NamespacedHorizontalPodAutoscaler<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchAutoscalingV2beta2NamespacedHorizontalPodAutoscaler$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/autoscaling/v2beta2/namespaces/\${params.parameter.namespace}/horizontalpodautoscalers/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read status of the specified HorizontalPodAutoscaler */
+        readAutoscalingV2beta2NamespacedHorizontalPodAutoscalerStatus: <ResponseContentType extends ResponseContentType$readAutoscalingV2beta2NamespacedHorizontalPodAutoscalerStatus>(params: Params$readAutoscalingV2beta2NamespacedHorizontalPodAutoscalerStatus<ResponseContentType>, option?: RequestOption): Promise<Response$readAutoscalingV2beta2NamespacedHorizontalPodAutoscalerStatus$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/autoscaling/v2beta2/namespaces/\${params.parameter.namespace}/horizontalpodautoscalers/\${params.parameter.name}/status\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace status of the specified HorizontalPodAutoscaler */
+        replaceAutoscalingV2beta2NamespacedHorizontalPodAutoscalerStatus: <ResponseContentType extends ResponseContentType$replaceAutoscalingV2beta2NamespacedHorizontalPodAutoscalerStatus>(params: Params$replaceAutoscalingV2beta2NamespacedHorizontalPodAutoscalerStatus<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceAutoscalingV2beta2NamespacedHorizontalPodAutoscalerStatus$Status$200 | Response$replaceAutoscalingV2beta2NamespacedHorizontalPodAutoscalerStatus$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/autoscaling/v2beta2/namespaces/\${params.parameter.namespace}/horizontalpodautoscalers/\${params.parameter.name}/status\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update status of the specified HorizontalPodAutoscaler */
+        patchAutoscalingV2beta2NamespacedHorizontalPodAutoscalerStatus: <RequestContentType extends RequestContentType$patchAutoscalingV2beta2NamespacedHorizontalPodAutoscalerStatus, ResponseContentType extends ResponseContentType$patchAutoscalingV2beta2NamespacedHorizontalPodAutoscalerStatus>(params: Params$patchAutoscalingV2beta2NamespacedHorizontalPodAutoscalerStatus<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchAutoscalingV2beta2NamespacedHorizontalPodAutoscalerStatus$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/autoscaling/v2beta2/namespaces/\${params.parameter.namespace}/horizontalpodautoscalers/\${params.parameter.name}/status\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** watch individual changes to a list of HorizontalPodAutoscaler. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchAutoscalingV2beta2HorizontalPodAutoscalerListForAllNamespaces: <ResponseContentType extends ResponseContentType$watchAutoscalingV2beta2HorizontalPodAutoscalerListForAllNamespaces>(params: Params$watchAutoscalingV2beta2HorizontalPodAutoscalerListForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$watchAutoscalingV2beta2HorizontalPodAutoscalerListForAllNamespaces$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/autoscaling/v2beta2/watch/horizontalpodautoscalers\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of HorizontalPodAutoscaler. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchAutoscalingV2beta2NamespacedHorizontalPodAutoscalerList: <ResponseContentType extends ResponseContentType$watchAutoscalingV2beta2NamespacedHorizontalPodAutoscalerList>(params: Params$watchAutoscalingV2beta2NamespacedHorizontalPodAutoscalerList<ResponseContentType>, option?: RequestOption): Promise<Response$watchAutoscalingV2beta2NamespacedHorizontalPodAutoscalerList$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/autoscaling/v2beta2/watch/namespaces/\${params.parameter.namespace}/horizontalpodautoscalers\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch changes to an object of kind HorizontalPodAutoscaler. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. */
+        watchAutoscalingV2beta2NamespacedHorizontalPodAutoscaler: <ResponseContentType extends ResponseContentType$watchAutoscalingV2beta2NamespacedHorizontalPodAutoscaler>(params: Params$watchAutoscalingV2beta2NamespacedHorizontalPodAutoscaler<ResponseContentType>, option?: RequestOption): Promise<Response$watchAutoscalingV2beta2NamespacedHorizontalPodAutoscaler$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/autoscaling/v2beta2/watch/namespaces/\${params.parameter.namespace}/horizontalpodautoscalers/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** get information of a group */
+        getBatchAPIGroup: <ResponseContentType extends ResponseContentType$getBatchAPIGroup>(params: Params$getBatchAPIGroup<ResponseContentType>, option?: RequestOption): Promise<Response$getBatchAPIGroup$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/batch/\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        /** get available resources */
+        getBatchV1APIResources: <ResponseContentType extends ResponseContentType$getBatchV1APIResources>(params: Params$getBatchV1APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getBatchV1APIResources$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/batch/v1/\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        /** list or watch objects of kind Job */
+        listBatchV1JobForAllNamespaces: <ResponseContentType extends ResponseContentType$listBatchV1JobForAllNamespaces>(params: Params$listBatchV1JobForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$listBatchV1JobForAllNamespaces$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/batch/v1/jobs\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** list or watch objects of kind Job */
+        listBatchV1NamespacedJob: <ResponseContentType extends ResponseContentType$listBatchV1NamespacedJob>(params: Params$listBatchV1NamespacedJob<ResponseContentType>, option?: RequestOption): Promise<Response$listBatchV1NamespacedJob$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/batch/v1/namespaces/\${params.parameter.namespace}/jobs\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** create a Job */
+        createBatchV1NamespacedJob: <ResponseContentType extends ResponseContentType$createBatchV1NamespacedJob>(params: Params$createBatchV1NamespacedJob<ResponseContentType>, option?: RequestOption): Promise<(Response$createBatchV1NamespacedJob$Status$200 | Response$createBatchV1NamespacedJob$Status$201 | Response$createBatchV1NamespacedJob$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/batch/v1/namespaces/\${params.parameter.namespace}/jobs\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete collection of Job */
+        deleteBatchV1CollectionNamespacedJob: <ResponseContentType extends ResponseContentType$deleteBatchV1CollectionNamespacedJob>(params: Params$deleteBatchV1CollectionNamespacedJob<ResponseContentType>, option?: RequestOption): Promise<Response$deleteBatchV1CollectionNamespacedJob$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/batch/v1/namespaces/\${params.parameter.namespace}/jobs\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read the specified Job */
+        readBatchV1NamespacedJob: <ResponseContentType extends ResponseContentType$readBatchV1NamespacedJob>(params: Params$readBatchV1NamespacedJob<ResponseContentType>, option?: RequestOption): Promise<Response$readBatchV1NamespacedJob$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/batch/v1/namespaces/\${params.parameter.namespace}/jobs/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                exact: { value: params.parameter.exact, explode: false },
+                export: { value: params.parameter.export, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace the specified Job */
+        replaceBatchV1NamespacedJob: <ResponseContentType extends ResponseContentType$replaceBatchV1NamespacedJob>(params: Params$replaceBatchV1NamespacedJob<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceBatchV1NamespacedJob$Status$200 | Response$replaceBatchV1NamespacedJob$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/batch/v1/namespaces/\${params.parameter.namespace}/jobs/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete a Job */
+        deleteBatchV1NamespacedJob: <ResponseContentType extends ResponseContentType$deleteBatchV1NamespacedJob>(params: Params$deleteBatchV1NamespacedJob<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteBatchV1NamespacedJob$Status$200 | Response$deleteBatchV1NamespacedJob$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/batch/v1/namespaces/\${params.parameter.namespace}/jobs/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update the specified Job */
+        patchBatchV1NamespacedJob: <RequestContentType extends RequestContentType$patchBatchV1NamespacedJob, ResponseContentType extends ResponseContentType$patchBatchV1NamespacedJob>(params: Params$patchBatchV1NamespacedJob<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchBatchV1NamespacedJob$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/batch/v1/namespaces/\${params.parameter.namespace}/jobs/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read status of the specified Job */
+        readBatchV1NamespacedJobStatus: <ResponseContentType extends ResponseContentType$readBatchV1NamespacedJobStatus>(params: Params$readBatchV1NamespacedJobStatus<ResponseContentType>, option?: RequestOption): Promise<Response$readBatchV1NamespacedJobStatus$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/batch/v1/namespaces/\${params.parameter.namespace}/jobs/\${params.parameter.name}/status\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace status of the specified Job */
+        replaceBatchV1NamespacedJobStatus: <ResponseContentType extends ResponseContentType$replaceBatchV1NamespacedJobStatus>(params: Params$replaceBatchV1NamespacedJobStatus<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceBatchV1NamespacedJobStatus$Status$200 | Response$replaceBatchV1NamespacedJobStatus$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/batch/v1/namespaces/\${params.parameter.namespace}/jobs/\${params.parameter.name}/status\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update status of the specified Job */
+        patchBatchV1NamespacedJobStatus: <RequestContentType extends RequestContentType$patchBatchV1NamespacedJobStatus, ResponseContentType extends ResponseContentType$patchBatchV1NamespacedJobStatus>(params: Params$patchBatchV1NamespacedJobStatus<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchBatchV1NamespacedJobStatus$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/batch/v1/namespaces/\${params.parameter.namespace}/jobs/\${params.parameter.name}/status\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** watch individual changes to a list of Job. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchBatchV1JobListForAllNamespaces: <ResponseContentType extends ResponseContentType$watchBatchV1JobListForAllNamespaces>(params: Params$watchBatchV1JobListForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$watchBatchV1JobListForAllNamespaces$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/batch/v1/watch/jobs\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of Job. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchBatchV1NamespacedJobList: <ResponseContentType extends ResponseContentType$watchBatchV1NamespacedJobList>(params: Params$watchBatchV1NamespacedJobList<ResponseContentType>, option?: RequestOption): Promise<Response$watchBatchV1NamespacedJobList$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/batch/v1/watch/namespaces/\${params.parameter.namespace}/jobs\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch changes to an object of kind Job. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. */
+        watchBatchV1NamespacedJob: <ResponseContentType extends ResponseContentType$watchBatchV1NamespacedJob>(params: Params$watchBatchV1NamespacedJob<ResponseContentType>, option?: RequestOption): Promise<Response$watchBatchV1NamespacedJob$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/batch/v1/watch/namespaces/\${params.parameter.namespace}/jobs/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** get available resources */
+        getBatchV1beta1APIResources: <ResponseContentType extends ResponseContentType$getBatchV1beta1APIResources>(params: Params$getBatchV1beta1APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getBatchV1beta1APIResources$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/batch/v1beta1/\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        /** list or watch objects of kind CronJob */
+        listBatchV1beta1CronJobForAllNamespaces: <ResponseContentType extends ResponseContentType$listBatchV1beta1CronJobForAllNamespaces>(params: Params$listBatchV1beta1CronJobForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$listBatchV1beta1CronJobForAllNamespaces$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/batch/v1beta1/cronjobs\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** list or watch objects of kind CronJob */
+        listBatchV1beta1NamespacedCronJob: <ResponseContentType extends ResponseContentType$listBatchV1beta1NamespacedCronJob>(params: Params$listBatchV1beta1NamespacedCronJob<ResponseContentType>, option?: RequestOption): Promise<Response$listBatchV1beta1NamespacedCronJob$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/batch/v1beta1/namespaces/\${params.parameter.namespace}/cronjobs\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** create a CronJob */
+        createBatchV1beta1NamespacedCronJob: <ResponseContentType extends ResponseContentType$createBatchV1beta1NamespacedCronJob>(params: Params$createBatchV1beta1NamespacedCronJob<ResponseContentType>, option?: RequestOption): Promise<(Response$createBatchV1beta1NamespacedCronJob$Status$200 | Response$createBatchV1beta1NamespacedCronJob$Status$201 | Response$createBatchV1beta1NamespacedCronJob$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/batch/v1beta1/namespaces/\${params.parameter.namespace}/cronjobs\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete collection of CronJob */
+        deleteBatchV1beta1CollectionNamespacedCronJob: <ResponseContentType extends ResponseContentType$deleteBatchV1beta1CollectionNamespacedCronJob>(params: Params$deleteBatchV1beta1CollectionNamespacedCronJob<ResponseContentType>, option?: RequestOption): Promise<Response$deleteBatchV1beta1CollectionNamespacedCronJob$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/batch/v1beta1/namespaces/\${params.parameter.namespace}/cronjobs\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read the specified CronJob */
+        readBatchV1beta1NamespacedCronJob: <ResponseContentType extends ResponseContentType$readBatchV1beta1NamespacedCronJob>(params: Params$readBatchV1beta1NamespacedCronJob<ResponseContentType>, option?: RequestOption): Promise<Response$readBatchV1beta1NamespacedCronJob$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/batch/v1beta1/namespaces/\${params.parameter.namespace}/cronjobs/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                exact: { value: params.parameter.exact, explode: false },
+                export: { value: params.parameter.export, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace the specified CronJob */
+        replaceBatchV1beta1NamespacedCronJob: <ResponseContentType extends ResponseContentType$replaceBatchV1beta1NamespacedCronJob>(params: Params$replaceBatchV1beta1NamespacedCronJob<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceBatchV1beta1NamespacedCronJob$Status$200 | Response$replaceBatchV1beta1NamespacedCronJob$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/batch/v1beta1/namespaces/\${params.parameter.namespace}/cronjobs/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete a CronJob */
+        deleteBatchV1beta1NamespacedCronJob: <ResponseContentType extends ResponseContentType$deleteBatchV1beta1NamespacedCronJob>(params: Params$deleteBatchV1beta1NamespacedCronJob<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteBatchV1beta1NamespacedCronJob$Status$200 | Response$deleteBatchV1beta1NamespacedCronJob$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/batch/v1beta1/namespaces/\${params.parameter.namespace}/cronjobs/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update the specified CronJob */
+        patchBatchV1beta1NamespacedCronJob: <RequestContentType extends RequestContentType$patchBatchV1beta1NamespacedCronJob, ResponseContentType extends ResponseContentType$patchBatchV1beta1NamespacedCronJob>(params: Params$patchBatchV1beta1NamespacedCronJob<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchBatchV1beta1NamespacedCronJob$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/batch/v1beta1/namespaces/\${params.parameter.namespace}/cronjobs/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read status of the specified CronJob */
+        readBatchV1beta1NamespacedCronJobStatus: <ResponseContentType extends ResponseContentType$readBatchV1beta1NamespacedCronJobStatus>(params: Params$readBatchV1beta1NamespacedCronJobStatus<ResponseContentType>, option?: RequestOption): Promise<Response$readBatchV1beta1NamespacedCronJobStatus$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/batch/v1beta1/namespaces/\${params.parameter.namespace}/cronjobs/\${params.parameter.name}/status\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace status of the specified CronJob */
+        replaceBatchV1beta1NamespacedCronJobStatus: <ResponseContentType extends ResponseContentType$replaceBatchV1beta1NamespacedCronJobStatus>(params: Params$replaceBatchV1beta1NamespacedCronJobStatus<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceBatchV1beta1NamespacedCronJobStatus$Status$200 | Response$replaceBatchV1beta1NamespacedCronJobStatus$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/batch/v1beta1/namespaces/\${params.parameter.namespace}/cronjobs/\${params.parameter.name}/status\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update status of the specified CronJob */
+        patchBatchV1beta1NamespacedCronJobStatus: <RequestContentType extends RequestContentType$patchBatchV1beta1NamespacedCronJobStatus, ResponseContentType extends ResponseContentType$patchBatchV1beta1NamespacedCronJobStatus>(params: Params$patchBatchV1beta1NamespacedCronJobStatus<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchBatchV1beta1NamespacedCronJobStatus$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/batch/v1beta1/namespaces/\${params.parameter.namespace}/cronjobs/\${params.parameter.name}/status\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** watch individual changes to a list of CronJob. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchBatchV1beta1CronJobListForAllNamespaces: <ResponseContentType extends ResponseContentType$watchBatchV1beta1CronJobListForAllNamespaces>(params: Params$watchBatchV1beta1CronJobListForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$watchBatchV1beta1CronJobListForAllNamespaces$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/batch/v1beta1/watch/cronjobs\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of CronJob. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchBatchV1beta1NamespacedCronJobList: <ResponseContentType extends ResponseContentType$watchBatchV1beta1NamespacedCronJobList>(params: Params$watchBatchV1beta1NamespacedCronJobList<ResponseContentType>, option?: RequestOption): Promise<Response$watchBatchV1beta1NamespacedCronJobList$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/batch/v1beta1/watch/namespaces/\${params.parameter.namespace}/cronjobs\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch changes to an object of kind CronJob. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. */
+        watchBatchV1beta1NamespacedCronJob: <ResponseContentType extends ResponseContentType$watchBatchV1beta1NamespacedCronJob>(params: Params$watchBatchV1beta1NamespacedCronJob<ResponseContentType>, option?: RequestOption): Promise<Response$watchBatchV1beta1NamespacedCronJob$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/batch/v1beta1/watch/namespaces/\${params.parameter.namespace}/cronjobs/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** get available resources */
+        getBatchV2alpha1APIResources: <ResponseContentType extends ResponseContentType$getBatchV2alpha1APIResources>(params: Params$getBatchV2alpha1APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getBatchV2alpha1APIResources$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/batch/v2alpha1/\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        /** list or watch objects of kind CronJob */
+        listBatchV2alpha1CronJobForAllNamespaces: <ResponseContentType extends ResponseContentType$listBatchV2alpha1CronJobForAllNamespaces>(params: Params$listBatchV2alpha1CronJobForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$listBatchV2alpha1CronJobForAllNamespaces$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/batch/v2alpha1/cronjobs\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** list or watch objects of kind CronJob */
+        listBatchV2alpha1NamespacedCronJob: <ResponseContentType extends ResponseContentType$listBatchV2alpha1NamespacedCronJob>(params: Params$listBatchV2alpha1NamespacedCronJob<ResponseContentType>, option?: RequestOption): Promise<Response$listBatchV2alpha1NamespacedCronJob$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/batch/v2alpha1/namespaces/\${params.parameter.namespace}/cronjobs\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** create a CronJob */
+        createBatchV2alpha1NamespacedCronJob: <ResponseContentType extends ResponseContentType$createBatchV2alpha1NamespacedCronJob>(params: Params$createBatchV2alpha1NamespacedCronJob<ResponseContentType>, option?: RequestOption): Promise<(Response$createBatchV2alpha1NamespacedCronJob$Status$200 | Response$createBatchV2alpha1NamespacedCronJob$Status$201 | Response$createBatchV2alpha1NamespacedCronJob$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/batch/v2alpha1/namespaces/\${params.parameter.namespace}/cronjobs\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete collection of CronJob */
+        deleteBatchV2alpha1CollectionNamespacedCronJob: <ResponseContentType extends ResponseContentType$deleteBatchV2alpha1CollectionNamespacedCronJob>(params: Params$deleteBatchV2alpha1CollectionNamespacedCronJob<ResponseContentType>, option?: RequestOption): Promise<Response$deleteBatchV2alpha1CollectionNamespacedCronJob$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/batch/v2alpha1/namespaces/\${params.parameter.namespace}/cronjobs\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read the specified CronJob */
+        readBatchV2alpha1NamespacedCronJob: <ResponseContentType extends ResponseContentType$readBatchV2alpha1NamespacedCronJob>(params: Params$readBatchV2alpha1NamespacedCronJob<ResponseContentType>, option?: RequestOption): Promise<Response$readBatchV2alpha1NamespacedCronJob$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/batch/v2alpha1/namespaces/\${params.parameter.namespace}/cronjobs/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                exact: { value: params.parameter.exact, explode: false },
+                export: { value: params.parameter.export, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace the specified CronJob */
+        replaceBatchV2alpha1NamespacedCronJob: <ResponseContentType extends ResponseContentType$replaceBatchV2alpha1NamespacedCronJob>(params: Params$replaceBatchV2alpha1NamespacedCronJob<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceBatchV2alpha1NamespacedCronJob$Status$200 | Response$replaceBatchV2alpha1NamespacedCronJob$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/batch/v2alpha1/namespaces/\${params.parameter.namespace}/cronjobs/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete a CronJob */
+        deleteBatchV2alpha1NamespacedCronJob: <ResponseContentType extends ResponseContentType$deleteBatchV2alpha1NamespacedCronJob>(params: Params$deleteBatchV2alpha1NamespacedCronJob<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteBatchV2alpha1NamespacedCronJob$Status$200 | Response$deleteBatchV2alpha1NamespacedCronJob$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/batch/v2alpha1/namespaces/\${params.parameter.namespace}/cronjobs/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update the specified CronJob */
+        patchBatchV2alpha1NamespacedCronJob: <RequestContentType extends RequestContentType$patchBatchV2alpha1NamespacedCronJob, ResponseContentType extends ResponseContentType$patchBatchV2alpha1NamespacedCronJob>(params: Params$patchBatchV2alpha1NamespacedCronJob<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchBatchV2alpha1NamespacedCronJob$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/batch/v2alpha1/namespaces/\${params.parameter.namespace}/cronjobs/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read status of the specified CronJob */
+        readBatchV2alpha1NamespacedCronJobStatus: <ResponseContentType extends ResponseContentType$readBatchV2alpha1NamespacedCronJobStatus>(params: Params$readBatchV2alpha1NamespacedCronJobStatus<ResponseContentType>, option?: RequestOption): Promise<Response$readBatchV2alpha1NamespacedCronJobStatus$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/batch/v2alpha1/namespaces/\${params.parameter.namespace}/cronjobs/\${params.parameter.name}/status\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace status of the specified CronJob */
+        replaceBatchV2alpha1NamespacedCronJobStatus: <ResponseContentType extends ResponseContentType$replaceBatchV2alpha1NamespacedCronJobStatus>(params: Params$replaceBatchV2alpha1NamespacedCronJobStatus<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceBatchV2alpha1NamespacedCronJobStatus$Status$200 | Response$replaceBatchV2alpha1NamespacedCronJobStatus$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/batch/v2alpha1/namespaces/\${params.parameter.namespace}/cronjobs/\${params.parameter.name}/status\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update status of the specified CronJob */
+        patchBatchV2alpha1NamespacedCronJobStatus: <RequestContentType extends RequestContentType$patchBatchV2alpha1NamespacedCronJobStatus, ResponseContentType extends ResponseContentType$patchBatchV2alpha1NamespacedCronJobStatus>(params: Params$patchBatchV2alpha1NamespacedCronJobStatus<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchBatchV2alpha1NamespacedCronJobStatus$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/batch/v2alpha1/namespaces/\${params.parameter.namespace}/cronjobs/\${params.parameter.name}/status\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** watch individual changes to a list of CronJob. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchBatchV2alpha1CronJobListForAllNamespaces: <ResponseContentType extends ResponseContentType$watchBatchV2alpha1CronJobListForAllNamespaces>(params: Params$watchBatchV2alpha1CronJobListForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$watchBatchV2alpha1CronJobListForAllNamespaces$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/batch/v2alpha1/watch/cronjobs\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of CronJob. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchBatchV2alpha1NamespacedCronJobList: <ResponseContentType extends ResponseContentType$watchBatchV2alpha1NamespacedCronJobList>(params: Params$watchBatchV2alpha1NamespacedCronJobList<ResponseContentType>, option?: RequestOption): Promise<Response$watchBatchV2alpha1NamespacedCronJobList$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/batch/v2alpha1/watch/namespaces/\${params.parameter.namespace}/cronjobs\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch changes to an object of kind CronJob. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. */
+        watchBatchV2alpha1NamespacedCronJob: <ResponseContentType extends ResponseContentType$watchBatchV2alpha1NamespacedCronJob>(params: Params$watchBatchV2alpha1NamespacedCronJob<ResponseContentType>, option?: RequestOption): Promise<Response$watchBatchV2alpha1NamespacedCronJob$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/batch/v2alpha1/watch/namespaces/\${params.parameter.namespace}/cronjobs/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** get information of a group */
+        getCertificatesAPIGroup: <ResponseContentType extends ResponseContentType$getCertificatesAPIGroup>(params: Params$getCertificatesAPIGroup<ResponseContentType>, option?: RequestOption): Promise<Response$getCertificatesAPIGroup$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/certificates.k8s.io/\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        /** get available resources */
+        getCertificatesV1beta1APIResources: <ResponseContentType extends ResponseContentType$getCertificatesV1beta1APIResources>(params: Params$getCertificatesV1beta1APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getCertificatesV1beta1APIResources$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/certificates.k8s.io/v1beta1/\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        /** list or watch objects of kind CertificateSigningRequest */
+        listCertificatesV1beta1CertificateSigningRequest: <ResponseContentType extends ResponseContentType$listCertificatesV1beta1CertificateSigningRequest>(params: Params$listCertificatesV1beta1CertificateSigningRequest<ResponseContentType>, option?: RequestOption): Promise<Response$listCertificatesV1beta1CertificateSigningRequest$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/certificates.k8s.io/v1beta1/certificatesigningrequests\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** create a CertificateSigningRequest */
+        createCertificatesV1beta1CertificateSigningRequest: <ResponseContentType extends ResponseContentType$createCertificatesV1beta1CertificateSigningRequest>(params: Params$createCertificatesV1beta1CertificateSigningRequest<ResponseContentType>, option?: RequestOption): Promise<(Response$createCertificatesV1beta1CertificateSigningRequest$Status$200 | Response$createCertificatesV1beta1CertificateSigningRequest$Status$201 | Response$createCertificatesV1beta1CertificateSigningRequest$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/certificates.k8s.io/v1beta1/certificatesigningrequests\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete collection of CertificateSigningRequest */
+        deleteCertificatesV1beta1CollectionCertificateSigningRequest: <ResponseContentType extends ResponseContentType$deleteCertificatesV1beta1CollectionCertificateSigningRequest>(params: Params$deleteCertificatesV1beta1CollectionCertificateSigningRequest<ResponseContentType>, option?: RequestOption): Promise<Response$deleteCertificatesV1beta1CollectionCertificateSigningRequest$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/certificates.k8s.io/v1beta1/certificatesigningrequests\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read the specified CertificateSigningRequest */
+        readCertificatesV1beta1CertificateSigningRequest: <ResponseContentType extends ResponseContentType$readCertificatesV1beta1CertificateSigningRequest>(params: Params$readCertificatesV1beta1CertificateSigningRequest<ResponseContentType>, option?: RequestOption): Promise<Response$readCertificatesV1beta1CertificateSigningRequest$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/certificates.k8s.io/v1beta1/certificatesigningrequests/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                exact: { value: params.parameter.exact, explode: false },
+                export: { value: params.parameter.export, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace the specified CertificateSigningRequest */
+        replaceCertificatesV1beta1CertificateSigningRequest: <ResponseContentType extends ResponseContentType$replaceCertificatesV1beta1CertificateSigningRequest>(params: Params$replaceCertificatesV1beta1CertificateSigningRequest<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceCertificatesV1beta1CertificateSigningRequest$Status$200 | Response$replaceCertificatesV1beta1CertificateSigningRequest$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/certificates.k8s.io/v1beta1/certificatesigningrequests/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete a CertificateSigningRequest */
+        deleteCertificatesV1beta1CertificateSigningRequest: <ResponseContentType extends ResponseContentType$deleteCertificatesV1beta1CertificateSigningRequest>(params: Params$deleteCertificatesV1beta1CertificateSigningRequest<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteCertificatesV1beta1CertificateSigningRequest$Status$200 | Response$deleteCertificatesV1beta1CertificateSigningRequest$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/certificates.k8s.io/v1beta1/certificatesigningrequests/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update the specified CertificateSigningRequest */
+        patchCertificatesV1beta1CertificateSigningRequest: <RequestContentType extends RequestContentType$patchCertificatesV1beta1CertificateSigningRequest, ResponseContentType extends ResponseContentType$patchCertificatesV1beta1CertificateSigningRequest>(params: Params$patchCertificatesV1beta1CertificateSigningRequest<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchCertificatesV1beta1CertificateSigningRequest$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/certificates.k8s.io/v1beta1/certificatesigningrequests/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** replace approval of the specified CertificateSigningRequest */
+        replaceCertificatesV1beta1CertificateSigningRequestApproval: <ResponseContentType extends ResponseContentType$replaceCertificatesV1beta1CertificateSigningRequestApproval>(params: Params$replaceCertificatesV1beta1CertificateSigningRequestApproval<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceCertificatesV1beta1CertificateSigningRequestApproval$Status$200 | Response$replaceCertificatesV1beta1CertificateSigningRequestApproval$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/certificates.k8s.io/v1beta1/certificatesigningrequests/\${params.parameter.name}/approval\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read status of the specified CertificateSigningRequest */
+        readCertificatesV1beta1CertificateSigningRequestStatus: <ResponseContentType extends ResponseContentType$readCertificatesV1beta1CertificateSigningRequestStatus>(params: Params$readCertificatesV1beta1CertificateSigningRequestStatus<ResponseContentType>, option?: RequestOption): Promise<Response$readCertificatesV1beta1CertificateSigningRequestStatus$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/certificates.k8s.io/v1beta1/certificatesigningrequests/\${params.parameter.name}/status\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace status of the specified CertificateSigningRequest */
+        replaceCertificatesV1beta1CertificateSigningRequestStatus: <ResponseContentType extends ResponseContentType$replaceCertificatesV1beta1CertificateSigningRequestStatus>(params: Params$replaceCertificatesV1beta1CertificateSigningRequestStatus<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceCertificatesV1beta1CertificateSigningRequestStatus$Status$200 | Response$replaceCertificatesV1beta1CertificateSigningRequestStatus$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/certificates.k8s.io/v1beta1/certificatesigningrequests/\${params.parameter.name}/status\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update status of the specified CertificateSigningRequest */
+        patchCertificatesV1beta1CertificateSigningRequestStatus: <RequestContentType extends RequestContentType$patchCertificatesV1beta1CertificateSigningRequestStatus, ResponseContentType extends ResponseContentType$patchCertificatesV1beta1CertificateSigningRequestStatus>(params: Params$patchCertificatesV1beta1CertificateSigningRequestStatus<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchCertificatesV1beta1CertificateSigningRequestStatus$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/certificates.k8s.io/v1beta1/certificatesigningrequests/\${params.parameter.name}/status\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** watch individual changes to a list of CertificateSigningRequest. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchCertificatesV1beta1CertificateSigningRequestList: <ResponseContentType extends ResponseContentType$watchCertificatesV1beta1CertificateSigningRequestList>(params: Params$watchCertificatesV1beta1CertificateSigningRequestList<ResponseContentType>, option?: RequestOption): Promise<Response$watchCertificatesV1beta1CertificateSigningRequestList$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/certificates.k8s.io/v1beta1/watch/certificatesigningrequests\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch changes to an object of kind CertificateSigningRequest. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. */
+        watchCertificatesV1beta1CertificateSigningRequest: <ResponseContentType extends ResponseContentType$watchCertificatesV1beta1CertificateSigningRequest>(params: Params$watchCertificatesV1beta1CertificateSigningRequest<ResponseContentType>, option?: RequestOption): Promise<Response$watchCertificatesV1beta1CertificateSigningRequest$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/certificates.k8s.io/v1beta1/watch/certificatesigningrequests/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** get information of a group */
+        getCoordinationAPIGroup: <ResponseContentType extends ResponseContentType$getCoordinationAPIGroup>(params: Params$getCoordinationAPIGroup<ResponseContentType>, option?: RequestOption): Promise<Response$getCoordinationAPIGroup$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/coordination.k8s.io/\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        /** get available resources */
+        getCoordinationV1APIResources: <ResponseContentType extends ResponseContentType$getCoordinationV1APIResources>(params: Params$getCoordinationV1APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getCoordinationV1APIResources$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/coordination.k8s.io/v1/\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        /** list or watch objects of kind Lease */
+        listCoordinationV1LeaseForAllNamespaces: <ResponseContentType extends ResponseContentType$listCoordinationV1LeaseForAllNamespaces>(params: Params$listCoordinationV1LeaseForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$listCoordinationV1LeaseForAllNamespaces$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/coordination.k8s.io/v1/leases\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** list or watch objects of kind Lease */
+        listCoordinationV1NamespacedLease: <ResponseContentType extends ResponseContentType$listCoordinationV1NamespacedLease>(params: Params$listCoordinationV1NamespacedLease<ResponseContentType>, option?: RequestOption): Promise<Response$listCoordinationV1NamespacedLease$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/coordination.k8s.io/v1/namespaces/\${params.parameter.namespace}/leases\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** create a Lease */
+        createCoordinationV1NamespacedLease: <ResponseContentType extends ResponseContentType$createCoordinationV1NamespacedLease>(params: Params$createCoordinationV1NamespacedLease<ResponseContentType>, option?: RequestOption): Promise<(Response$createCoordinationV1NamespacedLease$Status$200 | Response$createCoordinationV1NamespacedLease$Status$201 | Response$createCoordinationV1NamespacedLease$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/coordination.k8s.io/v1/namespaces/\${params.parameter.namespace}/leases\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete collection of Lease */
+        deleteCoordinationV1CollectionNamespacedLease: <ResponseContentType extends ResponseContentType$deleteCoordinationV1CollectionNamespacedLease>(params: Params$deleteCoordinationV1CollectionNamespacedLease<ResponseContentType>, option?: RequestOption): Promise<Response$deleteCoordinationV1CollectionNamespacedLease$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/coordination.k8s.io/v1/namespaces/\${params.parameter.namespace}/leases\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read the specified Lease */
+        readCoordinationV1NamespacedLease: <ResponseContentType extends ResponseContentType$readCoordinationV1NamespacedLease>(params: Params$readCoordinationV1NamespacedLease<ResponseContentType>, option?: RequestOption): Promise<Response$readCoordinationV1NamespacedLease$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/coordination.k8s.io/v1/namespaces/\${params.parameter.namespace}/leases/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                exact: { value: params.parameter.exact, explode: false },
+                export: { value: params.parameter.export, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace the specified Lease */
+        replaceCoordinationV1NamespacedLease: <ResponseContentType extends ResponseContentType$replaceCoordinationV1NamespacedLease>(params: Params$replaceCoordinationV1NamespacedLease<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceCoordinationV1NamespacedLease$Status$200 | Response$replaceCoordinationV1NamespacedLease$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/coordination.k8s.io/v1/namespaces/\${params.parameter.namespace}/leases/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete a Lease */
+        deleteCoordinationV1NamespacedLease: <ResponseContentType extends ResponseContentType$deleteCoordinationV1NamespacedLease>(params: Params$deleteCoordinationV1NamespacedLease<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteCoordinationV1NamespacedLease$Status$200 | Response$deleteCoordinationV1NamespacedLease$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/coordination.k8s.io/v1/namespaces/\${params.parameter.namespace}/leases/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update the specified Lease */
+        patchCoordinationV1NamespacedLease: <RequestContentType extends RequestContentType$patchCoordinationV1NamespacedLease, ResponseContentType extends ResponseContentType$patchCoordinationV1NamespacedLease>(params: Params$patchCoordinationV1NamespacedLease<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchCoordinationV1NamespacedLease$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/coordination.k8s.io/v1/namespaces/\${params.parameter.namespace}/leases/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** watch individual changes to a list of Lease. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchCoordinationV1LeaseListForAllNamespaces: <ResponseContentType extends ResponseContentType$watchCoordinationV1LeaseListForAllNamespaces>(params: Params$watchCoordinationV1LeaseListForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoordinationV1LeaseListForAllNamespaces$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/coordination.k8s.io/v1/watch/leases\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of Lease. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchCoordinationV1NamespacedLeaseList: <ResponseContentType extends ResponseContentType$watchCoordinationV1NamespacedLeaseList>(params: Params$watchCoordinationV1NamespacedLeaseList<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoordinationV1NamespacedLeaseList$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/coordination.k8s.io/v1/watch/namespaces/\${params.parameter.namespace}/leases\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch changes to an object of kind Lease. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. */
+        watchCoordinationV1NamespacedLease: <ResponseContentType extends ResponseContentType$watchCoordinationV1NamespacedLease>(params: Params$watchCoordinationV1NamespacedLease<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoordinationV1NamespacedLease$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/coordination.k8s.io/v1/watch/namespaces/\${params.parameter.namespace}/leases/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** get available resources */
+        getCoordinationV1beta1APIResources: <ResponseContentType extends ResponseContentType$getCoordinationV1beta1APIResources>(params: Params$getCoordinationV1beta1APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getCoordinationV1beta1APIResources$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/coordination.k8s.io/v1beta1/\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        /** list or watch objects of kind Lease */
+        listCoordinationV1beta1LeaseForAllNamespaces: <ResponseContentType extends ResponseContentType$listCoordinationV1beta1LeaseForAllNamespaces>(params: Params$listCoordinationV1beta1LeaseForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$listCoordinationV1beta1LeaseForAllNamespaces$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/coordination.k8s.io/v1beta1/leases\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** list or watch objects of kind Lease */
+        listCoordinationV1beta1NamespacedLease: <ResponseContentType extends ResponseContentType$listCoordinationV1beta1NamespacedLease>(params: Params$listCoordinationV1beta1NamespacedLease<ResponseContentType>, option?: RequestOption): Promise<Response$listCoordinationV1beta1NamespacedLease$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/coordination.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/leases\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** create a Lease */
+        createCoordinationV1beta1NamespacedLease: <ResponseContentType extends ResponseContentType$createCoordinationV1beta1NamespacedLease>(params: Params$createCoordinationV1beta1NamespacedLease<ResponseContentType>, option?: RequestOption): Promise<(Response$createCoordinationV1beta1NamespacedLease$Status$200 | Response$createCoordinationV1beta1NamespacedLease$Status$201 | Response$createCoordinationV1beta1NamespacedLease$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/coordination.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/leases\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete collection of Lease */
+        deleteCoordinationV1beta1CollectionNamespacedLease: <ResponseContentType extends ResponseContentType$deleteCoordinationV1beta1CollectionNamespacedLease>(params: Params$deleteCoordinationV1beta1CollectionNamespacedLease<ResponseContentType>, option?: RequestOption): Promise<Response$deleteCoordinationV1beta1CollectionNamespacedLease$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/coordination.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/leases\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read the specified Lease */
+        readCoordinationV1beta1NamespacedLease: <ResponseContentType extends ResponseContentType$readCoordinationV1beta1NamespacedLease>(params: Params$readCoordinationV1beta1NamespacedLease<ResponseContentType>, option?: RequestOption): Promise<Response$readCoordinationV1beta1NamespacedLease$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/coordination.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/leases/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                exact: { value: params.parameter.exact, explode: false },
+                export: { value: params.parameter.export, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace the specified Lease */
+        replaceCoordinationV1beta1NamespacedLease: <ResponseContentType extends ResponseContentType$replaceCoordinationV1beta1NamespacedLease>(params: Params$replaceCoordinationV1beta1NamespacedLease<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceCoordinationV1beta1NamespacedLease$Status$200 | Response$replaceCoordinationV1beta1NamespacedLease$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/coordination.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/leases/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete a Lease */
+        deleteCoordinationV1beta1NamespacedLease: <ResponseContentType extends ResponseContentType$deleteCoordinationV1beta1NamespacedLease>(params: Params$deleteCoordinationV1beta1NamespacedLease<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteCoordinationV1beta1NamespacedLease$Status$200 | Response$deleteCoordinationV1beta1NamespacedLease$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/coordination.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/leases/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update the specified Lease */
+        patchCoordinationV1beta1NamespacedLease: <RequestContentType extends RequestContentType$patchCoordinationV1beta1NamespacedLease, ResponseContentType extends ResponseContentType$patchCoordinationV1beta1NamespacedLease>(params: Params$patchCoordinationV1beta1NamespacedLease<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchCoordinationV1beta1NamespacedLease$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/coordination.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/leases/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** watch individual changes to a list of Lease. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchCoordinationV1beta1LeaseListForAllNamespaces: <ResponseContentType extends ResponseContentType$watchCoordinationV1beta1LeaseListForAllNamespaces>(params: Params$watchCoordinationV1beta1LeaseListForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoordinationV1beta1LeaseListForAllNamespaces$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/coordination.k8s.io/v1beta1/watch/leases\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of Lease. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchCoordinationV1beta1NamespacedLeaseList: <ResponseContentType extends ResponseContentType$watchCoordinationV1beta1NamespacedLeaseList>(params: Params$watchCoordinationV1beta1NamespacedLeaseList<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoordinationV1beta1NamespacedLeaseList$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/coordination.k8s.io/v1beta1/watch/namespaces/\${params.parameter.namespace}/leases\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch changes to an object of kind Lease. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. */
+        watchCoordinationV1beta1NamespacedLease: <ResponseContentType extends ResponseContentType$watchCoordinationV1beta1NamespacedLease>(params: Params$watchCoordinationV1beta1NamespacedLease<ResponseContentType>, option?: RequestOption): Promise<Response$watchCoordinationV1beta1NamespacedLease$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/coordination.k8s.io/v1beta1/watch/namespaces/\${params.parameter.namespace}/leases/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** get information of a group */
+        getDiscoveryAPIGroup: <ResponseContentType extends ResponseContentType$getDiscoveryAPIGroup>(params: Params$getDiscoveryAPIGroup<ResponseContentType>, option?: RequestOption): Promise<Response$getDiscoveryAPIGroup$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/discovery.k8s.io/\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        /** get available resources */
+        getDiscoveryV1beta1APIResources: <ResponseContentType extends ResponseContentType$getDiscoveryV1beta1APIResources>(params: Params$getDiscoveryV1beta1APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getDiscoveryV1beta1APIResources$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/discovery.k8s.io/v1beta1/\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        /** list or watch objects of kind EndpointSlice */
+        listDiscoveryV1beta1EndpointSliceForAllNamespaces: <ResponseContentType extends ResponseContentType$listDiscoveryV1beta1EndpointSliceForAllNamespaces>(params: Params$listDiscoveryV1beta1EndpointSliceForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$listDiscoveryV1beta1EndpointSliceForAllNamespaces$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/discovery.k8s.io/v1beta1/endpointslices\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** list or watch objects of kind EndpointSlice */
+        listDiscoveryV1beta1NamespacedEndpointSlice: <ResponseContentType extends ResponseContentType$listDiscoveryV1beta1NamespacedEndpointSlice>(params: Params$listDiscoveryV1beta1NamespacedEndpointSlice<ResponseContentType>, option?: RequestOption): Promise<Response$listDiscoveryV1beta1NamespacedEndpointSlice$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/discovery.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/endpointslices\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** create an EndpointSlice */
+        createDiscoveryV1beta1NamespacedEndpointSlice: <ResponseContentType extends ResponseContentType$createDiscoveryV1beta1NamespacedEndpointSlice>(params: Params$createDiscoveryV1beta1NamespacedEndpointSlice<ResponseContentType>, option?: RequestOption): Promise<(Response$createDiscoveryV1beta1NamespacedEndpointSlice$Status$200 | Response$createDiscoveryV1beta1NamespacedEndpointSlice$Status$201 | Response$createDiscoveryV1beta1NamespacedEndpointSlice$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/discovery.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/endpointslices\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete collection of EndpointSlice */
+        deleteDiscoveryV1beta1CollectionNamespacedEndpointSlice: <ResponseContentType extends ResponseContentType$deleteDiscoveryV1beta1CollectionNamespacedEndpointSlice>(params: Params$deleteDiscoveryV1beta1CollectionNamespacedEndpointSlice<ResponseContentType>, option?: RequestOption): Promise<Response$deleteDiscoveryV1beta1CollectionNamespacedEndpointSlice$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/discovery.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/endpointslices\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read the specified EndpointSlice */
+        readDiscoveryV1beta1NamespacedEndpointSlice: <ResponseContentType extends ResponseContentType$readDiscoveryV1beta1NamespacedEndpointSlice>(params: Params$readDiscoveryV1beta1NamespacedEndpointSlice<ResponseContentType>, option?: RequestOption): Promise<Response$readDiscoveryV1beta1NamespacedEndpointSlice$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/discovery.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/endpointslices/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                exact: { value: params.parameter.exact, explode: false },
+                export: { value: params.parameter.export, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace the specified EndpointSlice */
+        replaceDiscoveryV1beta1NamespacedEndpointSlice: <ResponseContentType extends ResponseContentType$replaceDiscoveryV1beta1NamespacedEndpointSlice>(params: Params$replaceDiscoveryV1beta1NamespacedEndpointSlice<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceDiscoveryV1beta1NamespacedEndpointSlice$Status$200 | Response$replaceDiscoveryV1beta1NamespacedEndpointSlice$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/discovery.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/endpointslices/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete an EndpointSlice */
+        deleteDiscoveryV1beta1NamespacedEndpointSlice: <ResponseContentType extends ResponseContentType$deleteDiscoveryV1beta1NamespacedEndpointSlice>(params: Params$deleteDiscoveryV1beta1NamespacedEndpointSlice<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteDiscoveryV1beta1NamespacedEndpointSlice$Status$200 | Response$deleteDiscoveryV1beta1NamespacedEndpointSlice$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/discovery.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/endpointslices/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update the specified EndpointSlice */
+        patchDiscoveryV1beta1NamespacedEndpointSlice: <RequestContentType extends RequestContentType$patchDiscoveryV1beta1NamespacedEndpointSlice, ResponseContentType extends ResponseContentType$patchDiscoveryV1beta1NamespacedEndpointSlice>(params: Params$patchDiscoveryV1beta1NamespacedEndpointSlice<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchDiscoveryV1beta1NamespacedEndpointSlice$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/discovery.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/endpointslices/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** watch individual changes to a list of EndpointSlice. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchDiscoveryV1beta1EndpointSliceListForAllNamespaces: <ResponseContentType extends ResponseContentType$watchDiscoveryV1beta1EndpointSliceListForAllNamespaces>(params: Params$watchDiscoveryV1beta1EndpointSliceListForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$watchDiscoveryV1beta1EndpointSliceListForAllNamespaces$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/discovery.k8s.io/v1beta1/watch/endpointslices\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of EndpointSlice. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchDiscoveryV1beta1NamespacedEndpointSliceList: <ResponseContentType extends ResponseContentType$watchDiscoveryV1beta1NamespacedEndpointSliceList>(params: Params$watchDiscoveryV1beta1NamespacedEndpointSliceList<ResponseContentType>, option?: RequestOption): Promise<Response$watchDiscoveryV1beta1NamespacedEndpointSliceList$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/discovery.k8s.io/v1beta1/watch/namespaces/\${params.parameter.namespace}/endpointslices\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch changes to an object of kind EndpointSlice. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. */
+        watchDiscoveryV1beta1NamespacedEndpointSlice: <ResponseContentType extends ResponseContentType$watchDiscoveryV1beta1NamespacedEndpointSlice>(params: Params$watchDiscoveryV1beta1NamespacedEndpointSlice<ResponseContentType>, option?: RequestOption): Promise<Response$watchDiscoveryV1beta1NamespacedEndpointSlice$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/discovery.k8s.io/v1beta1/watch/namespaces/\${params.parameter.namespace}/endpointslices/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** get information of a group */
+        getEventsAPIGroup: <ResponseContentType extends ResponseContentType$getEventsAPIGroup>(params: Params$getEventsAPIGroup<ResponseContentType>, option?: RequestOption): Promise<Response$getEventsAPIGroup$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/events.k8s.io/\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        /** get available resources */
+        getEventsV1beta1APIResources: <ResponseContentType extends ResponseContentType$getEventsV1beta1APIResources>(params: Params$getEventsV1beta1APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getEventsV1beta1APIResources$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/events.k8s.io/v1beta1/\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        /** list or watch objects of kind Event */
+        listEventsV1beta1EventForAllNamespaces: <ResponseContentType extends ResponseContentType$listEventsV1beta1EventForAllNamespaces>(params: Params$listEventsV1beta1EventForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$listEventsV1beta1EventForAllNamespaces$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/events.k8s.io/v1beta1/events\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** list or watch objects of kind Event */
+        listEventsV1beta1NamespacedEvent: <ResponseContentType extends ResponseContentType$listEventsV1beta1NamespacedEvent>(params: Params$listEventsV1beta1NamespacedEvent<ResponseContentType>, option?: RequestOption): Promise<Response$listEventsV1beta1NamespacedEvent$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/events.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/events\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** create an Event */
+        createEventsV1beta1NamespacedEvent: <ResponseContentType extends ResponseContentType$createEventsV1beta1NamespacedEvent>(params: Params$createEventsV1beta1NamespacedEvent<ResponseContentType>, option?: RequestOption): Promise<(Response$createEventsV1beta1NamespacedEvent$Status$200 | Response$createEventsV1beta1NamespacedEvent$Status$201 | Response$createEventsV1beta1NamespacedEvent$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/events.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/events\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete collection of Event */
+        deleteEventsV1beta1CollectionNamespacedEvent: <ResponseContentType extends ResponseContentType$deleteEventsV1beta1CollectionNamespacedEvent>(params: Params$deleteEventsV1beta1CollectionNamespacedEvent<ResponseContentType>, option?: RequestOption): Promise<Response$deleteEventsV1beta1CollectionNamespacedEvent$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/events.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/events\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read the specified Event */
+        readEventsV1beta1NamespacedEvent: <ResponseContentType extends ResponseContentType$readEventsV1beta1NamespacedEvent>(params: Params$readEventsV1beta1NamespacedEvent<ResponseContentType>, option?: RequestOption): Promise<Response$readEventsV1beta1NamespacedEvent$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/events.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/events/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                exact: { value: params.parameter.exact, explode: false },
+                export: { value: params.parameter.export, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace the specified Event */
+        replaceEventsV1beta1NamespacedEvent: <ResponseContentType extends ResponseContentType$replaceEventsV1beta1NamespacedEvent>(params: Params$replaceEventsV1beta1NamespacedEvent<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceEventsV1beta1NamespacedEvent$Status$200 | Response$replaceEventsV1beta1NamespacedEvent$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/events.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/events/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete an Event */
+        deleteEventsV1beta1NamespacedEvent: <ResponseContentType extends ResponseContentType$deleteEventsV1beta1NamespacedEvent>(params: Params$deleteEventsV1beta1NamespacedEvent<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteEventsV1beta1NamespacedEvent$Status$200 | Response$deleteEventsV1beta1NamespacedEvent$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/events.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/events/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update the specified Event */
+        patchEventsV1beta1NamespacedEvent: <RequestContentType extends RequestContentType$patchEventsV1beta1NamespacedEvent, ResponseContentType extends ResponseContentType$patchEventsV1beta1NamespacedEvent>(params: Params$patchEventsV1beta1NamespacedEvent<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchEventsV1beta1NamespacedEvent$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/events.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/events/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** watch individual changes to a list of Event. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchEventsV1beta1EventListForAllNamespaces: <ResponseContentType extends ResponseContentType$watchEventsV1beta1EventListForAllNamespaces>(params: Params$watchEventsV1beta1EventListForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$watchEventsV1beta1EventListForAllNamespaces$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/events.k8s.io/v1beta1/watch/events\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of Event. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchEventsV1beta1NamespacedEventList: <ResponseContentType extends ResponseContentType$watchEventsV1beta1NamespacedEventList>(params: Params$watchEventsV1beta1NamespacedEventList<ResponseContentType>, option?: RequestOption): Promise<Response$watchEventsV1beta1NamespacedEventList$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/events.k8s.io/v1beta1/watch/namespaces/\${params.parameter.namespace}/events\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** 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. */
+        watchEventsV1beta1NamespacedEvent: <ResponseContentType extends ResponseContentType$watchEventsV1beta1NamespacedEvent>(params: Params$watchEventsV1beta1NamespacedEvent<ResponseContentType>, option?: RequestOption): Promise<Response$watchEventsV1beta1NamespacedEvent$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/events.k8s.io/v1beta1/watch/namespaces/\${params.parameter.namespace}/events/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** get information of a group */
+        getExtensionsAPIGroup: <ResponseContentType extends ResponseContentType$getExtensionsAPIGroup>(params: Params$getExtensionsAPIGroup<ResponseContentType>, option?: RequestOption): Promise<Response$getExtensionsAPIGroup$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/extensions/\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        /** get available resources */
+        getExtensionsV1beta1APIResources: <ResponseContentType extends ResponseContentType$getExtensionsV1beta1APIResources>(params: Params$getExtensionsV1beta1APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getExtensionsV1beta1APIResources$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/extensions/v1beta1/\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        /** list or watch objects of kind Ingress */
+        listExtensionsV1beta1IngressForAllNamespaces: <ResponseContentType extends ResponseContentType$listExtensionsV1beta1IngressForAllNamespaces>(params: Params$listExtensionsV1beta1IngressForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$listExtensionsV1beta1IngressForAllNamespaces$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/extensions/v1beta1/ingresses\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** list or watch objects of kind Ingress */
+        listExtensionsV1beta1NamespacedIngress: <ResponseContentType extends ResponseContentType$listExtensionsV1beta1NamespacedIngress>(params: Params$listExtensionsV1beta1NamespacedIngress<ResponseContentType>, option?: RequestOption): Promise<Response$listExtensionsV1beta1NamespacedIngress$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/extensions/v1beta1/namespaces/\${params.parameter.namespace}/ingresses\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** create an Ingress */
+        createExtensionsV1beta1NamespacedIngress: <ResponseContentType extends ResponseContentType$createExtensionsV1beta1NamespacedIngress>(params: Params$createExtensionsV1beta1NamespacedIngress<ResponseContentType>, option?: RequestOption): Promise<(Response$createExtensionsV1beta1NamespacedIngress$Status$200 | Response$createExtensionsV1beta1NamespacedIngress$Status$201 | Response$createExtensionsV1beta1NamespacedIngress$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/extensions/v1beta1/namespaces/\${params.parameter.namespace}/ingresses\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete collection of Ingress */
+        deleteExtensionsV1beta1CollectionNamespacedIngress: <ResponseContentType extends ResponseContentType$deleteExtensionsV1beta1CollectionNamespacedIngress>(params: Params$deleteExtensionsV1beta1CollectionNamespacedIngress<ResponseContentType>, option?: RequestOption): Promise<Response$deleteExtensionsV1beta1CollectionNamespacedIngress$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/extensions/v1beta1/namespaces/\${params.parameter.namespace}/ingresses\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read the specified Ingress */
+        readExtensionsV1beta1NamespacedIngress: <ResponseContentType extends ResponseContentType$readExtensionsV1beta1NamespacedIngress>(params: Params$readExtensionsV1beta1NamespacedIngress<ResponseContentType>, option?: RequestOption): Promise<Response$readExtensionsV1beta1NamespacedIngress$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/extensions/v1beta1/namespaces/\${params.parameter.namespace}/ingresses/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                exact: { value: params.parameter.exact, explode: false },
+                export: { value: params.parameter.export, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace the specified Ingress */
+        replaceExtensionsV1beta1NamespacedIngress: <ResponseContentType extends ResponseContentType$replaceExtensionsV1beta1NamespacedIngress>(params: Params$replaceExtensionsV1beta1NamespacedIngress<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceExtensionsV1beta1NamespacedIngress$Status$200 | Response$replaceExtensionsV1beta1NamespacedIngress$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/extensions/v1beta1/namespaces/\${params.parameter.namespace}/ingresses/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete an Ingress */
+        deleteExtensionsV1beta1NamespacedIngress: <ResponseContentType extends ResponseContentType$deleteExtensionsV1beta1NamespacedIngress>(params: Params$deleteExtensionsV1beta1NamespacedIngress<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteExtensionsV1beta1NamespacedIngress$Status$200 | Response$deleteExtensionsV1beta1NamespacedIngress$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/extensions/v1beta1/namespaces/\${params.parameter.namespace}/ingresses/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update the specified Ingress */
+        patchExtensionsV1beta1NamespacedIngress: <RequestContentType extends RequestContentType$patchExtensionsV1beta1NamespacedIngress, ResponseContentType extends ResponseContentType$patchExtensionsV1beta1NamespacedIngress>(params: Params$patchExtensionsV1beta1NamespacedIngress<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchExtensionsV1beta1NamespacedIngress$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/extensions/v1beta1/namespaces/\${params.parameter.namespace}/ingresses/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read status of the specified Ingress */
+        readExtensionsV1beta1NamespacedIngressStatus: <ResponseContentType extends ResponseContentType$readExtensionsV1beta1NamespacedIngressStatus>(params: Params$readExtensionsV1beta1NamespacedIngressStatus<ResponseContentType>, option?: RequestOption): Promise<Response$readExtensionsV1beta1NamespacedIngressStatus$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/extensions/v1beta1/namespaces/\${params.parameter.namespace}/ingresses/\${params.parameter.name}/status\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace status of the specified Ingress */
+        replaceExtensionsV1beta1NamespacedIngressStatus: <ResponseContentType extends ResponseContentType$replaceExtensionsV1beta1NamespacedIngressStatus>(params: Params$replaceExtensionsV1beta1NamespacedIngressStatus<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceExtensionsV1beta1NamespacedIngressStatus$Status$200 | Response$replaceExtensionsV1beta1NamespacedIngressStatus$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/extensions/v1beta1/namespaces/\${params.parameter.namespace}/ingresses/\${params.parameter.name}/status\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update status of the specified Ingress */
+        patchExtensionsV1beta1NamespacedIngressStatus: <RequestContentType extends RequestContentType$patchExtensionsV1beta1NamespacedIngressStatus, ResponseContentType extends ResponseContentType$patchExtensionsV1beta1NamespacedIngressStatus>(params: Params$patchExtensionsV1beta1NamespacedIngressStatus<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchExtensionsV1beta1NamespacedIngressStatus$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/extensions/v1beta1/namespaces/\${params.parameter.namespace}/ingresses/\${params.parameter.name}/status\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** watch individual changes to a list of Ingress. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchExtensionsV1beta1IngressListForAllNamespaces: <ResponseContentType extends ResponseContentType$watchExtensionsV1beta1IngressListForAllNamespaces>(params: Params$watchExtensionsV1beta1IngressListForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$watchExtensionsV1beta1IngressListForAllNamespaces$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/extensions/v1beta1/watch/ingresses\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of Ingress. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchExtensionsV1beta1NamespacedIngressList: <ResponseContentType extends ResponseContentType$watchExtensionsV1beta1NamespacedIngressList>(params: Params$watchExtensionsV1beta1NamespacedIngressList<ResponseContentType>, option?: RequestOption): Promise<Response$watchExtensionsV1beta1NamespacedIngressList$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/extensions/v1beta1/watch/namespaces/\${params.parameter.namespace}/ingresses\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch changes to an object of kind Ingress. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. */
+        watchExtensionsV1beta1NamespacedIngress: <ResponseContentType extends ResponseContentType$watchExtensionsV1beta1NamespacedIngress>(params: Params$watchExtensionsV1beta1NamespacedIngress<ResponseContentType>, option?: RequestOption): Promise<Response$watchExtensionsV1beta1NamespacedIngress$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/extensions/v1beta1/watch/namespaces/\${params.parameter.namespace}/ingresses/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** get information of a group */
+        getFlowcontrolApiserverAPIGroup: <ResponseContentType extends ResponseContentType$getFlowcontrolApiserverAPIGroup>(params: Params$getFlowcontrolApiserverAPIGroup<ResponseContentType>, option?: RequestOption): Promise<Response$getFlowcontrolApiserverAPIGroup$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/flowcontrol.apiserver.k8s.io/\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        /** get available resources */
+        getFlowcontrolApiserverV1alpha1APIResources: <ResponseContentType extends ResponseContentType$getFlowcontrolApiserverV1alpha1APIResources>(params: Params$getFlowcontrolApiserverV1alpha1APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getFlowcontrolApiserverV1alpha1APIResources$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/flowcontrol.apiserver.k8s.io/v1alpha1/\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        /** list or watch objects of kind FlowSchema */
+        listFlowcontrolApiserverV1alpha1FlowSchema: <ResponseContentType extends ResponseContentType$listFlowcontrolApiserverV1alpha1FlowSchema>(params: Params$listFlowcontrolApiserverV1alpha1FlowSchema<ResponseContentType>, option?: RequestOption): Promise<Response$listFlowcontrolApiserverV1alpha1FlowSchema$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/flowcontrol.apiserver.k8s.io/v1alpha1/flowschemas\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** create a FlowSchema */
+        createFlowcontrolApiserverV1alpha1FlowSchema: <ResponseContentType extends ResponseContentType$createFlowcontrolApiserverV1alpha1FlowSchema>(params: Params$createFlowcontrolApiserverV1alpha1FlowSchema<ResponseContentType>, option?: RequestOption): Promise<(Response$createFlowcontrolApiserverV1alpha1FlowSchema$Status$200 | Response$createFlowcontrolApiserverV1alpha1FlowSchema$Status$201 | Response$createFlowcontrolApiserverV1alpha1FlowSchema$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/flowcontrol.apiserver.k8s.io/v1alpha1/flowschemas\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete collection of FlowSchema */
+        deleteFlowcontrolApiserverV1alpha1CollectionFlowSchema: <ResponseContentType extends ResponseContentType$deleteFlowcontrolApiserverV1alpha1CollectionFlowSchema>(params: Params$deleteFlowcontrolApiserverV1alpha1CollectionFlowSchema<ResponseContentType>, option?: RequestOption): Promise<Response$deleteFlowcontrolApiserverV1alpha1CollectionFlowSchema$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/flowcontrol.apiserver.k8s.io/v1alpha1/flowschemas\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read the specified FlowSchema */
+        readFlowcontrolApiserverV1alpha1FlowSchema: <ResponseContentType extends ResponseContentType$readFlowcontrolApiserverV1alpha1FlowSchema>(params: Params$readFlowcontrolApiserverV1alpha1FlowSchema<ResponseContentType>, option?: RequestOption): Promise<Response$readFlowcontrolApiserverV1alpha1FlowSchema$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/flowcontrol.apiserver.k8s.io/v1alpha1/flowschemas/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                exact: { value: params.parameter.exact, explode: false },
+                export: { value: params.parameter.export, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace the specified FlowSchema */
+        replaceFlowcontrolApiserverV1alpha1FlowSchema: <ResponseContentType extends ResponseContentType$replaceFlowcontrolApiserverV1alpha1FlowSchema>(params: Params$replaceFlowcontrolApiserverV1alpha1FlowSchema<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceFlowcontrolApiserverV1alpha1FlowSchema$Status$200 | Response$replaceFlowcontrolApiserverV1alpha1FlowSchema$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/flowcontrol.apiserver.k8s.io/v1alpha1/flowschemas/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete a FlowSchema */
+        deleteFlowcontrolApiserverV1alpha1FlowSchema: <ResponseContentType extends ResponseContentType$deleteFlowcontrolApiserverV1alpha1FlowSchema>(params: Params$deleteFlowcontrolApiserverV1alpha1FlowSchema<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteFlowcontrolApiserverV1alpha1FlowSchema$Status$200 | Response$deleteFlowcontrolApiserverV1alpha1FlowSchema$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/flowcontrol.apiserver.k8s.io/v1alpha1/flowschemas/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update the specified FlowSchema */
+        patchFlowcontrolApiserverV1alpha1FlowSchema: <RequestContentType extends RequestContentType$patchFlowcontrolApiserverV1alpha1FlowSchema, ResponseContentType extends ResponseContentType$patchFlowcontrolApiserverV1alpha1FlowSchema>(params: Params$patchFlowcontrolApiserverV1alpha1FlowSchema<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchFlowcontrolApiserverV1alpha1FlowSchema$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/flowcontrol.apiserver.k8s.io/v1alpha1/flowschemas/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read status of the specified FlowSchema */
+        readFlowcontrolApiserverV1alpha1FlowSchemaStatus: <ResponseContentType extends ResponseContentType$readFlowcontrolApiserverV1alpha1FlowSchemaStatus>(params: Params$readFlowcontrolApiserverV1alpha1FlowSchemaStatus<ResponseContentType>, option?: RequestOption): Promise<Response$readFlowcontrolApiserverV1alpha1FlowSchemaStatus$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/flowcontrol.apiserver.k8s.io/v1alpha1/flowschemas/\${params.parameter.name}/status\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace status of the specified FlowSchema */
+        replaceFlowcontrolApiserverV1alpha1FlowSchemaStatus: <ResponseContentType extends ResponseContentType$replaceFlowcontrolApiserverV1alpha1FlowSchemaStatus>(params: Params$replaceFlowcontrolApiserverV1alpha1FlowSchemaStatus<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceFlowcontrolApiserverV1alpha1FlowSchemaStatus$Status$200 | Response$replaceFlowcontrolApiserverV1alpha1FlowSchemaStatus$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/flowcontrol.apiserver.k8s.io/v1alpha1/flowschemas/\${params.parameter.name}/status\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update status of the specified FlowSchema */
+        patchFlowcontrolApiserverV1alpha1FlowSchemaStatus: <RequestContentType extends RequestContentType$patchFlowcontrolApiserverV1alpha1FlowSchemaStatus, ResponseContentType extends ResponseContentType$patchFlowcontrolApiserverV1alpha1FlowSchemaStatus>(params: Params$patchFlowcontrolApiserverV1alpha1FlowSchemaStatus<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchFlowcontrolApiserverV1alpha1FlowSchemaStatus$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/flowcontrol.apiserver.k8s.io/v1alpha1/flowschemas/\${params.parameter.name}/status\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** list or watch objects of kind PriorityLevelConfiguration */
+        listFlowcontrolApiserverV1alpha1PriorityLevelConfiguration: <ResponseContentType extends ResponseContentType$listFlowcontrolApiserverV1alpha1PriorityLevelConfiguration>(params: Params$listFlowcontrolApiserverV1alpha1PriorityLevelConfiguration<ResponseContentType>, option?: RequestOption): Promise<Response$listFlowcontrolApiserverV1alpha1PriorityLevelConfiguration$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/flowcontrol.apiserver.k8s.io/v1alpha1/prioritylevelconfigurations\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** create a PriorityLevelConfiguration */
+        createFlowcontrolApiserverV1alpha1PriorityLevelConfiguration: <ResponseContentType extends ResponseContentType$createFlowcontrolApiserverV1alpha1PriorityLevelConfiguration>(params: Params$createFlowcontrolApiserverV1alpha1PriorityLevelConfiguration<ResponseContentType>, option?: RequestOption): Promise<(Response$createFlowcontrolApiserverV1alpha1PriorityLevelConfiguration$Status$200 | Response$createFlowcontrolApiserverV1alpha1PriorityLevelConfiguration$Status$201 | Response$createFlowcontrolApiserverV1alpha1PriorityLevelConfiguration$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/flowcontrol.apiserver.k8s.io/v1alpha1/prioritylevelconfigurations\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete collection of PriorityLevelConfiguration */
+        deleteFlowcontrolApiserverV1alpha1CollectionPriorityLevelConfiguration: <ResponseContentType extends ResponseContentType$deleteFlowcontrolApiserverV1alpha1CollectionPriorityLevelConfiguration>(params: Params$deleteFlowcontrolApiserverV1alpha1CollectionPriorityLevelConfiguration<ResponseContentType>, option?: RequestOption): Promise<Response$deleteFlowcontrolApiserverV1alpha1CollectionPriorityLevelConfiguration$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/flowcontrol.apiserver.k8s.io/v1alpha1/prioritylevelconfigurations\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read the specified PriorityLevelConfiguration */
+        readFlowcontrolApiserverV1alpha1PriorityLevelConfiguration: <ResponseContentType extends ResponseContentType$readFlowcontrolApiserverV1alpha1PriorityLevelConfiguration>(params: Params$readFlowcontrolApiserverV1alpha1PriorityLevelConfiguration<ResponseContentType>, option?: RequestOption): Promise<Response$readFlowcontrolApiserverV1alpha1PriorityLevelConfiguration$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/flowcontrol.apiserver.k8s.io/v1alpha1/prioritylevelconfigurations/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                exact: { value: params.parameter.exact, explode: false },
+                export: { value: params.parameter.export, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace the specified PriorityLevelConfiguration */
+        replaceFlowcontrolApiserverV1alpha1PriorityLevelConfiguration: <ResponseContentType extends ResponseContentType$replaceFlowcontrolApiserverV1alpha1PriorityLevelConfiguration>(params: Params$replaceFlowcontrolApiserverV1alpha1PriorityLevelConfiguration<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceFlowcontrolApiserverV1alpha1PriorityLevelConfiguration$Status$200 | Response$replaceFlowcontrolApiserverV1alpha1PriorityLevelConfiguration$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/flowcontrol.apiserver.k8s.io/v1alpha1/prioritylevelconfigurations/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete a PriorityLevelConfiguration */
+        deleteFlowcontrolApiserverV1alpha1PriorityLevelConfiguration: <ResponseContentType extends ResponseContentType$deleteFlowcontrolApiserverV1alpha1PriorityLevelConfiguration>(params: Params$deleteFlowcontrolApiserverV1alpha1PriorityLevelConfiguration<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteFlowcontrolApiserverV1alpha1PriorityLevelConfiguration$Status$200 | Response$deleteFlowcontrolApiserverV1alpha1PriorityLevelConfiguration$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/flowcontrol.apiserver.k8s.io/v1alpha1/prioritylevelconfigurations/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update the specified PriorityLevelConfiguration */
+        patchFlowcontrolApiserverV1alpha1PriorityLevelConfiguration: <RequestContentType extends RequestContentType$patchFlowcontrolApiserverV1alpha1PriorityLevelConfiguration, ResponseContentType extends ResponseContentType$patchFlowcontrolApiserverV1alpha1PriorityLevelConfiguration>(params: Params$patchFlowcontrolApiserverV1alpha1PriorityLevelConfiguration<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchFlowcontrolApiserverV1alpha1PriorityLevelConfiguration$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/flowcontrol.apiserver.k8s.io/v1alpha1/prioritylevelconfigurations/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read status of the specified PriorityLevelConfiguration */
+        readFlowcontrolApiserverV1alpha1PriorityLevelConfigurationStatus: <ResponseContentType extends ResponseContentType$readFlowcontrolApiserverV1alpha1PriorityLevelConfigurationStatus>(params: Params$readFlowcontrolApiserverV1alpha1PriorityLevelConfigurationStatus<ResponseContentType>, option?: RequestOption): Promise<Response$readFlowcontrolApiserverV1alpha1PriorityLevelConfigurationStatus$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/flowcontrol.apiserver.k8s.io/v1alpha1/prioritylevelconfigurations/\${params.parameter.name}/status\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace status of the specified PriorityLevelConfiguration */
+        replaceFlowcontrolApiserverV1alpha1PriorityLevelConfigurationStatus: <ResponseContentType extends ResponseContentType$replaceFlowcontrolApiserverV1alpha1PriorityLevelConfigurationStatus>(params: Params$replaceFlowcontrolApiserverV1alpha1PriorityLevelConfigurationStatus<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceFlowcontrolApiserverV1alpha1PriorityLevelConfigurationStatus$Status$200 | Response$replaceFlowcontrolApiserverV1alpha1PriorityLevelConfigurationStatus$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/flowcontrol.apiserver.k8s.io/v1alpha1/prioritylevelconfigurations/\${params.parameter.name}/status\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update status of the specified PriorityLevelConfiguration */
+        patchFlowcontrolApiserverV1alpha1PriorityLevelConfigurationStatus: <RequestContentType extends RequestContentType$patchFlowcontrolApiserverV1alpha1PriorityLevelConfigurationStatus, ResponseContentType extends ResponseContentType$patchFlowcontrolApiserverV1alpha1PriorityLevelConfigurationStatus>(params: Params$patchFlowcontrolApiserverV1alpha1PriorityLevelConfigurationStatus<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchFlowcontrolApiserverV1alpha1PriorityLevelConfigurationStatus$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/flowcontrol.apiserver.k8s.io/v1alpha1/prioritylevelconfigurations/\${params.parameter.name}/status\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** watch individual changes to a list of FlowSchema. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchFlowcontrolApiserverV1alpha1FlowSchemaList: <ResponseContentType extends ResponseContentType$watchFlowcontrolApiserverV1alpha1FlowSchemaList>(params: Params$watchFlowcontrolApiserverV1alpha1FlowSchemaList<ResponseContentType>, option?: RequestOption): Promise<Response$watchFlowcontrolApiserverV1alpha1FlowSchemaList$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/flowcontrol.apiserver.k8s.io/v1alpha1/watch/flowschemas\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch changes to an object of kind FlowSchema. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. */
+        watchFlowcontrolApiserverV1alpha1FlowSchema: <ResponseContentType extends ResponseContentType$watchFlowcontrolApiserverV1alpha1FlowSchema>(params: Params$watchFlowcontrolApiserverV1alpha1FlowSchema<ResponseContentType>, option?: RequestOption): Promise<Response$watchFlowcontrolApiserverV1alpha1FlowSchema$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/flowcontrol.apiserver.k8s.io/v1alpha1/watch/flowschemas/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of PriorityLevelConfiguration. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchFlowcontrolApiserverV1alpha1PriorityLevelConfigurationList: <ResponseContentType extends ResponseContentType$watchFlowcontrolApiserverV1alpha1PriorityLevelConfigurationList>(params: Params$watchFlowcontrolApiserverV1alpha1PriorityLevelConfigurationList<ResponseContentType>, option?: RequestOption): Promise<Response$watchFlowcontrolApiserverV1alpha1PriorityLevelConfigurationList$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/flowcontrol.apiserver.k8s.io/v1alpha1/watch/prioritylevelconfigurations\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch changes to an object of kind PriorityLevelConfiguration. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. */
+        watchFlowcontrolApiserverV1alpha1PriorityLevelConfiguration: <ResponseContentType extends ResponseContentType$watchFlowcontrolApiserverV1alpha1PriorityLevelConfiguration>(params: Params$watchFlowcontrolApiserverV1alpha1PriorityLevelConfiguration<ResponseContentType>, option?: RequestOption): Promise<Response$watchFlowcontrolApiserverV1alpha1PriorityLevelConfiguration$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/flowcontrol.apiserver.k8s.io/v1alpha1/watch/prioritylevelconfigurations/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** get information of a group */
+        getNetworkingAPIGroup: <ResponseContentType extends ResponseContentType$getNetworkingAPIGroup>(params: Params$getNetworkingAPIGroup<ResponseContentType>, option?: RequestOption): Promise<Response$getNetworkingAPIGroup$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/networking.k8s.io/\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        /** get available resources */
+        getNetworkingV1APIResources: <ResponseContentType extends ResponseContentType$getNetworkingV1APIResources>(params: Params$getNetworkingV1APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getNetworkingV1APIResources$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/networking.k8s.io/v1/\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        /** list or watch objects of kind NetworkPolicy */
+        listNetworkingV1NamespacedNetworkPolicy: <ResponseContentType extends ResponseContentType$listNetworkingV1NamespacedNetworkPolicy>(params: Params$listNetworkingV1NamespacedNetworkPolicy<ResponseContentType>, option?: RequestOption): Promise<Response$listNetworkingV1NamespacedNetworkPolicy$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/networking.k8s.io/v1/namespaces/\${params.parameter.namespace}/networkpolicies\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** create a NetworkPolicy */
+        createNetworkingV1NamespacedNetworkPolicy: <ResponseContentType extends ResponseContentType$createNetworkingV1NamespacedNetworkPolicy>(params: Params$createNetworkingV1NamespacedNetworkPolicy<ResponseContentType>, option?: RequestOption): Promise<(Response$createNetworkingV1NamespacedNetworkPolicy$Status$200 | Response$createNetworkingV1NamespacedNetworkPolicy$Status$201 | Response$createNetworkingV1NamespacedNetworkPolicy$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/networking.k8s.io/v1/namespaces/\${params.parameter.namespace}/networkpolicies\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete collection of NetworkPolicy */
+        deleteNetworkingV1CollectionNamespacedNetworkPolicy: <ResponseContentType extends ResponseContentType$deleteNetworkingV1CollectionNamespacedNetworkPolicy>(params: Params$deleteNetworkingV1CollectionNamespacedNetworkPolicy<ResponseContentType>, option?: RequestOption): Promise<Response$deleteNetworkingV1CollectionNamespacedNetworkPolicy$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/networking.k8s.io/v1/namespaces/\${params.parameter.namespace}/networkpolicies\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read the specified NetworkPolicy */
+        readNetworkingV1NamespacedNetworkPolicy: <ResponseContentType extends ResponseContentType$readNetworkingV1NamespacedNetworkPolicy>(params: Params$readNetworkingV1NamespacedNetworkPolicy<ResponseContentType>, option?: RequestOption): Promise<Response$readNetworkingV1NamespacedNetworkPolicy$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/networking.k8s.io/v1/namespaces/\${params.parameter.namespace}/networkpolicies/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                exact: { value: params.parameter.exact, explode: false },
+                export: { value: params.parameter.export, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace the specified NetworkPolicy */
+        replaceNetworkingV1NamespacedNetworkPolicy: <ResponseContentType extends ResponseContentType$replaceNetworkingV1NamespacedNetworkPolicy>(params: Params$replaceNetworkingV1NamespacedNetworkPolicy<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceNetworkingV1NamespacedNetworkPolicy$Status$200 | Response$replaceNetworkingV1NamespacedNetworkPolicy$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/networking.k8s.io/v1/namespaces/\${params.parameter.namespace}/networkpolicies/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete a NetworkPolicy */
+        deleteNetworkingV1NamespacedNetworkPolicy: <ResponseContentType extends ResponseContentType$deleteNetworkingV1NamespacedNetworkPolicy>(params: Params$deleteNetworkingV1NamespacedNetworkPolicy<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteNetworkingV1NamespacedNetworkPolicy$Status$200 | Response$deleteNetworkingV1NamespacedNetworkPolicy$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/networking.k8s.io/v1/namespaces/\${params.parameter.namespace}/networkpolicies/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update the specified NetworkPolicy */
+        patchNetworkingV1NamespacedNetworkPolicy: <RequestContentType extends RequestContentType$patchNetworkingV1NamespacedNetworkPolicy, ResponseContentType extends ResponseContentType$patchNetworkingV1NamespacedNetworkPolicy>(params: Params$patchNetworkingV1NamespacedNetworkPolicy<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchNetworkingV1NamespacedNetworkPolicy$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/networking.k8s.io/v1/namespaces/\${params.parameter.namespace}/networkpolicies/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** list or watch objects of kind NetworkPolicy */
+        listNetworkingV1NetworkPolicyForAllNamespaces: <ResponseContentType extends ResponseContentType$listNetworkingV1NetworkPolicyForAllNamespaces>(params: Params$listNetworkingV1NetworkPolicyForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$listNetworkingV1NetworkPolicyForAllNamespaces$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/networking.k8s.io/v1/networkpolicies\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of NetworkPolicy. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchNetworkingV1NamespacedNetworkPolicyList: <ResponseContentType extends ResponseContentType$watchNetworkingV1NamespacedNetworkPolicyList>(params: Params$watchNetworkingV1NamespacedNetworkPolicyList<ResponseContentType>, option?: RequestOption): Promise<Response$watchNetworkingV1NamespacedNetworkPolicyList$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/networking.k8s.io/v1/watch/namespaces/\${params.parameter.namespace}/networkpolicies\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch changes to an object of kind NetworkPolicy. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. */
+        watchNetworkingV1NamespacedNetworkPolicy: <ResponseContentType extends ResponseContentType$watchNetworkingV1NamespacedNetworkPolicy>(params: Params$watchNetworkingV1NamespacedNetworkPolicy<ResponseContentType>, option?: RequestOption): Promise<Response$watchNetworkingV1NamespacedNetworkPolicy$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/networking.k8s.io/v1/watch/namespaces/\${params.parameter.namespace}/networkpolicies/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of NetworkPolicy. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchNetworkingV1NetworkPolicyListForAllNamespaces: <ResponseContentType extends ResponseContentType$watchNetworkingV1NetworkPolicyListForAllNamespaces>(params: Params$watchNetworkingV1NetworkPolicyListForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$watchNetworkingV1NetworkPolicyListForAllNamespaces$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/networking.k8s.io/v1/watch/networkpolicies\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** get available resources */
+        getNetworkingV1beta1APIResources: <ResponseContentType extends ResponseContentType$getNetworkingV1beta1APIResources>(params: Params$getNetworkingV1beta1APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getNetworkingV1beta1APIResources$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/networking.k8s.io/v1beta1/\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        /** list or watch objects of kind IngressClass */
+        listNetworkingV1beta1IngressClass: <ResponseContentType extends ResponseContentType$listNetworkingV1beta1IngressClass>(params: Params$listNetworkingV1beta1IngressClass<ResponseContentType>, option?: RequestOption): Promise<Response$listNetworkingV1beta1IngressClass$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/networking.k8s.io/v1beta1/ingressclasses\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** create an IngressClass */
+        createNetworkingV1beta1IngressClass: <ResponseContentType extends ResponseContentType$createNetworkingV1beta1IngressClass>(params: Params$createNetworkingV1beta1IngressClass<ResponseContentType>, option?: RequestOption): Promise<(Response$createNetworkingV1beta1IngressClass$Status$200 | Response$createNetworkingV1beta1IngressClass$Status$201 | Response$createNetworkingV1beta1IngressClass$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/networking.k8s.io/v1beta1/ingressclasses\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete collection of IngressClass */
+        deleteNetworkingV1beta1CollectionIngressClass: <ResponseContentType extends ResponseContentType$deleteNetworkingV1beta1CollectionIngressClass>(params: Params$deleteNetworkingV1beta1CollectionIngressClass<ResponseContentType>, option?: RequestOption): Promise<Response$deleteNetworkingV1beta1CollectionIngressClass$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/networking.k8s.io/v1beta1/ingressclasses\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read the specified IngressClass */
+        readNetworkingV1beta1IngressClass: <ResponseContentType extends ResponseContentType$readNetworkingV1beta1IngressClass>(params: Params$readNetworkingV1beta1IngressClass<ResponseContentType>, option?: RequestOption): Promise<Response$readNetworkingV1beta1IngressClass$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/networking.k8s.io/v1beta1/ingressclasses/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                exact: { value: params.parameter.exact, explode: false },
+                export: { value: params.parameter.export, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace the specified IngressClass */
+        replaceNetworkingV1beta1IngressClass: <ResponseContentType extends ResponseContentType$replaceNetworkingV1beta1IngressClass>(params: Params$replaceNetworkingV1beta1IngressClass<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceNetworkingV1beta1IngressClass$Status$200 | Response$replaceNetworkingV1beta1IngressClass$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/networking.k8s.io/v1beta1/ingressclasses/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete an IngressClass */
+        deleteNetworkingV1beta1IngressClass: <ResponseContentType extends ResponseContentType$deleteNetworkingV1beta1IngressClass>(params: Params$deleteNetworkingV1beta1IngressClass<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteNetworkingV1beta1IngressClass$Status$200 | Response$deleteNetworkingV1beta1IngressClass$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/networking.k8s.io/v1beta1/ingressclasses/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update the specified IngressClass */
+        patchNetworkingV1beta1IngressClass: <RequestContentType extends RequestContentType$patchNetworkingV1beta1IngressClass, ResponseContentType extends ResponseContentType$patchNetworkingV1beta1IngressClass>(params: Params$patchNetworkingV1beta1IngressClass<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchNetworkingV1beta1IngressClass$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/networking.k8s.io/v1beta1/ingressclasses/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** list or watch objects of kind Ingress */
+        listNetworkingV1beta1IngressForAllNamespaces: <ResponseContentType extends ResponseContentType$listNetworkingV1beta1IngressForAllNamespaces>(params: Params$listNetworkingV1beta1IngressForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$listNetworkingV1beta1IngressForAllNamespaces$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/networking.k8s.io/v1beta1/ingresses\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** list or watch objects of kind Ingress */
+        listNetworkingV1beta1NamespacedIngress: <ResponseContentType extends ResponseContentType$listNetworkingV1beta1NamespacedIngress>(params: Params$listNetworkingV1beta1NamespacedIngress<ResponseContentType>, option?: RequestOption): Promise<Response$listNetworkingV1beta1NamespacedIngress$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/networking.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/ingresses\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** create an Ingress */
+        createNetworkingV1beta1NamespacedIngress: <ResponseContentType extends ResponseContentType$createNetworkingV1beta1NamespacedIngress>(params: Params$createNetworkingV1beta1NamespacedIngress<ResponseContentType>, option?: RequestOption): Promise<(Response$createNetworkingV1beta1NamespacedIngress$Status$200 | Response$createNetworkingV1beta1NamespacedIngress$Status$201 | Response$createNetworkingV1beta1NamespacedIngress$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/networking.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/ingresses\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete collection of Ingress */
+        deleteNetworkingV1beta1CollectionNamespacedIngress: <ResponseContentType extends ResponseContentType$deleteNetworkingV1beta1CollectionNamespacedIngress>(params: Params$deleteNetworkingV1beta1CollectionNamespacedIngress<ResponseContentType>, option?: RequestOption): Promise<Response$deleteNetworkingV1beta1CollectionNamespacedIngress$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/networking.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/ingresses\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read the specified Ingress */
+        readNetworkingV1beta1NamespacedIngress: <ResponseContentType extends ResponseContentType$readNetworkingV1beta1NamespacedIngress>(params: Params$readNetworkingV1beta1NamespacedIngress<ResponseContentType>, option?: RequestOption): Promise<Response$readNetworkingV1beta1NamespacedIngress$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/networking.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/ingresses/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                exact: { value: params.parameter.exact, explode: false },
+                export: { value: params.parameter.export, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace the specified Ingress */
+        replaceNetworkingV1beta1NamespacedIngress: <ResponseContentType extends ResponseContentType$replaceNetworkingV1beta1NamespacedIngress>(params: Params$replaceNetworkingV1beta1NamespacedIngress<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceNetworkingV1beta1NamespacedIngress$Status$200 | Response$replaceNetworkingV1beta1NamespacedIngress$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/networking.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/ingresses/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete an Ingress */
+        deleteNetworkingV1beta1NamespacedIngress: <ResponseContentType extends ResponseContentType$deleteNetworkingV1beta1NamespacedIngress>(params: Params$deleteNetworkingV1beta1NamespacedIngress<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteNetworkingV1beta1NamespacedIngress$Status$200 | Response$deleteNetworkingV1beta1NamespacedIngress$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/networking.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/ingresses/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update the specified Ingress */
+        patchNetworkingV1beta1NamespacedIngress: <RequestContentType extends RequestContentType$patchNetworkingV1beta1NamespacedIngress, ResponseContentType extends ResponseContentType$patchNetworkingV1beta1NamespacedIngress>(params: Params$patchNetworkingV1beta1NamespacedIngress<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchNetworkingV1beta1NamespacedIngress$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/networking.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/ingresses/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read status of the specified Ingress */
+        readNetworkingV1beta1NamespacedIngressStatus: <ResponseContentType extends ResponseContentType$readNetworkingV1beta1NamespacedIngressStatus>(params: Params$readNetworkingV1beta1NamespacedIngressStatus<ResponseContentType>, option?: RequestOption): Promise<Response$readNetworkingV1beta1NamespacedIngressStatus$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/networking.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/ingresses/\${params.parameter.name}/status\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace status of the specified Ingress */
+        replaceNetworkingV1beta1NamespacedIngressStatus: <ResponseContentType extends ResponseContentType$replaceNetworkingV1beta1NamespacedIngressStatus>(params: Params$replaceNetworkingV1beta1NamespacedIngressStatus<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceNetworkingV1beta1NamespacedIngressStatus$Status$200 | Response$replaceNetworkingV1beta1NamespacedIngressStatus$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/networking.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/ingresses/\${params.parameter.name}/status\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update status of the specified Ingress */
+        patchNetworkingV1beta1NamespacedIngressStatus: <RequestContentType extends RequestContentType$patchNetworkingV1beta1NamespacedIngressStatus, ResponseContentType extends ResponseContentType$patchNetworkingV1beta1NamespacedIngressStatus>(params: Params$patchNetworkingV1beta1NamespacedIngressStatus<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchNetworkingV1beta1NamespacedIngressStatus$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/networking.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/ingresses/\${params.parameter.name}/status\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** watch individual changes to a list of IngressClass. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchNetworkingV1beta1IngressClassList: <ResponseContentType extends ResponseContentType$watchNetworkingV1beta1IngressClassList>(params: Params$watchNetworkingV1beta1IngressClassList<ResponseContentType>, option?: RequestOption): Promise<Response$watchNetworkingV1beta1IngressClassList$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/networking.k8s.io/v1beta1/watch/ingressclasses\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch changes to an object of kind IngressClass. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. */
+        watchNetworkingV1beta1IngressClass: <ResponseContentType extends ResponseContentType$watchNetworkingV1beta1IngressClass>(params: Params$watchNetworkingV1beta1IngressClass<ResponseContentType>, option?: RequestOption): Promise<Response$watchNetworkingV1beta1IngressClass$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/networking.k8s.io/v1beta1/watch/ingressclasses/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of Ingress. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchNetworkingV1beta1IngressListForAllNamespaces: <ResponseContentType extends ResponseContentType$watchNetworkingV1beta1IngressListForAllNamespaces>(params: Params$watchNetworkingV1beta1IngressListForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$watchNetworkingV1beta1IngressListForAllNamespaces$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/networking.k8s.io/v1beta1/watch/ingresses\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of Ingress. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchNetworkingV1beta1NamespacedIngressList: <ResponseContentType extends ResponseContentType$watchNetworkingV1beta1NamespacedIngressList>(params: Params$watchNetworkingV1beta1NamespacedIngressList<ResponseContentType>, option?: RequestOption): Promise<Response$watchNetworkingV1beta1NamespacedIngressList$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/networking.k8s.io/v1beta1/watch/namespaces/\${params.parameter.namespace}/ingresses\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch changes to an object of kind Ingress. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. */
+        watchNetworkingV1beta1NamespacedIngress: <ResponseContentType extends ResponseContentType$watchNetworkingV1beta1NamespacedIngress>(params: Params$watchNetworkingV1beta1NamespacedIngress<ResponseContentType>, option?: RequestOption): Promise<Response$watchNetworkingV1beta1NamespacedIngress$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/networking.k8s.io/v1beta1/watch/namespaces/\${params.parameter.namespace}/ingresses/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** get information of a group */
+        getNodeAPIGroup: <ResponseContentType extends ResponseContentType$getNodeAPIGroup>(params: Params$getNodeAPIGroup<ResponseContentType>, option?: RequestOption): Promise<Response$getNodeAPIGroup$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/node.k8s.io/\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        /** get available resources */
+        getNodeV1alpha1APIResources: <ResponseContentType extends ResponseContentType$getNodeV1alpha1APIResources>(params: Params$getNodeV1alpha1APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getNodeV1alpha1APIResources$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/node.k8s.io/v1alpha1/\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        /** list or watch objects of kind RuntimeClass */
+        listNodeV1alpha1RuntimeClass: <ResponseContentType extends ResponseContentType$listNodeV1alpha1RuntimeClass>(params: Params$listNodeV1alpha1RuntimeClass<ResponseContentType>, option?: RequestOption): Promise<Response$listNodeV1alpha1RuntimeClass$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/node.k8s.io/v1alpha1/runtimeclasses\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** create a RuntimeClass */
+        createNodeV1alpha1RuntimeClass: <ResponseContentType extends ResponseContentType$createNodeV1alpha1RuntimeClass>(params: Params$createNodeV1alpha1RuntimeClass<ResponseContentType>, option?: RequestOption): Promise<(Response$createNodeV1alpha1RuntimeClass$Status$200 | Response$createNodeV1alpha1RuntimeClass$Status$201 | Response$createNodeV1alpha1RuntimeClass$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/node.k8s.io/v1alpha1/runtimeclasses\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete collection of RuntimeClass */
+        deleteNodeV1alpha1CollectionRuntimeClass: <ResponseContentType extends ResponseContentType$deleteNodeV1alpha1CollectionRuntimeClass>(params: Params$deleteNodeV1alpha1CollectionRuntimeClass<ResponseContentType>, option?: RequestOption): Promise<Response$deleteNodeV1alpha1CollectionRuntimeClass$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/node.k8s.io/v1alpha1/runtimeclasses\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read the specified RuntimeClass */
+        readNodeV1alpha1RuntimeClass: <ResponseContentType extends ResponseContentType$readNodeV1alpha1RuntimeClass>(params: Params$readNodeV1alpha1RuntimeClass<ResponseContentType>, option?: RequestOption): Promise<Response$readNodeV1alpha1RuntimeClass$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/node.k8s.io/v1alpha1/runtimeclasses/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                exact: { value: params.parameter.exact, explode: false },
+                export: { value: params.parameter.export, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace the specified RuntimeClass */
+        replaceNodeV1alpha1RuntimeClass: <ResponseContentType extends ResponseContentType$replaceNodeV1alpha1RuntimeClass>(params: Params$replaceNodeV1alpha1RuntimeClass<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceNodeV1alpha1RuntimeClass$Status$200 | Response$replaceNodeV1alpha1RuntimeClass$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/node.k8s.io/v1alpha1/runtimeclasses/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete a RuntimeClass */
+        deleteNodeV1alpha1RuntimeClass: <ResponseContentType extends ResponseContentType$deleteNodeV1alpha1RuntimeClass>(params: Params$deleteNodeV1alpha1RuntimeClass<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteNodeV1alpha1RuntimeClass$Status$200 | Response$deleteNodeV1alpha1RuntimeClass$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/node.k8s.io/v1alpha1/runtimeclasses/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update the specified RuntimeClass */
+        patchNodeV1alpha1RuntimeClass: <RequestContentType extends RequestContentType$patchNodeV1alpha1RuntimeClass, ResponseContentType extends ResponseContentType$patchNodeV1alpha1RuntimeClass>(params: Params$patchNodeV1alpha1RuntimeClass<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchNodeV1alpha1RuntimeClass$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/node.k8s.io/v1alpha1/runtimeclasses/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** watch individual changes to a list of RuntimeClass. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchNodeV1alpha1RuntimeClassList: <ResponseContentType extends ResponseContentType$watchNodeV1alpha1RuntimeClassList>(params: Params$watchNodeV1alpha1RuntimeClassList<ResponseContentType>, option?: RequestOption): Promise<Response$watchNodeV1alpha1RuntimeClassList$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/node.k8s.io/v1alpha1/watch/runtimeclasses\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch changes to an object of kind RuntimeClass. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. */
+        watchNodeV1alpha1RuntimeClass: <ResponseContentType extends ResponseContentType$watchNodeV1alpha1RuntimeClass>(params: Params$watchNodeV1alpha1RuntimeClass<ResponseContentType>, option?: RequestOption): Promise<Response$watchNodeV1alpha1RuntimeClass$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/node.k8s.io/v1alpha1/watch/runtimeclasses/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** get available resources */
+        getNodeV1beta1APIResources: <ResponseContentType extends ResponseContentType$getNodeV1beta1APIResources>(params: Params$getNodeV1beta1APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getNodeV1beta1APIResources$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/node.k8s.io/v1beta1/\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        /** list or watch objects of kind RuntimeClass */
+        listNodeV1beta1RuntimeClass: <ResponseContentType extends ResponseContentType$listNodeV1beta1RuntimeClass>(params: Params$listNodeV1beta1RuntimeClass<ResponseContentType>, option?: RequestOption): Promise<Response$listNodeV1beta1RuntimeClass$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/node.k8s.io/v1beta1/runtimeclasses\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** create a RuntimeClass */
+        createNodeV1beta1RuntimeClass: <ResponseContentType extends ResponseContentType$createNodeV1beta1RuntimeClass>(params: Params$createNodeV1beta1RuntimeClass<ResponseContentType>, option?: RequestOption): Promise<(Response$createNodeV1beta1RuntimeClass$Status$200 | Response$createNodeV1beta1RuntimeClass$Status$201 | Response$createNodeV1beta1RuntimeClass$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/node.k8s.io/v1beta1/runtimeclasses\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete collection of RuntimeClass */
+        deleteNodeV1beta1CollectionRuntimeClass: <ResponseContentType extends ResponseContentType$deleteNodeV1beta1CollectionRuntimeClass>(params: Params$deleteNodeV1beta1CollectionRuntimeClass<ResponseContentType>, option?: RequestOption): Promise<Response$deleteNodeV1beta1CollectionRuntimeClass$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/node.k8s.io/v1beta1/runtimeclasses\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read the specified RuntimeClass */
+        readNodeV1beta1RuntimeClass: <ResponseContentType extends ResponseContentType$readNodeV1beta1RuntimeClass>(params: Params$readNodeV1beta1RuntimeClass<ResponseContentType>, option?: RequestOption): Promise<Response$readNodeV1beta1RuntimeClass$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/node.k8s.io/v1beta1/runtimeclasses/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                exact: { value: params.parameter.exact, explode: false },
+                export: { value: params.parameter.export, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace the specified RuntimeClass */
+        replaceNodeV1beta1RuntimeClass: <ResponseContentType extends ResponseContentType$replaceNodeV1beta1RuntimeClass>(params: Params$replaceNodeV1beta1RuntimeClass<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceNodeV1beta1RuntimeClass$Status$200 | Response$replaceNodeV1beta1RuntimeClass$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/node.k8s.io/v1beta1/runtimeclasses/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete a RuntimeClass */
+        deleteNodeV1beta1RuntimeClass: <ResponseContentType extends ResponseContentType$deleteNodeV1beta1RuntimeClass>(params: Params$deleteNodeV1beta1RuntimeClass<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteNodeV1beta1RuntimeClass$Status$200 | Response$deleteNodeV1beta1RuntimeClass$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/node.k8s.io/v1beta1/runtimeclasses/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update the specified RuntimeClass */
+        patchNodeV1beta1RuntimeClass: <RequestContentType extends RequestContentType$patchNodeV1beta1RuntimeClass, ResponseContentType extends ResponseContentType$patchNodeV1beta1RuntimeClass>(params: Params$patchNodeV1beta1RuntimeClass<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchNodeV1beta1RuntimeClass$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/node.k8s.io/v1beta1/runtimeclasses/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** watch individual changes to a list of RuntimeClass. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchNodeV1beta1RuntimeClassList: <ResponseContentType extends ResponseContentType$watchNodeV1beta1RuntimeClassList>(params: Params$watchNodeV1beta1RuntimeClassList<ResponseContentType>, option?: RequestOption): Promise<Response$watchNodeV1beta1RuntimeClassList$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/node.k8s.io/v1beta1/watch/runtimeclasses\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch changes to an object of kind RuntimeClass. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. */
+        watchNodeV1beta1RuntimeClass: <ResponseContentType extends ResponseContentType$watchNodeV1beta1RuntimeClass>(params: Params$watchNodeV1beta1RuntimeClass<ResponseContentType>, option?: RequestOption): Promise<Response$watchNodeV1beta1RuntimeClass$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/node.k8s.io/v1beta1/watch/runtimeclasses/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** get information of a group */
+        getPolicyAPIGroup: <ResponseContentType extends ResponseContentType$getPolicyAPIGroup>(params: Params$getPolicyAPIGroup<ResponseContentType>, option?: RequestOption): Promise<Response$getPolicyAPIGroup$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/policy/\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        /** get available resources */
+        getPolicyV1beta1APIResources: <ResponseContentType extends ResponseContentType$getPolicyV1beta1APIResources>(params: Params$getPolicyV1beta1APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getPolicyV1beta1APIResources$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/policy/v1beta1/\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        /** list or watch objects of kind PodDisruptionBudget */
+        listPolicyV1beta1NamespacedPodDisruptionBudget: <ResponseContentType extends ResponseContentType$listPolicyV1beta1NamespacedPodDisruptionBudget>(params: Params$listPolicyV1beta1NamespacedPodDisruptionBudget<ResponseContentType>, option?: RequestOption): Promise<Response$listPolicyV1beta1NamespacedPodDisruptionBudget$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/policy/v1beta1/namespaces/\${params.parameter.namespace}/poddisruptionbudgets\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** create a PodDisruptionBudget */
+        createPolicyV1beta1NamespacedPodDisruptionBudget: <ResponseContentType extends ResponseContentType$createPolicyV1beta1NamespacedPodDisruptionBudget>(params: Params$createPolicyV1beta1NamespacedPodDisruptionBudget<ResponseContentType>, option?: RequestOption): Promise<(Response$createPolicyV1beta1NamespacedPodDisruptionBudget$Status$200 | Response$createPolicyV1beta1NamespacedPodDisruptionBudget$Status$201 | Response$createPolicyV1beta1NamespacedPodDisruptionBudget$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/policy/v1beta1/namespaces/\${params.parameter.namespace}/poddisruptionbudgets\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete collection of PodDisruptionBudget */
+        deletePolicyV1beta1CollectionNamespacedPodDisruptionBudget: <ResponseContentType extends ResponseContentType$deletePolicyV1beta1CollectionNamespacedPodDisruptionBudget>(params: Params$deletePolicyV1beta1CollectionNamespacedPodDisruptionBudget<ResponseContentType>, option?: RequestOption): Promise<Response$deletePolicyV1beta1CollectionNamespacedPodDisruptionBudget$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/policy/v1beta1/namespaces/\${params.parameter.namespace}/poddisruptionbudgets\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read the specified PodDisruptionBudget */
+        readPolicyV1beta1NamespacedPodDisruptionBudget: <ResponseContentType extends ResponseContentType$readPolicyV1beta1NamespacedPodDisruptionBudget>(params: Params$readPolicyV1beta1NamespacedPodDisruptionBudget<ResponseContentType>, option?: RequestOption): Promise<Response$readPolicyV1beta1NamespacedPodDisruptionBudget$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/policy/v1beta1/namespaces/\${params.parameter.namespace}/poddisruptionbudgets/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                exact: { value: params.parameter.exact, explode: false },
+                export: { value: params.parameter.export, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace the specified PodDisruptionBudget */
+        replacePolicyV1beta1NamespacedPodDisruptionBudget: <ResponseContentType extends ResponseContentType$replacePolicyV1beta1NamespacedPodDisruptionBudget>(params: Params$replacePolicyV1beta1NamespacedPodDisruptionBudget<ResponseContentType>, option?: RequestOption): Promise<(Response$replacePolicyV1beta1NamespacedPodDisruptionBudget$Status$200 | Response$replacePolicyV1beta1NamespacedPodDisruptionBudget$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/policy/v1beta1/namespaces/\${params.parameter.namespace}/poddisruptionbudgets/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete a PodDisruptionBudget */
+        deletePolicyV1beta1NamespacedPodDisruptionBudget: <ResponseContentType extends ResponseContentType$deletePolicyV1beta1NamespacedPodDisruptionBudget>(params: Params$deletePolicyV1beta1NamespacedPodDisruptionBudget<ResponseContentType>, option?: RequestOption): Promise<(Response$deletePolicyV1beta1NamespacedPodDisruptionBudget$Status$200 | Response$deletePolicyV1beta1NamespacedPodDisruptionBudget$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/policy/v1beta1/namespaces/\${params.parameter.namespace}/poddisruptionbudgets/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update the specified PodDisruptionBudget */
+        patchPolicyV1beta1NamespacedPodDisruptionBudget: <RequestContentType extends RequestContentType$patchPolicyV1beta1NamespacedPodDisruptionBudget, ResponseContentType extends ResponseContentType$patchPolicyV1beta1NamespacedPodDisruptionBudget>(params: Params$patchPolicyV1beta1NamespacedPodDisruptionBudget<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchPolicyV1beta1NamespacedPodDisruptionBudget$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/policy/v1beta1/namespaces/\${params.parameter.namespace}/poddisruptionbudgets/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read status of the specified PodDisruptionBudget */
+        readPolicyV1beta1NamespacedPodDisruptionBudgetStatus: <ResponseContentType extends ResponseContentType$readPolicyV1beta1NamespacedPodDisruptionBudgetStatus>(params: Params$readPolicyV1beta1NamespacedPodDisruptionBudgetStatus<ResponseContentType>, option?: RequestOption): Promise<Response$readPolicyV1beta1NamespacedPodDisruptionBudgetStatus$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/policy/v1beta1/namespaces/\${params.parameter.namespace}/poddisruptionbudgets/\${params.parameter.name}/status\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace status of the specified PodDisruptionBudget */
+        replacePolicyV1beta1NamespacedPodDisruptionBudgetStatus: <ResponseContentType extends ResponseContentType$replacePolicyV1beta1NamespacedPodDisruptionBudgetStatus>(params: Params$replacePolicyV1beta1NamespacedPodDisruptionBudgetStatus<ResponseContentType>, option?: RequestOption): Promise<(Response$replacePolicyV1beta1NamespacedPodDisruptionBudgetStatus$Status$200 | Response$replacePolicyV1beta1NamespacedPodDisruptionBudgetStatus$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/policy/v1beta1/namespaces/\${params.parameter.namespace}/poddisruptionbudgets/\${params.parameter.name}/status\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update status of the specified PodDisruptionBudget */
+        patchPolicyV1beta1NamespacedPodDisruptionBudgetStatus: <RequestContentType extends RequestContentType$patchPolicyV1beta1NamespacedPodDisruptionBudgetStatus, ResponseContentType extends ResponseContentType$patchPolicyV1beta1NamespacedPodDisruptionBudgetStatus>(params: Params$patchPolicyV1beta1NamespacedPodDisruptionBudgetStatus<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchPolicyV1beta1NamespacedPodDisruptionBudgetStatus$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/policy/v1beta1/namespaces/\${params.parameter.namespace}/poddisruptionbudgets/\${params.parameter.name}/status\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** list or watch objects of kind PodDisruptionBudget */
+        listPolicyV1beta1PodDisruptionBudgetForAllNamespaces: <ResponseContentType extends ResponseContentType$listPolicyV1beta1PodDisruptionBudgetForAllNamespaces>(params: Params$listPolicyV1beta1PodDisruptionBudgetForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$listPolicyV1beta1PodDisruptionBudgetForAllNamespaces$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/policy/v1beta1/poddisruptionbudgets\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** list or watch objects of kind PodSecurityPolicy */
+        listPolicyV1beta1PodSecurityPolicy: <ResponseContentType extends ResponseContentType$listPolicyV1beta1PodSecurityPolicy>(params: Params$listPolicyV1beta1PodSecurityPolicy<ResponseContentType>, option?: RequestOption): Promise<Response$listPolicyV1beta1PodSecurityPolicy$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/policy/v1beta1/podsecuritypolicies\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** create a PodSecurityPolicy */
+        createPolicyV1beta1PodSecurityPolicy: <ResponseContentType extends ResponseContentType$createPolicyV1beta1PodSecurityPolicy>(params: Params$createPolicyV1beta1PodSecurityPolicy<ResponseContentType>, option?: RequestOption): Promise<(Response$createPolicyV1beta1PodSecurityPolicy$Status$200 | Response$createPolicyV1beta1PodSecurityPolicy$Status$201 | Response$createPolicyV1beta1PodSecurityPolicy$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/policy/v1beta1/podsecuritypolicies\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete collection of PodSecurityPolicy */
+        deletePolicyV1beta1CollectionPodSecurityPolicy: <ResponseContentType extends ResponseContentType$deletePolicyV1beta1CollectionPodSecurityPolicy>(params: Params$deletePolicyV1beta1CollectionPodSecurityPolicy<ResponseContentType>, option?: RequestOption): Promise<Response$deletePolicyV1beta1CollectionPodSecurityPolicy$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/policy/v1beta1/podsecuritypolicies\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read the specified PodSecurityPolicy */
+        readPolicyV1beta1PodSecurityPolicy: <ResponseContentType extends ResponseContentType$readPolicyV1beta1PodSecurityPolicy>(params: Params$readPolicyV1beta1PodSecurityPolicy<ResponseContentType>, option?: RequestOption): Promise<Response$readPolicyV1beta1PodSecurityPolicy$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/policy/v1beta1/podsecuritypolicies/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                exact: { value: params.parameter.exact, explode: false },
+                export: { value: params.parameter.export, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace the specified PodSecurityPolicy */
+        replacePolicyV1beta1PodSecurityPolicy: <ResponseContentType extends ResponseContentType$replacePolicyV1beta1PodSecurityPolicy>(params: Params$replacePolicyV1beta1PodSecurityPolicy<ResponseContentType>, option?: RequestOption): Promise<(Response$replacePolicyV1beta1PodSecurityPolicy$Status$200 | Response$replacePolicyV1beta1PodSecurityPolicy$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/policy/v1beta1/podsecuritypolicies/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete a PodSecurityPolicy */
+        deletePolicyV1beta1PodSecurityPolicy: <ResponseContentType extends ResponseContentType$deletePolicyV1beta1PodSecurityPolicy>(params: Params$deletePolicyV1beta1PodSecurityPolicy<ResponseContentType>, option?: RequestOption): Promise<(Response$deletePolicyV1beta1PodSecurityPolicy$Status$200 | Response$deletePolicyV1beta1PodSecurityPolicy$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/policy/v1beta1/podsecuritypolicies/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update the specified PodSecurityPolicy */
+        patchPolicyV1beta1PodSecurityPolicy: <RequestContentType extends RequestContentType$patchPolicyV1beta1PodSecurityPolicy, ResponseContentType extends ResponseContentType$patchPolicyV1beta1PodSecurityPolicy>(params: Params$patchPolicyV1beta1PodSecurityPolicy<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchPolicyV1beta1PodSecurityPolicy$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/policy/v1beta1/podsecuritypolicies/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** watch individual changes to a list of PodDisruptionBudget. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchPolicyV1beta1NamespacedPodDisruptionBudgetList: <ResponseContentType extends ResponseContentType$watchPolicyV1beta1NamespacedPodDisruptionBudgetList>(params: Params$watchPolicyV1beta1NamespacedPodDisruptionBudgetList<ResponseContentType>, option?: RequestOption): Promise<Response$watchPolicyV1beta1NamespacedPodDisruptionBudgetList$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/policy/v1beta1/watch/namespaces/\${params.parameter.namespace}/poddisruptionbudgets\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch changes to an object of kind PodDisruptionBudget. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. */
+        watchPolicyV1beta1NamespacedPodDisruptionBudget: <ResponseContentType extends ResponseContentType$watchPolicyV1beta1NamespacedPodDisruptionBudget>(params: Params$watchPolicyV1beta1NamespacedPodDisruptionBudget<ResponseContentType>, option?: RequestOption): Promise<Response$watchPolicyV1beta1NamespacedPodDisruptionBudget$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/policy/v1beta1/watch/namespaces/\${params.parameter.namespace}/poddisruptionbudgets/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of PodDisruptionBudget. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchPolicyV1beta1PodDisruptionBudgetListForAllNamespaces: <ResponseContentType extends ResponseContentType$watchPolicyV1beta1PodDisruptionBudgetListForAllNamespaces>(params: Params$watchPolicyV1beta1PodDisruptionBudgetListForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$watchPolicyV1beta1PodDisruptionBudgetListForAllNamespaces$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/policy/v1beta1/watch/poddisruptionbudgets\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of PodSecurityPolicy. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchPolicyV1beta1PodSecurityPolicyList: <ResponseContentType extends ResponseContentType$watchPolicyV1beta1PodSecurityPolicyList>(params: Params$watchPolicyV1beta1PodSecurityPolicyList<ResponseContentType>, option?: RequestOption): Promise<Response$watchPolicyV1beta1PodSecurityPolicyList$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/policy/v1beta1/watch/podsecuritypolicies\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch changes to an object of kind PodSecurityPolicy. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. */
+        watchPolicyV1beta1PodSecurityPolicy: <ResponseContentType extends ResponseContentType$watchPolicyV1beta1PodSecurityPolicy>(params: Params$watchPolicyV1beta1PodSecurityPolicy<ResponseContentType>, option?: RequestOption): Promise<Response$watchPolicyV1beta1PodSecurityPolicy$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/policy/v1beta1/watch/podsecuritypolicies/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** get information of a group */
+        getRbacAuthorizationAPIGroup: <ResponseContentType extends ResponseContentType$getRbacAuthorizationAPIGroup>(params: Params$getRbacAuthorizationAPIGroup<ResponseContentType>, option?: RequestOption): Promise<Response$getRbacAuthorizationAPIGroup$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        /** get available resources */
+        getRbacAuthorizationV1APIResources: <ResponseContentType extends ResponseContentType$getRbacAuthorizationV1APIResources>(params: Params$getRbacAuthorizationV1APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getRbacAuthorizationV1APIResources$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        /** list or watch objects of kind ClusterRoleBinding */
+        listRbacAuthorizationV1ClusterRoleBinding: <ResponseContentType extends ResponseContentType$listRbacAuthorizationV1ClusterRoleBinding>(params: Params$listRbacAuthorizationV1ClusterRoleBinding<ResponseContentType>, option?: RequestOption): Promise<Response$listRbacAuthorizationV1ClusterRoleBinding$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/clusterrolebindings\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** create a ClusterRoleBinding */
+        createRbacAuthorizationV1ClusterRoleBinding: <ResponseContentType extends ResponseContentType$createRbacAuthorizationV1ClusterRoleBinding>(params: Params$createRbacAuthorizationV1ClusterRoleBinding<ResponseContentType>, option?: RequestOption): Promise<(Response$createRbacAuthorizationV1ClusterRoleBinding$Status$200 | Response$createRbacAuthorizationV1ClusterRoleBinding$Status$201 | Response$createRbacAuthorizationV1ClusterRoleBinding$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/clusterrolebindings\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete collection of ClusterRoleBinding */
+        deleteRbacAuthorizationV1CollectionClusterRoleBinding: <ResponseContentType extends ResponseContentType$deleteRbacAuthorizationV1CollectionClusterRoleBinding>(params: Params$deleteRbacAuthorizationV1CollectionClusterRoleBinding<ResponseContentType>, option?: RequestOption): Promise<Response$deleteRbacAuthorizationV1CollectionClusterRoleBinding$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/clusterrolebindings\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read the specified ClusterRoleBinding */
+        readRbacAuthorizationV1ClusterRoleBinding: <ResponseContentType extends ResponseContentType$readRbacAuthorizationV1ClusterRoleBinding>(params: Params$readRbacAuthorizationV1ClusterRoleBinding<ResponseContentType>, option?: RequestOption): Promise<Response$readRbacAuthorizationV1ClusterRoleBinding$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/clusterrolebindings/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace the specified ClusterRoleBinding */
+        replaceRbacAuthorizationV1ClusterRoleBinding: <ResponseContentType extends ResponseContentType$replaceRbacAuthorizationV1ClusterRoleBinding>(params: Params$replaceRbacAuthorizationV1ClusterRoleBinding<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceRbacAuthorizationV1ClusterRoleBinding$Status$200 | Response$replaceRbacAuthorizationV1ClusterRoleBinding$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/clusterrolebindings/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete a ClusterRoleBinding */
+        deleteRbacAuthorizationV1ClusterRoleBinding: <ResponseContentType extends ResponseContentType$deleteRbacAuthorizationV1ClusterRoleBinding>(params: Params$deleteRbacAuthorizationV1ClusterRoleBinding<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteRbacAuthorizationV1ClusterRoleBinding$Status$200 | Response$deleteRbacAuthorizationV1ClusterRoleBinding$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/clusterrolebindings/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update the specified ClusterRoleBinding */
+        patchRbacAuthorizationV1ClusterRoleBinding: <RequestContentType extends RequestContentType$patchRbacAuthorizationV1ClusterRoleBinding, ResponseContentType extends ResponseContentType$patchRbacAuthorizationV1ClusterRoleBinding>(params: Params$patchRbacAuthorizationV1ClusterRoleBinding<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchRbacAuthorizationV1ClusterRoleBinding$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/clusterrolebindings/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** list or watch objects of kind ClusterRole */
+        listRbacAuthorizationV1ClusterRole: <ResponseContentType extends ResponseContentType$listRbacAuthorizationV1ClusterRole>(params: Params$listRbacAuthorizationV1ClusterRole<ResponseContentType>, option?: RequestOption): Promise<Response$listRbacAuthorizationV1ClusterRole$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/clusterroles\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** create a ClusterRole */
+        createRbacAuthorizationV1ClusterRole: <ResponseContentType extends ResponseContentType$createRbacAuthorizationV1ClusterRole>(params: Params$createRbacAuthorizationV1ClusterRole<ResponseContentType>, option?: RequestOption): Promise<(Response$createRbacAuthorizationV1ClusterRole$Status$200 | Response$createRbacAuthorizationV1ClusterRole$Status$201 | Response$createRbacAuthorizationV1ClusterRole$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/clusterroles\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete collection of ClusterRole */
+        deleteRbacAuthorizationV1CollectionClusterRole: <ResponseContentType extends ResponseContentType$deleteRbacAuthorizationV1CollectionClusterRole>(params: Params$deleteRbacAuthorizationV1CollectionClusterRole<ResponseContentType>, option?: RequestOption): Promise<Response$deleteRbacAuthorizationV1CollectionClusterRole$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/clusterroles\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read the specified ClusterRole */
+        readRbacAuthorizationV1ClusterRole: <ResponseContentType extends ResponseContentType$readRbacAuthorizationV1ClusterRole>(params: Params$readRbacAuthorizationV1ClusterRole<ResponseContentType>, option?: RequestOption): Promise<Response$readRbacAuthorizationV1ClusterRole$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/clusterroles/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace the specified ClusterRole */
+        replaceRbacAuthorizationV1ClusterRole: <ResponseContentType extends ResponseContentType$replaceRbacAuthorizationV1ClusterRole>(params: Params$replaceRbacAuthorizationV1ClusterRole<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceRbacAuthorizationV1ClusterRole$Status$200 | Response$replaceRbacAuthorizationV1ClusterRole$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/clusterroles/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete a ClusterRole */
+        deleteRbacAuthorizationV1ClusterRole: <ResponseContentType extends ResponseContentType$deleteRbacAuthorizationV1ClusterRole>(params: Params$deleteRbacAuthorizationV1ClusterRole<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteRbacAuthorizationV1ClusterRole$Status$200 | Response$deleteRbacAuthorizationV1ClusterRole$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/clusterroles/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update the specified ClusterRole */
+        patchRbacAuthorizationV1ClusterRole: <RequestContentType extends RequestContentType$patchRbacAuthorizationV1ClusterRole, ResponseContentType extends ResponseContentType$patchRbacAuthorizationV1ClusterRole>(params: Params$patchRbacAuthorizationV1ClusterRole<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchRbacAuthorizationV1ClusterRole$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/clusterroles/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** list or watch objects of kind RoleBinding */
+        listRbacAuthorizationV1NamespacedRoleBinding: <ResponseContentType extends ResponseContentType$listRbacAuthorizationV1NamespacedRoleBinding>(params: Params$listRbacAuthorizationV1NamespacedRoleBinding<ResponseContentType>, option?: RequestOption): Promise<Response$listRbacAuthorizationV1NamespacedRoleBinding$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/namespaces/\${params.parameter.namespace}/rolebindings\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** create a RoleBinding */
+        createRbacAuthorizationV1NamespacedRoleBinding: <ResponseContentType extends ResponseContentType$createRbacAuthorizationV1NamespacedRoleBinding>(params: Params$createRbacAuthorizationV1NamespacedRoleBinding<ResponseContentType>, option?: RequestOption): Promise<(Response$createRbacAuthorizationV1NamespacedRoleBinding$Status$200 | Response$createRbacAuthorizationV1NamespacedRoleBinding$Status$201 | Response$createRbacAuthorizationV1NamespacedRoleBinding$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/namespaces/\${params.parameter.namespace}/rolebindings\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete collection of RoleBinding */
+        deleteRbacAuthorizationV1CollectionNamespacedRoleBinding: <ResponseContentType extends ResponseContentType$deleteRbacAuthorizationV1CollectionNamespacedRoleBinding>(params: Params$deleteRbacAuthorizationV1CollectionNamespacedRoleBinding<ResponseContentType>, option?: RequestOption): Promise<Response$deleteRbacAuthorizationV1CollectionNamespacedRoleBinding$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/namespaces/\${params.parameter.namespace}/rolebindings\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read the specified RoleBinding */
+        readRbacAuthorizationV1NamespacedRoleBinding: <ResponseContentType extends ResponseContentType$readRbacAuthorizationV1NamespacedRoleBinding>(params: Params$readRbacAuthorizationV1NamespacedRoleBinding<ResponseContentType>, option?: RequestOption): Promise<Response$readRbacAuthorizationV1NamespacedRoleBinding$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/namespaces/\${params.parameter.namespace}/rolebindings/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace the specified RoleBinding */
+        replaceRbacAuthorizationV1NamespacedRoleBinding: <ResponseContentType extends ResponseContentType$replaceRbacAuthorizationV1NamespacedRoleBinding>(params: Params$replaceRbacAuthorizationV1NamespacedRoleBinding<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceRbacAuthorizationV1NamespacedRoleBinding$Status$200 | Response$replaceRbacAuthorizationV1NamespacedRoleBinding$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/namespaces/\${params.parameter.namespace}/rolebindings/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete a RoleBinding */
+        deleteRbacAuthorizationV1NamespacedRoleBinding: <ResponseContentType extends ResponseContentType$deleteRbacAuthorizationV1NamespacedRoleBinding>(params: Params$deleteRbacAuthorizationV1NamespacedRoleBinding<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteRbacAuthorizationV1NamespacedRoleBinding$Status$200 | Response$deleteRbacAuthorizationV1NamespacedRoleBinding$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/namespaces/\${params.parameter.namespace}/rolebindings/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update the specified RoleBinding */
+        patchRbacAuthorizationV1NamespacedRoleBinding: <RequestContentType extends RequestContentType$patchRbacAuthorizationV1NamespacedRoleBinding, ResponseContentType extends ResponseContentType$patchRbacAuthorizationV1NamespacedRoleBinding>(params: Params$patchRbacAuthorizationV1NamespacedRoleBinding<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchRbacAuthorizationV1NamespacedRoleBinding$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/namespaces/\${params.parameter.namespace}/rolebindings/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** list or watch objects of kind Role */
+        listRbacAuthorizationV1NamespacedRole: <ResponseContentType extends ResponseContentType$listRbacAuthorizationV1NamespacedRole>(params: Params$listRbacAuthorizationV1NamespacedRole<ResponseContentType>, option?: RequestOption): Promise<Response$listRbacAuthorizationV1NamespacedRole$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/namespaces/\${params.parameter.namespace}/roles\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** create a Role */
+        createRbacAuthorizationV1NamespacedRole: <ResponseContentType extends ResponseContentType$createRbacAuthorizationV1NamespacedRole>(params: Params$createRbacAuthorizationV1NamespacedRole<ResponseContentType>, option?: RequestOption): Promise<(Response$createRbacAuthorizationV1NamespacedRole$Status$200 | Response$createRbacAuthorizationV1NamespacedRole$Status$201 | Response$createRbacAuthorizationV1NamespacedRole$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/namespaces/\${params.parameter.namespace}/roles\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete collection of Role */
+        deleteRbacAuthorizationV1CollectionNamespacedRole: <ResponseContentType extends ResponseContentType$deleteRbacAuthorizationV1CollectionNamespacedRole>(params: Params$deleteRbacAuthorizationV1CollectionNamespacedRole<ResponseContentType>, option?: RequestOption): Promise<Response$deleteRbacAuthorizationV1CollectionNamespacedRole$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/namespaces/\${params.parameter.namespace}/roles\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read the specified Role */
+        readRbacAuthorizationV1NamespacedRole: <ResponseContentType extends ResponseContentType$readRbacAuthorizationV1NamespacedRole>(params: Params$readRbacAuthorizationV1NamespacedRole<ResponseContentType>, option?: RequestOption): Promise<Response$readRbacAuthorizationV1NamespacedRole$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/namespaces/\${params.parameter.namespace}/roles/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace the specified Role */
+        replaceRbacAuthorizationV1NamespacedRole: <ResponseContentType extends ResponseContentType$replaceRbacAuthorizationV1NamespacedRole>(params: Params$replaceRbacAuthorizationV1NamespacedRole<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceRbacAuthorizationV1NamespacedRole$Status$200 | Response$replaceRbacAuthorizationV1NamespacedRole$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/namespaces/\${params.parameter.namespace}/roles/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete a Role */
+        deleteRbacAuthorizationV1NamespacedRole: <ResponseContentType extends ResponseContentType$deleteRbacAuthorizationV1NamespacedRole>(params: Params$deleteRbacAuthorizationV1NamespacedRole<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteRbacAuthorizationV1NamespacedRole$Status$200 | Response$deleteRbacAuthorizationV1NamespacedRole$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/namespaces/\${params.parameter.namespace}/roles/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update the specified Role */
+        patchRbacAuthorizationV1NamespacedRole: <RequestContentType extends RequestContentType$patchRbacAuthorizationV1NamespacedRole, ResponseContentType extends ResponseContentType$patchRbacAuthorizationV1NamespacedRole>(params: Params$patchRbacAuthorizationV1NamespacedRole<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchRbacAuthorizationV1NamespacedRole$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/namespaces/\${params.parameter.namespace}/roles/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** list or watch objects of kind RoleBinding */
+        listRbacAuthorizationV1RoleBindingForAllNamespaces: <ResponseContentType extends ResponseContentType$listRbacAuthorizationV1RoleBindingForAllNamespaces>(params: Params$listRbacAuthorizationV1RoleBindingForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$listRbacAuthorizationV1RoleBindingForAllNamespaces$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/rolebindings\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** list or watch objects of kind Role */
+        listRbacAuthorizationV1RoleForAllNamespaces: <ResponseContentType extends ResponseContentType$listRbacAuthorizationV1RoleForAllNamespaces>(params: Params$listRbacAuthorizationV1RoleForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$listRbacAuthorizationV1RoleForAllNamespaces$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/roles\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of ClusterRoleBinding. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchRbacAuthorizationV1ClusterRoleBindingList: <ResponseContentType extends ResponseContentType$watchRbacAuthorizationV1ClusterRoleBindingList>(params: Params$watchRbacAuthorizationV1ClusterRoleBindingList<ResponseContentType>, option?: RequestOption): Promise<Response$watchRbacAuthorizationV1ClusterRoleBindingList$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/watch/clusterrolebindings\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch changes to an object of kind ClusterRoleBinding. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. */
+        watchRbacAuthorizationV1ClusterRoleBinding: <ResponseContentType extends ResponseContentType$watchRbacAuthorizationV1ClusterRoleBinding>(params: Params$watchRbacAuthorizationV1ClusterRoleBinding<ResponseContentType>, option?: RequestOption): Promise<Response$watchRbacAuthorizationV1ClusterRoleBinding$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/watch/clusterrolebindings/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of ClusterRole. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchRbacAuthorizationV1ClusterRoleList: <ResponseContentType extends ResponseContentType$watchRbacAuthorizationV1ClusterRoleList>(params: Params$watchRbacAuthorizationV1ClusterRoleList<ResponseContentType>, option?: RequestOption): Promise<Response$watchRbacAuthorizationV1ClusterRoleList$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/watch/clusterroles\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch changes to an object of kind ClusterRole. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. */
+        watchRbacAuthorizationV1ClusterRole: <ResponseContentType extends ResponseContentType$watchRbacAuthorizationV1ClusterRole>(params: Params$watchRbacAuthorizationV1ClusterRole<ResponseContentType>, option?: RequestOption): Promise<Response$watchRbacAuthorizationV1ClusterRole$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/watch/clusterroles/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of RoleBinding. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchRbacAuthorizationV1NamespacedRoleBindingList: <ResponseContentType extends ResponseContentType$watchRbacAuthorizationV1NamespacedRoleBindingList>(params: Params$watchRbacAuthorizationV1NamespacedRoleBindingList<ResponseContentType>, option?: RequestOption): Promise<Response$watchRbacAuthorizationV1NamespacedRoleBindingList$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/watch/namespaces/\${params.parameter.namespace}/rolebindings\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch changes to an object of kind RoleBinding. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. */
+        watchRbacAuthorizationV1NamespacedRoleBinding: <ResponseContentType extends ResponseContentType$watchRbacAuthorizationV1NamespacedRoleBinding>(params: Params$watchRbacAuthorizationV1NamespacedRoleBinding<ResponseContentType>, option?: RequestOption): Promise<Response$watchRbacAuthorizationV1NamespacedRoleBinding$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/watch/namespaces/\${params.parameter.namespace}/rolebindings/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of Role. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchRbacAuthorizationV1NamespacedRoleList: <ResponseContentType extends ResponseContentType$watchRbacAuthorizationV1NamespacedRoleList>(params: Params$watchRbacAuthorizationV1NamespacedRoleList<ResponseContentType>, option?: RequestOption): Promise<Response$watchRbacAuthorizationV1NamespacedRoleList$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/watch/namespaces/\${params.parameter.namespace}/roles\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch changes to an object of kind Role. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. */
+        watchRbacAuthorizationV1NamespacedRole: <ResponseContentType extends ResponseContentType$watchRbacAuthorizationV1NamespacedRole>(params: Params$watchRbacAuthorizationV1NamespacedRole<ResponseContentType>, option?: RequestOption): Promise<Response$watchRbacAuthorizationV1NamespacedRole$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/watch/namespaces/\${params.parameter.namespace}/roles/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of RoleBinding. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchRbacAuthorizationV1RoleBindingListForAllNamespaces: <ResponseContentType extends ResponseContentType$watchRbacAuthorizationV1RoleBindingListForAllNamespaces>(params: Params$watchRbacAuthorizationV1RoleBindingListForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$watchRbacAuthorizationV1RoleBindingListForAllNamespaces$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/watch/rolebindings\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of Role. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchRbacAuthorizationV1RoleListForAllNamespaces: <ResponseContentType extends ResponseContentType$watchRbacAuthorizationV1RoleListForAllNamespaces>(params: Params$watchRbacAuthorizationV1RoleListForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$watchRbacAuthorizationV1RoleListForAllNamespaces$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1/watch/roles\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** get available resources */
+        getRbacAuthorizationV1alpha1APIResources: <ResponseContentType extends ResponseContentType$getRbacAuthorizationV1alpha1APIResources>(params: Params$getRbacAuthorizationV1alpha1APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getRbacAuthorizationV1alpha1APIResources$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        /** list or watch objects of kind ClusterRoleBinding */
+        listRbacAuthorizationV1alpha1ClusterRoleBinding: <ResponseContentType extends ResponseContentType$listRbacAuthorizationV1alpha1ClusterRoleBinding>(params: Params$listRbacAuthorizationV1alpha1ClusterRoleBinding<ResponseContentType>, option?: RequestOption): Promise<Response$listRbacAuthorizationV1alpha1ClusterRoleBinding$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/clusterrolebindings\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** create a ClusterRoleBinding */
+        createRbacAuthorizationV1alpha1ClusterRoleBinding: <ResponseContentType extends ResponseContentType$createRbacAuthorizationV1alpha1ClusterRoleBinding>(params: Params$createRbacAuthorizationV1alpha1ClusterRoleBinding<ResponseContentType>, option?: RequestOption): Promise<(Response$createRbacAuthorizationV1alpha1ClusterRoleBinding$Status$200 | Response$createRbacAuthorizationV1alpha1ClusterRoleBinding$Status$201 | Response$createRbacAuthorizationV1alpha1ClusterRoleBinding$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/clusterrolebindings\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete collection of ClusterRoleBinding */
+        deleteRbacAuthorizationV1alpha1CollectionClusterRoleBinding: <ResponseContentType extends ResponseContentType$deleteRbacAuthorizationV1alpha1CollectionClusterRoleBinding>(params: Params$deleteRbacAuthorizationV1alpha1CollectionClusterRoleBinding<ResponseContentType>, option?: RequestOption): Promise<Response$deleteRbacAuthorizationV1alpha1CollectionClusterRoleBinding$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/clusterrolebindings\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read the specified ClusterRoleBinding */
+        readRbacAuthorizationV1alpha1ClusterRoleBinding: <ResponseContentType extends ResponseContentType$readRbacAuthorizationV1alpha1ClusterRoleBinding>(params: Params$readRbacAuthorizationV1alpha1ClusterRoleBinding<ResponseContentType>, option?: RequestOption): Promise<Response$readRbacAuthorizationV1alpha1ClusterRoleBinding$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/clusterrolebindings/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace the specified ClusterRoleBinding */
+        replaceRbacAuthorizationV1alpha1ClusterRoleBinding: <ResponseContentType extends ResponseContentType$replaceRbacAuthorizationV1alpha1ClusterRoleBinding>(params: Params$replaceRbacAuthorizationV1alpha1ClusterRoleBinding<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceRbacAuthorizationV1alpha1ClusterRoleBinding$Status$200 | Response$replaceRbacAuthorizationV1alpha1ClusterRoleBinding$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/clusterrolebindings/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete a ClusterRoleBinding */
+        deleteRbacAuthorizationV1alpha1ClusterRoleBinding: <ResponseContentType extends ResponseContentType$deleteRbacAuthorizationV1alpha1ClusterRoleBinding>(params: Params$deleteRbacAuthorizationV1alpha1ClusterRoleBinding<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteRbacAuthorizationV1alpha1ClusterRoleBinding$Status$200 | Response$deleteRbacAuthorizationV1alpha1ClusterRoleBinding$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/clusterrolebindings/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update the specified ClusterRoleBinding */
+        patchRbacAuthorizationV1alpha1ClusterRoleBinding: <RequestContentType extends RequestContentType$patchRbacAuthorizationV1alpha1ClusterRoleBinding, ResponseContentType extends ResponseContentType$patchRbacAuthorizationV1alpha1ClusterRoleBinding>(params: Params$patchRbacAuthorizationV1alpha1ClusterRoleBinding<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchRbacAuthorizationV1alpha1ClusterRoleBinding$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/clusterrolebindings/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** list or watch objects of kind ClusterRole */
+        listRbacAuthorizationV1alpha1ClusterRole: <ResponseContentType extends ResponseContentType$listRbacAuthorizationV1alpha1ClusterRole>(params: Params$listRbacAuthorizationV1alpha1ClusterRole<ResponseContentType>, option?: RequestOption): Promise<Response$listRbacAuthorizationV1alpha1ClusterRole$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/clusterroles\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** create a ClusterRole */
+        createRbacAuthorizationV1alpha1ClusterRole: <ResponseContentType extends ResponseContentType$createRbacAuthorizationV1alpha1ClusterRole>(params: Params$createRbacAuthorizationV1alpha1ClusterRole<ResponseContentType>, option?: RequestOption): Promise<(Response$createRbacAuthorizationV1alpha1ClusterRole$Status$200 | Response$createRbacAuthorizationV1alpha1ClusterRole$Status$201 | Response$createRbacAuthorizationV1alpha1ClusterRole$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/clusterroles\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete collection of ClusterRole */
+        deleteRbacAuthorizationV1alpha1CollectionClusterRole: <ResponseContentType extends ResponseContentType$deleteRbacAuthorizationV1alpha1CollectionClusterRole>(params: Params$deleteRbacAuthorizationV1alpha1CollectionClusterRole<ResponseContentType>, option?: RequestOption): Promise<Response$deleteRbacAuthorizationV1alpha1CollectionClusterRole$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/clusterroles\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read the specified ClusterRole */
+        readRbacAuthorizationV1alpha1ClusterRole: <ResponseContentType extends ResponseContentType$readRbacAuthorizationV1alpha1ClusterRole>(params: Params$readRbacAuthorizationV1alpha1ClusterRole<ResponseContentType>, option?: RequestOption): Promise<Response$readRbacAuthorizationV1alpha1ClusterRole$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/clusterroles/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace the specified ClusterRole */
+        replaceRbacAuthorizationV1alpha1ClusterRole: <ResponseContentType extends ResponseContentType$replaceRbacAuthorizationV1alpha1ClusterRole>(params: Params$replaceRbacAuthorizationV1alpha1ClusterRole<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceRbacAuthorizationV1alpha1ClusterRole$Status$200 | Response$replaceRbacAuthorizationV1alpha1ClusterRole$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/clusterroles/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete a ClusterRole */
+        deleteRbacAuthorizationV1alpha1ClusterRole: <ResponseContentType extends ResponseContentType$deleteRbacAuthorizationV1alpha1ClusterRole>(params: Params$deleteRbacAuthorizationV1alpha1ClusterRole<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteRbacAuthorizationV1alpha1ClusterRole$Status$200 | Response$deleteRbacAuthorizationV1alpha1ClusterRole$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/clusterroles/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update the specified ClusterRole */
+        patchRbacAuthorizationV1alpha1ClusterRole: <RequestContentType extends RequestContentType$patchRbacAuthorizationV1alpha1ClusterRole, ResponseContentType extends ResponseContentType$patchRbacAuthorizationV1alpha1ClusterRole>(params: Params$patchRbacAuthorizationV1alpha1ClusterRole<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchRbacAuthorizationV1alpha1ClusterRole$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/clusterroles/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** list or watch objects of kind RoleBinding */
+        listRbacAuthorizationV1alpha1NamespacedRoleBinding: <ResponseContentType extends ResponseContentType$listRbacAuthorizationV1alpha1NamespacedRoleBinding>(params: Params$listRbacAuthorizationV1alpha1NamespacedRoleBinding<ResponseContentType>, option?: RequestOption): Promise<Response$listRbacAuthorizationV1alpha1NamespacedRoleBinding$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/namespaces/\${params.parameter.namespace}/rolebindings\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** create a RoleBinding */
+        createRbacAuthorizationV1alpha1NamespacedRoleBinding: <ResponseContentType extends ResponseContentType$createRbacAuthorizationV1alpha1NamespacedRoleBinding>(params: Params$createRbacAuthorizationV1alpha1NamespacedRoleBinding<ResponseContentType>, option?: RequestOption): Promise<(Response$createRbacAuthorizationV1alpha1NamespacedRoleBinding$Status$200 | Response$createRbacAuthorizationV1alpha1NamespacedRoleBinding$Status$201 | Response$createRbacAuthorizationV1alpha1NamespacedRoleBinding$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/namespaces/\${params.parameter.namespace}/rolebindings\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete collection of RoleBinding */
+        deleteRbacAuthorizationV1alpha1CollectionNamespacedRoleBinding: <ResponseContentType extends ResponseContentType$deleteRbacAuthorizationV1alpha1CollectionNamespacedRoleBinding>(params: Params$deleteRbacAuthorizationV1alpha1CollectionNamespacedRoleBinding<ResponseContentType>, option?: RequestOption): Promise<Response$deleteRbacAuthorizationV1alpha1CollectionNamespacedRoleBinding$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/namespaces/\${params.parameter.namespace}/rolebindings\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read the specified RoleBinding */
+        readRbacAuthorizationV1alpha1NamespacedRoleBinding: <ResponseContentType extends ResponseContentType$readRbacAuthorizationV1alpha1NamespacedRoleBinding>(params: Params$readRbacAuthorizationV1alpha1NamespacedRoleBinding<ResponseContentType>, option?: RequestOption): Promise<Response$readRbacAuthorizationV1alpha1NamespacedRoleBinding$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/namespaces/\${params.parameter.namespace}/rolebindings/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace the specified RoleBinding */
+        replaceRbacAuthorizationV1alpha1NamespacedRoleBinding: <ResponseContentType extends ResponseContentType$replaceRbacAuthorizationV1alpha1NamespacedRoleBinding>(params: Params$replaceRbacAuthorizationV1alpha1NamespacedRoleBinding<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceRbacAuthorizationV1alpha1NamespacedRoleBinding$Status$200 | Response$replaceRbacAuthorizationV1alpha1NamespacedRoleBinding$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/namespaces/\${params.parameter.namespace}/rolebindings/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete a RoleBinding */
+        deleteRbacAuthorizationV1alpha1NamespacedRoleBinding: <ResponseContentType extends ResponseContentType$deleteRbacAuthorizationV1alpha1NamespacedRoleBinding>(params: Params$deleteRbacAuthorizationV1alpha1NamespacedRoleBinding<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteRbacAuthorizationV1alpha1NamespacedRoleBinding$Status$200 | Response$deleteRbacAuthorizationV1alpha1NamespacedRoleBinding$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/namespaces/\${params.parameter.namespace}/rolebindings/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update the specified RoleBinding */
+        patchRbacAuthorizationV1alpha1NamespacedRoleBinding: <RequestContentType extends RequestContentType$patchRbacAuthorizationV1alpha1NamespacedRoleBinding, ResponseContentType extends ResponseContentType$patchRbacAuthorizationV1alpha1NamespacedRoleBinding>(params: Params$patchRbacAuthorizationV1alpha1NamespacedRoleBinding<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchRbacAuthorizationV1alpha1NamespacedRoleBinding$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/namespaces/\${params.parameter.namespace}/rolebindings/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** list or watch objects of kind Role */
+        listRbacAuthorizationV1alpha1NamespacedRole: <ResponseContentType extends ResponseContentType$listRbacAuthorizationV1alpha1NamespacedRole>(params: Params$listRbacAuthorizationV1alpha1NamespacedRole<ResponseContentType>, option?: RequestOption): Promise<Response$listRbacAuthorizationV1alpha1NamespacedRole$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/namespaces/\${params.parameter.namespace}/roles\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** create a Role */
+        createRbacAuthorizationV1alpha1NamespacedRole: <ResponseContentType extends ResponseContentType$createRbacAuthorizationV1alpha1NamespacedRole>(params: Params$createRbacAuthorizationV1alpha1NamespacedRole<ResponseContentType>, option?: RequestOption): Promise<(Response$createRbacAuthorizationV1alpha1NamespacedRole$Status$200 | Response$createRbacAuthorizationV1alpha1NamespacedRole$Status$201 | Response$createRbacAuthorizationV1alpha1NamespacedRole$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/namespaces/\${params.parameter.namespace}/roles\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete collection of Role */
+        deleteRbacAuthorizationV1alpha1CollectionNamespacedRole: <ResponseContentType extends ResponseContentType$deleteRbacAuthorizationV1alpha1CollectionNamespacedRole>(params: Params$deleteRbacAuthorizationV1alpha1CollectionNamespacedRole<ResponseContentType>, option?: RequestOption): Promise<Response$deleteRbacAuthorizationV1alpha1CollectionNamespacedRole$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/namespaces/\${params.parameter.namespace}/roles\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read the specified Role */
+        readRbacAuthorizationV1alpha1NamespacedRole: <ResponseContentType extends ResponseContentType$readRbacAuthorizationV1alpha1NamespacedRole>(params: Params$readRbacAuthorizationV1alpha1NamespacedRole<ResponseContentType>, option?: RequestOption): Promise<Response$readRbacAuthorizationV1alpha1NamespacedRole$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/namespaces/\${params.parameter.namespace}/roles/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace the specified Role */
+        replaceRbacAuthorizationV1alpha1NamespacedRole: <ResponseContentType extends ResponseContentType$replaceRbacAuthorizationV1alpha1NamespacedRole>(params: Params$replaceRbacAuthorizationV1alpha1NamespacedRole<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceRbacAuthorizationV1alpha1NamespacedRole$Status$200 | Response$replaceRbacAuthorizationV1alpha1NamespacedRole$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/namespaces/\${params.parameter.namespace}/roles/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete a Role */
+        deleteRbacAuthorizationV1alpha1NamespacedRole: <ResponseContentType extends ResponseContentType$deleteRbacAuthorizationV1alpha1NamespacedRole>(params: Params$deleteRbacAuthorizationV1alpha1NamespacedRole<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteRbacAuthorizationV1alpha1NamespacedRole$Status$200 | Response$deleteRbacAuthorizationV1alpha1NamespacedRole$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/namespaces/\${params.parameter.namespace}/roles/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update the specified Role */
+        patchRbacAuthorizationV1alpha1NamespacedRole: <RequestContentType extends RequestContentType$patchRbacAuthorizationV1alpha1NamespacedRole, ResponseContentType extends ResponseContentType$patchRbacAuthorizationV1alpha1NamespacedRole>(params: Params$patchRbacAuthorizationV1alpha1NamespacedRole<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchRbacAuthorizationV1alpha1NamespacedRole$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/namespaces/\${params.parameter.namespace}/roles/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** list or watch objects of kind RoleBinding */
+        listRbacAuthorizationV1alpha1RoleBindingForAllNamespaces: <ResponseContentType extends ResponseContentType$listRbacAuthorizationV1alpha1RoleBindingForAllNamespaces>(params: Params$listRbacAuthorizationV1alpha1RoleBindingForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$listRbacAuthorizationV1alpha1RoleBindingForAllNamespaces$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/rolebindings\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** list or watch objects of kind Role */
+        listRbacAuthorizationV1alpha1RoleForAllNamespaces: <ResponseContentType extends ResponseContentType$listRbacAuthorizationV1alpha1RoleForAllNamespaces>(params: Params$listRbacAuthorizationV1alpha1RoleForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$listRbacAuthorizationV1alpha1RoleForAllNamespaces$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/roles\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of ClusterRoleBinding. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchRbacAuthorizationV1alpha1ClusterRoleBindingList: <ResponseContentType extends ResponseContentType$watchRbacAuthorizationV1alpha1ClusterRoleBindingList>(params: Params$watchRbacAuthorizationV1alpha1ClusterRoleBindingList<ResponseContentType>, option?: RequestOption): Promise<Response$watchRbacAuthorizationV1alpha1ClusterRoleBindingList$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/watch/clusterrolebindings\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch changes to an object of kind ClusterRoleBinding. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. */
+        watchRbacAuthorizationV1alpha1ClusterRoleBinding: <ResponseContentType extends ResponseContentType$watchRbacAuthorizationV1alpha1ClusterRoleBinding>(params: Params$watchRbacAuthorizationV1alpha1ClusterRoleBinding<ResponseContentType>, option?: RequestOption): Promise<Response$watchRbacAuthorizationV1alpha1ClusterRoleBinding$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/watch/clusterrolebindings/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of ClusterRole. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchRbacAuthorizationV1alpha1ClusterRoleList: <ResponseContentType extends ResponseContentType$watchRbacAuthorizationV1alpha1ClusterRoleList>(params: Params$watchRbacAuthorizationV1alpha1ClusterRoleList<ResponseContentType>, option?: RequestOption): Promise<Response$watchRbacAuthorizationV1alpha1ClusterRoleList$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/watch/clusterroles\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch changes to an object of kind ClusterRole. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. */
+        watchRbacAuthorizationV1alpha1ClusterRole: <ResponseContentType extends ResponseContentType$watchRbacAuthorizationV1alpha1ClusterRole>(params: Params$watchRbacAuthorizationV1alpha1ClusterRole<ResponseContentType>, option?: RequestOption): Promise<Response$watchRbacAuthorizationV1alpha1ClusterRole$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/watch/clusterroles/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of RoleBinding. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchRbacAuthorizationV1alpha1NamespacedRoleBindingList: <ResponseContentType extends ResponseContentType$watchRbacAuthorizationV1alpha1NamespacedRoleBindingList>(params: Params$watchRbacAuthorizationV1alpha1NamespacedRoleBindingList<ResponseContentType>, option?: RequestOption): Promise<Response$watchRbacAuthorizationV1alpha1NamespacedRoleBindingList$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/watch/namespaces/\${params.parameter.namespace}/rolebindings\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch changes to an object of kind RoleBinding. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. */
+        watchRbacAuthorizationV1alpha1NamespacedRoleBinding: <ResponseContentType extends ResponseContentType$watchRbacAuthorizationV1alpha1NamespacedRoleBinding>(params: Params$watchRbacAuthorizationV1alpha1NamespacedRoleBinding<ResponseContentType>, option?: RequestOption): Promise<Response$watchRbacAuthorizationV1alpha1NamespacedRoleBinding$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/watch/namespaces/\${params.parameter.namespace}/rolebindings/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of Role. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchRbacAuthorizationV1alpha1NamespacedRoleList: <ResponseContentType extends ResponseContentType$watchRbacAuthorizationV1alpha1NamespacedRoleList>(params: Params$watchRbacAuthorizationV1alpha1NamespacedRoleList<ResponseContentType>, option?: RequestOption): Promise<Response$watchRbacAuthorizationV1alpha1NamespacedRoleList$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/watch/namespaces/\${params.parameter.namespace}/roles\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch changes to an object of kind Role. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. */
+        watchRbacAuthorizationV1alpha1NamespacedRole: <ResponseContentType extends ResponseContentType$watchRbacAuthorizationV1alpha1NamespacedRole>(params: Params$watchRbacAuthorizationV1alpha1NamespacedRole<ResponseContentType>, option?: RequestOption): Promise<Response$watchRbacAuthorizationV1alpha1NamespacedRole$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/watch/namespaces/\${params.parameter.namespace}/roles/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of RoleBinding. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchRbacAuthorizationV1alpha1RoleBindingListForAllNamespaces: <ResponseContentType extends ResponseContentType$watchRbacAuthorizationV1alpha1RoleBindingListForAllNamespaces>(params: Params$watchRbacAuthorizationV1alpha1RoleBindingListForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$watchRbacAuthorizationV1alpha1RoleBindingListForAllNamespaces$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/watch/rolebindings\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of Role. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchRbacAuthorizationV1alpha1RoleListForAllNamespaces: <ResponseContentType extends ResponseContentType$watchRbacAuthorizationV1alpha1RoleListForAllNamespaces>(params: Params$watchRbacAuthorizationV1alpha1RoleListForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$watchRbacAuthorizationV1alpha1RoleListForAllNamespaces$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1alpha1/watch/roles\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** get available resources */
+        getRbacAuthorizationV1beta1APIResources: <ResponseContentType extends ResponseContentType$getRbacAuthorizationV1beta1APIResources>(params: Params$getRbacAuthorizationV1beta1APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getRbacAuthorizationV1beta1APIResources$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        /** list or watch objects of kind ClusterRoleBinding */
+        listRbacAuthorizationV1beta1ClusterRoleBinding: <ResponseContentType extends ResponseContentType$listRbacAuthorizationV1beta1ClusterRoleBinding>(params: Params$listRbacAuthorizationV1beta1ClusterRoleBinding<ResponseContentType>, option?: RequestOption): Promise<Response$listRbacAuthorizationV1beta1ClusterRoleBinding$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/clusterrolebindings\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** create a ClusterRoleBinding */
+        createRbacAuthorizationV1beta1ClusterRoleBinding: <ResponseContentType extends ResponseContentType$createRbacAuthorizationV1beta1ClusterRoleBinding>(params: Params$createRbacAuthorizationV1beta1ClusterRoleBinding<ResponseContentType>, option?: RequestOption): Promise<(Response$createRbacAuthorizationV1beta1ClusterRoleBinding$Status$200 | Response$createRbacAuthorizationV1beta1ClusterRoleBinding$Status$201 | Response$createRbacAuthorizationV1beta1ClusterRoleBinding$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/clusterrolebindings\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete collection of ClusterRoleBinding */
+        deleteRbacAuthorizationV1beta1CollectionClusterRoleBinding: <ResponseContentType extends ResponseContentType$deleteRbacAuthorizationV1beta1CollectionClusterRoleBinding>(params: Params$deleteRbacAuthorizationV1beta1CollectionClusterRoleBinding<ResponseContentType>, option?: RequestOption): Promise<Response$deleteRbacAuthorizationV1beta1CollectionClusterRoleBinding$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/clusterrolebindings\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read the specified ClusterRoleBinding */
+        readRbacAuthorizationV1beta1ClusterRoleBinding: <ResponseContentType extends ResponseContentType$readRbacAuthorizationV1beta1ClusterRoleBinding>(params: Params$readRbacAuthorizationV1beta1ClusterRoleBinding<ResponseContentType>, option?: RequestOption): Promise<Response$readRbacAuthorizationV1beta1ClusterRoleBinding$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/clusterrolebindings/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace the specified ClusterRoleBinding */
+        replaceRbacAuthorizationV1beta1ClusterRoleBinding: <ResponseContentType extends ResponseContentType$replaceRbacAuthorizationV1beta1ClusterRoleBinding>(params: Params$replaceRbacAuthorizationV1beta1ClusterRoleBinding<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceRbacAuthorizationV1beta1ClusterRoleBinding$Status$200 | Response$replaceRbacAuthorizationV1beta1ClusterRoleBinding$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/clusterrolebindings/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete a ClusterRoleBinding */
+        deleteRbacAuthorizationV1beta1ClusterRoleBinding: <ResponseContentType extends ResponseContentType$deleteRbacAuthorizationV1beta1ClusterRoleBinding>(params: Params$deleteRbacAuthorizationV1beta1ClusterRoleBinding<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteRbacAuthorizationV1beta1ClusterRoleBinding$Status$200 | Response$deleteRbacAuthorizationV1beta1ClusterRoleBinding$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/clusterrolebindings/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update the specified ClusterRoleBinding */
+        patchRbacAuthorizationV1beta1ClusterRoleBinding: <RequestContentType extends RequestContentType$patchRbacAuthorizationV1beta1ClusterRoleBinding, ResponseContentType extends ResponseContentType$patchRbacAuthorizationV1beta1ClusterRoleBinding>(params: Params$patchRbacAuthorizationV1beta1ClusterRoleBinding<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchRbacAuthorizationV1beta1ClusterRoleBinding$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/clusterrolebindings/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** list or watch objects of kind ClusterRole */
+        listRbacAuthorizationV1beta1ClusterRole: <ResponseContentType extends ResponseContentType$listRbacAuthorizationV1beta1ClusterRole>(params: Params$listRbacAuthorizationV1beta1ClusterRole<ResponseContentType>, option?: RequestOption): Promise<Response$listRbacAuthorizationV1beta1ClusterRole$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/clusterroles\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** create a ClusterRole */
+        createRbacAuthorizationV1beta1ClusterRole: <ResponseContentType extends ResponseContentType$createRbacAuthorizationV1beta1ClusterRole>(params: Params$createRbacAuthorizationV1beta1ClusterRole<ResponseContentType>, option?: RequestOption): Promise<(Response$createRbacAuthorizationV1beta1ClusterRole$Status$200 | Response$createRbacAuthorizationV1beta1ClusterRole$Status$201 | Response$createRbacAuthorizationV1beta1ClusterRole$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/clusterroles\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete collection of ClusterRole */
+        deleteRbacAuthorizationV1beta1CollectionClusterRole: <ResponseContentType extends ResponseContentType$deleteRbacAuthorizationV1beta1CollectionClusterRole>(params: Params$deleteRbacAuthorizationV1beta1CollectionClusterRole<ResponseContentType>, option?: RequestOption): Promise<Response$deleteRbacAuthorizationV1beta1CollectionClusterRole$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/clusterroles\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read the specified ClusterRole */
+        readRbacAuthorizationV1beta1ClusterRole: <ResponseContentType extends ResponseContentType$readRbacAuthorizationV1beta1ClusterRole>(params: Params$readRbacAuthorizationV1beta1ClusterRole<ResponseContentType>, option?: RequestOption): Promise<Response$readRbacAuthorizationV1beta1ClusterRole$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/clusterroles/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace the specified ClusterRole */
+        replaceRbacAuthorizationV1beta1ClusterRole: <ResponseContentType extends ResponseContentType$replaceRbacAuthorizationV1beta1ClusterRole>(params: Params$replaceRbacAuthorizationV1beta1ClusterRole<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceRbacAuthorizationV1beta1ClusterRole$Status$200 | Response$replaceRbacAuthorizationV1beta1ClusterRole$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/clusterroles/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete a ClusterRole */
+        deleteRbacAuthorizationV1beta1ClusterRole: <ResponseContentType extends ResponseContentType$deleteRbacAuthorizationV1beta1ClusterRole>(params: Params$deleteRbacAuthorizationV1beta1ClusterRole<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteRbacAuthorizationV1beta1ClusterRole$Status$200 | Response$deleteRbacAuthorizationV1beta1ClusterRole$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/clusterroles/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update the specified ClusterRole */
+        patchRbacAuthorizationV1beta1ClusterRole: <RequestContentType extends RequestContentType$patchRbacAuthorizationV1beta1ClusterRole, ResponseContentType extends ResponseContentType$patchRbacAuthorizationV1beta1ClusterRole>(params: Params$patchRbacAuthorizationV1beta1ClusterRole<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchRbacAuthorizationV1beta1ClusterRole$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/clusterroles/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** list or watch objects of kind RoleBinding */
+        listRbacAuthorizationV1beta1NamespacedRoleBinding: <ResponseContentType extends ResponseContentType$listRbacAuthorizationV1beta1NamespacedRoleBinding>(params: Params$listRbacAuthorizationV1beta1NamespacedRoleBinding<ResponseContentType>, option?: RequestOption): Promise<Response$listRbacAuthorizationV1beta1NamespacedRoleBinding$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/rolebindings\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** create a RoleBinding */
+        createRbacAuthorizationV1beta1NamespacedRoleBinding: <ResponseContentType extends ResponseContentType$createRbacAuthorizationV1beta1NamespacedRoleBinding>(params: Params$createRbacAuthorizationV1beta1NamespacedRoleBinding<ResponseContentType>, option?: RequestOption): Promise<(Response$createRbacAuthorizationV1beta1NamespacedRoleBinding$Status$200 | Response$createRbacAuthorizationV1beta1NamespacedRoleBinding$Status$201 | Response$createRbacAuthorizationV1beta1NamespacedRoleBinding$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/rolebindings\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete collection of RoleBinding */
+        deleteRbacAuthorizationV1beta1CollectionNamespacedRoleBinding: <ResponseContentType extends ResponseContentType$deleteRbacAuthorizationV1beta1CollectionNamespacedRoleBinding>(params: Params$deleteRbacAuthorizationV1beta1CollectionNamespacedRoleBinding<ResponseContentType>, option?: RequestOption): Promise<Response$deleteRbacAuthorizationV1beta1CollectionNamespacedRoleBinding$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/rolebindings\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read the specified RoleBinding */
+        readRbacAuthorizationV1beta1NamespacedRoleBinding: <ResponseContentType extends ResponseContentType$readRbacAuthorizationV1beta1NamespacedRoleBinding>(params: Params$readRbacAuthorizationV1beta1NamespacedRoleBinding<ResponseContentType>, option?: RequestOption): Promise<Response$readRbacAuthorizationV1beta1NamespacedRoleBinding$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/rolebindings/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace the specified RoleBinding */
+        replaceRbacAuthorizationV1beta1NamespacedRoleBinding: <ResponseContentType extends ResponseContentType$replaceRbacAuthorizationV1beta1NamespacedRoleBinding>(params: Params$replaceRbacAuthorizationV1beta1NamespacedRoleBinding<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceRbacAuthorizationV1beta1NamespacedRoleBinding$Status$200 | Response$replaceRbacAuthorizationV1beta1NamespacedRoleBinding$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/rolebindings/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete a RoleBinding */
+        deleteRbacAuthorizationV1beta1NamespacedRoleBinding: <ResponseContentType extends ResponseContentType$deleteRbacAuthorizationV1beta1NamespacedRoleBinding>(params: Params$deleteRbacAuthorizationV1beta1NamespacedRoleBinding<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteRbacAuthorizationV1beta1NamespacedRoleBinding$Status$200 | Response$deleteRbacAuthorizationV1beta1NamespacedRoleBinding$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/rolebindings/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update the specified RoleBinding */
+        patchRbacAuthorizationV1beta1NamespacedRoleBinding: <RequestContentType extends RequestContentType$patchRbacAuthorizationV1beta1NamespacedRoleBinding, ResponseContentType extends ResponseContentType$patchRbacAuthorizationV1beta1NamespacedRoleBinding>(params: Params$patchRbacAuthorizationV1beta1NamespacedRoleBinding<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchRbacAuthorizationV1beta1NamespacedRoleBinding$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/rolebindings/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** list or watch objects of kind Role */
+        listRbacAuthorizationV1beta1NamespacedRole: <ResponseContentType extends ResponseContentType$listRbacAuthorizationV1beta1NamespacedRole>(params: Params$listRbacAuthorizationV1beta1NamespacedRole<ResponseContentType>, option?: RequestOption): Promise<Response$listRbacAuthorizationV1beta1NamespacedRole$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/roles\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** create a Role */
+        createRbacAuthorizationV1beta1NamespacedRole: <ResponseContentType extends ResponseContentType$createRbacAuthorizationV1beta1NamespacedRole>(params: Params$createRbacAuthorizationV1beta1NamespacedRole<ResponseContentType>, option?: RequestOption): Promise<(Response$createRbacAuthorizationV1beta1NamespacedRole$Status$200 | Response$createRbacAuthorizationV1beta1NamespacedRole$Status$201 | Response$createRbacAuthorizationV1beta1NamespacedRole$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/roles\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete collection of Role */
+        deleteRbacAuthorizationV1beta1CollectionNamespacedRole: <ResponseContentType extends ResponseContentType$deleteRbacAuthorizationV1beta1CollectionNamespacedRole>(params: Params$deleteRbacAuthorizationV1beta1CollectionNamespacedRole<ResponseContentType>, option?: RequestOption): Promise<Response$deleteRbacAuthorizationV1beta1CollectionNamespacedRole$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/roles\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read the specified Role */
+        readRbacAuthorizationV1beta1NamespacedRole: <ResponseContentType extends ResponseContentType$readRbacAuthorizationV1beta1NamespacedRole>(params: Params$readRbacAuthorizationV1beta1NamespacedRole<ResponseContentType>, option?: RequestOption): Promise<Response$readRbacAuthorizationV1beta1NamespacedRole$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/roles/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace the specified Role */
+        replaceRbacAuthorizationV1beta1NamespacedRole: <ResponseContentType extends ResponseContentType$replaceRbacAuthorizationV1beta1NamespacedRole>(params: Params$replaceRbacAuthorizationV1beta1NamespacedRole<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceRbacAuthorizationV1beta1NamespacedRole$Status$200 | Response$replaceRbacAuthorizationV1beta1NamespacedRole$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/roles/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete a Role */
+        deleteRbacAuthorizationV1beta1NamespacedRole: <ResponseContentType extends ResponseContentType$deleteRbacAuthorizationV1beta1NamespacedRole>(params: Params$deleteRbacAuthorizationV1beta1NamespacedRole<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteRbacAuthorizationV1beta1NamespacedRole$Status$200 | Response$deleteRbacAuthorizationV1beta1NamespacedRole$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/roles/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update the specified Role */
+        patchRbacAuthorizationV1beta1NamespacedRole: <RequestContentType extends RequestContentType$patchRbacAuthorizationV1beta1NamespacedRole, ResponseContentType extends ResponseContentType$patchRbacAuthorizationV1beta1NamespacedRole>(params: Params$patchRbacAuthorizationV1beta1NamespacedRole<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchRbacAuthorizationV1beta1NamespacedRole$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/namespaces/\${params.parameter.namespace}/roles/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** list or watch objects of kind RoleBinding */
+        listRbacAuthorizationV1beta1RoleBindingForAllNamespaces: <ResponseContentType extends ResponseContentType$listRbacAuthorizationV1beta1RoleBindingForAllNamespaces>(params: Params$listRbacAuthorizationV1beta1RoleBindingForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$listRbacAuthorizationV1beta1RoleBindingForAllNamespaces$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/rolebindings\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** list or watch objects of kind Role */
+        listRbacAuthorizationV1beta1RoleForAllNamespaces: <ResponseContentType extends ResponseContentType$listRbacAuthorizationV1beta1RoleForAllNamespaces>(params: Params$listRbacAuthorizationV1beta1RoleForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$listRbacAuthorizationV1beta1RoleForAllNamespaces$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/roles\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of ClusterRoleBinding. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchRbacAuthorizationV1beta1ClusterRoleBindingList: <ResponseContentType extends ResponseContentType$watchRbacAuthorizationV1beta1ClusterRoleBindingList>(params: Params$watchRbacAuthorizationV1beta1ClusterRoleBindingList<ResponseContentType>, option?: RequestOption): Promise<Response$watchRbacAuthorizationV1beta1ClusterRoleBindingList$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/watch/clusterrolebindings\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch changes to an object of kind ClusterRoleBinding. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. */
+        watchRbacAuthorizationV1beta1ClusterRoleBinding: <ResponseContentType extends ResponseContentType$watchRbacAuthorizationV1beta1ClusterRoleBinding>(params: Params$watchRbacAuthorizationV1beta1ClusterRoleBinding<ResponseContentType>, option?: RequestOption): Promise<Response$watchRbacAuthorizationV1beta1ClusterRoleBinding$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/watch/clusterrolebindings/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of ClusterRole. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchRbacAuthorizationV1beta1ClusterRoleList: <ResponseContentType extends ResponseContentType$watchRbacAuthorizationV1beta1ClusterRoleList>(params: Params$watchRbacAuthorizationV1beta1ClusterRoleList<ResponseContentType>, option?: RequestOption): Promise<Response$watchRbacAuthorizationV1beta1ClusterRoleList$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/watch/clusterroles\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch changes to an object of kind ClusterRole. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. */
+        watchRbacAuthorizationV1beta1ClusterRole: <ResponseContentType extends ResponseContentType$watchRbacAuthorizationV1beta1ClusterRole>(params: Params$watchRbacAuthorizationV1beta1ClusterRole<ResponseContentType>, option?: RequestOption): Promise<Response$watchRbacAuthorizationV1beta1ClusterRole$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/watch/clusterroles/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of RoleBinding. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchRbacAuthorizationV1beta1NamespacedRoleBindingList: <ResponseContentType extends ResponseContentType$watchRbacAuthorizationV1beta1NamespacedRoleBindingList>(params: Params$watchRbacAuthorizationV1beta1NamespacedRoleBindingList<ResponseContentType>, option?: RequestOption): Promise<Response$watchRbacAuthorizationV1beta1NamespacedRoleBindingList$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/watch/namespaces/\${params.parameter.namespace}/rolebindings\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch changes to an object of kind RoleBinding. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. */
+        watchRbacAuthorizationV1beta1NamespacedRoleBinding: <ResponseContentType extends ResponseContentType$watchRbacAuthorizationV1beta1NamespacedRoleBinding>(params: Params$watchRbacAuthorizationV1beta1NamespacedRoleBinding<ResponseContentType>, option?: RequestOption): Promise<Response$watchRbacAuthorizationV1beta1NamespacedRoleBinding$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/watch/namespaces/\${params.parameter.namespace}/rolebindings/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of Role. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchRbacAuthorizationV1beta1NamespacedRoleList: <ResponseContentType extends ResponseContentType$watchRbacAuthorizationV1beta1NamespacedRoleList>(params: Params$watchRbacAuthorizationV1beta1NamespacedRoleList<ResponseContentType>, option?: RequestOption): Promise<Response$watchRbacAuthorizationV1beta1NamespacedRoleList$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/watch/namespaces/\${params.parameter.namespace}/roles\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch changes to an object of kind Role. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. */
+        watchRbacAuthorizationV1beta1NamespacedRole: <ResponseContentType extends ResponseContentType$watchRbacAuthorizationV1beta1NamespacedRole>(params: Params$watchRbacAuthorizationV1beta1NamespacedRole<ResponseContentType>, option?: RequestOption): Promise<Response$watchRbacAuthorizationV1beta1NamespacedRole$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/watch/namespaces/\${params.parameter.namespace}/roles/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of RoleBinding. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchRbacAuthorizationV1beta1RoleBindingListForAllNamespaces: <ResponseContentType extends ResponseContentType$watchRbacAuthorizationV1beta1RoleBindingListForAllNamespaces>(params: Params$watchRbacAuthorizationV1beta1RoleBindingListForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$watchRbacAuthorizationV1beta1RoleBindingListForAllNamespaces$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/watch/rolebindings\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of Role. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchRbacAuthorizationV1beta1RoleListForAllNamespaces: <ResponseContentType extends ResponseContentType$watchRbacAuthorizationV1beta1RoleListForAllNamespaces>(params: Params$watchRbacAuthorizationV1beta1RoleListForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$watchRbacAuthorizationV1beta1RoleListForAllNamespaces$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/rbac.authorization.k8s.io/v1beta1/watch/roles\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** get information of a group */
+        getSchedulingAPIGroup: <ResponseContentType extends ResponseContentType$getSchedulingAPIGroup>(params: Params$getSchedulingAPIGroup<ResponseContentType>, option?: RequestOption): Promise<Response$getSchedulingAPIGroup$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/scheduling.k8s.io/\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        /** get available resources */
+        getSchedulingV1APIResources: <ResponseContentType extends ResponseContentType$getSchedulingV1APIResources>(params: Params$getSchedulingV1APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getSchedulingV1APIResources$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/scheduling.k8s.io/v1/\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        /** list or watch objects of kind PriorityClass */
+        listSchedulingV1PriorityClass: <ResponseContentType extends ResponseContentType$listSchedulingV1PriorityClass>(params: Params$listSchedulingV1PriorityClass<ResponseContentType>, option?: RequestOption): Promise<Response$listSchedulingV1PriorityClass$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/scheduling.k8s.io/v1/priorityclasses\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** create a PriorityClass */
+        createSchedulingV1PriorityClass: <ResponseContentType extends ResponseContentType$createSchedulingV1PriorityClass>(params: Params$createSchedulingV1PriorityClass<ResponseContentType>, option?: RequestOption): Promise<(Response$createSchedulingV1PriorityClass$Status$200 | Response$createSchedulingV1PriorityClass$Status$201 | Response$createSchedulingV1PriorityClass$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/scheduling.k8s.io/v1/priorityclasses\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete collection of PriorityClass */
+        deleteSchedulingV1CollectionPriorityClass: <ResponseContentType extends ResponseContentType$deleteSchedulingV1CollectionPriorityClass>(params: Params$deleteSchedulingV1CollectionPriorityClass<ResponseContentType>, option?: RequestOption): Promise<Response$deleteSchedulingV1CollectionPriorityClass$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/scheduling.k8s.io/v1/priorityclasses\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read the specified PriorityClass */
+        readSchedulingV1PriorityClass: <ResponseContentType extends ResponseContentType$readSchedulingV1PriorityClass>(params: Params$readSchedulingV1PriorityClass<ResponseContentType>, option?: RequestOption): Promise<Response$readSchedulingV1PriorityClass$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/scheduling.k8s.io/v1/priorityclasses/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                exact: { value: params.parameter.exact, explode: false },
+                export: { value: params.parameter.export, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace the specified PriorityClass */
+        replaceSchedulingV1PriorityClass: <ResponseContentType extends ResponseContentType$replaceSchedulingV1PriorityClass>(params: Params$replaceSchedulingV1PriorityClass<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceSchedulingV1PriorityClass$Status$200 | Response$replaceSchedulingV1PriorityClass$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/scheduling.k8s.io/v1/priorityclasses/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete a PriorityClass */
+        deleteSchedulingV1PriorityClass: <ResponseContentType extends ResponseContentType$deleteSchedulingV1PriorityClass>(params: Params$deleteSchedulingV1PriorityClass<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteSchedulingV1PriorityClass$Status$200 | Response$deleteSchedulingV1PriorityClass$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/scheduling.k8s.io/v1/priorityclasses/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update the specified PriorityClass */
+        patchSchedulingV1PriorityClass: <RequestContentType extends RequestContentType$patchSchedulingV1PriorityClass, ResponseContentType extends ResponseContentType$patchSchedulingV1PriorityClass>(params: Params$patchSchedulingV1PriorityClass<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchSchedulingV1PriorityClass$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/scheduling.k8s.io/v1/priorityclasses/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** watch individual changes to a list of PriorityClass. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchSchedulingV1PriorityClassList: <ResponseContentType extends ResponseContentType$watchSchedulingV1PriorityClassList>(params: Params$watchSchedulingV1PriorityClassList<ResponseContentType>, option?: RequestOption): Promise<Response$watchSchedulingV1PriorityClassList$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/scheduling.k8s.io/v1/watch/priorityclasses\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch changes to an object of kind PriorityClass. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. */
+        watchSchedulingV1PriorityClass: <ResponseContentType extends ResponseContentType$watchSchedulingV1PriorityClass>(params: Params$watchSchedulingV1PriorityClass<ResponseContentType>, option?: RequestOption): Promise<Response$watchSchedulingV1PriorityClass$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/scheduling.k8s.io/v1/watch/priorityclasses/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** get available resources */
+        getSchedulingV1alpha1APIResources: <ResponseContentType extends ResponseContentType$getSchedulingV1alpha1APIResources>(params: Params$getSchedulingV1alpha1APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getSchedulingV1alpha1APIResources$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/scheduling.k8s.io/v1alpha1/\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        /** list or watch objects of kind PriorityClass */
+        listSchedulingV1alpha1PriorityClass: <ResponseContentType extends ResponseContentType$listSchedulingV1alpha1PriorityClass>(params: Params$listSchedulingV1alpha1PriorityClass<ResponseContentType>, option?: RequestOption): Promise<Response$listSchedulingV1alpha1PriorityClass$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/scheduling.k8s.io/v1alpha1/priorityclasses\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** create a PriorityClass */
+        createSchedulingV1alpha1PriorityClass: <ResponseContentType extends ResponseContentType$createSchedulingV1alpha1PriorityClass>(params: Params$createSchedulingV1alpha1PriorityClass<ResponseContentType>, option?: RequestOption): Promise<(Response$createSchedulingV1alpha1PriorityClass$Status$200 | Response$createSchedulingV1alpha1PriorityClass$Status$201 | Response$createSchedulingV1alpha1PriorityClass$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/scheduling.k8s.io/v1alpha1/priorityclasses\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete collection of PriorityClass */
+        deleteSchedulingV1alpha1CollectionPriorityClass: <ResponseContentType extends ResponseContentType$deleteSchedulingV1alpha1CollectionPriorityClass>(params: Params$deleteSchedulingV1alpha1CollectionPriorityClass<ResponseContentType>, option?: RequestOption): Promise<Response$deleteSchedulingV1alpha1CollectionPriorityClass$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/scheduling.k8s.io/v1alpha1/priorityclasses\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read the specified PriorityClass */
+        readSchedulingV1alpha1PriorityClass: <ResponseContentType extends ResponseContentType$readSchedulingV1alpha1PriorityClass>(params: Params$readSchedulingV1alpha1PriorityClass<ResponseContentType>, option?: RequestOption): Promise<Response$readSchedulingV1alpha1PriorityClass$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/scheduling.k8s.io/v1alpha1/priorityclasses/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                exact: { value: params.parameter.exact, explode: false },
+                export: { value: params.parameter.export, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace the specified PriorityClass */
+        replaceSchedulingV1alpha1PriorityClass: <ResponseContentType extends ResponseContentType$replaceSchedulingV1alpha1PriorityClass>(params: Params$replaceSchedulingV1alpha1PriorityClass<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceSchedulingV1alpha1PriorityClass$Status$200 | Response$replaceSchedulingV1alpha1PriorityClass$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/scheduling.k8s.io/v1alpha1/priorityclasses/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete a PriorityClass */
+        deleteSchedulingV1alpha1PriorityClass: <ResponseContentType extends ResponseContentType$deleteSchedulingV1alpha1PriorityClass>(params: Params$deleteSchedulingV1alpha1PriorityClass<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteSchedulingV1alpha1PriorityClass$Status$200 | Response$deleteSchedulingV1alpha1PriorityClass$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/scheduling.k8s.io/v1alpha1/priorityclasses/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update the specified PriorityClass */
+        patchSchedulingV1alpha1PriorityClass: <RequestContentType extends RequestContentType$patchSchedulingV1alpha1PriorityClass, ResponseContentType extends ResponseContentType$patchSchedulingV1alpha1PriorityClass>(params: Params$patchSchedulingV1alpha1PriorityClass<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchSchedulingV1alpha1PriorityClass$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/scheduling.k8s.io/v1alpha1/priorityclasses/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** watch individual changes to a list of PriorityClass. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchSchedulingV1alpha1PriorityClassList: <ResponseContentType extends ResponseContentType$watchSchedulingV1alpha1PriorityClassList>(params: Params$watchSchedulingV1alpha1PriorityClassList<ResponseContentType>, option?: RequestOption): Promise<Response$watchSchedulingV1alpha1PriorityClassList$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/scheduling.k8s.io/v1alpha1/watch/priorityclasses\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch changes to an object of kind PriorityClass. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. */
+        watchSchedulingV1alpha1PriorityClass: <ResponseContentType extends ResponseContentType$watchSchedulingV1alpha1PriorityClass>(params: Params$watchSchedulingV1alpha1PriorityClass<ResponseContentType>, option?: RequestOption): Promise<Response$watchSchedulingV1alpha1PriorityClass$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/scheduling.k8s.io/v1alpha1/watch/priorityclasses/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** get available resources */
+        getSchedulingV1beta1APIResources: <ResponseContentType extends ResponseContentType$getSchedulingV1beta1APIResources>(params: Params$getSchedulingV1beta1APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getSchedulingV1beta1APIResources$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/scheduling.k8s.io/v1beta1/\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        /** list or watch objects of kind PriorityClass */
+        listSchedulingV1beta1PriorityClass: <ResponseContentType extends ResponseContentType$listSchedulingV1beta1PriorityClass>(params: Params$listSchedulingV1beta1PriorityClass<ResponseContentType>, option?: RequestOption): Promise<Response$listSchedulingV1beta1PriorityClass$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/scheduling.k8s.io/v1beta1/priorityclasses\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** create a PriorityClass */
+        createSchedulingV1beta1PriorityClass: <ResponseContentType extends ResponseContentType$createSchedulingV1beta1PriorityClass>(params: Params$createSchedulingV1beta1PriorityClass<ResponseContentType>, option?: RequestOption): Promise<(Response$createSchedulingV1beta1PriorityClass$Status$200 | Response$createSchedulingV1beta1PriorityClass$Status$201 | Response$createSchedulingV1beta1PriorityClass$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/scheduling.k8s.io/v1beta1/priorityclasses\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete collection of PriorityClass */
+        deleteSchedulingV1beta1CollectionPriorityClass: <ResponseContentType extends ResponseContentType$deleteSchedulingV1beta1CollectionPriorityClass>(params: Params$deleteSchedulingV1beta1CollectionPriorityClass<ResponseContentType>, option?: RequestOption): Promise<Response$deleteSchedulingV1beta1CollectionPriorityClass$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/scheduling.k8s.io/v1beta1/priorityclasses\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read the specified PriorityClass */
+        readSchedulingV1beta1PriorityClass: <ResponseContentType extends ResponseContentType$readSchedulingV1beta1PriorityClass>(params: Params$readSchedulingV1beta1PriorityClass<ResponseContentType>, option?: RequestOption): Promise<Response$readSchedulingV1beta1PriorityClass$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/scheduling.k8s.io/v1beta1/priorityclasses/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                exact: { value: params.parameter.exact, explode: false },
+                export: { value: params.parameter.export, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace the specified PriorityClass */
+        replaceSchedulingV1beta1PriorityClass: <ResponseContentType extends ResponseContentType$replaceSchedulingV1beta1PriorityClass>(params: Params$replaceSchedulingV1beta1PriorityClass<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceSchedulingV1beta1PriorityClass$Status$200 | Response$replaceSchedulingV1beta1PriorityClass$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/scheduling.k8s.io/v1beta1/priorityclasses/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete a PriorityClass */
+        deleteSchedulingV1beta1PriorityClass: <ResponseContentType extends ResponseContentType$deleteSchedulingV1beta1PriorityClass>(params: Params$deleteSchedulingV1beta1PriorityClass<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteSchedulingV1beta1PriorityClass$Status$200 | Response$deleteSchedulingV1beta1PriorityClass$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/scheduling.k8s.io/v1beta1/priorityclasses/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update the specified PriorityClass */
+        patchSchedulingV1beta1PriorityClass: <RequestContentType extends RequestContentType$patchSchedulingV1beta1PriorityClass, ResponseContentType extends ResponseContentType$patchSchedulingV1beta1PriorityClass>(params: Params$patchSchedulingV1beta1PriorityClass<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchSchedulingV1beta1PriorityClass$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/scheduling.k8s.io/v1beta1/priorityclasses/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** watch individual changes to a list of PriorityClass. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchSchedulingV1beta1PriorityClassList: <ResponseContentType extends ResponseContentType$watchSchedulingV1beta1PriorityClassList>(params: Params$watchSchedulingV1beta1PriorityClassList<ResponseContentType>, option?: RequestOption): Promise<Response$watchSchedulingV1beta1PriorityClassList$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/scheduling.k8s.io/v1beta1/watch/priorityclasses\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch changes to an object of kind PriorityClass. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. */
+        watchSchedulingV1beta1PriorityClass: <ResponseContentType extends ResponseContentType$watchSchedulingV1beta1PriorityClass>(params: Params$watchSchedulingV1beta1PriorityClass<ResponseContentType>, option?: RequestOption): Promise<Response$watchSchedulingV1beta1PriorityClass$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/scheduling.k8s.io/v1beta1/watch/priorityclasses/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** get information of a group */
+        getSettingsAPIGroup: <ResponseContentType extends ResponseContentType$getSettingsAPIGroup>(params: Params$getSettingsAPIGroup<ResponseContentType>, option?: RequestOption): Promise<Response$getSettingsAPIGroup$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/settings.k8s.io/\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        /** get available resources */
+        getSettingsV1alpha1APIResources: <ResponseContentType extends ResponseContentType$getSettingsV1alpha1APIResources>(params: Params$getSettingsV1alpha1APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getSettingsV1alpha1APIResources$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/settings.k8s.io/v1alpha1/\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        /** list or watch objects of kind PodPreset */
+        listSettingsV1alpha1NamespacedPodPreset: <ResponseContentType extends ResponseContentType$listSettingsV1alpha1NamespacedPodPreset>(params: Params$listSettingsV1alpha1NamespacedPodPreset<ResponseContentType>, option?: RequestOption): Promise<Response$listSettingsV1alpha1NamespacedPodPreset$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/settings.k8s.io/v1alpha1/namespaces/\${params.parameter.namespace}/podpresets\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** create a PodPreset */
+        createSettingsV1alpha1NamespacedPodPreset: <ResponseContentType extends ResponseContentType$createSettingsV1alpha1NamespacedPodPreset>(params: Params$createSettingsV1alpha1NamespacedPodPreset<ResponseContentType>, option?: RequestOption): Promise<(Response$createSettingsV1alpha1NamespacedPodPreset$Status$200 | Response$createSettingsV1alpha1NamespacedPodPreset$Status$201 | Response$createSettingsV1alpha1NamespacedPodPreset$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/settings.k8s.io/v1alpha1/namespaces/\${params.parameter.namespace}/podpresets\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete collection of PodPreset */
+        deleteSettingsV1alpha1CollectionNamespacedPodPreset: <ResponseContentType extends ResponseContentType$deleteSettingsV1alpha1CollectionNamespacedPodPreset>(params: Params$deleteSettingsV1alpha1CollectionNamespacedPodPreset<ResponseContentType>, option?: RequestOption): Promise<Response$deleteSettingsV1alpha1CollectionNamespacedPodPreset$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/settings.k8s.io/v1alpha1/namespaces/\${params.parameter.namespace}/podpresets\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read the specified PodPreset */
+        readSettingsV1alpha1NamespacedPodPreset: <ResponseContentType extends ResponseContentType$readSettingsV1alpha1NamespacedPodPreset>(params: Params$readSettingsV1alpha1NamespacedPodPreset<ResponseContentType>, option?: RequestOption): Promise<Response$readSettingsV1alpha1NamespacedPodPreset$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/settings.k8s.io/v1alpha1/namespaces/\${params.parameter.namespace}/podpresets/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                exact: { value: params.parameter.exact, explode: false },
+                export: { value: params.parameter.export, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace the specified PodPreset */
+        replaceSettingsV1alpha1NamespacedPodPreset: <ResponseContentType extends ResponseContentType$replaceSettingsV1alpha1NamespacedPodPreset>(params: Params$replaceSettingsV1alpha1NamespacedPodPreset<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceSettingsV1alpha1NamespacedPodPreset$Status$200 | Response$replaceSettingsV1alpha1NamespacedPodPreset$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/settings.k8s.io/v1alpha1/namespaces/\${params.parameter.namespace}/podpresets/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete a PodPreset */
+        deleteSettingsV1alpha1NamespacedPodPreset: <ResponseContentType extends ResponseContentType$deleteSettingsV1alpha1NamespacedPodPreset>(params: Params$deleteSettingsV1alpha1NamespacedPodPreset<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteSettingsV1alpha1NamespacedPodPreset$Status$200 | Response$deleteSettingsV1alpha1NamespacedPodPreset$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/settings.k8s.io/v1alpha1/namespaces/\${params.parameter.namespace}/podpresets/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update the specified PodPreset */
+        patchSettingsV1alpha1NamespacedPodPreset: <RequestContentType extends RequestContentType$patchSettingsV1alpha1NamespacedPodPreset, ResponseContentType extends ResponseContentType$patchSettingsV1alpha1NamespacedPodPreset>(params: Params$patchSettingsV1alpha1NamespacedPodPreset<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchSettingsV1alpha1NamespacedPodPreset$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/settings.k8s.io/v1alpha1/namespaces/\${params.parameter.namespace}/podpresets/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** list or watch objects of kind PodPreset */
+        listSettingsV1alpha1PodPresetForAllNamespaces: <ResponseContentType extends ResponseContentType$listSettingsV1alpha1PodPresetForAllNamespaces>(params: Params$listSettingsV1alpha1PodPresetForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$listSettingsV1alpha1PodPresetForAllNamespaces$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/settings.k8s.io/v1alpha1/podpresets\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of PodPreset. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchSettingsV1alpha1NamespacedPodPresetList: <ResponseContentType extends ResponseContentType$watchSettingsV1alpha1NamespacedPodPresetList>(params: Params$watchSettingsV1alpha1NamespacedPodPresetList<ResponseContentType>, option?: RequestOption): Promise<Response$watchSettingsV1alpha1NamespacedPodPresetList$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/settings.k8s.io/v1alpha1/watch/namespaces/\${params.parameter.namespace}/podpresets\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch changes to an object of kind PodPreset. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. */
+        watchSettingsV1alpha1NamespacedPodPreset: <ResponseContentType extends ResponseContentType$watchSettingsV1alpha1NamespacedPodPreset>(params: Params$watchSettingsV1alpha1NamespacedPodPreset<ResponseContentType>, option?: RequestOption): Promise<Response$watchSettingsV1alpha1NamespacedPodPreset$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/settings.k8s.io/v1alpha1/watch/namespaces/\${params.parameter.namespace}/podpresets/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of PodPreset. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchSettingsV1alpha1PodPresetListForAllNamespaces: <ResponseContentType extends ResponseContentType$watchSettingsV1alpha1PodPresetListForAllNamespaces>(params: Params$watchSettingsV1alpha1PodPresetListForAllNamespaces<ResponseContentType>, option?: RequestOption): Promise<Response$watchSettingsV1alpha1PodPresetListForAllNamespaces$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/settings.k8s.io/v1alpha1/watch/podpresets\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** get information of a group */
+        getStorageAPIGroup: <ResponseContentType extends ResponseContentType$getStorageAPIGroup>(params: Params$getStorageAPIGroup<ResponseContentType>, option?: RequestOption): Promise<Response$getStorageAPIGroup$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        /** get available resources */
+        getStorageV1APIResources: <ResponseContentType extends ResponseContentType$getStorageV1APIResources>(params: Params$getStorageV1APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getStorageV1APIResources$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1/\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        /** list or watch objects of kind CSIDriver */
+        listStorageV1CSIDriver: <ResponseContentType extends ResponseContentType$listStorageV1CSIDriver>(params: Params$listStorageV1CSIDriver<ResponseContentType>, option?: RequestOption): Promise<Response$listStorageV1CSIDriver$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1/csidrivers\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** create a CSIDriver */
+        createStorageV1CSIDriver: <ResponseContentType extends ResponseContentType$createStorageV1CSIDriver>(params: Params$createStorageV1CSIDriver<ResponseContentType>, option?: RequestOption): Promise<(Response$createStorageV1CSIDriver$Status$200 | Response$createStorageV1CSIDriver$Status$201 | Response$createStorageV1CSIDriver$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1/csidrivers\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete collection of CSIDriver */
+        deleteStorageV1CollectionCSIDriver: <ResponseContentType extends ResponseContentType$deleteStorageV1CollectionCSIDriver>(params: Params$deleteStorageV1CollectionCSIDriver<ResponseContentType>, option?: RequestOption): Promise<Response$deleteStorageV1CollectionCSIDriver$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1/csidrivers\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read the specified CSIDriver */
+        readStorageV1CSIDriver: <ResponseContentType extends ResponseContentType$readStorageV1CSIDriver>(params: Params$readStorageV1CSIDriver<ResponseContentType>, option?: RequestOption): Promise<Response$readStorageV1CSIDriver$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1/csidrivers/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                exact: { value: params.parameter.exact, explode: false },
+                export: { value: params.parameter.export, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace the specified CSIDriver */
+        replaceStorageV1CSIDriver: <ResponseContentType extends ResponseContentType$replaceStorageV1CSIDriver>(params: Params$replaceStorageV1CSIDriver<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceStorageV1CSIDriver$Status$200 | Response$replaceStorageV1CSIDriver$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1/csidrivers/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete a CSIDriver */
+        deleteStorageV1CSIDriver: <ResponseContentType extends ResponseContentType$deleteStorageV1CSIDriver>(params: Params$deleteStorageV1CSIDriver<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteStorageV1CSIDriver$Status$200 | Response$deleteStorageV1CSIDriver$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1/csidrivers/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update the specified CSIDriver */
+        patchStorageV1CSIDriver: <RequestContentType extends RequestContentType$patchStorageV1CSIDriver, ResponseContentType extends ResponseContentType$patchStorageV1CSIDriver>(params: Params$patchStorageV1CSIDriver<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchStorageV1CSIDriver$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1/csidrivers/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** list or watch objects of kind CSINode */
+        listStorageV1CSINode: <ResponseContentType extends ResponseContentType$listStorageV1CSINode>(params: Params$listStorageV1CSINode<ResponseContentType>, option?: RequestOption): Promise<Response$listStorageV1CSINode$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1/csinodes\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** create a CSINode */
+        createStorageV1CSINode: <ResponseContentType extends ResponseContentType$createStorageV1CSINode>(params: Params$createStorageV1CSINode<ResponseContentType>, option?: RequestOption): Promise<(Response$createStorageV1CSINode$Status$200 | Response$createStorageV1CSINode$Status$201 | Response$createStorageV1CSINode$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1/csinodes\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete collection of CSINode */
+        deleteStorageV1CollectionCSINode: <ResponseContentType extends ResponseContentType$deleteStorageV1CollectionCSINode>(params: Params$deleteStorageV1CollectionCSINode<ResponseContentType>, option?: RequestOption): Promise<Response$deleteStorageV1CollectionCSINode$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1/csinodes\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read the specified CSINode */
+        readStorageV1CSINode: <ResponseContentType extends ResponseContentType$readStorageV1CSINode>(params: Params$readStorageV1CSINode<ResponseContentType>, option?: RequestOption): Promise<Response$readStorageV1CSINode$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1/csinodes/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                exact: { value: params.parameter.exact, explode: false },
+                export: { value: params.parameter.export, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace the specified CSINode */
+        replaceStorageV1CSINode: <ResponseContentType extends ResponseContentType$replaceStorageV1CSINode>(params: Params$replaceStorageV1CSINode<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceStorageV1CSINode$Status$200 | Response$replaceStorageV1CSINode$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1/csinodes/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete a CSINode */
+        deleteStorageV1CSINode: <ResponseContentType extends ResponseContentType$deleteStorageV1CSINode>(params: Params$deleteStorageV1CSINode<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteStorageV1CSINode$Status$200 | Response$deleteStorageV1CSINode$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1/csinodes/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update the specified CSINode */
+        patchStorageV1CSINode: <RequestContentType extends RequestContentType$patchStorageV1CSINode, ResponseContentType extends ResponseContentType$patchStorageV1CSINode>(params: Params$patchStorageV1CSINode<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchStorageV1CSINode$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1/csinodes/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** list or watch objects of kind StorageClass */
+        listStorageV1StorageClass: <ResponseContentType extends ResponseContentType$listStorageV1StorageClass>(params: Params$listStorageV1StorageClass<ResponseContentType>, option?: RequestOption): Promise<Response$listStorageV1StorageClass$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1/storageclasses\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** create a StorageClass */
+        createStorageV1StorageClass: <ResponseContentType extends ResponseContentType$createStorageV1StorageClass>(params: Params$createStorageV1StorageClass<ResponseContentType>, option?: RequestOption): Promise<(Response$createStorageV1StorageClass$Status$200 | Response$createStorageV1StorageClass$Status$201 | Response$createStorageV1StorageClass$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1/storageclasses\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete collection of StorageClass */
+        deleteStorageV1CollectionStorageClass: <ResponseContentType extends ResponseContentType$deleteStorageV1CollectionStorageClass>(params: Params$deleteStorageV1CollectionStorageClass<ResponseContentType>, option?: RequestOption): Promise<Response$deleteStorageV1CollectionStorageClass$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1/storageclasses\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read the specified StorageClass */
+        readStorageV1StorageClass: <ResponseContentType extends ResponseContentType$readStorageV1StorageClass>(params: Params$readStorageV1StorageClass<ResponseContentType>, option?: RequestOption): Promise<Response$readStorageV1StorageClass$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1/storageclasses/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                exact: { value: params.parameter.exact, explode: false },
+                export: { value: params.parameter.export, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace the specified StorageClass */
+        replaceStorageV1StorageClass: <ResponseContentType extends ResponseContentType$replaceStorageV1StorageClass>(params: Params$replaceStorageV1StorageClass<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceStorageV1StorageClass$Status$200 | Response$replaceStorageV1StorageClass$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1/storageclasses/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete a StorageClass */
+        deleteStorageV1StorageClass: <ResponseContentType extends ResponseContentType$deleteStorageV1StorageClass>(params: Params$deleteStorageV1StorageClass<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteStorageV1StorageClass$Status$200 | Response$deleteStorageV1StorageClass$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1/storageclasses/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update the specified StorageClass */
+        patchStorageV1StorageClass: <RequestContentType extends RequestContentType$patchStorageV1StorageClass, ResponseContentType extends ResponseContentType$patchStorageV1StorageClass>(params: Params$patchStorageV1StorageClass<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchStorageV1StorageClass$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1/storageclasses/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** list or watch objects of kind VolumeAttachment */
+        listStorageV1VolumeAttachment: <ResponseContentType extends ResponseContentType$listStorageV1VolumeAttachment>(params: Params$listStorageV1VolumeAttachment<ResponseContentType>, option?: RequestOption): Promise<Response$listStorageV1VolumeAttachment$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1/volumeattachments\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** create a VolumeAttachment */
+        createStorageV1VolumeAttachment: <ResponseContentType extends ResponseContentType$createStorageV1VolumeAttachment>(params: Params$createStorageV1VolumeAttachment<ResponseContentType>, option?: RequestOption): Promise<(Response$createStorageV1VolumeAttachment$Status$200 | Response$createStorageV1VolumeAttachment$Status$201 | Response$createStorageV1VolumeAttachment$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1/volumeattachments\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete collection of VolumeAttachment */
+        deleteStorageV1CollectionVolumeAttachment: <ResponseContentType extends ResponseContentType$deleteStorageV1CollectionVolumeAttachment>(params: Params$deleteStorageV1CollectionVolumeAttachment<ResponseContentType>, option?: RequestOption): Promise<Response$deleteStorageV1CollectionVolumeAttachment$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1/volumeattachments\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read the specified VolumeAttachment */
+        readStorageV1VolumeAttachment: <ResponseContentType extends ResponseContentType$readStorageV1VolumeAttachment>(params: Params$readStorageV1VolumeAttachment<ResponseContentType>, option?: RequestOption): Promise<Response$readStorageV1VolumeAttachment$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1/volumeattachments/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                exact: { value: params.parameter.exact, explode: false },
+                export: { value: params.parameter.export, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace the specified VolumeAttachment */
+        replaceStorageV1VolumeAttachment: <ResponseContentType extends ResponseContentType$replaceStorageV1VolumeAttachment>(params: Params$replaceStorageV1VolumeAttachment<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceStorageV1VolumeAttachment$Status$200 | Response$replaceStorageV1VolumeAttachment$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1/volumeattachments/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete a VolumeAttachment */
+        deleteStorageV1VolumeAttachment: <ResponseContentType extends ResponseContentType$deleteStorageV1VolumeAttachment>(params: Params$deleteStorageV1VolumeAttachment<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteStorageV1VolumeAttachment$Status$200 | Response$deleteStorageV1VolumeAttachment$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1/volumeattachments/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update the specified VolumeAttachment */
+        patchStorageV1VolumeAttachment: <RequestContentType extends RequestContentType$patchStorageV1VolumeAttachment, ResponseContentType extends ResponseContentType$patchStorageV1VolumeAttachment>(params: Params$patchStorageV1VolumeAttachment<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchStorageV1VolumeAttachment$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1/volumeattachments/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read status of the specified VolumeAttachment */
+        readStorageV1VolumeAttachmentStatus: <ResponseContentType extends ResponseContentType$readStorageV1VolumeAttachmentStatus>(params: Params$readStorageV1VolumeAttachmentStatus<ResponseContentType>, option?: RequestOption): Promise<Response$readStorageV1VolumeAttachmentStatus$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1/volumeattachments/\${params.parameter.name}/status\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace status of the specified VolumeAttachment */
+        replaceStorageV1VolumeAttachmentStatus: <ResponseContentType extends ResponseContentType$replaceStorageV1VolumeAttachmentStatus>(params: Params$replaceStorageV1VolumeAttachmentStatus<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceStorageV1VolumeAttachmentStatus$Status$200 | Response$replaceStorageV1VolumeAttachmentStatus$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1/volumeattachments/\${params.parameter.name}/status\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update status of the specified VolumeAttachment */
+        patchStorageV1VolumeAttachmentStatus: <RequestContentType extends RequestContentType$patchStorageV1VolumeAttachmentStatus, ResponseContentType extends ResponseContentType$patchStorageV1VolumeAttachmentStatus>(params: Params$patchStorageV1VolumeAttachmentStatus<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchStorageV1VolumeAttachmentStatus$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1/volumeattachments/\${params.parameter.name}/status\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** watch individual changes to a list of CSIDriver. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchStorageV1CSIDriverList: <ResponseContentType extends ResponseContentType$watchStorageV1CSIDriverList>(params: Params$watchStorageV1CSIDriverList<ResponseContentType>, option?: RequestOption): Promise<Response$watchStorageV1CSIDriverList$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1/watch/csidrivers\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch changes to an object of kind CSIDriver. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. */
+        watchStorageV1CSIDriver: <ResponseContentType extends ResponseContentType$watchStorageV1CSIDriver>(params: Params$watchStorageV1CSIDriver<ResponseContentType>, option?: RequestOption): Promise<Response$watchStorageV1CSIDriver$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1/watch/csidrivers/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of CSINode. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchStorageV1CSINodeList: <ResponseContentType extends ResponseContentType$watchStorageV1CSINodeList>(params: Params$watchStorageV1CSINodeList<ResponseContentType>, option?: RequestOption): Promise<Response$watchStorageV1CSINodeList$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1/watch/csinodes\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch changes to an object of kind CSINode. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. */
+        watchStorageV1CSINode: <ResponseContentType extends ResponseContentType$watchStorageV1CSINode>(params: Params$watchStorageV1CSINode<ResponseContentType>, option?: RequestOption): Promise<Response$watchStorageV1CSINode$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1/watch/csinodes/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of StorageClass. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchStorageV1StorageClassList: <ResponseContentType extends ResponseContentType$watchStorageV1StorageClassList>(params: Params$watchStorageV1StorageClassList<ResponseContentType>, option?: RequestOption): Promise<Response$watchStorageV1StorageClassList$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1/watch/storageclasses\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch changes to an object of kind StorageClass. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. */
+        watchStorageV1StorageClass: <ResponseContentType extends ResponseContentType$watchStorageV1StorageClass>(params: Params$watchStorageV1StorageClass<ResponseContentType>, option?: RequestOption): Promise<Response$watchStorageV1StorageClass$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1/watch/storageclasses/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of VolumeAttachment. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchStorageV1VolumeAttachmentList: <ResponseContentType extends ResponseContentType$watchStorageV1VolumeAttachmentList>(params: Params$watchStorageV1VolumeAttachmentList<ResponseContentType>, option?: RequestOption): Promise<Response$watchStorageV1VolumeAttachmentList$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1/watch/volumeattachments\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch changes to an object of kind VolumeAttachment. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. */
+        watchStorageV1VolumeAttachment: <ResponseContentType extends ResponseContentType$watchStorageV1VolumeAttachment>(params: Params$watchStorageV1VolumeAttachment<ResponseContentType>, option?: RequestOption): Promise<Response$watchStorageV1VolumeAttachment$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1/watch/volumeattachments/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** get available resources */
+        getStorageV1alpha1APIResources: <ResponseContentType extends ResponseContentType$getStorageV1alpha1APIResources>(params: Params$getStorageV1alpha1APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getStorageV1alpha1APIResources$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1alpha1/\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        /** list or watch objects of kind VolumeAttachment */
+        listStorageV1alpha1VolumeAttachment: <ResponseContentType extends ResponseContentType$listStorageV1alpha1VolumeAttachment>(params: Params$listStorageV1alpha1VolumeAttachment<ResponseContentType>, option?: RequestOption): Promise<Response$listStorageV1alpha1VolumeAttachment$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1alpha1/volumeattachments\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** create a VolumeAttachment */
+        createStorageV1alpha1VolumeAttachment: <ResponseContentType extends ResponseContentType$createStorageV1alpha1VolumeAttachment>(params: Params$createStorageV1alpha1VolumeAttachment<ResponseContentType>, option?: RequestOption): Promise<(Response$createStorageV1alpha1VolumeAttachment$Status$200 | Response$createStorageV1alpha1VolumeAttachment$Status$201 | Response$createStorageV1alpha1VolumeAttachment$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1alpha1/volumeattachments\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete collection of VolumeAttachment */
+        deleteStorageV1alpha1CollectionVolumeAttachment: <ResponseContentType extends ResponseContentType$deleteStorageV1alpha1CollectionVolumeAttachment>(params: Params$deleteStorageV1alpha1CollectionVolumeAttachment<ResponseContentType>, option?: RequestOption): Promise<Response$deleteStorageV1alpha1CollectionVolumeAttachment$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1alpha1/volumeattachments\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read the specified VolumeAttachment */
+        readStorageV1alpha1VolumeAttachment: <ResponseContentType extends ResponseContentType$readStorageV1alpha1VolumeAttachment>(params: Params$readStorageV1alpha1VolumeAttachment<ResponseContentType>, option?: RequestOption): Promise<Response$readStorageV1alpha1VolumeAttachment$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1alpha1/volumeattachments/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                exact: { value: params.parameter.exact, explode: false },
+                export: { value: params.parameter.export, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace the specified VolumeAttachment */
+        replaceStorageV1alpha1VolumeAttachment: <ResponseContentType extends ResponseContentType$replaceStorageV1alpha1VolumeAttachment>(params: Params$replaceStorageV1alpha1VolumeAttachment<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceStorageV1alpha1VolumeAttachment$Status$200 | Response$replaceStorageV1alpha1VolumeAttachment$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1alpha1/volumeattachments/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete a VolumeAttachment */
+        deleteStorageV1alpha1VolumeAttachment: <ResponseContentType extends ResponseContentType$deleteStorageV1alpha1VolumeAttachment>(params: Params$deleteStorageV1alpha1VolumeAttachment<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteStorageV1alpha1VolumeAttachment$Status$200 | Response$deleteStorageV1alpha1VolumeAttachment$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1alpha1/volumeattachments/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update the specified VolumeAttachment */
+        patchStorageV1alpha1VolumeAttachment: <RequestContentType extends RequestContentType$patchStorageV1alpha1VolumeAttachment, ResponseContentType extends ResponseContentType$patchStorageV1alpha1VolumeAttachment>(params: Params$patchStorageV1alpha1VolumeAttachment<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchStorageV1alpha1VolumeAttachment$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1alpha1/volumeattachments/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** watch individual changes to a list of VolumeAttachment. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchStorageV1alpha1VolumeAttachmentList: <ResponseContentType extends ResponseContentType$watchStorageV1alpha1VolumeAttachmentList>(params: Params$watchStorageV1alpha1VolumeAttachmentList<ResponseContentType>, option?: RequestOption): Promise<Response$watchStorageV1alpha1VolumeAttachmentList$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1alpha1/watch/volumeattachments\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch changes to an object of kind VolumeAttachment. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. */
+        watchStorageV1alpha1VolumeAttachment: <ResponseContentType extends ResponseContentType$watchStorageV1alpha1VolumeAttachment>(params: Params$watchStorageV1alpha1VolumeAttachment<ResponseContentType>, option?: RequestOption): Promise<Response$watchStorageV1alpha1VolumeAttachment$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1alpha1/watch/volumeattachments/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** get available resources */
+        getStorageV1beta1APIResources: <ResponseContentType extends ResponseContentType$getStorageV1beta1APIResources>(params: Params$getStorageV1beta1APIResources<ResponseContentType>, option?: RequestOption): Promise<Response$getStorageV1beta1APIResources$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1beta1/\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        /** list or watch objects of kind CSIDriver */
+        listStorageV1beta1CSIDriver: <ResponseContentType extends ResponseContentType$listStorageV1beta1CSIDriver>(params: Params$listStorageV1beta1CSIDriver<ResponseContentType>, option?: RequestOption): Promise<Response$listStorageV1beta1CSIDriver$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1beta1/csidrivers\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** create a CSIDriver */
+        createStorageV1beta1CSIDriver: <ResponseContentType extends ResponseContentType$createStorageV1beta1CSIDriver>(params: Params$createStorageV1beta1CSIDriver<ResponseContentType>, option?: RequestOption): Promise<(Response$createStorageV1beta1CSIDriver$Status$200 | Response$createStorageV1beta1CSIDriver$Status$201 | Response$createStorageV1beta1CSIDriver$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1beta1/csidrivers\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete collection of CSIDriver */
+        deleteStorageV1beta1CollectionCSIDriver: <ResponseContentType extends ResponseContentType$deleteStorageV1beta1CollectionCSIDriver>(params: Params$deleteStorageV1beta1CollectionCSIDriver<ResponseContentType>, option?: RequestOption): Promise<Response$deleteStorageV1beta1CollectionCSIDriver$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1beta1/csidrivers\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read the specified CSIDriver */
+        readStorageV1beta1CSIDriver: <ResponseContentType extends ResponseContentType$readStorageV1beta1CSIDriver>(params: Params$readStorageV1beta1CSIDriver<ResponseContentType>, option?: RequestOption): Promise<Response$readStorageV1beta1CSIDriver$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1beta1/csidrivers/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                exact: { value: params.parameter.exact, explode: false },
+                export: { value: params.parameter.export, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace the specified CSIDriver */
+        replaceStorageV1beta1CSIDriver: <ResponseContentType extends ResponseContentType$replaceStorageV1beta1CSIDriver>(params: Params$replaceStorageV1beta1CSIDriver<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceStorageV1beta1CSIDriver$Status$200 | Response$replaceStorageV1beta1CSIDriver$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1beta1/csidrivers/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete a CSIDriver */
+        deleteStorageV1beta1CSIDriver: <ResponseContentType extends ResponseContentType$deleteStorageV1beta1CSIDriver>(params: Params$deleteStorageV1beta1CSIDriver<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteStorageV1beta1CSIDriver$Status$200 | Response$deleteStorageV1beta1CSIDriver$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1beta1/csidrivers/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update the specified CSIDriver */
+        patchStorageV1beta1CSIDriver: <RequestContentType extends RequestContentType$patchStorageV1beta1CSIDriver, ResponseContentType extends ResponseContentType$patchStorageV1beta1CSIDriver>(params: Params$patchStorageV1beta1CSIDriver<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchStorageV1beta1CSIDriver$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1beta1/csidrivers/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** list or watch objects of kind CSINode */
+        listStorageV1beta1CSINode: <ResponseContentType extends ResponseContentType$listStorageV1beta1CSINode>(params: Params$listStorageV1beta1CSINode<ResponseContentType>, option?: RequestOption): Promise<Response$listStorageV1beta1CSINode$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1beta1/csinodes\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** create a CSINode */
+        createStorageV1beta1CSINode: <ResponseContentType extends ResponseContentType$createStorageV1beta1CSINode>(params: Params$createStorageV1beta1CSINode<ResponseContentType>, option?: RequestOption): Promise<(Response$createStorageV1beta1CSINode$Status$200 | Response$createStorageV1beta1CSINode$Status$201 | Response$createStorageV1beta1CSINode$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1beta1/csinodes\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete collection of CSINode */
+        deleteStorageV1beta1CollectionCSINode: <ResponseContentType extends ResponseContentType$deleteStorageV1beta1CollectionCSINode>(params: Params$deleteStorageV1beta1CollectionCSINode<ResponseContentType>, option?: RequestOption): Promise<Response$deleteStorageV1beta1CollectionCSINode$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1beta1/csinodes\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read the specified CSINode */
+        readStorageV1beta1CSINode: <ResponseContentType extends ResponseContentType$readStorageV1beta1CSINode>(params: Params$readStorageV1beta1CSINode<ResponseContentType>, option?: RequestOption): Promise<Response$readStorageV1beta1CSINode$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1beta1/csinodes/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                exact: { value: params.parameter.exact, explode: false },
+                export: { value: params.parameter.export, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace the specified CSINode */
+        replaceStorageV1beta1CSINode: <ResponseContentType extends ResponseContentType$replaceStorageV1beta1CSINode>(params: Params$replaceStorageV1beta1CSINode<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceStorageV1beta1CSINode$Status$200 | Response$replaceStorageV1beta1CSINode$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1beta1/csinodes/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete a CSINode */
+        deleteStorageV1beta1CSINode: <ResponseContentType extends ResponseContentType$deleteStorageV1beta1CSINode>(params: Params$deleteStorageV1beta1CSINode<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteStorageV1beta1CSINode$Status$200 | Response$deleteStorageV1beta1CSINode$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1beta1/csinodes/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update the specified CSINode */
+        patchStorageV1beta1CSINode: <RequestContentType extends RequestContentType$patchStorageV1beta1CSINode, ResponseContentType extends ResponseContentType$patchStorageV1beta1CSINode>(params: Params$patchStorageV1beta1CSINode<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchStorageV1beta1CSINode$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1beta1/csinodes/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** list or watch objects of kind StorageClass */
+        listStorageV1beta1StorageClass: <ResponseContentType extends ResponseContentType$listStorageV1beta1StorageClass>(params: Params$listStorageV1beta1StorageClass<ResponseContentType>, option?: RequestOption): Promise<Response$listStorageV1beta1StorageClass$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1beta1/storageclasses\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** create a StorageClass */
+        createStorageV1beta1StorageClass: <ResponseContentType extends ResponseContentType$createStorageV1beta1StorageClass>(params: Params$createStorageV1beta1StorageClass<ResponseContentType>, option?: RequestOption): Promise<(Response$createStorageV1beta1StorageClass$Status$200 | Response$createStorageV1beta1StorageClass$Status$201 | Response$createStorageV1beta1StorageClass$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1beta1/storageclasses\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete collection of StorageClass */
+        deleteStorageV1beta1CollectionStorageClass: <ResponseContentType extends ResponseContentType$deleteStorageV1beta1CollectionStorageClass>(params: Params$deleteStorageV1beta1CollectionStorageClass<ResponseContentType>, option?: RequestOption): Promise<Response$deleteStorageV1beta1CollectionStorageClass$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1beta1/storageclasses\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read the specified StorageClass */
+        readStorageV1beta1StorageClass: <ResponseContentType extends ResponseContentType$readStorageV1beta1StorageClass>(params: Params$readStorageV1beta1StorageClass<ResponseContentType>, option?: RequestOption): Promise<Response$readStorageV1beta1StorageClass$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1beta1/storageclasses/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                exact: { value: params.parameter.exact, explode: false },
+                export: { value: params.parameter.export, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace the specified StorageClass */
+        replaceStorageV1beta1StorageClass: <ResponseContentType extends ResponseContentType$replaceStorageV1beta1StorageClass>(params: Params$replaceStorageV1beta1StorageClass<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceStorageV1beta1StorageClass$Status$200 | Response$replaceStorageV1beta1StorageClass$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1beta1/storageclasses/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete a StorageClass */
+        deleteStorageV1beta1StorageClass: <ResponseContentType extends ResponseContentType$deleteStorageV1beta1StorageClass>(params: Params$deleteStorageV1beta1StorageClass<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteStorageV1beta1StorageClass$Status$200 | Response$deleteStorageV1beta1StorageClass$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1beta1/storageclasses/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update the specified StorageClass */
+        patchStorageV1beta1StorageClass: <RequestContentType extends RequestContentType$patchStorageV1beta1StorageClass, ResponseContentType extends ResponseContentType$patchStorageV1beta1StorageClass>(params: Params$patchStorageV1beta1StorageClass<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchStorageV1beta1StorageClass$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1beta1/storageclasses/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** list or watch objects of kind VolumeAttachment */
+        listStorageV1beta1VolumeAttachment: <ResponseContentType extends ResponseContentType$listStorageV1beta1VolumeAttachment>(params: Params$listStorageV1beta1VolumeAttachment<ResponseContentType>, option?: RequestOption): Promise<Response$listStorageV1beta1VolumeAttachment$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1beta1/volumeattachments\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** create a VolumeAttachment */
+        createStorageV1beta1VolumeAttachment: <ResponseContentType extends ResponseContentType$createStorageV1beta1VolumeAttachment>(params: Params$createStorageV1beta1VolumeAttachment<ResponseContentType>, option?: RequestOption): Promise<(Response$createStorageV1beta1VolumeAttachment$Status$200 | Response$createStorageV1beta1VolumeAttachment$Status$201 | Response$createStorageV1beta1VolumeAttachment$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1beta1/volumeattachments\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("POST", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete collection of VolumeAttachment */
+        deleteStorageV1beta1CollectionVolumeAttachment: <ResponseContentType extends ResponseContentType$deleteStorageV1beta1CollectionVolumeAttachment>(params: Params$deleteStorageV1beta1CollectionVolumeAttachment<ResponseContentType>, option?: RequestOption): Promise<Response$deleteStorageV1beta1CollectionVolumeAttachment$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1beta1/volumeattachments\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** read the specified VolumeAttachment */
+        readStorageV1beta1VolumeAttachment: <ResponseContentType extends ResponseContentType$readStorageV1beta1VolumeAttachment>(params: Params$readStorageV1beta1VolumeAttachment<ResponseContentType>, option?: RequestOption): Promise<Response$readStorageV1beta1VolumeAttachment$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1beta1/volumeattachments/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                exact: { value: params.parameter.exact, explode: false },
+                export: { value: params.parameter.export, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** replace the specified VolumeAttachment */
+        replaceStorageV1beta1VolumeAttachment: <ResponseContentType extends ResponseContentType$replaceStorageV1beta1VolumeAttachment>(params: Params$replaceStorageV1beta1VolumeAttachment<ResponseContentType>, option?: RequestOption): Promise<(Response$replaceStorageV1beta1VolumeAttachment$Status$200 | Response$replaceStorageV1beta1VolumeAttachment$Status$201)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1beta1/volumeattachments/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false }
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** delete a VolumeAttachment */
+        deleteStorageV1beta1VolumeAttachment: <ResponseContentType extends ResponseContentType$deleteStorageV1beta1VolumeAttachment>(params: Params$deleteStorageV1beta1VolumeAttachment<ResponseContentType>, option?: RequestOption): Promise<(Response$deleteStorageV1beta1VolumeAttachment$Status$200 | Response$deleteStorageV1beta1VolumeAttachment$Status$202)[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1beta1/volumeattachments/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": "*/*",
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                gracePeriodSeconds: { value: params.parameter.gracePeriodSeconds, explode: false },
+                orphanDependents: { value: params.parameter.orphanDependents, explode: false },
+                propagationPolicy: { value: params.parameter.propagationPolicy, explode: false }
+            };
+            return apiClient.request("DELETE", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** partially update the specified VolumeAttachment */
+        patchStorageV1beta1VolumeAttachment: <RequestContentType extends RequestContentType$patchStorageV1beta1VolumeAttachment, ResponseContentType extends ResponseContentType$patchStorageV1beta1VolumeAttachment>(params: Params$patchStorageV1beta1VolumeAttachment<RequestContentType, ResponseContentType>, option?: RequestOption): Promise<Response$patchStorageV1beta1VolumeAttachment$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1beta1/volumeattachments/\${params.parameter.name}\`;
+            const headers = {
+                "Content-Type": params.headers["Content-Type"],
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                pretty: { value: params.parameter.pretty, explode: false },
+                dryRun: { value: params.parameter.dryRun, explode: false },
+                fieldManager: { value: params.parameter.fieldManager, explode: false },
+                force: { value: params.parameter.force, explode: false }
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, queryParameters, option);
+        },
+        /** watch individual changes to a list of CSIDriver. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchStorageV1beta1CSIDriverList: <ResponseContentType extends ResponseContentType$watchStorageV1beta1CSIDriverList>(params: Params$watchStorageV1beta1CSIDriverList<ResponseContentType>, option?: RequestOption): Promise<Response$watchStorageV1beta1CSIDriverList$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1beta1/watch/csidrivers\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch changes to an object of kind CSIDriver. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. */
+        watchStorageV1beta1CSIDriver: <ResponseContentType extends ResponseContentType$watchStorageV1beta1CSIDriver>(params: Params$watchStorageV1beta1CSIDriver<ResponseContentType>, option?: RequestOption): Promise<Response$watchStorageV1beta1CSIDriver$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1beta1/watch/csidrivers/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of CSINode. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchStorageV1beta1CSINodeList: <ResponseContentType extends ResponseContentType$watchStorageV1beta1CSINodeList>(params: Params$watchStorageV1beta1CSINodeList<ResponseContentType>, option?: RequestOption): Promise<Response$watchStorageV1beta1CSINodeList$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1beta1/watch/csinodes\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch changes to an object of kind CSINode. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. */
+        watchStorageV1beta1CSINode: <ResponseContentType extends ResponseContentType$watchStorageV1beta1CSINode>(params: Params$watchStorageV1beta1CSINode<ResponseContentType>, option?: RequestOption): Promise<Response$watchStorageV1beta1CSINode$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1beta1/watch/csinodes/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of StorageClass. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchStorageV1beta1StorageClassList: <ResponseContentType extends ResponseContentType$watchStorageV1beta1StorageClassList>(params: Params$watchStorageV1beta1StorageClassList<ResponseContentType>, option?: RequestOption): Promise<Response$watchStorageV1beta1StorageClassList$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1beta1/watch/storageclasses\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch changes to an object of kind StorageClass. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. */
+        watchStorageV1beta1StorageClass: <ResponseContentType extends ResponseContentType$watchStorageV1beta1StorageClass>(params: Params$watchStorageV1beta1StorageClass<ResponseContentType>, option?: RequestOption): Promise<Response$watchStorageV1beta1StorageClass$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1beta1/watch/storageclasses/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch individual changes to a list of VolumeAttachment. deprecated: use the 'watch' parameter with a list operation instead. */
+        watchStorageV1beta1VolumeAttachmentList: <ResponseContentType extends ResponseContentType$watchStorageV1beta1VolumeAttachmentList>(params: Params$watchStorageV1beta1VolumeAttachmentList<ResponseContentType>, option?: RequestOption): Promise<Response$watchStorageV1beta1VolumeAttachmentList$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1beta1/watch/volumeattachments\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /** watch changes to an object of kind VolumeAttachment. deprecated: use the 'watch' parameter with a list operation instead, filtered to a single item with the 'fieldSelector' parameter. */
+        watchStorageV1beta1VolumeAttachment: <ResponseContentType extends ResponseContentType$watchStorageV1beta1VolumeAttachment>(params: Params$watchStorageV1beta1VolumeAttachment<ResponseContentType>, option?: RequestOption): Promise<Response$watchStorageV1beta1VolumeAttachment$Status$200[ResponseContentType]> => {
+            const url = baseUrl + \`/apis/storage.k8s.io/v1beta1/watch/volumeattachments/\${params.parameter.name}\`;
+            const headers = {
+                Accept: params.headers.Accept
+            };
+            const queryParameters: QueryParameters = {
+                allowWatchBookmarks: { value: params.parameter.allowWatchBookmarks, explode: false },
+                continue: { value: params.parameter.continue, explode: false },
+                fieldSelector: { value: params.parameter.fieldSelector, explode: false },
+                labelSelector: { value: params.parameter.labelSelector, explode: false },
+                limit: { value: params.parameter.limit, explode: false },
+                pretty: { value: params.parameter.pretty, explode: false },
+                resourceVersion: { value: params.parameter.resourceVersion, explode: false },
+                timeoutSeconds: { value: params.parameter.timeoutSeconds, explode: false },
+                watch: { value: params.parameter.watch, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        logFileListHandler: (option?: RequestOption): Promise<void> => {
+            const url = baseUrl + \`/logs/\`;
+            const headers = {};
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        logFileHandler: (params: Params$logFileHandler, option?: RequestOption): Promise<void> => {
+            const url = baseUrl + \`/logs/\${params.parameter.logpath}\`;
+            const headers = {};
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        /** get the code version */
+        getCodeVersion: (option?: RequestOption): Promise<Response$getCodeVersion$Status$200["application/json"]> => {
+            const url = baseUrl + \`/version/\`;
+            const headers = {
+                Accept: "application/json"
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        }
     };
-    return { getCoreAPIVersions, getCoreV1APIResources, listCoreV1ComponentStatus, readCoreV1ComponentStatus, listCoreV1ConfigMapForAllNamespaces, listCoreV1EndpointsForAllNamespaces, listCoreV1EventForAllNamespaces, listCoreV1LimitRangeForAllNamespaces, listCoreV1Namespace, createCoreV1Namespace, createCoreV1NamespacedBinding, listCoreV1NamespacedConfigMap, createCoreV1NamespacedConfigMap, deleteCoreV1CollectionNamespacedConfigMap, readCoreV1NamespacedConfigMap, replaceCoreV1NamespacedConfigMap, deleteCoreV1NamespacedConfigMap, patchCoreV1NamespacedConfigMap, listCoreV1NamespacedEndpoints, createCoreV1NamespacedEndpoints, deleteCoreV1CollectionNamespacedEndpoints, readCoreV1NamespacedEndpoints, replaceCoreV1NamespacedEndpoints, deleteCoreV1NamespacedEndpoints, patchCoreV1NamespacedEndpoints, listCoreV1NamespacedEvent, createCoreV1NamespacedEvent, deleteCoreV1CollectionNamespacedEvent, readCoreV1NamespacedEvent, replaceCoreV1NamespacedEvent, deleteCoreV1NamespacedEvent, patchCoreV1NamespacedEvent, listCoreV1NamespacedLimitRange, createCoreV1NamespacedLimitRange, deleteCoreV1CollectionNamespacedLimitRange, readCoreV1NamespacedLimitRange, replaceCoreV1NamespacedLimitRange, deleteCoreV1NamespacedLimitRange, patchCoreV1NamespacedLimitRange, listCoreV1NamespacedPersistentVolumeClaim, createCoreV1NamespacedPersistentVolumeClaim, deleteCoreV1CollectionNamespacedPersistentVolumeClaim, readCoreV1NamespacedPersistentVolumeClaim, replaceCoreV1NamespacedPersistentVolumeClaim, deleteCoreV1NamespacedPersistentVolumeClaim, patchCoreV1NamespacedPersistentVolumeClaim, readCoreV1NamespacedPersistentVolumeClaimStatus, replaceCoreV1NamespacedPersistentVolumeClaimStatus, patchCoreV1NamespacedPersistentVolumeClaimStatus, listCoreV1NamespacedPod, createCoreV1NamespacedPod, deleteCoreV1CollectionNamespacedPod, readCoreV1NamespacedPod, replaceCoreV1NamespacedPod, deleteCoreV1NamespacedPod, patchCoreV1NamespacedPod, connectCoreV1GetNamespacedPodAttach, connectCoreV1PostNamespacedPodAttach, createCoreV1NamespacedPodBinding, createCoreV1NamespacedPodEviction, connectCoreV1GetNamespacedPodExec, connectCoreV1PostNamespacedPodExec, readCoreV1NamespacedPodLog, connectCoreV1GetNamespacedPodPortforward, connectCoreV1PostNamespacedPodPortforward, connectCoreV1GetNamespacedPodProxy, connectCoreV1PutNamespacedPodProxy, connectCoreV1PostNamespacedPodProxy, connectCoreV1DeleteNamespacedPodProxy, connectCoreV1OptionsNamespacedPodProxy, connectCoreV1HeadNamespacedPodProxy, connectCoreV1PatchNamespacedPodProxy, connectCoreV1GetNamespacedPodProxyWithPath, connectCoreV1PutNamespacedPodProxyWithPath, connectCoreV1PostNamespacedPodProxyWithPath, connectCoreV1DeleteNamespacedPodProxyWithPath, connectCoreV1OptionsNamespacedPodProxyWithPath, connectCoreV1HeadNamespacedPodProxyWithPath, connectCoreV1PatchNamespacedPodProxyWithPath, readCoreV1NamespacedPodStatus, replaceCoreV1NamespacedPodStatus, patchCoreV1NamespacedPodStatus, listCoreV1NamespacedPodTemplate, createCoreV1NamespacedPodTemplate, deleteCoreV1CollectionNamespacedPodTemplate, readCoreV1NamespacedPodTemplate, replaceCoreV1NamespacedPodTemplate, deleteCoreV1NamespacedPodTemplate, patchCoreV1NamespacedPodTemplate, listCoreV1NamespacedReplicationController, createCoreV1NamespacedReplicationController, deleteCoreV1CollectionNamespacedReplicationController, readCoreV1NamespacedReplicationController, replaceCoreV1NamespacedReplicationController, deleteCoreV1NamespacedReplicationController, patchCoreV1NamespacedReplicationController, readCoreV1NamespacedReplicationControllerScale, replaceCoreV1NamespacedReplicationControllerScale, patchCoreV1NamespacedReplicationControllerScale, readCoreV1NamespacedReplicationControllerStatus, replaceCoreV1NamespacedReplicationControllerStatus, patchCoreV1NamespacedReplicationControllerStatus, listCoreV1NamespacedResourceQuota, createCoreV1NamespacedResourceQuota, deleteCoreV1CollectionNamespacedResourceQuota, readCoreV1NamespacedResourceQuota, replaceCoreV1NamespacedResourceQuota, deleteCoreV1NamespacedResourceQuota, patchCoreV1NamespacedResourceQuota, readCoreV1NamespacedResourceQuotaStatus, replaceCoreV1NamespacedResourceQuotaStatus, patchCoreV1NamespacedResourceQuotaStatus, listCoreV1NamespacedSecret, createCoreV1NamespacedSecret, deleteCoreV1CollectionNamespacedSecret, readCoreV1NamespacedSecret, replaceCoreV1NamespacedSecret, deleteCoreV1NamespacedSecret, patchCoreV1NamespacedSecret, listCoreV1NamespacedServiceAccount, createCoreV1NamespacedServiceAccount, deleteCoreV1CollectionNamespacedServiceAccount, readCoreV1NamespacedServiceAccount, replaceCoreV1NamespacedServiceAccount, deleteCoreV1NamespacedServiceAccount, patchCoreV1NamespacedServiceAccount, createCoreV1NamespacedServiceAccountToken, listCoreV1NamespacedService, createCoreV1NamespacedService, readCoreV1NamespacedService, replaceCoreV1NamespacedService, deleteCoreV1NamespacedService, patchCoreV1NamespacedService, connectCoreV1GetNamespacedServiceProxy, connectCoreV1PutNamespacedServiceProxy, connectCoreV1PostNamespacedServiceProxy, connectCoreV1DeleteNamespacedServiceProxy, connectCoreV1OptionsNamespacedServiceProxy, connectCoreV1HeadNamespacedServiceProxy, connectCoreV1PatchNamespacedServiceProxy, connectCoreV1GetNamespacedServiceProxyWithPath, connectCoreV1PutNamespacedServiceProxyWithPath, connectCoreV1PostNamespacedServiceProxyWithPath, connectCoreV1DeleteNamespacedServiceProxyWithPath, connectCoreV1OptionsNamespacedServiceProxyWithPath, connectCoreV1HeadNamespacedServiceProxyWithPath, connectCoreV1PatchNamespacedServiceProxyWithPath, readCoreV1NamespacedServiceStatus, replaceCoreV1NamespacedServiceStatus, patchCoreV1NamespacedServiceStatus, readCoreV1Namespace, replaceCoreV1Namespace, deleteCoreV1Namespace, patchCoreV1Namespace, replaceCoreV1NamespaceFinalize, readCoreV1NamespaceStatus, replaceCoreV1NamespaceStatus, patchCoreV1NamespaceStatus, listCoreV1Node, createCoreV1Node, deleteCoreV1CollectionNode, readCoreV1Node, replaceCoreV1Node, deleteCoreV1Node, patchCoreV1Node, connectCoreV1GetNodeProxy, connectCoreV1PutNodeProxy, connectCoreV1PostNodeProxy, connectCoreV1DeleteNodeProxy, connectCoreV1OptionsNodeProxy, connectCoreV1HeadNodeProxy, connectCoreV1PatchNodeProxy, connectCoreV1GetNodeProxyWithPath, connectCoreV1PutNodeProxyWithPath, connectCoreV1PostNodeProxyWithPath, connectCoreV1DeleteNodeProxyWithPath, connectCoreV1OptionsNodeProxyWithPath, connectCoreV1HeadNodeProxyWithPath, connectCoreV1PatchNodeProxyWithPath, readCoreV1NodeStatus, replaceCoreV1NodeStatus, patchCoreV1NodeStatus, listCoreV1PersistentVolumeClaimForAllNamespaces, listCoreV1PersistentVolume, createCoreV1PersistentVolume, deleteCoreV1CollectionPersistentVolume, readCoreV1PersistentVolume, replaceCoreV1PersistentVolume, deleteCoreV1PersistentVolume, patchCoreV1PersistentVolume, readCoreV1PersistentVolumeStatus, replaceCoreV1PersistentVolumeStatus, patchCoreV1PersistentVolumeStatus, listCoreV1PodForAllNamespaces, listCoreV1PodTemplateForAllNamespaces, listCoreV1ReplicationControllerForAllNamespaces, listCoreV1ResourceQuotaForAllNamespaces, listCoreV1SecretForAllNamespaces, listCoreV1ServiceAccountForAllNamespaces, listCoreV1ServiceForAllNamespaces, watchCoreV1ConfigMapListForAllNamespaces, watchCoreV1EndpointsListForAllNamespaces, watchCoreV1EventListForAllNamespaces, watchCoreV1LimitRangeListForAllNamespaces, watchCoreV1NamespaceList, watchCoreV1NamespacedConfigMapList, watchCoreV1NamespacedConfigMap, watchCoreV1NamespacedEndpointsList, watchCoreV1NamespacedEndpoints, watchCoreV1NamespacedEventList, watchCoreV1NamespacedEvent, watchCoreV1NamespacedLimitRangeList, watchCoreV1NamespacedLimitRange, watchCoreV1NamespacedPersistentVolumeClaimList, watchCoreV1NamespacedPersistentVolumeClaim, watchCoreV1NamespacedPodList, watchCoreV1NamespacedPod, watchCoreV1NamespacedPodTemplateList, watchCoreV1NamespacedPodTemplate, watchCoreV1NamespacedReplicationControllerList, watchCoreV1NamespacedReplicationController, watchCoreV1NamespacedResourceQuotaList, watchCoreV1NamespacedResourceQuota, watchCoreV1NamespacedSecretList, watchCoreV1NamespacedSecret, watchCoreV1NamespacedServiceAccountList, watchCoreV1NamespacedServiceAccount, watchCoreV1NamespacedServiceList, watchCoreV1NamespacedService, watchCoreV1Namespace, watchCoreV1NodeList, watchCoreV1Node, watchCoreV1PersistentVolumeClaimListForAllNamespaces, watchCoreV1PersistentVolumeList, watchCoreV1PersistentVolume, watchCoreV1PodListForAllNamespaces, watchCoreV1PodTemplateListForAllNamespaces, watchCoreV1ReplicationControllerListForAllNamespaces, watchCoreV1ResourceQuotaListForAllNamespaces, watchCoreV1SecretListForAllNamespaces, watchCoreV1ServiceAccountListForAllNamespaces, watchCoreV1ServiceListForAllNamespaces, getAPIVersions, getAdmissionregistrationAPIGroup, getAdmissionregistrationV1APIResources, listAdmissionregistrationV1MutatingWebhookConfiguration, createAdmissionregistrationV1MutatingWebhookConfiguration, deleteAdmissionregistrationV1CollectionMutatingWebhookConfiguration, readAdmissionregistrationV1MutatingWebhookConfiguration, replaceAdmissionregistrationV1MutatingWebhookConfiguration, deleteAdmissionregistrationV1MutatingWebhookConfiguration, patchAdmissionregistrationV1MutatingWebhookConfiguration, listAdmissionregistrationV1ValidatingWebhookConfiguration, createAdmissionregistrationV1ValidatingWebhookConfiguration, deleteAdmissionregistrationV1CollectionValidatingWebhookConfiguration, readAdmissionregistrationV1ValidatingWebhookConfiguration, replaceAdmissionregistrationV1ValidatingWebhookConfiguration, deleteAdmissionregistrationV1ValidatingWebhookConfiguration, patchAdmissionregistrationV1ValidatingWebhookConfiguration, watchAdmissionregistrationV1MutatingWebhookConfigurationList, watchAdmissionregistrationV1MutatingWebhookConfiguration, watchAdmissionregistrationV1ValidatingWebhookConfigurationList, watchAdmissionregistrationV1ValidatingWebhookConfiguration, getAdmissionregistrationV1beta1APIResources, listAdmissionregistrationV1beta1MutatingWebhookConfiguration, createAdmissionregistrationV1beta1MutatingWebhookConfiguration, deleteAdmissionregistrationV1beta1CollectionMutatingWebhookConfiguration, readAdmissionregistrationV1beta1MutatingWebhookConfiguration, replaceAdmissionregistrationV1beta1MutatingWebhookConfiguration, deleteAdmissionregistrationV1beta1MutatingWebhookConfiguration, patchAdmissionregistrationV1beta1MutatingWebhookConfiguration, listAdmissionregistrationV1beta1ValidatingWebhookConfiguration, createAdmissionregistrationV1beta1ValidatingWebhookConfiguration, deleteAdmissionregistrationV1beta1CollectionValidatingWebhookConfiguration, readAdmissionregistrationV1beta1ValidatingWebhookConfiguration, replaceAdmissionregistrationV1beta1ValidatingWebhookConfiguration, deleteAdmissionregistrationV1beta1ValidatingWebhookConfiguration, patchAdmissionregistrationV1beta1ValidatingWebhookConfiguration, watchAdmissionregistrationV1beta1MutatingWebhookConfigurationList, watchAdmissionregistrationV1beta1MutatingWebhookConfiguration, watchAdmissionregistrationV1beta1ValidatingWebhookConfigurationList, watchAdmissionregistrationV1beta1ValidatingWebhookConfiguration, getApiextensionsAPIGroup, getApiextensionsV1APIResources, listApiextensionsV1CustomResourceDefinition, createApiextensionsV1CustomResourceDefinition, deleteApiextensionsV1CollectionCustomResourceDefinition, readApiextensionsV1CustomResourceDefinition, replaceApiextensionsV1CustomResourceDefinition, deleteApiextensionsV1CustomResourceDefinition, patchApiextensionsV1CustomResourceDefinition, readApiextensionsV1CustomResourceDefinitionStatus, replaceApiextensionsV1CustomResourceDefinitionStatus, patchApiextensionsV1CustomResourceDefinitionStatus, watchApiextensionsV1CustomResourceDefinitionList, watchApiextensionsV1CustomResourceDefinition, getApiextensionsV1beta1APIResources, listApiextensionsV1beta1CustomResourceDefinition, createApiextensionsV1beta1CustomResourceDefinition, deleteApiextensionsV1beta1CollectionCustomResourceDefinition, readApiextensionsV1beta1CustomResourceDefinition, replaceApiextensionsV1beta1CustomResourceDefinition, deleteApiextensionsV1beta1CustomResourceDefinition, patchApiextensionsV1beta1CustomResourceDefinition, readApiextensionsV1beta1CustomResourceDefinitionStatus, replaceApiextensionsV1beta1CustomResourceDefinitionStatus, patchApiextensionsV1beta1CustomResourceDefinitionStatus, watchApiextensionsV1beta1CustomResourceDefinitionList, watchApiextensionsV1beta1CustomResourceDefinition, getApiregistrationAPIGroup, getApiregistrationV1APIResources, listApiregistrationV1APIService, createApiregistrationV1APIService, deleteApiregistrationV1CollectionAPIService, readApiregistrationV1APIService, replaceApiregistrationV1APIService, deleteApiregistrationV1APIService, patchApiregistrationV1APIService, readApiregistrationV1APIServiceStatus, replaceApiregistrationV1APIServiceStatus, patchApiregistrationV1APIServiceStatus, watchApiregistrationV1APIServiceList, watchApiregistrationV1APIService, getApiregistrationV1beta1APIResources, listApiregistrationV1beta1APIService, createApiregistrationV1beta1APIService, deleteApiregistrationV1beta1CollectionAPIService, readApiregistrationV1beta1APIService, replaceApiregistrationV1beta1APIService, deleteApiregistrationV1beta1APIService, patchApiregistrationV1beta1APIService, readApiregistrationV1beta1APIServiceStatus, replaceApiregistrationV1beta1APIServiceStatus, patchApiregistrationV1beta1APIServiceStatus, watchApiregistrationV1beta1APIServiceList, watchApiregistrationV1beta1APIService, getAppsAPIGroup, getAppsV1APIResources, listAppsV1ControllerRevisionForAllNamespaces, listAppsV1DaemonSetForAllNamespaces, listAppsV1DeploymentForAllNamespaces, listAppsV1NamespacedControllerRevision, createAppsV1NamespacedControllerRevision, deleteAppsV1CollectionNamespacedControllerRevision, readAppsV1NamespacedControllerRevision, replaceAppsV1NamespacedControllerRevision, deleteAppsV1NamespacedControllerRevision, patchAppsV1NamespacedControllerRevision, listAppsV1NamespacedDaemonSet, createAppsV1NamespacedDaemonSet, deleteAppsV1CollectionNamespacedDaemonSet, readAppsV1NamespacedDaemonSet, replaceAppsV1NamespacedDaemonSet, deleteAppsV1NamespacedDaemonSet, patchAppsV1NamespacedDaemonSet, readAppsV1NamespacedDaemonSetStatus, replaceAppsV1NamespacedDaemonSetStatus, patchAppsV1NamespacedDaemonSetStatus, listAppsV1NamespacedDeployment, createAppsV1NamespacedDeployment, deleteAppsV1CollectionNamespacedDeployment, readAppsV1NamespacedDeployment, replaceAppsV1NamespacedDeployment, deleteAppsV1NamespacedDeployment, patchAppsV1NamespacedDeployment, readAppsV1NamespacedDeploymentScale, replaceAppsV1NamespacedDeploymentScale, patchAppsV1NamespacedDeploymentScale, readAppsV1NamespacedDeploymentStatus, replaceAppsV1NamespacedDeploymentStatus, patchAppsV1NamespacedDeploymentStatus, listAppsV1NamespacedReplicaSet, createAppsV1NamespacedReplicaSet, deleteAppsV1CollectionNamespacedReplicaSet, readAppsV1NamespacedReplicaSet, replaceAppsV1NamespacedReplicaSet, deleteAppsV1NamespacedReplicaSet, patchAppsV1NamespacedReplicaSet, readAppsV1NamespacedReplicaSetScale, replaceAppsV1NamespacedReplicaSetScale, patchAppsV1NamespacedReplicaSetScale, readAppsV1NamespacedReplicaSetStatus, replaceAppsV1NamespacedReplicaSetStatus, patchAppsV1NamespacedReplicaSetStatus, listAppsV1NamespacedStatefulSet, createAppsV1NamespacedStatefulSet, deleteAppsV1CollectionNamespacedStatefulSet, readAppsV1NamespacedStatefulSet, replaceAppsV1NamespacedStatefulSet, deleteAppsV1NamespacedStatefulSet, patchAppsV1NamespacedStatefulSet, readAppsV1NamespacedStatefulSetScale, replaceAppsV1NamespacedStatefulSetScale, patchAppsV1NamespacedStatefulSetScale, readAppsV1NamespacedStatefulSetStatus, replaceAppsV1NamespacedStatefulSetStatus, patchAppsV1NamespacedStatefulSetStatus, listAppsV1ReplicaSetForAllNamespaces, listAppsV1StatefulSetForAllNamespaces, watchAppsV1ControllerRevisionListForAllNamespaces, watchAppsV1DaemonSetListForAllNamespaces, watchAppsV1DeploymentListForAllNamespaces, watchAppsV1NamespacedControllerRevisionList, watchAppsV1NamespacedControllerRevision, watchAppsV1NamespacedDaemonSetList, watchAppsV1NamespacedDaemonSet, watchAppsV1NamespacedDeploymentList, watchAppsV1NamespacedDeployment, watchAppsV1NamespacedReplicaSetList, watchAppsV1NamespacedReplicaSet, watchAppsV1NamespacedStatefulSetList, watchAppsV1NamespacedStatefulSet, watchAppsV1ReplicaSetListForAllNamespaces, watchAppsV1StatefulSetListForAllNamespaces, getAuditregistrationAPIGroup, getAuditregistrationV1alpha1APIResources, listAuditregistrationV1alpha1AuditSink, createAuditregistrationV1alpha1AuditSink, deleteAuditregistrationV1alpha1CollectionAuditSink, readAuditregistrationV1alpha1AuditSink, replaceAuditregistrationV1alpha1AuditSink, deleteAuditregistrationV1alpha1AuditSink, patchAuditregistrationV1alpha1AuditSink, watchAuditregistrationV1alpha1AuditSinkList, watchAuditregistrationV1alpha1AuditSink, getAuthenticationAPIGroup, getAuthenticationV1APIResources, createAuthenticationV1TokenReview, getAuthenticationV1beta1APIResources, createAuthenticationV1beta1TokenReview, getAuthorizationAPIGroup, getAuthorizationV1APIResources, createAuthorizationV1NamespacedLocalSubjectAccessReview, createAuthorizationV1SelfSubjectAccessReview, createAuthorizationV1SelfSubjectRulesReview, createAuthorizationV1SubjectAccessReview, getAuthorizationV1beta1APIResources, createAuthorizationV1beta1NamespacedLocalSubjectAccessReview, createAuthorizationV1beta1SelfSubjectAccessReview, createAuthorizationV1beta1SelfSubjectRulesReview, createAuthorizationV1beta1SubjectAccessReview, getAutoscalingAPIGroup, getAutoscalingV1APIResources, listAutoscalingV1HorizontalPodAutoscalerForAllNamespaces, listAutoscalingV1NamespacedHorizontalPodAutoscaler, createAutoscalingV1NamespacedHorizontalPodAutoscaler, deleteAutoscalingV1CollectionNamespacedHorizontalPodAutoscaler, readAutoscalingV1NamespacedHorizontalPodAutoscaler, replaceAutoscalingV1NamespacedHorizontalPodAutoscaler, deleteAutoscalingV1NamespacedHorizontalPodAutoscaler, patchAutoscalingV1NamespacedHorizontalPodAutoscaler, readAutoscalingV1NamespacedHorizontalPodAutoscalerStatus, replaceAutoscalingV1NamespacedHorizontalPodAutoscalerStatus, patchAutoscalingV1NamespacedHorizontalPodAutoscalerStatus, watchAutoscalingV1HorizontalPodAutoscalerListForAllNamespaces, watchAutoscalingV1NamespacedHorizontalPodAutoscalerList, watchAutoscalingV1NamespacedHorizontalPodAutoscaler, getAutoscalingV2beta1APIResources, listAutoscalingV2beta1HorizontalPodAutoscalerForAllNamespaces, listAutoscalingV2beta1NamespacedHorizontalPodAutoscaler, createAutoscalingV2beta1NamespacedHorizontalPodAutoscaler, deleteAutoscalingV2beta1CollectionNamespacedHorizontalPodAutoscaler, readAutoscalingV2beta1NamespacedHorizontalPodAutoscaler, replaceAutoscalingV2beta1NamespacedHorizontalPodAutoscaler, deleteAutoscalingV2beta1NamespacedHorizontalPodAutoscaler, patchAutoscalingV2beta1NamespacedHorizontalPodAutoscaler, readAutoscalingV2beta1NamespacedHorizontalPodAutoscalerStatus, replaceAutoscalingV2beta1NamespacedHorizontalPodAutoscalerStatus, patchAutoscalingV2beta1NamespacedHorizontalPodAutoscalerStatus, watchAutoscalingV2beta1HorizontalPodAutoscalerListForAllNamespaces, watchAutoscalingV2beta1NamespacedHorizontalPodAutoscalerList, watchAutoscalingV2beta1NamespacedHorizontalPodAutoscaler, getAutoscalingV2beta2APIResources, listAutoscalingV2beta2HorizontalPodAutoscalerForAllNamespaces, listAutoscalingV2beta2NamespacedHorizontalPodAutoscaler, createAutoscalingV2beta2NamespacedHorizontalPodAutoscaler, deleteAutoscalingV2beta2CollectionNamespacedHorizontalPodAutoscaler, readAutoscalingV2beta2NamespacedHorizontalPodAutoscaler, replaceAutoscalingV2beta2NamespacedHorizontalPodAutoscaler, deleteAutoscalingV2beta2NamespacedHorizontalPodAutoscaler, patchAutoscalingV2beta2NamespacedHorizontalPodAutoscaler, readAutoscalingV2beta2NamespacedHorizontalPodAutoscalerStatus, replaceAutoscalingV2beta2NamespacedHorizontalPodAutoscalerStatus, patchAutoscalingV2beta2NamespacedHorizontalPodAutoscalerStatus, watchAutoscalingV2beta2HorizontalPodAutoscalerListForAllNamespaces, watchAutoscalingV2beta2NamespacedHorizontalPodAutoscalerList, watchAutoscalingV2beta2NamespacedHorizontalPodAutoscaler, getBatchAPIGroup, getBatchV1APIResources, listBatchV1JobForAllNamespaces, listBatchV1NamespacedJob, createBatchV1NamespacedJob, deleteBatchV1CollectionNamespacedJob, readBatchV1NamespacedJob, replaceBatchV1NamespacedJob, deleteBatchV1NamespacedJob, patchBatchV1NamespacedJob, readBatchV1NamespacedJobStatus, replaceBatchV1NamespacedJobStatus, patchBatchV1NamespacedJobStatus, watchBatchV1JobListForAllNamespaces, watchBatchV1NamespacedJobList, watchBatchV1NamespacedJob, getBatchV1beta1APIResources, listBatchV1beta1CronJobForAllNamespaces, listBatchV1beta1NamespacedCronJob, createBatchV1beta1NamespacedCronJob, deleteBatchV1beta1CollectionNamespacedCronJob, readBatchV1beta1NamespacedCronJob, replaceBatchV1beta1NamespacedCronJob, deleteBatchV1beta1NamespacedCronJob, patchBatchV1beta1NamespacedCronJob, readBatchV1beta1NamespacedCronJobStatus, replaceBatchV1beta1NamespacedCronJobStatus, patchBatchV1beta1NamespacedCronJobStatus, watchBatchV1beta1CronJobListForAllNamespaces, watchBatchV1beta1NamespacedCronJobList, watchBatchV1beta1NamespacedCronJob, getBatchV2alpha1APIResources, listBatchV2alpha1CronJobForAllNamespaces, listBatchV2alpha1NamespacedCronJob, createBatchV2alpha1NamespacedCronJob, deleteBatchV2alpha1CollectionNamespacedCronJob, readBatchV2alpha1NamespacedCronJob, replaceBatchV2alpha1NamespacedCronJob, deleteBatchV2alpha1NamespacedCronJob, patchBatchV2alpha1NamespacedCronJob, readBatchV2alpha1NamespacedCronJobStatus, replaceBatchV2alpha1NamespacedCronJobStatus, patchBatchV2alpha1NamespacedCronJobStatus, watchBatchV2alpha1CronJobListForAllNamespaces, watchBatchV2alpha1NamespacedCronJobList, watchBatchV2alpha1NamespacedCronJob, getCertificatesAPIGroup, getCertificatesV1beta1APIResources, listCertificatesV1beta1CertificateSigningRequest, createCertificatesV1beta1CertificateSigningRequest, deleteCertificatesV1beta1CollectionCertificateSigningRequest, readCertificatesV1beta1CertificateSigningRequest, replaceCertificatesV1beta1CertificateSigningRequest, deleteCertificatesV1beta1CertificateSigningRequest, patchCertificatesV1beta1CertificateSigningRequest, replaceCertificatesV1beta1CertificateSigningRequestApproval, readCertificatesV1beta1CertificateSigningRequestStatus, replaceCertificatesV1beta1CertificateSigningRequestStatus, patchCertificatesV1beta1CertificateSigningRequestStatus, watchCertificatesV1beta1CertificateSigningRequestList, watchCertificatesV1beta1CertificateSigningRequest, getCoordinationAPIGroup, getCoordinationV1APIResources, listCoordinationV1LeaseForAllNamespaces, listCoordinationV1NamespacedLease, createCoordinationV1NamespacedLease, deleteCoordinationV1CollectionNamespacedLease, readCoordinationV1NamespacedLease, replaceCoordinationV1NamespacedLease, deleteCoordinationV1NamespacedLease, patchCoordinationV1NamespacedLease, watchCoordinationV1LeaseListForAllNamespaces, watchCoordinationV1NamespacedLeaseList, watchCoordinationV1NamespacedLease, getCoordinationV1beta1APIResources, listCoordinationV1beta1LeaseForAllNamespaces, listCoordinationV1beta1NamespacedLease, createCoordinationV1beta1NamespacedLease, deleteCoordinationV1beta1CollectionNamespacedLease, readCoordinationV1beta1NamespacedLease, replaceCoordinationV1beta1NamespacedLease, deleteCoordinationV1beta1NamespacedLease, patchCoordinationV1beta1NamespacedLease, watchCoordinationV1beta1LeaseListForAllNamespaces, watchCoordinationV1beta1NamespacedLeaseList, watchCoordinationV1beta1NamespacedLease, getDiscoveryAPIGroup, getDiscoveryV1beta1APIResources, listDiscoveryV1beta1EndpointSliceForAllNamespaces, listDiscoveryV1beta1NamespacedEndpointSlice, createDiscoveryV1beta1NamespacedEndpointSlice, deleteDiscoveryV1beta1CollectionNamespacedEndpointSlice, readDiscoveryV1beta1NamespacedEndpointSlice, replaceDiscoveryV1beta1NamespacedEndpointSlice, deleteDiscoveryV1beta1NamespacedEndpointSlice, patchDiscoveryV1beta1NamespacedEndpointSlice, watchDiscoveryV1beta1EndpointSliceListForAllNamespaces, watchDiscoveryV1beta1NamespacedEndpointSliceList, watchDiscoveryV1beta1NamespacedEndpointSlice, getEventsAPIGroup, getEventsV1beta1APIResources, listEventsV1beta1EventForAllNamespaces, listEventsV1beta1NamespacedEvent, createEventsV1beta1NamespacedEvent, deleteEventsV1beta1CollectionNamespacedEvent, readEventsV1beta1NamespacedEvent, replaceEventsV1beta1NamespacedEvent, deleteEventsV1beta1NamespacedEvent, patchEventsV1beta1NamespacedEvent, watchEventsV1beta1EventListForAllNamespaces, watchEventsV1beta1NamespacedEventList, watchEventsV1beta1NamespacedEvent, getExtensionsAPIGroup, getExtensionsV1beta1APIResources, listExtensionsV1beta1IngressForAllNamespaces, listExtensionsV1beta1NamespacedIngress, createExtensionsV1beta1NamespacedIngress, deleteExtensionsV1beta1CollectionNamespacedIngress, readExtensionsV1beta1NamespacedIngress, replaceExtensionsV1beta1NamespacedIngress, deleteExtensionsV1beta1NamespacedIngress, patchExtensionsV1beta1NamespacedIngress, readExtensionsV1beta1NamespacedIngressStatus, replaceExtensionsV1beta1NamespacedIngressStatus, patchExtensionsV1beta1NamespacedIngressStatus, watchExtensionsV1beta1IngressListForAllNamespaces, watchExtensionsV1beta1NamespacedIngressList, watchExtensionsV1beta1NamespacedIngress, getFlowcontrolApiserverAPIGroup, getFlowcontrolApiserverV1alpha1APIResources, listFlowcontrolApiserverV1alpha1FlowSchema, createFlowcontrolApiserverV1alpha1FlowSchema, deleteFlowcontrolApiserverV1alpha1CollectionFlowSchema, readFlowcontrolApiserverV1alpha1FlowSchema, replaceFlowcontrolApiserverV1alpha1FlowSchema, deleteFlowcontrolApiserverV1alpha1FlowSchema, patchFlowcontrolApiserverV1alpha1FlowSchema, readFlowcontrolApiserverV1alpha1FlowSchemaStatus, replaceFlowcontrolApiserverV1alpha1FlowSchemaStatus, patchFlowcontrolApiserverV1alpha1FlowSchemaStatus, listFlowcontrolApiserverV1alpha1PriorityLevelConfiguration, createFlowcontrolApiserverV1alpha1PriorityLevelConfiguration, deleteFlowcontrolApiserverV1alpha1CollectionPriorityLevelConfiguration, readFlowcontrolApiserverV1alpha1PriorityLevelConfiguration, replaceFlowcontrolApiserverV1alpha1PriorityLevelConfiguration, deleteFlowcontrolApiserverV1alpha1PriorityLevelConfiguration, patchFlowcontrolApiserverV1alpha1PriorityLevelConfiguration, readFlowcontrolApiserverV1alpha1PriorityLevelConfigurationStatus, replaceFlowcontrolApiserverV1alpha1PriorityLevelConfigurationStatus, patchFlowcontrolApiserverV1alpha1PriorityLevelConfigurationStatus, watchFlowcontrolApiserverV1alpha1FlowSchemaList, watchFlowcontrolApiserverV1alpha1FlowSchema, watchFlowcontrolApiserverV1alpha1PriorityLevelConfigurationList, watchFlowcontrolApiserverV1alpha1PriorityLevelConfiguration, getNetworkingAPIGroup, getNetworkingV1APIResources, listNetworkingV1NamespacedNetworkPolicy, createNetworkingV1NamespacedNetworkPolicy, deleteNetworkingV1CollectionNamespacedNetworkPolicy, readNetworkingV1NamespacedNetworkPolicy, replaceNetworkingV1NamespacedNetworkPolicy, deleteNetworkingV1NamespacedNetworkPolicy, patchNetworkingV1NamespacedNetworkPolicy, listNetworkingV1NetworkPolicyForAllNamespaces, watchNetworkingV1NamespacedNetworkPolicyList, watchNetworkingV1NamespacedNetworkPolicy, watchNetworkingV1NetworkPolicyListForAllNamespaces, getNetworkingV1beta1APIResources, listNetworkingV1beta1IngressClass, createNetworkingV1beta1IngressClass, deleteNetworkingV1beta1CollectionIngressClass, readNetworkingV1beta1IngressClass, replaceNetworkingV1beta1IngressClass, deleteNetworkingV1beta1IngressClass, patchNetworkingV1beta1IngressClass, listNetworkingV1beta1IngressForAllNamespaces, listNetworkingV1beta1NamespacedIngress, createNetworkingV1beta1NamespacedIngress, deleteNetworkingV1beta1CollectionNamespacedIngress, readNetworkingV1beta1NamespacedIngress, replaceNetworkingV1beta1NamespacedIngress, deleteNetworkingV1beta1NamespacedIngress, patchNetworkingV1beta1NamespacedIngress, readNetworkingV1beta1NamespacedIngressStatus, replaceNetworkingV1beta1NamespacedIngressStatus, patchNetworkingV1beta1NamespacedIngressStatus, watchNetworkingV1beta1IngressClassList, watchNetworkingV1beta1IngressClass, watchNetworkingV1beta1IngressListForAllNamespaces, watchNetworkingV1beta1NamespacedIngressList, watchNetworkingV1beta1NamespacedIngress, getNodeAPIGroup, getNodeV1alpha1APIResources, listNodeV1alpha1RuntimeClass, createNodeV1alpha1RuntimeClass, deleteNodeV1alpha1CollectionRuntimeClass, readNodeV1alpha1RuntimeClass, replaceNodeV1alpha1RuntimeClass, deleteNodeV1alpha1RuntimeClass, patchNodeV1alpha1RuntimeClass, watchNodeV1alpha1RuntimeClassList, watchNodeV1alpha1RuntimeClass, getNodeV1beta1APIResources, listNodeV1beta1RuntimeClass, createNodeV1beta1RuntimeClass, deleteNodeV1beta1CollectionRuntimeClass, readNodeV1beta1RuntimeClass, replaceNodeV1beta1RuntimeClass, deleteNodeV1beta1RuntimeClass, patchNodeV1beta1RuntimeClass, watchNodeV1beta1RuntimeClassList, watchNodeV1beta1RuntimeClass, getPolicyAPIGroup, getPolicyV1beta1APIResources, listPolicyV1beta1NamespacedPodDisruptionBudget, createPolicyV1beta1NamespacedPodDisruptionBudget, deletePolicyV1beta1CollectionNamespacedPodDisruptionBudget, readPolicyV1beta1NamespacedPodDisruptionBudget, replacePolicyV1beta1NamespacedPodDisruptionBudget, deletePolicyV1beta1NamespacedPodDisruptionBudget, patchPolicyV1beta1NamespacedPodDisruptionBudget, readPolicyV1beta1NamespacedPodDisruptionBudgetStatus, replacePolicyV1beta1NamespacedPodDisruptionBudgetStatus, patchPolicyV1beta1NamespacedPodDisruptionBudgetStatus, listPolicyV1beta1PodDisruptionBudgetForAllNamespaces, listPolicyV1beta1PodSecurityPolicy, createPolicyV1beta1PodSecurityPolicy, deletePolicyV1beta1CollectionPodSecurityPolicy, readPolicyV1beta1PodSecurityPolicy, replacePolicyV1beta1PodSecurityPolicy, deletePolicyV1beta1PodSecurityPolicy, patchPolicyV1beta1PodSecurityPolicy, watchPolicyV1beta1NamespacedPodDisruptionBudgetList, watchPolicyV1beta1NamespacedPodDisruptionBudget, watchPolicyV1beta1PodDisruptionBudgetListForAllNamespaces, watchPolicyV1beta1PodSecurityPolicyList, watchPolicyV1beta1PodSecurityPolicy, getRbacAuthorizationAPIGroup, getRbacAuthorizationV1APIResources, listRbacAuthorizationV1ClusterRoleBinding, createRbacAuthorizationV1ClusterRoleBinding, deleteRbacAuthorizationV1CollectionClusterRoleBinding, readRbacAuthorizationV1ClusterRoleBinding, replaceRbacAuthorizationV1ClusterRoleBinding, deleteRbacAuthorizationV1ClusterRoleBinding, patchRbacAuthorizationV1ClusterRoleBinding, listRbacAuthorizationV1ClusterRole, createRbacAuthorizationV1ClusterRole, deleteRbacAuthorizationV1CollectionClusterRole, readRbacAuthorizationV1ClusterRole, replaceRbacAuthorizationV1ClusterRole, deleteRbacAuthorizationV1ClusterRole, patchRbacAuthorizationV1ClusterRole, listRbacAuthorizationV1NamespacedRoleBinding, createRbacAuthorizationV1NamespacedRoleBinding, deleteRbacAuthorizationV1CollectionNamespacedRoleBinding, readRbacAuthorizationV1NamespacedRoleBinding, replaceRbacAuthorizationV1NamespacedRoleBinding, deleteRbacAuthorizationV1NamespacedRoleBinding, patchRbacAuthorizationV1NamespacedRoleBinding, listRbacAuthorizationV1NamespacedRole, createRbacAuthorizationV1NamespacedRole, deleteRbacAuthorizationV1CollectionNamespacedRole, readRbacAuthorizationV1NamespacedRole, replaceRbacAuthorizationV1NamespacedRole, deleteRbacAuthorizationV1NamespacedRole, patchRbacAuthorizationV1NamespacedRole, listRbacAuthorizationV1RoleBindingForAllNamespaces, listRbacAuthorizationV1RoleForAllNamespaces, watchRbacAuthorizationV1ClusterRoleBindingList, watchRbacAuthorizationV1ClusterRoleBinding, watchRbacAuthorizationV1ClusterRoleList, watchRbacAuthorizationV1ClusterRole, watchRbacAuthorizationV1NamespacedRoleBindingList, watchRbacAuthorizationV1NamespacedRoleBinding, watchRbacAuthorizationV1NamespacedRoleList, watchRbacAuthorizationV1NamespacedRole, watchRbacAuthorizationV1RoleBindingListForAllNamespaces, watchRbacAuthorizationV1RoleListForAllNamespaces, getRbacAuthorizationV1alpha1APIResources, listRbacAuthorizationV1alpha1ClusterRoleBinding, createRbacAuthorizationV1alpha1ClusterRoleBinding, deleteRbacAuthorizationV1alpha1CollectionClusterRoleBinding, readRbacAuthorizationV1alpha1ClusterRoleBinding, replaceRbacAuthorizationV1alpha1ClusterRoleBinding, deleteRbacAuthorizationV1alpha1ClusterRoleBinding, patchRbacAuthorizationV1alpha1ClusterRoleBinding, listRbacAuthorizationV1alpha1ClusterRole, createRbacAuthorizationV1alpha1ClusterRole, deleteRbacAuthorizationV1alpha1CollectionClusterRole, readRbacAuthorizationV1alpha1ClusterRole, replaceRbacAuthorizationV1alpha1ClusterRole, deleteRbacAuthorizationV1alpha1ClusterRole, patchRbacAuthorizationV1alpha1ClusterRole, listRbacAuthorizationV1alpha1NamespacedRoleBinding, createRbacAuthorizationV1alpha1NamespacedRoleBinding, deleteRbacAuthorizationV1alpha1CollectionNamespacedRoleBinding, readRbacAuthorizationV1alpha1NamespacedRoleBinding, replaceRbacAuthorizationV1alpha1NamespacedRoleBinding, deleteRbacAuthorizationV1alpha1NamespacedRoleBinding, patchRbacAuthorizationV1alpha1NamespacedRoleBinding, listRbacAuthorizationV1alpha1NamespacedRole, createRbacAuthorizationV1alpha1NamespacedRole, deleteRbacAuthorizationV1alpha1CollectionNamespacedRole, readRbacAuthorizationV1alpha1NamespacedRole, replaceRbacAuthorizationV1alpha1NamespacedRole, deleteRbacAuthorizationV1alpha1NamespacedRole, patchRbacAuthorizationV1alpha1NamespacedRole, listRbacAuthorizationV1alpha1RoleBindingForAllNamespaces, listRbacAuthorizationV1alpha1RoleForAllNamespaces, watchRbacAuthorizationV1alpha1ClusterRoleBindingList, watchRbacAuthorizationV1alpha1ClusterRoleBinding, watchRbacAuthorizationV1alpha1ClusterRoleList, watchRbacAuthorizationV1alpha1ClusterRole, watchRbacAuthorizationV1alpha1NamespacedRoleBindingList, watchRbacAuthorizationV1alpha1NamespacedRoleBinding, watchRbacAuthorizationV1alpha1NamespacedRoleList, watchRbacAuthorizationV1alpha1NamespacedRole, watchRbacAuthorizationV1alpha1RoleBindingListForAllNamespaces, watchRbacAuthorizationV1alpha1RoleListForAllNamespaces, getRbacAuthorizationV1beta1APIResources, listRbacAuthorizationV1beta1ClusterRoleBinding, createRbacAuthorizationV1beta1ClusterRoleBinding, deleteRbacAuthorizationV1beta1CollectionClusterRoleBinding, readRbacAuthorizationV1beta1ClusterRoleBinding, replaceRbacAuthorizationV1beta1ClusterRoleBinding, deleteRbacAuthorizationV1beta1ClusterRoleBinding, patchRbacAuthorizationV1beta1ClusterRoleBinding, listRbacAuthorizationV1beta1ClusterRole, createRbacAuthorizationV1beta1ClusterRole, deleteRbacAuthorizationV1beta1CollectionClusterRole, readRbacAuthorizationV1beta1ClusterRole, replaceRbacAuthorizationV1beta1ClusterRole, deleteRbacAuthorizationV1beta1ClusterRole, patchRbacAuthorizationV1beta1ClusterRole, listRbacAuthorizationV1beta1NamespacedRoleBinding, createRbacAuthorizationV1beta1NamespacedRoleBinding, deleteRbacAuthorizationV1beta1CollectionNamespacedRoleBinding, readRbacAuthorizationV1beta1NamespacedRoleBinding, replaceRbacAuthorizationV1beta1NamespacedRoleBinding, deleteRbacAuthorizationV1beta1NamespacedRoleBinding, patchRbacAuthorizationV1beta1NamespacedRoleBinding, listRbacAuthorizationV1beta1NamespacedRole, createRbacAuthorizationV1beta1NamespacedRole, deleteRbacAuthorizationV1beta1CollectionNamespacedRole, readRbacAuthorizationV1beta1NamespacedRole, replaceRbacAuthorizationV1beta1NamespacedRole, deleteRbacAuthorizationV1beta1NamespacedRole, patchRbacAuthorizationV1beta1NamespacedRole, listRbacAuthorizationV1beta1RoleBindingForAllNamespaces, listRbacAuthorizationV1beta1RoleForAllNamespaces, watchRbacAuthorizationV1beta1ClusterRoleBindingList, watchRbacAuthorizationV1beta1ClusterRoleBinding, watchRbacAuthorizationV1beta1ClusterRoleList, watchRbacAuthorizationV1beta1ClusterRole, watchRbacAuthorizationV1beta1NamespacedRoleBindingList, watchRbacAuthorizationV1beta1NamespacedRoleBinding, watchRbacAuthorizationV1beta1NamespacedRoleList, watchRbacAuthorizationV1beta1NamespacedRole, watchRbacAuthorizationV1beta1RoleBindingListForAllNamespaces, watchRbacAuthorizationV1beta1RoleListForAllNamespaces, getSchedulingAPIGroup, getSchedulingV1APIResources, listSchedulingV1PriorityClass, createSchedulingV1PriorityClass, deleteSchedulingV1CollectionPriorityClass, readSchedulingV1PriorityClass, replaceSchedulingV1PriorityClass, deleteSchedulingV1PriorityClass, patchSchedulingV1PriorityClass, watchSchedulingV1PriorityClassList, watchSchedulingV1PriorityClass, getSchedulingV1alpha1APIResources, listSchedulingV1alpha1PriorityClass, createSchedulingV1alpha1PriorityClass, deleteSchedulingV1alpha1CollectionPriorityClass, readSchedulingV1alpha1PriorityClass, replaceSchedulingV1alpha1PriorityClass, deleteSchedulingV1alpha1PriorityClass, patchSchedulingV1alpha1PriorityClass, watchSchedulingV1alpha1PriorityClassList, watchSchedulingV1alpha1PriorityClass, getSchedulingV1beta1APIResources, listSchedulingV1beta1PriorityClass, createSchedulingV1beta1PriorityClass, deleteSchedulingV1beta1CollectionPriorityClass, readSchedulingV1beta1PriorityClass, replaceSchedulingV1beta1PriorityClass, deleteSchedulingV1beta1PriorityClass, patchSchedulingV1beta1PriorityClass, watchSchedulingV1beta1PriorityClassList, watchSchedulingV1beta1PriorityClass, getSettingsAPIGroup, getSettingsV1alpha1APIResources, listSettingsV1alpha1NamespacedPodPreset, createSettingsV1alpha1NamespacedPodPreset, deleteSettingsV1alpha1CollectionNamespacedPodPreset, readSettingsV1alpha1NamespacedPodPreset, replaceSettingsV1alpha1NamespacedPodPreset, deleteSettingsV1alpha1NamespacedPodPreset, patchSettingsV1alpha1NamespacedPodPreset, listSettingsV1alpha1PodPresetForAllNamespaces, watchSettingsV1alpha1NamespacedPodPresetList, watchSettingsV1alpha1NamespacedPodPreset, watchSettingsV1alpha1PodPresetListForAllNamespaces, getStorageAPIGroup, getStorageV1APIResources, listStorageV1CSIDriver, createStorageV1CSIDriver, deleteStorageV1CollectionCSIDriver, readStorageV1CSIDriver, replaceStorageV1CSIDriver, deleteStorageV1CSIDriver, patchStorageV1CSIDriver, listStorageV1CSINode, createStorageV1CSINode, deleteStorageV1CollectionCSINode, readStorageV1CSINode, replaceStorageV1CSINode, deleteStorageV1CSINode, patchStorageV1CSINode, listStorageV1StorageClass, createStorageV1StorageClass, deleteStorageV1CollectionStorageClass, readStorageV1StorageClass, replaceStorageV1StorageClass, deleteStorageV1StorageClass, patchStorageV1StorageClass, listStorageV1VolumeAttachment, createStorageV1VolumeAttachment, deleteStorageV1CollectionVolumeAttachment, readStorageV1VolumeAttachment, replaceStorageV1VolumeAttachment, deleteStorageV1VolumeAttachment, patchStorageV1VolumeAttachment, readStorageV1VolumeAttachmentStatus, replaceStorageV1VolumeAttachmentStatus, patchStorageV1VolumeAttachmentStatus, watchStorageV1CSIDriverList, watchStorageV1CSIDriver, watchStorageV1CSINodeList, watchStorageV1CSINode, watchStorageV1StorageClassList, watchStorageV1StorageClass, watchStorageV1VolumeAttachmentList, watchStorageV1VolumeAttachment, getStorageV1alpha1APIResources, listStorageV1alpha1VolumeAttachment, createStorageV1alpha1VolumeAttachment, deleteStorageV1alpha1CollectionVolumeAttachment, readStorageV1alpha1VolumeAttachment, replaceStorageV1alpha1VolumeAttachment, deleteStorageV1alpha1VolumeAttachment, patchStorageV1alpha1VolumeAttachment, watchStorageV1alpha1VolumeAttachmentList, watchStorageV1alpha1VolumeAttachment, getStorageV1beta1APIResources, listStorageV1beta1CSIDriver, createStorageV1beta1CSIDriver, deleteStorageV1beta1CollectionCSIDriver, readStorageV1beta1CSIDriver, replaceStorageV1beta1CSIDriver, deleteStorageV1beta1CSIDriver, patchStorageV1beta1CSIDriver, listStorageV1beta1CSINode, createStorageV1beta1CSINode, deleteStorageV1beta1CollectionCSINode, readStorageV1beta1CSINode, replaceStorageV1beta1CSINode, deleteStorageV1beta1CSINode, patchStorageV1beta1CSINode, listStorageV1beta1StorageClass, createStorageV1beta1StorageClass, deleteStorageV1beta1CollectionStorageClass, readStorageV1beta1StorageClass, replaceStorageV1beta1StorageClass, deleteStorageV1beta1StorageClass, patchStorageV1beta1StorageClass, listStorageV1beta1VolumeAttachment, createStorageV1beta1VolumeAttachment, deleteStorageV1beta1CollectionVolumeAttachment, readStorageV1beta1VolumeAttachment, replaceStorageV1beta1VolumeAttachment, deleteStorageV1beta1VolumeAttachment, patchStorageV1beta1VolumeAttachment, watchStorageV1beta1CSIDriverList, watchStorageV1beta1CSIDriver, watchStorageV1beta1CSINodeList, watchStorageV1beta1CSINode, watchStorageV1beta1StorageClassList, watchStorageV1beta1StorageClass, watchStorageV1beta1VolumeAttachmentList, watchStorageV1beta1VolumeAttachment, logFileListHandler, logFileHandler, getCodeVersion };
 };
+export type Client = ReturnType<typeof createClient>;
 "
 `;
diff --git a/test/__tests__/functional/__snapshots__/multi-type.test.domain.ts.snap b/test/__tests__/functional/__snapshots__/multi-type.test.domain.ts.snap
index 7bdfd7b9..07b5bd58 100644
--- a/test/__tests__/functional/__snapshots__/multi-type.test.domain.ts.snap
+++ b/test/__tests__/functional/__snapshots__/multi-type.test.domain.ts.snap
@@ -46,22 +46,32 @@ export interface ApiClient<RequestOption> {
     request: <T = SuccessResponses>(httpMethod: HttpMethod, url: string, headers: ObjectLike | any, requestBody: ObjectLike | any, queryParameters: QueryParameters | undefined, options?: RequestOption) => Promise<T>;
 }
 export const createClient = <RequestOption>(apiClient: ApiClient<RequestOption>, baseUrl: string) => {
-    const putAnyOf = (params: Params$putAnyOf, option?: RequestOption): Promise<void> => {
-        const url = baseUrl + \`/pets\`;
-        const headers = {
-            "Content-Type": "application/json"
-        };
-        return apiClient.request("PUT", url, headers, params.requestBody, undefined, option);
+    return {
+        /**
+         * operationId: putAnyOf
+         * Request URI: /pets
+         */
+        putAnyOf: (params: Params$putAnyOf, option?: RequestOption): Promise<void> => {
+            const url = baseUrl + \`/pets\`;
+            const headers = {
+                "Content-Type": "application/json"
+            };
+            return apiClient.request("PUT", url, headers, params.requestBody, undefined, option);
+        },
+        /**
+         * operationId: patchOneOf
+         * Request URI: /pets
+         */
+        patchOneOf: (params: Params$patchOneOf, option?: RequestOption): Promise<void> => {
+            const url = baseUrl + \`/pets\`;
+            const headers = {
+                "Content-Type": "application/json"
+            };
+            return apiClient.request("PATCH", url, headers, params.requestBody, undefined, option);
+        }
     };
-    const patchOneOf = (params: Params$patchOneOf, option?: RequestOption): Promise<void> => {
-        const url = baseUrl + \`/pets\`;
-        const headers = {
-            "Content-Type": "application/json"
-        };
-        return apiClient.request("PATCH", url, headers, params.requestBody, undefined, option);
-    };
-    return { putAnyOf, patchOneOf };
 };
+export type Client = ReturnType<typeof createClient>;
 "
 `;
 
diff --git a/test/__tests__/functional/__snapshots__/spit-code-test.ts.snap b/test/__tests__/functional/__snapshots__/spit-code-test.ts.snap
index fa7d9ff3..d1a9f350 100644
--- a/test/__tests__/functional/__snapshots__/spit-code-test.ts.snap
+++ b/test/__tests__/functional/__snapshots__/spit-code-test.ts.snap
@@ -127,76 +127,110 @@ export interface ApiClient<RequestOption> {
     request: <T = SuccessResponses>(httpMethod: HttpMethod, url: string, headers: ObjectLike | any, requestBody: ObjectLike | any, queryParameters: QueryParameters | undefined, options?: RequestOption) => Promise<T>;
 }
 export const createClient = <RequestOption>(apiClient: ApiClient<RequestOption>, baseUrl: string) => {
-    const getIncludeLocalReference = (params: Params$getIncludeLocalReference, option?: RequestOption): Promise<Response$getIncludeLocalReference$Status$200["application/json"]> => {
-        const url = baseUrl + \`/get/IncludeLocalReference\`;
-        const headers = {
-            Accept: "application/json"
-        };
-        const queryParameters: QueryParameters = {
-            StringQuery: { value: params.parameter.StringQuery, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const getIncludeRemoteReference = (params: Params$getIncludeRemoteReference, option?: RequestOption): Promise<void> => {
-        const url = baseUrl + \`/get/IncludeRemoteReference\`;
-        const headers = {
-            "Content-Type": "application/json"
-        };
-        const queryParameters: QueryParameters = {
-            IncludeRemoteReference: { value: params.parameter.IncludeRemoteReference, explode: false }
-        };
-        return apiClient.request("GET", url, headers, params.requestBody, queryParameters, option);
-    };
-    const getFullRemoteReference = (params: Params$getFullRemoteReference, option?: RequestOption): Promise<Response$getFullRemoteReference$Status$200["application/json"]> => {
-        const url = baseUrl + \`/FullRemoteReference\`;
-        const headers = {
-            Accept: "application/json"
-        };
-        const queryParameters: QueryParameters = {
-            FullRemoteReferenceQuery: { value: params.parameter.FullRemoteReferenceQuery, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const i$have$dot = (option?: RequestOption): Promise<Response$i$have$dot$Status$200["application/json"]> => {
-        const url = baseUrl + \`/i/have/dot\`;
-        const headers = {
-            Accept: "application/json"
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const getReferenceItems = (option?: RequestOption): Promise<Response$getReferenceItems$Status$200["application/json"]> => {
-        const url = baseUrl + \`/get/reference/items\`;
-        const headers = {
-            Accept: "application/json"
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const searchBook = (params: Params$searchBook, option?: RequestOption): Promise<Response$searchBook$Status$200["application/json"]> => {
-        const url = baseUrl + \`/get/search/\${params.parameter["book.name"]}\`;
-        const headers = {
-            Accept: "application/json"
-        };
-        const queryParameters: QueryParameters = {
-            "from.publishedAt": { value: params.parameter["from.publishedAt"], explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const getBookById = (params: Params$getBookById, option?: RequestOption): Promise<Response$getBookById$Status$200["application/json"]> => {
-        const url = baseUrl + \`/get/books/\${params.parameter.id}\`;
-        const headers = {
-            Accept: "application/json"
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const deleteBook = (params: Params$deleteBook, option?: RequestOption): Promise<Response$deleteBook$Status$200["application/json"]> => {
-        const url = baseUrl + \`/get/books/\${params.parameter.id}\`;
-        const headers = {
-            Accept: "application/json"
-        };
-        return apiClient.request("DELETE", url, headers, undefined, undefined, option);
+    return {
+        /**
+         * operationId: getIncludeLocalReference
+         * Request URI: /get/IncludeLocalReference
+         */
+        getIncludeLocalReference: (params: Params$getIncludeLocalReference, option?: RequestOption): Promise<Response$getIncludeLocalReference$Status$200["application/json"]> => {
+            const url = baseUrl + \`/get/IncludeLocalReference\`;
+            const headers = {
+                Accept: "application/json"
+            };
+            const queryParameters: QueryParameters = {
+                StringQuery: { value: params.parameter.StringQuery, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /**
+         * operationId: getIncludeRemoteReference
+         * Request URI: /get/IncludeRemoteReference
+         */
+        getIncludeRemoteReference: (params: Params$getIncludeRemoteReference, option?: RequestOption): Promise<void> => {
+            const url = baseUrl + \`/get/IncludeRemoteReference\`;
+            const headers = {
+                "Content-Type": "application/json"
+            };
+            const queryParameters: QueryParameters = {
+                IncludeRemoteReference: { value: params.parameter.IncludeRemoteReference, explode: false }
+            };
+            return apiClient.request("GET", url, headers, params.requestBody, queryParameters, option);
+        },
+        /**
+         * operationId: getFullRemoteReference
+         * Request URI: /FullRemoteReference
+         */
+        getFullRemoteReference: (params: Params$getFullRemoteReference, option?: RequestOption): Promise<Response$getFullRemoteReference$Status$200["application/json"]> => {
+            const url = baseUrl + \`/FullRemoteReference\`;
+            const headers = {
+                Accept: "application/json"
+            };
+            const queryParameters: QueryParameters = {
+                FullRemoteReferenceQuery: { value: params.parameter.FullRemoteReferenceQuery, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /**
+         * operationId: i.have.dot
+         * Request URI: /i/have/dot
+         */
+        i$have$dot: (option?: RequestOption): Promise<Response$i$have$dot$Status$200["application/json"]> => {
+            const url = baseUrl + \`/i/have/dot\`;
+            const headers = {
+                Accept: "application/json"
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        /**
+         * operationId: getReferenceItems
+         * Request URI: /get/reference/items
+         */
+        getReferenceItems: (option?: RequestOption): Promise<Response$getReferenceItems$Status$200["application/json"]> => {
+            const url = baseUrl + \`/get/reference/items\`;
+            const headers = {
+                Accept: "application/json"
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        /**
+         * operationId: searchBook
+         * Request URI: /get/search/{book.name}
+         */
+        searchBook: (params: Params$searchBook, option?: RequestOption): Promise<Response$searchBook$Status$200["application/json"]> => {
+            const url = baseUrl + \`/get/search/\${params.parameter["book.name"]}\`;
+            const headers = {
+                Accept: "application/json"
+            };
+            const queryParameters: QueryParameters = {
+                "from.publishedAt": { value: params.parameter["from.publishedAt"], explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        /**
+         * operationId: getBookById
+         * Request URI: /get/books/{id}
+         */
+        getBookById: (params: Params$getBookById, option?: RequestOption): Promise<Response$getBookById$Status$200["application/json"]> => {
+            const url = baseUrl + \`/get/books/\${params.parameter.id}\`;
+            const headers = {
+                Accept: "application/json"
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        /**
+         * operationId: deleteBook
+         * Request URI: /get/books/{id}
+         */
+        deleteBook: (params: Params$deleteBook, option?: RequestOption): Promise<Response$deleteBook$Status$200["application/json"]> => {
+            const url = baseUrl + \`/get/books/\${params.parameter.id}\`;
+            const headers = {
+                Accept: "application/json"
+            };
+            return apiClient.request("DELETE", url, headers, undefined, undefined, option);
+        }
     };
-    return { getIncludeLocalReference, getIncludeRemoteReference, getFullRemoteReference, i$have$dot, getReferenceItems, searchBook, getBookById, deleteBook };
 };
+export type Client = ReturnType<typeof createClient>;
 "
 `;
 
diff --git a/test/__tests__/functional/__snapshots__/template-only-test.ts.snap b/test/__tests__/functional/__snapshots__/template-only-test.ts.snap
index 524be93c..84c9d1a3 100644
--- a/test/__tests__/functional/__snapshots__/template-only-test.ts.snap
+++ b/test/__tests__/functional/__snapshots__/template-only-test.ts.snap
@@ -64,76 +64,78 @@ export interface ApiClient<RequestOption> {
     request: <T = SuccessResponses>(httpMethod: HttpMethod, url: string, headers: ObjectLike | any, requestBody: ObjectLike | any, queryParameters: QueryParameters | undefined, options?: RequestOption) => Promise<T>;
 }
 export const createClient = <RequestOption>(apiClient: ApiClient<RequestOption>, baseUrl: string) => {
-    const getIncludeLocalReference = (params: Params$getIncludeLocalReference, option?: RequestOption): Promise<Response$getIncludeLocalReference$Status$200["application/json"]> => {
-        const url = baseUrl + \`/get/IncludeLocalReference\`;
-        const headers = {
-            Accept: "application/json"
-        };
-        const queryParameters: QueryParameters = {
-            StringQuery: { value: params.parameter.StringQuery, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+    return {
+        getIncludeLocalReference: (params: Params$getIncludeLocalReference, option?: RequestOption): Promise<Response$getIncludeLocalReference$Status$200["application/json"]> => {
+            const url = baseUrl + \`/get/IncludeLocalReference\`;
+            const headers = {
+                Accept: "application/json"
+            };
+            const queryParameters: QueryParameters = {
+                StringQuery: { value: params.parameter.StringQuery, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        getIncludeRemoteReference: (params: Params$getIncludeRemoteReference, option?: RequestOption): Promise<void> => {
+            const url = baseUrl + \`/get/IncludeRemoteReference\`;
+            const headers = {
+                "Content-Type": "application/json"
+            };
+            const queryParameters: QueryParameters = {
+                IncludeRemoteReference: { value: params.parameter.IncludeRemoteReference, explode: false }
+            };
+            return apiClient.request("GET", url, headers, params.requestBody, queryParameters, option);
+        },
+        getFullRemoteReference: (params: Params$getFullRemoteReference, option?: RequestOption): Promise<Response$getFullRemoteReference$Status$200["application/json"]> => {
+            const url = baseUrl + \`/FullRemoteReference\`;
+            const headers = {
+                Accept: "application/json"
+            };
+            const queryParameters: QueryParameters = {
+                FullRemoteReferenceQuery: { value: params.parameter.FullRemoteReferenceQuery, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        i$have$dot: (option?: RequestOption): Promise<Response$i$have$dot$Status$200["application/json"]> => {
+            const url = baseUrl + \`/i/have/dot\`;
+            const headers = {
+                Accept: "application/json"
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        getReferenceItems: (option?: RequestOption): Promise<Response$getReferenceItems$Status$200["application/json"]> => {
+            const url = baseUrl + \`/get/reference/items\`;
+            const headers = {
+                Accept: "application/json"
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        searchBook: (params: Params$searchBook, option?: RequestOption): Promise<Response$searchBook$Status$200["application/json"]> => {
+            const url = baseUrl + \`/get/search/\${params.parameter["book.name"]}\`;
+            const headers = {
+                Accept: "application/json"
+            };
+            const queryParameters: QueryParameters = {
+                "from.publishedAt": { value: params.parameter["from.publishedAt"], explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        getBookById: (params: Params$getBookById, option?: RequestOption): Promise<Response$getBookById$Status$200["application/json"]> => {
+            const url = baseUrl + \`/get/books/\${params.parameter.id}\`;
+            const headers = {
+                Accept: "application/json"
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        deleteBook: (params: Params$deleteBook, option?: RequestOption): Promise<Response$deleteBook$Status$200["application/json"]> => {
+            const url = baseUrl + \`/get/books/\${params.parameter.id}\`;
+            const headers = {
+                Accept: "application/json"
+            };
+            return apiClient.request("DELETE", url, headers, undefined, undefined, option);
+        }
     };
-    const getIncludeRemoteReference = (params: Params$getIncludeRemoteReference, option?: RequestOption): Promise<void> => {
-        const url = baseUrl + \`/get/IncludeRemoteReference\`;
-        const headers = {
-            "Content-Type": "application/json"
-        };
-        const queryParameters: QueryParameters = {
-            IncludeRemoteReference: { value: params.parameter.IncludeRemoteReference, explode: false }
-        };
-        return apiClient.request("GET", url, headers, params.requestBody, queryParameters, option);
-    };
-    const getFullRemoteReference = (params: Params$getFullRemoteReference, option?: RequestOption): Promise<Response$getFullRemoteReference$Status$200["application/json"]> => {
-        const url = baseUrl + \`/FullRemoteReference\`;
-        const headers = {
-            Accept: "application/json"
-        };
-        const queryParameters: QueryParameters = {
-            FullRemoteReferenceQuery: { value: params.parameter.FullRemoteReferenceQuery, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const i$have$dot = (option?: RequestOption): Promise<Response$i$have$dot$Status$200["application/json"]> => {
-        const url = baseUrl + \`/i/have/dot\`;
-        const headers = {
-            Accept: "application/json"
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const getReferenceItems = (option?: RequestOption): Promise<Response$getReferenceItems$Status$200["application/json"]> => {
-        const url = baseUrl + \`/get/reference/items\`;
-        const headers = {
-            Accept: "application/json"
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const searchBook = (params: Params$searchBook, option?: RequestOption): Promise<Response$searchBook$Status$200["application/json"]> => {
-        const url = baseUrl + \`/get/search/\${params.parameter["book.name"]}\`;
-        const headers = {
-            Accept: "application/json"
-        };
-        const queryParameters: QueryParameters = {
-            "from.publishedAt": { value: params.parameter["from.publishedAt"], explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const getBookById = (params: Params$getBookById, option?: RequestOption): Promise<Response$getBookById$Status$200["application/json"]> => {
-        const url = baseUrl + \`/get/books/\${params.parameter.id}\`;
-        const headers = {
-            Accept: "application/json"
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const deleteBook = (params: Params$deleteBook, option?: RequestOption): Promise<Response$deleteBook$Status$200["application/json"]> => {
-        const url = baseUrl + \`/get/books/\${params.parameter.id}\`;
-        const headers = {
-            Accept: "application/json"
-        };
-        return apiClient.request("DELETE", url, headers, undefined, undefined, option);
-    };
-    return { getIncludeLocalReference, getIncludeRemoteReference, getFullRemoteReference, i$have$dot, getReferenceItems, searchBook, getBookById, deleteBook };
 };
+export type Client = ReturnType<typeof createClient>;
 "
 `;
 
@@ -201,76 +203,78 @@ export interface ApiClient<RequestOption> {
     request: <T = SuccessResponses>(httpMethod: HttpMethod, url: string, headers: ObjectLike | any, requestBody: ObjectLike | any, queryParameters: QueryParameters | undefined, options?: RequestOption) => T;
 }
 export const createClient = <RequestOption>(apiClient: ApiClient<RequestOption>, baseUrl: string) => {
-    const getIncludeLocalReference = (params: Params$getIncludeLocalReference, option?: RequestOption): Response$getIncludeLocalReference$Status$200["application/json"] => {
-        const url = baseUrl + \`/get/IncludeLocalReference\`;
-        const headers = {
-            Accept: "application/json"
-        };
-        const queryParameters: QueryParameters = {
-            StringQuery: { value: params.parameter.StringQuery, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const getIncludeRemoteReference = (params: Params$getIncludeRemoteReference, option?: RequestOption): void => {
-        const url = baseUrl + \`/get/IncludeRemoteReference\`;
-        const headers = {
-            "Content-Type": "application/json"
-        };
-        const queryParameters: QueryParameters = {
-            IncludeRemoteReference: { value: params.parameter.IncludeRemoteReference, explode: false }
-        };
-        return apiClient.request("GET", url, headers, params.requestBody, queryParameters, option);
-    };
-    const getFullRemoteReference = (params: Params$getFullRemoteReference, option?: RequestOption): Response$getFullRemoteReference$Status$200["application/json"] => {
-        const url = baseUrl + \`/FullRemoteReference\`;
-        const headers = {
-            Accept: "application/json"
-        };
-        const queryParameters: QueryParameters = {
-            FullRemoteReferenceQuery: { value: params.parameter.FullRemoteReferenceQuery, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const i$have$dot = (option?: RequestOption): Response$i$have$dot$Status$200["application/json"] => {
-        const url = baseUrl + \`/i/have/dot\`;
-        const headers = {
-            Accept: "application/json"
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const getReferenceItems = (option?: RequestOption): Response$getReferenceItems$Status$200["application/json"] => {
-        const url = baseUrl + \`/get/reference/items\`;
-        const headers = {
-            Accept: "application/json"
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const searchBook = (params: Params$searchBook, option?: RequestOption): Response$searchBook$Status$200["application/json"] => {
-        const url = baseUrl + \`/get/search/\${params.parameter["book.name"]}\`;
-        const headers = {
-            Accept: "application/json"
-        };
-        const queryParameters: QueryParameters = {
-            "from.publishedAt": { value: params.parameter["from.publishedAt"], explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const getBookById = (params: Params$getBookById, option?: RequestOption): Response$getBookById$Status$200["application/json"] => {
-        const url = baseUrl + \`/get/books/\${params.parameter.id}\`;
-        const headers = {
-            Accept: "application/json"
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const deleteBook = (params: Params$deleteBook, option?: RequestOption): Response$deleteBook$Status$200["application/json"] => {
-        const url = baseUrl + \`/get/books/\${params.parameter.id}\`;
-        const headers = {
-            Accept: "application/json"
-        };
-        return apiClient.request("DELETE", url, headers, undefined, undefined, option);
+    return {
+        getIncludeLocalReference: (params: Params$getIncludeLocalReference, option?: RequestOption): Response$getIncludeLocalReference$Status$200["application/json"] => {
+            const url = baseUrl + \`/get/IncludeLocalReference\`;
+            const headers = {
+                Accept: "application/json"
+            };
+            const queryParameters: QueryParameters = {
+                StringQuery: { value: params.parameter.StringQuery, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        getIncludeRemoteReference: (params: Params$getIncludeRemoteReference, option?: RequestOption): void => {
+            const url = baseUrl + \`/get/IncludeRemoteReference\`;
+            const headers = {
+                "Content-Type": "application/json"
+            };
+            const queryParameters: QueryParameters = {
+                IncludeRemoteReference: { value: params.parameter.IncludeRemoteReference, explode: false }
+            };
+            return apiClient.request("GET", url, headers, params.requestBody, queryParameters, option);
+        },
+        getFullRemoteReference: (params: Params$getFullRemoteReference, option?: RequestOption): Response$getFullRemoteReference$Status$200["application/json"] => {
+            const url = baseUrl + \`/FullRemoteReference\`;
+            const headers = {
+                Accept: "application/json"
+            };
+            const queryParameters: QueryParameters = {
+                FullRemoteReferenceQuery: { value: params.parameter.FullRemoteReferenceQuery, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        i$have$dot: (option?: RequestOption): Response$i$have$dot$Status$200["application/json"] => {
+            const url = baseUrl + \`/i/have/dot\`;
+            const headers = {
+                Accept: "application/json"
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        getReferenceItems: (option?: RequestOption): Response$getReferenceItems$Status$200["application/json"] => {
+            const url = baseUrl + \`/get/reference/items\`;
+            const headers = {
+                Accept: "application/json"
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        searchBook: (params: Params$searchBook, option?: RequestOption): Response$searchBook$Status$200["application/json"] => {
+            const url = baseUrl + \`/get/search/\${params.parameter["book.name"]}\`;
+            const headers = {
+                Accept: "application/json"
+            };
+            const queryParameters: QueryParameters = {
+                "from.publishedAt": { value: params.parameter["from.publishedAt"], explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        getBookById: (params: Params$getBookById, option?: RequestOption): Response$getBookById$Status$200["application/json"] => {
+            const url = baseUrl + \`/get/books/\${params.parameter.id}\`;
+            const headers = {
+                Accept: "application/json"
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        deleteBook: (params: Params$deleteBook, option?: RequestOption): Response$deleteBook$Status$200["application/json"] => {
+            const url = baseUrl + \`/get/books/\${params.parameter.id}\`;
+            const headers = {
+                Accept: "application/json"
+            };
+            return apiClient.request("DELETE", url, headers, undefined, undefined, option);
+        }
     };
-    return { getIncludeLocalReference, getIncludeRemoteReference, getFullRemoteReference, i$have$dot, getReferenceItems, searchBook, getBookById, deleteBook };
 };
+export type Client = ReturnType<typeof createClient>;
 "
 `;
 
@@ -304,5 +308,6 @@ export interface ApiClient<RequestOption> {
 export const createClient = <RequestOption>(apiClient: ApiClient<RequestOption>, baseUrl: string) => {
     return {};
 };
+export type Client = ReturnType<typeof createClient>;
 "
 `;
diff --git a/test/__tests__/functional/__snapshots__/typedef-with-template-test.ts.snap b/test/__tests__/functional/__snapshots__/typedef-with-template-test.ts.snap
index 6c449804..603a90a9 100644
--- a/test/__tests__/functional/__snapshots__/typedef-with-template-test.ts.snap
+++ b/test/__tests__/functional/__snapshots__/typedef-with-template-test.ts.snap
@@ -413,76 +413,78 @@ export interface ApiClient<RequestOption> {
     request: <T = SuccessResponses>(httpMethod: HttpMethod, url: string, headers: ObjectLike | any, requestBody: ObjectLike | any, queryParameters: QueryParameters | undefined, options?: RequestOption) => Promise<T>;
 }
 export const createClient = <RequestOption>(apiClient: ApiClient<RequestOption>, baseUrl: string) => {
-    const getIncludeLocalReference = (params: Params$getIncludeLocalReference, option?: RequestOption): Promise<Response$getIncludeLocalReference$Status$200["application/json"]> => {
-        const url = baseUrl + \`/get/IncludeLocalReference\`;
-        const headers = {
-            Accept: "application/json"
-        };
-        const queryParameters: QueryParameters = {
-            StringQuery: { value: params.parameter.StringQuery, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const getIncludeRemoteReference = (params: Params$getIncludeRemoteReference, option?: RequestOption): Promise<void> => {
-        const url = baseUrl + \`/get/IncludeRemoteReference\`;
-        const headers = {
-            "Content-Type": "application/json"
-        };
-        const queryParameters: QueryParameters = {
-            IncludeRemoteReference: { value: params.parameter.IncludeRemoteReference, explode: false }
-        };
-        return apiClient.request("GET", url, headers, params.requestBody, queryParameters, option);
-    };
-    const getFullRemoteReference = (params: Params$getFullRemoteReference, option?: RequestOption): Promise<Response$getFullRemoteReference$Status$200["application/json"]> => {
-        const url = baseUrl + \`/FullRemoteReference\`;
-        const headers = {
-            Accept: "application/json"
-        };
-        const queryParameters: QueryParameters = {
-            FullRemoteReferenceQuery: { value: params.parameter.FullRemoteReferenceQuery, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const i$have$dot = (option?: RequestOption): Promise<Response$i$have$dot$Status$200["application/json"]> => {
-        const url = baseUrl + \`/i/have/dot\`;
-        const headers = {
-            Accept: "application/json"
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const getReferenceItems = (option?: RequestOption): Promise<Response$getReferenceItems$Status$200["application/json"]> => {
-        const url = baseUrl + \`/get/reference/items\`;
-        const headers = {
-            Accept: "application/json"
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const searchBook = (params: Params$searchBook, option?: RequestOption): Promise<Response$searchBook$Status$200["application/json"]> => {
-        const url = baseUrl + \`/get/search/\${params.parameter["book.name"]}\`;
-        const headers = {
-            Accept: "application/json"
-        };
-        const queryParameters: QueryParameters = {
-            "from.publishedAt": { value: params.parameter["from.publishedAt"], explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const getBookById = (params: Params$getBookById, option?: RequestOption): Promise<Response$getBookById$Status$200["application/json"]> => {
-        const url = baseUrl + \`/get/books/\${params.parameter.id}\`;
-        const headers = {
-            Accept: "application/json"
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const deleteBook = (params: Params$deleteBook, option?: RequestOption): Promise<Response$deleteBook$Status$200["application/json"]> => {
-        const url = baseUrl + \`/get/books/\${params.parameter.id}\`;
-        const headers = {
-            Accept: "application/json"
-        };
-        return apiClient.request("DELETE", url, headers, undefined, undefined, option);
+    return {
+        getIncludeLocalReference: (params: Params$getIncludeLocalReference, option?: RequestOption): Promise<Response$getIncludeLocalReference$Status$200["application/json"]> => {
+            const url = baseUrl + \`/get/IncludeLocalReference\`;
+            const headers = {
+                Accept: "application/json"
+            };
+            const queryParameters: QueryParameters = {
+                StringQuery: { value: params.parameter.StringQuery, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        getIncludeRemoteReference: (params: Params$getIncludeRemoteReference, option?: RequestOption): Promise<void> => {
+            const url = baseUrl + \`/get/IncludeRemoteReference\`;
+            const headers = {
+                "Content-Type": "application/json"
+            };
+            const queryParameters: QueryParameters = {
+                IncludeRemoteReference: { value: params.parameter.IncludeRemoteReference, explode: false }
+            };
+            return apiClient.request("GET", url, headers, params.requestBody, queryParameters, option);
+        },
+        getFullRemoteReference: (params: Params$getFullRemoteReference, option?: RequestOption): Promise<Response$getFullRemoteReference$Status$200["application/json"]> => {
+            const url = baseUrl + \`/FullRemoteReference\`;
+            const headers = {
+                Accept: "application/json"
+            };
+            const queryParameters: QueryParameters = {
+                FullRemoteReferenceQuery: { value: params.parameter.FullRemoteReferenceQuery, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        i$have$dot: (option?: RequestOption): Promise<Response$i$have$dot$Status$200["application/json"]> => {
+            const url = baseUrl + \`/i/have/dot\`;
+            const headers = {
+                Accept: "application/json"
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        getReferenceItems: (option?: RequestOption): Promise<Response$getReferenceItems$Status$200["application/json"]> => {
+            const url = baseUrl + \`/get/reference/items\`;
+            const headers = {
+                Accept: "application/json"
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        searchBook: (params: Params$searchBook, option?: RequestOption): Promise<Response$searchBook$Status$200["application/json"]> => {
+            const url = baseUrl + \`/get/search/\${params.parameter["book.name"]}\`;
+            const headers = {
+                Accept: "application/json"
+            };
+            const queryParameters: QueryParameters = {
+                "from.publishedAt": { value: params.parameter["from.publishedAt"], explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        getBookById: (params: Params$getBookById, option?: RequestOption): Promise<Response$getBookById$Status$200["application/json"]> => {
+            const url = baseUrl + \`/get/books/\${params.parameter.id}\`;
+            const headers = {
+                Accept: "application/json"
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        deleteBook: (params: Params$deleteBook, option?: RequestOption): Promise<Response$deleteBook$Status$200["application/json"]> => {
+            const url = baseUrl + \`/get/books/\${params.parameter.id}\`;
+            const headers = {
+                Accept: "application/json"
+            };
+            return apiClient.request("DELETE", url, headers, undefined, undefined, option);
+        }
     };
-    return { getIncludeLocalReference, getIncludeRemoteReference, getFullRemoteReference, i$have$dot, getReferenceItems, searchBook, getBookById, deleteBook };
 };
+export type Client = ReturnType<typeof createClient>;
 "
 `;
 
@@ -533,18 +535,20 @@ export interface ApiClient<RequestOption> {
     request: <T = SuccessResponses>(httpMethod: HttpMethod, url: string, headers: ObjectLike | any, requestBody: ObjectLike | any, queryParameters: QueryParameters | undefined, options?: RequestOption) => Promise<T>;
 }
 export const createClient = <RequestOption>(apiClient: ApiClient<RequestOption>, baseUrl: string) => {
-    const getHelloWorld = (params: Params$getHelloWorld, option?: RequestOption): Promise<Response$getHelloWorld$Status$200["application/json"]> => {
-        const url = baseUrl + \`/hello/world\`;
-        const headers = {
-            Accept: "application/json"
-        };
-        const queryParameters: QueryParameters = {
-            word: { value: params.parameter.word, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+    return {
+        getHelloWorld: (params: Params$getHelloWorld, option?: RequestOption): Promise<Response$getHelloWorld$Status$200["application/json"]> => {
+            const url = baseUrl + \`/hello/world\`;
+            const headers = {
+                Accept: "application/json"
+            };
+            const queryParameters: QueryParameters = {
+                word: { value: params.parameter.word, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        }
     };
-    return { getHelloWorld };
 };
+export type Client = ReturnType<typeof createClient>;
 "
 `;
 
@@ -961,76 +965,78 @@ export interface ApiClient<RequestOption> {
     request: <T = SuccessResponses>(httpMethod: HttpMethod, url: string, headers: ObjectLike | any, requestBody: ObjectLike | any, queryParameters: QueryParameters | undefined, options?: RequestOption) => T;
 }
 export const createClient = <RequestOption>(apiClient: ApiClient<RequestOption>, baseUrl: string) => {
-    const getIncludeLocalReference = (params: Params$getIncludeLocalReference, option?: RequestOption): Response$getIncludeLocalReference$Status$200["application/json"] => {
-        const url = baseUrl + \`/get/IncludeLocalReference\`;
-        const headers = {
-            Accept: "application/json"
-        };
-        const queryParameters: QueryParameters = {
-            StringQuery: { value: params.parameter.StringQuery, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const getIncludeRemoteReference = (params: Params$getIncludeRemoteReference, option?: RequestOption): void => {
-        const url = baseUrl + \`/get/IncludeRemoteReference\`;
-        const headers = {
-            "Content-Type": "application/json"
-        };
-        const queryParameters: QueryParameters = {
-            IncludeRemoteReference: { value: params.parameter.IncludeRemoteReference, explode: false }
-        };
-        return apiClient.request("GET", url, headers, params.requestBody, queryParameters, option);
-    };
-    const getFullRemoteReference = (params: Params$getFullRemoteReference, option?: RequestOption): Response$getFullRemoteReference$Status$200["application/json"] => {
-        const url = baseUrl + \`/FullRemoteReference\`;
-        const headers = {
-            Accept: "application/json"
-        };
-        const queryParameters: QueryParameters = {
-            FullRemoteReferenceQuery: { value: params.parameter.FullRemoteReferenceQuery, explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const i$have$dot = (option?: RequestOption): Response$i$have$dot$Status$200["application/json"] => {
-        const url = baseUrl + \`/i/have/dot\`;
-        const headers = {
-            Accept: "application/json"
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const getReferenceItems = (option?: RequestOption): Response$getReferenceItems$Status$200["application/json"] => {
-        const url = baseUrl + \`/get/reference/items\`;
-        const headers = {
-            Accept: "application/json"
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const searchBook = (params: Params$searchBook, option?: RequestOption): Response$searchBook$Status$200["application/json"] => {
-        const url = baseUrl + \`/get/search/\${params.parameter["book.name"]}\`;
-        const headers = {
-            Accept: "application/json"
-        };
-        const queryParameters: QueryParameters = {
-            "from.publishedAt": { value: params.parameter["from.publishedAt"], explode: false }
-        };
-        return apiClient.request("GET", url, headers, undefined, queryParameters, option);
-    };
-    const getBookById = (params: Params$getBookById, option?: RequestOption): Response$getBookById$Status$200["application/json"] => {
-        const url = baseUrl + \`/get/books/\${params.parameter.id}\`;
-        const headers = {
-            Accept: "application/json"
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const deleteBook = (params: Params$deleteBook, option?: RequestOption): Response$deleteBook$Status$200["application/json"] => {
-        const url = baseUrl + \`/get/books/\${params.parameter.id}\`;
-        const headers = {
-            Accept: "application/json"
-        };
-        return apiClient.request("DELETE", url, headers, undefined, undefined, option);
+    return {
+        getIncludeLocalReference: (params: Params$getIncludeLocalReference, option?: RequestOption): Response$getIncludeLocalReference$Status$200["application/json"] => {
+            const url = baseUrl + \`/get/IncludeLocalReference\`;
+            const headers = {
+                Accept: "application/json"
+            };
+            const queryParameters: QueryParameters = {
+                StringQuery: { value: params.parameter.StringQuery, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        getIncludeRemoteReference: (params: Params$getIncludeRemoteReference, option?: RequestOption): void => {
+            const url = baseUrl + \`/get/IncludeRemoteReference\`;
+            const headers = {
+                "Content-Type": "application/json"
+            };
+            const queryParameters: QueryParameters = {
+                IncludeRemoteReference: { value: params.parameter.IncludeRemoteReference, explode: false }
+            };
+            return apiClient.request("GET", url, headers, params.requestBody, queryParameters, option);
+        },
+        getFullRemoteReference: (params: Params$getFullRemoteReference, option?: RequestOption): Response$getFullRemoteReference$Status$200["application/json"] => {
+            const url = baseUrl + \`/FullRemoteReference\`;
+            const headers = {
+                Accept: "application/json"
+            };
+            const queryParameters: QueryParameters = {
+                FullRemoteReferenceQuery: { value: params.parameter.FullRemoteReferenceQuery, explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        i$have$dot: (option?: RequestOption): Response$i$have$dot$Status$200["application/json"] => {
+            const url = baseUrl + \`/i/have/dot\`;
+            const headers = {
+                Accept: "application/json"
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        getReferenceItems: (option?: RequestOption): Response$getReferenceItems$Status$200["application/json"] => {
+            const url = baseUrl + \`/get/reference/items\`;
+            const headers = {
+                Accept: "application/json"
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        searchBook: (params: Params$searchBook, option?: RequestOption): Response$searchBook$Status$200["application/json"] => {
+            const url = baseUrl + \`/get/search/\${params.parameter["book.name"]}\`;
+            const headers = {
+                Accept: "application/json"
+            };
+            const queryParameters: QueryParameters = {
+                "from.publishedAt": { value: params.parameter["from.publishedAt"], explode: false }
+            };
+            return apiClient.request("GET", url, headers, undefined, queryParameters, option);
+        },
+        getBookById: (params: Params$getBookById, option?: RequestOption): Response$getBookById$Status$200["application/json"] => {
+            const url = baseUrl + \`/get/books/\${params.parameter.id}\`;
+            const headers = {
+                Accept: "application/json"
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        deleteBook: (params: Params$deleteBook, option?: RequestOption): Response$deleteBook$Status$200["application/json"] => {
+            const url = baseUrl + \`/get/books/\${params.parameter.id}\`;
+            const headers = {
+                Accept: "application/json"
+            };
+            return apiClient.request("DELETE", url, headers, undefined, undefined, option);
+        }
     };
-    return { getIncludeLocalReference, getIncludeRemoteReference, getFullRemoteReference, i$have$dot, getReferenceItems, searchBook, getBookById, deleteBook };
 };
+export type Client = ReturnType<typeof createClient>;
 "
 `;
 
@@ -1087,6 +1093,7 @@ export interface ApiClient<RequestOption> {
 export const createClient = <RequestOption>(apiClient: ApiClient<RequestOption>, baseUrl: string) => {
     return {};
 };
+export type Client = ReturnType<typeof createClient>;
 "
 `;
 
@@ -1193,36 +1200,38 @@ export interface ApiClient<RequestOption> {
     request: <T = SuccessResponses>(httpMethod: HttpMethod, url: string, headers: ObjectLike | any, requestBody: ObjectLike | any, queryParameters: QueryParameters | undefined, options?: RequestOption) => Promise<T>;
 }
 export const createClient = <RequestOption>(apiClient: ApiClient<RequestOption>, baseUrl: string) => {
-    const getBook = (params: Params$getBook, option?: RequestOption): Promise<Response$getBook$Status$200["application/json"]> => {
-        const url = baseUrl + \`/get/book/\${params.parameter.id}\`;
-        const headers = {
-            Accept: "application/json"
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const getDescription = (params: Params$getDescription, option?: RequestOption): Promise<Response$getDescription$Status$200["application/json"]> => {
-        const url = baseUrl + \`/get/book/\${params.parameter.id}/description\`;
-        const headers = {
-            Accept: "application/json"
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const getAuthor = (params: Params$getAuthor, option?: RequestOption): Promise<Response$getAuthor$Status$200["application/json"]> => {
-        const url = baseUrl + \`/get/author/\${params.parameter.id}\`;
-        const headers = {
-            Accept: "application/json"
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const getPublisher = (params: Params$getPublisher, option?: RequestOption): Promise<Response$getPublisher$Status$200["application/json"]> => {
-        const url = baseUrl + \`/get/publisher/\${params.parameter.id}\`;
-        const headers = {
-            Accept: "application/json"
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
+    return {
+        getBook: (params: Params$getBook, option?: RequestOption): Promise<Response$getBook$Status$200["application/json"]> => {
+            const url = baseUrl + \`/get/book/\${params.parameter.id}\`;
+            const headers = {
+                Accept: "application/json"
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        getDescription: (params: Params$getDescription, option?: RequestOption): Promise<Response$getDescription$Status$200["application/json"]> => {
+            const url = baseUrl + \`/get/book/\${params.parameter.id}/description\`;
+            const headers = {
+                Accept: "application/json"
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        getAuthor: (params: Params$getAuthor, option?: RequestOption): Promise<Response$getAuthor$Status$200["application/json"]> => {
+            const url = baseUrl + \`/get/author/\${params.parameter.id}\`;
+            const headers = {
+                Accept: "application/json"
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        getPublisher: (params: Params$getPublisher, option?: RequestOption): Promise<Response$getPublisher$Status$200["application/json"]> => {
+            const url = baseUrl + \`/get/publisher/\${params.parameter.id}\`;
+            const headers = {
+                Accept: "application/json"
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        }
     };
-    return { getBook, getDescription, getAuthor, getPublisher };
 };
+export type Client = ReturnType<typeof createClient>;
 "
 `;
 
@@ -1337,35 +1346,37 @@ export interface ApiClient<RequestOption> {
     request: <T = SuccessResponses>(httpMethod: HttpMethod, url: string, headers: ObjectLike | any, requestBody: ObjectLike | any, queryParameters: QueryParameters | undefined, options?: RequestOption) => Promise<T>;
 }
 export const createClient = <RequestOption>(apiClient: ApiClient<RequestOption>, baseUrl: string) => {
-    const getBook = (params: Params$getBook, option?: RequestOption): Promise<Response$getBook$Status$200["application/json"]> => {
-        const url = baseUrl + \`/get/book/\${params.parameter.id}\`;
-        const headers = {
-            Accept: "application/json"
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const getDescription = (params: Params$getDescription, option?: RequestOption): Promise<Response$getDescription$Status$200["application/json"]> => {
-        const url = baseUrl + \`/get/book/\${params.parameter.id}/description\`;
-        const headers = {
-            Accept: "application/json"
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const getAuthor = (params: Params$getAuthor, option?: RequestOption): Promise<Response$getAuthor$Status$200["application/json"]> => {
-        const url = baseUrl + \`/get/author/\${params.parameter.id}\`;
-        const headers = {
-            Accept: "application/json"
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
-    };
-    const getPublisher = (params: Params$getPublisher, option?: RequestOption): Promise<Response$getPublisher$Status$200["application/json"]> => {
-        const url = baseUrl + \`/get/publisher/\${params.parameter.id}\`;
-        const headers = {
-            Accept: "application/json"
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
+    return {
+        getBook: (params: Params$getBook, option?: RequestOption): Promise<Response$getBook$Status$200["application/json"]> => {
+            const url = baseUrl + \`/get/book/\${params.parameter.id}\`;
+            const headers = {
+                Accept: "application/json"
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        getDescription: (params: Params$getDescription, option?: RequestOption): Promise<Response$getDescription$Status$200["application/json"]> => {
+            const url = baseUrl + \`/get/book/\${params.parameter.id}/description\`;
+            const headers = {
+                Accept: "application/json"
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        getAuthor: (params: Params$getAuthor, option?: RequestOption): Promise<Response$getAuthor$Status$200["application/json"]> => {
+            const url = baseUrl + \`/get/author/\${params.parameter.id}\`;
+            const headers = {
+                Accept: "application/json"
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        },
+        getPublisher: (params: Params$getPublisher, option?: RequestOption): Promise<Response$getPublisher$Status$200["application/json"]> => {
+            const url = baseUrl + \`/get/publisher/\${params.parameter.id}\`;
+            const headers = {
+                Accept: "application/json"
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        }
     };
-    return { getBook, getDescription, getAuthor, getPublisher };
 };
+export type Client = ReturnType<typeof createClient>;
 "
 `;
diff --git a/test/__tests__/functional/__snapshots__/unknown-schema-domain-test.ts.snap b/test/__tests__/functional/__snapshots__/unknown-schema-domain-test.ts.snap
index 5619cd6e..f182363c 100644
--- a/test/__tests__/functional/__snapshots__/unknown-schema-domain-test.ts.snap
+++ b/test/__tests__/functional/__snapshots__/unknown-schema-domain-test.ts.snap
@@ -45,14 +45,16 @@ export interface ApiClient<RequestOption> {
     request: <T = SuccessResponses>(httpMethod: HttpMethod, url: string, headers: ObjectLike | any, requestBody: ObjectLike | any, queryParameters: QueryParameters | undefined, options?: RequestOption) => Promise<T>;
 }
 export const createClient = <RequestOption>(apiClient: ApiClient<RequestOption>, baseUrl: string) => {
-    const getUnknown = (params: Params$getUnknown, option?: RequestOption): Promise<Response$getUnknown$Status$200["application/json"]> => {
-        const url = baseUrl + \`/get/unknown\`;
-        const headers = {
-            Accept: "application/json"
-        };
-        return apiClient.request("GET", url, headers, undefined, undefined, option);
+    return {
+        getUnknown: (params: Params$getUnknown, option?: RequestOption): Promise<Response$getUnknown$Status$200["application/json"]> => {
+            const url = baseUrl + \`/get/unknown\`;
+            const headers = {
+                Accept: "application/json"
+            };
+            return apiClient.request("GET", url, headers, undefined, undefined, option);
+        }
     };
-    return { getUnknown };
 };
+export type Client = ReturnType<typeof createClient>;
 "
 `;