@scaleway/sdk-k8s 2.17.0 → 2.18.0

package/dist/v1/index.js

@@ -0,0 +1,14 @@
+import { __exportAll } from "../_virtual/_rolldown/runtime.js";
+import { CLUSTER_TRANSIENT_STATUSES, NODE_TRANSIENT_STATUSES, POOL_TRANSIENT_STATUSES } from "./content.gen.js";
+import { K8SUtilsAPI } from "./api.utils.js";
+import { validation_rules_gen_exports } from "./validation-rules.gen.js";
+//#region src/v1/index.ts
+var v1_exports = /* @__PURE__ */ __exportAll({
+	API: () => K8SUtilsAPI,
+	CLUSTER_TRANSIENT_STATUSES: () => CLUSTER_TRANSIENT_STATUSES,
+	NODE_TRANSIENT_STATUSES: () => NODE_TRANSIENT_STATUSES,
+	POOL_TRANSIENT_STATUSES: () => POOL_TRANSIENT_STATUSES,
+	ValidationRules: () => validation_rules_gen_exports
+});
+//#endregion
+export { K8SUtilsAPI as API, CLUSTER_TRANSIENT_STATUSES, NODE_TRANSIENT_STATUSES, POOL_TRANSIENT_STATUSES, validation_rules_gen_exports as ValidationRules, v1_exports };

package/dist/v1/marshalling.gen.d.ts

@@ -0,0 +1,30 @@
+import type { DefaultValues } from '@scaleway/sdk-client';
+import type { Version, Cluster, Node, Pool, AddClusterACLRulesResponse, ExternalNodeAuth, ListClusterACLRulesResponse, ListClusterAvailableTypesResponse, ListClusterAvailableVersionsResponse, ListClusterTypesResponse, ListClustersResponse, ListNodesResponse, ListPoolsResponse, ListVersionsResponse, NodeMetadata, SetClusterACLRulesResponse, AddClusterACLRulesRequest, CreateClusterRequest, CreatePoolRequest, SetClusterACLRulesRequest, SetClusterTypeRequest, SetPoolLabelsRequest, SetPoolStartupTaintsRequest, SetPoolTaintsRequest, UpdateClusterRequest, UpdatePoolRequest, UpgradeClusterRequest, UpgradePoolRequest } from './types.gen.js';
+export declare const unmarshalVersion: (data: unknown) => Version;
+export declare const unmarshalCluster: (data: unknown) => Cluster;
+export declare const unmarshalNode: (data: unknown) => Node;
+export declare const unmarshalPool: (data: unknown) => Pool;
+export declare const unmarshalAddClusterACLRulesResponse: (data: unknown) => AddClusterACLRulesResponse;
+export declare const unmarshalExternalNodeAuth: (data: unknown) => ExternalNodeAuth;
+export declare const unmarshalListClusterACLRulesResponse: (data: unknown) => ListClusterACLRulesResponse;
+export declare const unmarshalListClusterAvailableTypesResponse: (data: unknown) => ListClusterAvailableTypesResponse;
+export declare const unmarshalListClusterAvailableVersionsResponse: (data: unknown) => ListClusterAvailableVersionsResponse;
+export declare const unmarshalListClusterTypesResponse: (data: unknown) => ListClusterTypesResponse;
+export declare const unmarshalListClustersResponse: (data: unknown) => ListClustersResponse;
+export declare const unmarshalListNodesResponse: (data: unknown) => ListNodesResponse;
+export declare const unmarshalListPoolsResponse: (data: unknown) => ListPoolsResponse;
+export declare const unmarshalListVersionsResponse: (data: unknown) => ListVersionsResponse;
+export declare const unmarshalNodeMetadata: (data: unknown) => NodeMetadata;
+export declare const unmarshalSetClusterACLRulesResponse: (data: unknown) => SetClusterACLRulesResponse;
+export declare const marshalAddClusterACLRulesRequest: (request: AddClusterACLRulesRequest, defaults: DefaultValues) => Record<string, unknown>;
+export declare const marshalCreateClusterRequest: (request: CreateClusterRequest, defaults: DefaultValues) => Record<string, unknown>;
+export declare const marshalCreatePoolRequest: (request: CreatePoolRequest, defaults: DefaultValues) => Record<string, unknown>;
+export declare const marshalSetClusterACLRulesRequest: (request: SetClusterACLRulesRequest, defaults: DefaultValues) => Record<string, unknown>;
+export declare const marshalSetClusterTypeRequest: (request: SetClusterTypeRequest, defaults: DefaultValues) => Record<string, unknown>;
+export declare const marshalSetPoolLabelsRequest: (request: SetPoolLabelsRequest, defaults: DefaultValues) => Record<string, unknown>;
+export declare const marshalSetPoolStartupTaintsRequest: (request: SetPoolStartupTaintsRequest, defaults: DefaultValues) => Record<string, unknown>;
+export declare const marshalSetPoolTaintsRequest: (request: SetPoolTaintsRequest, defaults: DefaultValues) => Record<string, unknown>;
+export declare const marshalUpdateClusterRequest: (request: UpdateClusterRequest, defaults: DefaultValues) => Record<string, unknown>;
+export declare const marshalUpdatePoolRequest: (request: UpdatePoolRequest, defaults: DefaultValues) => Record<string, unknown>;
+export declare const marshalUpgradeClusterRequest: (request: UpgradeClusterRequest, defaults: DefaultValues) => Record<string, unknown>;
+export declare const marshalUpgradePoolRequest: (request: UpgradePoolRequest, defaults: DefaultValues) => Record<string, unknown>;

package/dist/v1/marshalling.gen.js

@@ -0,0 +1,480 @@
+import { isJSONObject, resolveOneOf, unmarshalArrayOfObject, unmarshalDate } from "@scaleway/sdk-client";
+import randomName from "@scaleway/random-name";
+//#region src/v1/marshalling.gen.ts
+const unmarshalVersion = (data) => {
+	if (!isJSONObject(data)) throw new TypeError(`Unmarshalling the type 'Version' failed as data isn't a dictionary.`);
+	return {
+		availableAdmissionPlugins: data.available_admission_plugins,
+		availableCnis: data.available_cnis,
+		availableContainerRuntimes: data.available_container_runtimes,
+		availableFeatureGates: data.available_feature_gates,
+		availableKubeletArgs: data.available_kubelet_args,
+		deprecatedAt: unmarshalDate(data.deprecated_at),
+		endOfLifeAt: unmarshalDate(data.end_of_life_at),
+		label: data.label,
+		name: data.name,
+		region: data.region,
+		releasedAt: unmarshalDate(data.released_at)
+	};
+};
+const unmarshalMaintenanceWindow = (data) => {
+	if (!isJSONObject(data)) throw new TypeError(`Unmarshalling the type 'MaintenanceWindow' failed as data isn't a dictionary.`);
+	return {
+		day: data.day,
+		startHour: data.start_hour
+	};
+};
+const unmarshalClusterAutoUpgrade = (data) => {
+	if (!isJSONObject(data)) throw new TypeError(`Unmarshalling the type 'ClusterAutoUpgrade' failed as data isn't a dictionary.`);
+	return {
+		enabled: data.enabled,
+		maintenanceWindow: data.maintenance_window ? unmarshalMaintenanceWindow(data.maintenance_window) : void 0
+	};
+};
+const unmarshalClusterAutoscalerConfig = (data) => {
+	if (!isJSONObject(data)) throw new TypeError(`Unmarshalling the type 'ClusterAutoscalerConfig' failed as data isn't a dictionary.`);
+	return {
+		balanceSimilarNodeGroups: data.balance_similar_node_groups,
+		estimator: data.estimator,
+		expander: data.expander,
+		expendablePodsPriorityCutoff: data.expendable_pods_priority_cutoff,
+		ignoreDaemonsetsUtilization: data.ignore_daemonsets_utilization,
+		logLevel: data.log_level,
+		maxGracefulTerminationSec: data.max_graceful_termination_sec,
+		scaleDownDelayAfterAdd: data.scale_down_delay_after_add,
+		scaleDownDisabled: data.scale_down_disabled,
+		scaleDownUnneededTime: data.scale_down_unneeded_time,
+		scaleDownUtilizationThreshold: data.scale_down_utilization_threshold,
+		skipNodesWithLocalStorage: data.skip_nodes_with_local_storage
+	};
+};
+const unmarshalClusterOpenIDConnectConfig = (data) => {
+	if (!isJSONObject(data)) throw new TypeError(`Unmarshalling the type 'ClusterOpenIDConnectConfig' failed as data isn't a dictionary.`);
+	return {
+		clientId: data.client_id,
+		groupsClaim: data.groups_claim,
+		groupsPrefix: data.groups_prefix,
+		issuerUrl: data.issuer_url,
+		requiredClaim: data.required_claim,
+		usernameClaim: data.username_claim,
+		usernamePrefix: data.username_prefix
+	};
+};
+const unmarshalCluster = (data) => {
+	if (!isJSONObject(data)) throw new TypeError(`Unmarshalling the type 'Cluster' failed as data isn't a dictionary.`);
+	return {
+		aclAvailable: data.acl_available,
+		admissionPlugins: data.admission_plugins,
+		apiserverCertSans: data.apiserver_cert_sans,
+		autoUpgrade: data.auto_upgrade ? unmarshalClusterAutoUpgrade(data.auto_upgrade) : void 0,
+		autoscalerConfig: data.autoscaler_config ? unmarshalClusterAutoscalerConfig(data.autoscaler_config) : void 0,
+		clusterUrl: data.cluster_url,
+		cni: data.cni,
+		commitmentEndsAt: unmarshalDate(data.commitment_ends_at),
+		createdAt: unmarshalDate(data.created_at),
+		description: data.description,
+		dnsWildcard: data.dns_wildcard,
+		featureGates: data.feature_gates,
+		iamNodesGroupId: data.iam_nodes_group_id,
+		id: data.id,
+		name: data.name,
+		openIdConnectConfig: data.open_id_connect_config ? unmarshalClusterOpenIDConnectConfig(data.open_id_connect_config) : void 0,
+		organizationId: data.organization_id,
+		podCidr: data.pod_cidr,
+		privateNetworkId: data.private_network_id,
+		projectId: data.project_id,
+		region: data.region,
+		serviceCidr: data.service_cidr,
+		serviceDnsIp: data.service_dns_ip,
+		status: data.status,
+		tags: data.tags,
+		type: data.type,
+		updatedAt: unmarshalDate(data.updated_at),
+		upgradeAvailable: data.upgrade_available,
+		version: data.version
+	};
+};
+const unmarshalNode = (data) => {
+	if (!isJSONObject(data)) throw new TypeError(`Unmarshalling the type 'Node' failed as data isn't a dictionary.`);
+	return {
+		clusterId: data.cluster_id,
+		conditions: data.conditions,
+		createdAt: unmarshalDate(data.created_at),
+		errorMessage: data.error_message,
+		id: data.id,
+		name: data.name,
+		poolId: data.pool_id,
+		providerId: data.provider_id,
+		publicIpV4: data.public_ip_v4,
+		publicIpV6: data.public_ip_v6,
+		region: data.region,
+		status: data.status,
+		updatedAt: unmarshalDate(data.updated_at)
+	};
+};
+const unmarshalCoreV1Taint = (data) => {
+	if (!isJSONObject(data)) throw new TypeError(`Unmarshalling the type 'CoreV1Taint' failed as data isn't a dictionary.`);
+	return {
+		effect: data.effect,
+		key: data.key,
+		value: data.value
+	};
+};
+const unmarshalPoolUpgradePolicy = (data) => {
+	if (!isJSONObject(data)) throw new TypeError(`Unmarshalling the type 'PoolUpgradePolicy' failed as data isn't a dictionary.`);
+	return {
+		maxSurge: data.max_surge,
+		maxUnavailable: data.max_unavailable
+	};
+};
+const unmarshalPool = (data) => {
+	if (!isJSONObject(data)) throw new TypeError(`Unmarshalling the type 'Pool' failed as data isn't a dictionary.`);
+	return {
+		autohealing: data.autohealing,
+		autoscaling: data.autoscaling,
+		clusterId: data.cluster_id,
+		containerRuntime: data.container_runtime,
+		createdAt: unmarshalDate(data.created_at),
+		errorMessage: data.error_message,
+		id: data.id,
+		kubeletArgs: data.kubelet_args,
+		labels: data.labels,
+		maxSize: data.max_size,
+		minSize: data.min_size,
+		name: data.name,
+		nodeType: data.node_type,
+		placementGroupId: data.placement_group_id,
+		privateNetworkId: data.private_network_id,
+		publicIpDisabled: data.public_ip_disabled,
+		region: data.region,
+		rootVolumeSize: data.root_volume_size,
+		rootVolumeType: data.root_volume_type,
+		securityGroupId: data.security_group_id,
+		size: data.size,
+		startupTaints: unmarshalArrayOfObject(data.startup_taints, unmarshalCoreV1Taint),
+		status: data.status,
+		tags: data.tags,
+		taints: unmarshalArrayOfObject(data.taints, unmarshalCoreV1Taint),
+		updatedAt: unmarshalDate(data.updated_at),
+		upgradePolicy: data.upgrade_policy ? unmarshalPoolUpgradePolicy(data.upgrade_policy) : void 0,
+		version: data.version,
+		zone: data.zone
+	};
+};
+const unmarshalACLRule = (data) => {
+	if (!isJSONObject(data)) throw new TypeError(`Unmarshalling the type 'ACLRule' failed as data isn't a dictionary.`);
+	return {
+		description: data.description,
+		id: data.id,
+		ip: data.ip,
+		region: data.region,
+		scalewayRanges: data.scaleway_ranges
+	};
+};
+const unmarshalAddClusterACLRulesResponse = (data) => {
+	if (!isJSONObject(data)) throw new TypeError(`Unmarshalling the type 'AddClusterACLRulesResponse' failed as data isn't a dictionary.`);
+	return { rules: unmarshalArrayOfObject(data.rules, unmarshalACLRule) };
+};
+const unmarshalExternalNodeAuth = (data) => {
+	if (!isJSONObject(data)) throw new TypeError(`Unmarshalling the type 'ExternalNodeAuth' failed as data isn't a dictionary.`);
+	return {
+		metadataUrl: data.metadata_url,
+		nodeSecretKey: data.node_secret_key
+	};
+};
+const unmarshalListClusterACLRulesResponse = (data) => {
+	if (!isJSONObject(data)) throw new TypeError(`Unmarshalling the type 'ListClusterACLRulesResponse' failed as data isn't a dictionary.`);
+	return {
+		rules: unmarshalArrayOfObject(data.rules, unmarshalACLRule),
+		totalCount: data.total_count
+	};
+};
+const unmarshalClusterType = (data) => {
+	if (!isJSONObject(data)) throw new TypeError(`Unmarshalling the type 'ClusterType' failed as data isn't a dictionary.`);
+	return {
+		auditLogsSupported: data.audit_logs_supported,
+		availability: data.availability,
+		commitmentDelay: data.commitment_delay,
+		dedicated: data.dedicated,
+		maxEtcdSize: data.max_etcd_size,
+		maxNodes: data.max_nodes,
+		memory: data.memory,
+		name: data.name,
+		region: data.region,
+		resiliency: data.resiliency,
+		sla: data.sla
+	};
+};
+const unmarshalListClusterAvailableTypesResponse = (data) => {
+	if (!isJSONObject(data)) throw new TypeError(`Unmarshalling the type 'ListClusterAvailableTypesResponse' failed as data isn't a dictionary.`);
+	return {
+		clusterTypes: unmarshalArrayOfObject(data.cluster_types, unmarshalClusterType),
+		totalCount: data.total_count
+	};
+};
+const unmarshalListClusterAvailableVersionsResponse = (data) => {
+	if (!isJSONObject(data)) throw new TypeError(`Unmarshalling the type 'ListClusterAvailableVersionsResponse' failed as data isn't a dictionary.`);
+	return { versions: unmarshalArrayOfObject(data.versions, unmarshalVersion) };
+};
+const unmarshalListClusterTypesResponse = (data) => {
+	if (!isJSONObject(data)) throw new TypeError(`Unmarshalling the type 'ListClusterTypesResponse' failed as data isn't a dictionary.`);
+	return {
+		clusterTypes: unmarshalArrayOfObject(data.cluster_types, unmarshalClusterType),
+		totalCount: data.total_count
+	};
+};
+const unmarshalListClustersResponse = (data) => {
+	if (!isJSONObject(data)) throw new TypeError(`Unmarshalling the type 'ListClustersResponse' failed as data isn't a dictionary.`);
+	return {
+		clusters: unmarshalArrayOfObject(data.clusters, unmarshalCluster),
+		totalCount: data.total_count
+	};
+};
+const unmarshalListNodesResponse = (data) => {
+	if (!isJSONObject(data)) throw new TypeError(`Unmarshalling the type 'ListNodesResponse' failed as data isn't a dictionary.`);
+	return {
+		nodes: unmarshalArrayOfObject(data.nodes, unmarshalNode),
+		totalCount: data.total_count
+	};
+};
+const unmarshalListPoolsResponse = (data) => {
+	if (!isJSONObject(data)) throw new TypeError(`Unmarshalling the type 'ListPoolsResponse' failed as data isn't a dictionary.`);
+	return {
+		pools: unmarshalArrayOfObject(data.pools, unmarshalPool),
+		totalCount: data.total_count
+	};
+};
+const unmarshalListVersionsResponse = (data) => {
+	if (!isJSONObject(data)) throw new TypeError(`Unmarshalling the type 'ListVersionsResponse' failed as data isn't a dictionary.`);
+	return { versions: unmarshalArrayOfObject(data.versions, unmarshalVersion) };
+};
+const unmarshalNodeMetadataCoreV1Taint = (data) => {
+	if (!isJSONObject(data)) throw new TypeError(`Unmarshalling the type 'NodeMetadataCoreV1Taint' failed as data isn't a dictionary.`);
+	return {
+		effect: data.effect,
+		key: data.key,
+		value: data.value
+	};
+};
+const unmarshalNodeMetadata = (data) => {
+	if (!isJSONObject(data)) throw new TypeError(`Unmarshalling the type 'NodeMetadata' failed as data isn't a dictionary.`);
+	return {
+		clusterCa: data.cluster_ca,
+		clusterUrl: data.cluster_url,
+		credentialProviderConfig: data.credential_provider_config,
+		externalIp: data.external_ip,
+		hasGpu: data.has_gpu,
+		id: data.id,
+		installerTags: data.installer_tags,
+		kubeletConfig: data.kubelet_config,
+		name: data.name,
+		nodeLabels: data.node_labels,
+		nodeTaints: unmarshalArrayOfObject(data.node_taints, unmarshalNodeMetadataCoreV1Taint),
+		poolVersion: data.pool_version,
+		providerId: data.provider_id,
+		repoUri: data.repo_uri,
+		resolvconfPath: data.resolvconf_path,
+		templateArgs: data.template_args,
+		updaterBinPath: data.updater_bin_path,
+		updaterBinUrl: data.updater_bin_url,
+		updaterBinVersion: data.updater_bin_version
+	};
+};
+const unmarshalSetClusterACLRulesResponse = (data) => {
+	if (!isJSONObject(data)) throw new TypeError(`Unmarshalling the type 'SetClusterACLRulesResponse' failed as data isn't a dictionary.`);
+	return { rules: unmarshalArrayOfObject(data.rules, unmarshalACLRule) };
+};
+const marshalACLRuleRequest = (request, defaults) => ({
+	description: request.description,
+	...resolveOneOf([{
+		param: "ip",
+		value: request.ip
+	}, {
+		param: "scaleway_ranges",
+		value: request.scalewayRanges
+	}])
+});
+const marshalAddClusterACLRulesRequest = (request, defaults) => ({ acls: request.acls !== void 0 ? request.acls.map((elt) => marshalACLRuleRequest(elt, defaults)) : void 0 });
+const marshalMaintenanceWindow = (request, defaults) => ({
+	day: request.day,
+	start_hour: request.startHour
+});
+const marshalCoreV1Taint = (request, defaults) => ({
+	effect: request.effect,
+	key: request.key,
+	value: request.value
+});
+const marshalCreateClusterRequestPoolConfigUpgradePolicy = (request, defaults) => ({
+	max_surge: request.maxSurge,
+	max_unavailable: request.maxUnavailable
+});
+const marshalCreateClusterRequestAutoUpgrade = (request, defaults) => ({
+	enable: request.enable,
+	maintenance_window: request.maintenanceWindow !== void 0 ? marshalMaintenanceWindow(request.maintenanceWindow, defaults) : void 0
+});
+const marshalCreateClusterRequestAutoscalerConfig = (request, defaults) => ({
+	balance_similar_node_groups: request.balanceSimilarNodeGroups,
+	estimator: request.estimator,
+	expander: request.expander,
+	expendable_pods_priority_cutoff: request.expendablePodsPriorityCutoff,
+	ignore_daemonsets_utilization: request.ignoreDaemonsetsUtilization,
+	log_level: request.logLevel,
+	max_graceful_termination_sec: request.maxGracefulTerminationSec,
+	scale_down_delay_after_add: request.scaleDownDelayAfterAdd,
+	scale_down_disabled: request.scaleDownDisabled,
+	scale_down_unneeded_time: request.scaleDownUnneededTime,
+	scale_down_utilization_threshold: request.scaleDownUtilizationThreshold,
+	skip_nodes_with_local_storage: request.skipNodesWithLocalStorage
+});
+const marshalCreateClusterRequestOpenIDConnectConfig = (request, defaults) => ({
+	client_id: request.clientId,
+	groups_claim: request.groupsClaim,
+	groups_prefix: request.groupsPrefix,
+	issuer_url: request.issuerUrl,
+	required_claim: request.requiredClaim,
+	username_claim: request.usernameClaim,
+	username_prefix: request.usernamePrefix
+});
+const marshalCreateClusterRequestPoolConfig = (request, defaults) => ({
+	autohealing: request.autohealing,
+	autoscaling: request.autoscaling,
+	container_runtime: request.containerRuntime,
+	kubelet_args: request.kubeletArgs,
+	labels: request.labels,
+	max_size: request.maxSize,
+	min_size: request.minSize,
+	name: request.name,
+	node_type: request.nodeType,
+	placement_group_id: request.placementGroupId,
+	private_network_id: request.privateNetworkId,
+	public_ip_disabled: request.publicIpDisabled,
+	root_volume_size: request.rootVolumeSize,
+	root_volume_type: request.rootVolumeType,
+	security_group_id: request.securityGroupId,
+	size: request.size,
+	startup_taints: request.startupTaints.map((elt) => marshalCoreV1Taint(elt, defaults)),
+	tags: request.tags,
+	taints: request.taints.map((elt) => marshalCoreV1Taint(elt, defaults)),
+	upgrade_policy: request.upgradePolicy !== void 0 ? marshalCreateClusterRequestPoolConfigUpgradePolicy(request.upgradePolicy, defaults) : void 0,
+	zone: request.zone
+});
+const marshalCreateClusterRequest = (request, defaults) => ({
+	admission_plugins: request.admissionPlugins,
+	apiserver_cert_sans: request.apiserverCertSans,
+	auto_upgrade: request.autoUpgrade !== void 0 ? marshalCreateClusterRequestAutoUpgrade(request.autoUpgrade, defaults) : void 0,
+	autoscaler_config: request.autoscalerConfig !== void 0 ? marshalCreateClusterRequestAutoscalerConfig(request.autoscalerConfig, defaults) : void 0,
+	cni: request.cni,
+	description: request.description,
+	feature_gates: request.featureGates,
+	name: request.name || randomName("k8s"),
+	open_id_connect_config: request.openIdConnectConfig !== void 0 ? marshalCreateClusterRequestOpenIDConnectConfig(request.openIdConnectConfig, defaults) : void 0,
+	pod_cidr: request.podCidr,
+	pools: request.pools !== void 0 ? request.pools.map((elt) => marshalCreateClusterRequestPoolConfig(elt, defaults)) : void 0,
+	private_network_id: request.privateNetworkId,
+	service_cidr: request.serviceCidr,
+	service_dns_ip: request.serviceDnsIp,
+	tags: request.tags,
+	type: request.type,
+	version: request.version,
+	...resolveOneOf([{
+		default: defaults.defaultProjectId,
+		param: "project_id",
+		value: request.projectId
+	}, {
+		default: defaults.defaultOrganizationId,
+		param: "organization_id",
+		value: request.organizationId
+	}])
+});
+const marshalCreatePoolRequestUpgradePolicy = (request, defaults) => ({
+	max_surge: request.maxSurge,
+	max_unavailable: request.maxUnavailable
+});
+const marshalCreatePoolRequest = (request, defaults) => ({
+	autohealing: request.autohealing,
+	autoscaling: request.autoscaling,
+	container_runtime: request.containerRuntime,
+	kubelet_args: request.kubeletArgs !== void 0 ? request.kubeletArgs : void 0,
+	labels: request.labels !== void 0 ? request.labels : void 0,
+	max_size: request.maxSize,
+	min_size: request.minSize,
+	name: request.name || randomName("pool"),
+	node_type: request.nodeType,
+	placement_group_id: request.placementGroupId,
+	private_network_id: request.privateNetworkId,
+	public_ip_disabled: request.publicIpDisabled,
+	root_volume_size: request.rootVolumeSize,
+	root_volume_type: request.rootVolumeType,
+	security_group_id: request.securityGroupId,
+	size: request.size,
+	startup_taints: request.startupTaints !== void 0 ? request.startupTaints.map((elt) => marshalCoreV1Taint(elt, defaults)) : void 0,
+	tags: request.tags,
+	taints: request.taints !== void 0 ? request.taints.map((elt) => marshalCoreV1Taint(elt, defaults)) : void 0,
+	upgrade_policy: request.upgradePolicy !== void 0 ? marshalCreatePoolRequestUpgradePolicy(request.upgradePolicy, defaults) : void 0,
+	zone: request.zone ?? defaults.defaultZone
+});
+const marshalSetClusterACLRulesRequest = (request, defaults) => ({ acls: request.acls !== void 0 ? request.acls.map((elt) => marshalACLRuleRequest(elt, defaults)) : void 0 });
+const marshalSetClusterTypeRequest = (request, defaults) => ({ type: request.type });
+const marshalSetPoolLabelsRequest = (request, defaults) => ({ labels: request.labels !== void 0 ? request.labels : void 0 });
+const marshalSetPoolStartupTaintsRequest = (request, defaults) => ({ startup_taints: request.startupTaints !== void 0 ? request.startupTaints.map((elt) => marshalCoreV1Taint(elt, defaults)) : void 0 });
+const marshalSetPoolTaintsRequest = (request, defaults) => ({ taints: request.taints !== void 0 ? request.taints.map((elt) => marshalCoreV1Taint(elt, defaults)) : void 0 });
+const marshalUpdateClusterRequestAutoUpgrade = (request, defaults) => ({
+	enable: request.enable,
+	maintenance_window: request.maintenanceWindow !== void 0 ? marshalMaintenanceWindow(request.maintenanceWindow, defaults) : void 0
+});
+const marshalUpdateClusterRequestAutoscalerConfig = (request, defaults) => ({
+	balance_similar_node_groups: request.balanceSimilarNodeGroups,
+	estimator: request.estimator,
+	expander: request.expander,
+	expendable_pods_priority_cutoff: request.expendablePodsPriorityCutoff,
+	ignore_daemonsets_utilization: request.ignoreDaemonsetsUtilization,
+	log_level: request.logLevel,
+	max_graceful_termination_sec: request.maxGracefulTerminationSec,
+	scale_down_delay_after_add: request.scaleDownDelayAfterAdd,
+	scale_down_disabled: request.scaleDownDisabled,
+	scale_down_unneeded_time: request.scaleDownUnneededTime,
+	scale_down_utilization_threshold: request.scaleDownUtilizationThreshold,
+	skip_nodes_with_local_storage: request.skipNodesWithLocalStorage
+});
+const marshalUpdateClusterRequestOpenIDConnectConfig = (request, defaults) => ({
+	client_id: request.clientId,
+	groups_claim: request.groupsClaim,
+	groups_prefix: request.groupsPrefix,
+	issuer_url: request.issuerUrl,
+	required_claim: request.requiredClaim,
+	username_claim: request.usernameClaim,
+	username_prefix: request.usernamePrefix
+});
+const marshalUpdateClusterRequest = (request, defaults) => ({
+	admission_plugins: request.admissionPlugins,
+	apiserver_cert_sans: request.apiserverCertSans,
+	auto_upgrade: request.autoUpgrade !== void 0 ? marshalUpdateClusterRequestAutoUpgrade(request.autoUpgrade, defaults) : void 0,
+	autoscaler_config: request.autoscalerConfig !== void 0 ? marshalUpdateClusterRequestAutoscalerConfig(request.autoscalerConfig, defaults) : void 0,
+	description: request.description,
+	feature_gates: request.featureGates,
+	name: request.name,
+	open_id_connect_config: request.openIdConnectConfig !== void 0 ? marshalUpdateClusterRequestOpenIDConnectConfig(request.openIdConnectConfig, defaults) : void 0,
+	tags: request.tags
+});
+const marshalUpdatePoolRequestUpgradePolicy = (request, defaults) => ({
+	max_surge: request.maxSurge,
+	max_unavailable: request.maxUnavailable
+});
+const marshalUpdatePoolRequest = (request, defaults) => ({
+	autohealing: request.autohealing,
+	autoscaling: request.autoscaling,
+	kubelet_args: request.kubeletArgs,
+	max_size: request.maxSize,
+	min_size: request.minSize,
+	security_group_id: request.securityGroupId,
+	size: request.size,
+	tags: request.tags,
+	upgrade_policy: request.upgradePolicy !== void 0 ? marshalUpdatePoolRequestUpgradePolicy(request.upgradePolicy, defaults) : void 0
+});
+const marshalUpgradeClusterRequest = (request, defaults) => ({
+	upgrade_pools: request.upgradePools,
+	version: request.version
+});
+const marshalUpgradePoolRequest = (request, defaults) => ({ version: request.version });
+//#endregion
+export { marshalAddClusterACLRulesRequest, marshalCreateClusterRequest, marshalCreatePoolRequest, marshalSetClusterACLRulesRequest, marshalSetClusterTypeRequest, marshalSetPoolLabelsRequest, marshalSetPoolStartupTaintsRequest, marshalSetPoolTaintsRequest, marshalUpdateClusterRequest, marshalUpdatePoolRequest, marshalUpgradeClusterRequest, marshalUpgradePoolRequest, unmarshalAddClusterACLRulesResponse, unmarshalCluster, unmarshalExternalNodeAuth, unmarshalListClusterACLRulesResponse, unmarshalListClusterAvailableTypesResponse, unmarshalListClusterAvailableVersionsResponse, unmarshalListClusterTypesResponse, unmarshalListClustersResponse, unmarshalListNodesResponse, unmarshalListPoolsResponse, unmarshalListVersionsResponse, unmarshalNode, unmarshalNodeMetadata, unmarshalPool, unmarshalSetClusterACLRulesResponse, unmarshalVersion };

package/dist/v1/metadata.gen.d.ts

@@ -0,0 +1,149 @@
+export declare const queriesMetadata: {
+    readonly namespace: 'k8s';
+    readonly version: 'v1';
+    readonly folderName: 'k8Sv1';
+    readonly services: readonly [{
+        readonly apiClass: 'API';
+        readonly methods: readonly [{
+            readonly methodName: 'listClusters';
+            readonly protoName: 'ListClusters';
+            readonly paramsType: 'ListClustersRequest';
+            readonly returnType: 'ListClustersResponse';
+            readonly isList: true;
+            readonly paginationType: 'offset';
+            readonly pageParamKey: 'page';
+            readonly listItemType: 'Cluster';
+            readonly isPrivate: false;
+            readonly description: '"';
+        }, {
+            readonly methodName: 'getCluster';
+            readonly protoName: 'GetCluster';
+            readonly paramsType: 'GetClusterRequest';
+            readonly returnType: 'Cluster';
+            readonly isList: false;
+            readonly paginationType: 'none';
+            readonly isPrivate: false;
+            readonly description: '"';
+            readonly hasWaiter: true;
+        }, {
+            readonly methodName: 'listClusterAvailableVersions';
+            readonly protoName: 'ListClusterAvailableVersions';
+            readonly paramsType: 'ListClusterAvailableVersionsRequest';
+            readonly returnType: 'ListClusterAvailableVersionsResponse';
+            readonly isList: false;
+            readonly paginationType: 'none';
+            readonly isPrivate: false;
+            readonly description: '"';
+        }, {
+            readonly methodName: 'listClusterAvailableTypes';
+            readonly protoName: 'ListClusterAvailableTypes';
+            readonly paramsType: 'ListClusterAvailableTypesRequest';
+            readonly returnType: 'ListClusterAvailableTypesResponse';
+            readonly isList: false;
+            readonly paginationType: 'none';
+            readonly isPrivate: false;
+            readonly description: '"';
+        }, {
+            readonly methodName: '_getClusterKubeConfig';
+            readonly protoName: 'GetClusterKubeConfig';
+            readonly paramsType: 'GetClusterKubeConfigRequest';
+            readonly returnType: 'Blob';
+            readonly isList: false;
+            readonly paginationType: 'none';
+            readonly isPrivate: true;
+            readonly description: '"';
+        }, {
+            readonly methodName: 'listClusterACLRules';
+            readonly protoName: 'ListClusterACLRules';
+            readonly paramsType: 'ListClusterACLRulesRequest';
+            readonly returnType: 'ListClusterACLRulesResponse';
+            readonly isList: true;
+            readonly paginationType: 'offset';
+            readonly pageParamKey: 'page';
+            readonly listItemType: 'ACLRule';
+            readonly isPrivate: false;
+            readonly description: '"';
+        }, {
+            readonly methodName: 'listPools';
+            readonly protoName: 'ListPools';
+            readonly paramsType: 'ListPoolsRequest';
+            readonly returnType: 'ListPoolsResponse';
+            readonly isList: true;
+            readonly paginationType: 'offset';
+            readonly pageParamKey: 'page';
+            readonly listItemType: 'Pool';
+            readonly isPrivate: false;
+            readonly description: '"';
+        }, {
+            readonly methodName: 'getPool';
+            readonly protoName: 'GetPool';
+            readonly paramsType: 'GetPoolRequest';
+            readonly returnType: 'Pool';
+            readonly isList: false;
+            readonly paginationType: 'none';
+            readonly isPrivate: false;
+            readonly description: '"';
+            readonly hasWaiter: true;
+        }, {
+            readonly methodName: 'getNodeMetadata';
+            readonly protoName: 'GetNodeMetadata';
+            readonly paramsType: 'GetNodeMetadataRequest';
+            readonly returnType: 'NodeMetadata';
+            readonly isList: false;
+            readonly paginationType: 'none';
+            readonly isPrivate: false;
+            readonly description: '"';
+        }, {
+            readonly methodName: 'listNodes';
+            readonly protoName: 'ListNodes';
+            readonly paramsType: 'ListNodesRequest';
+            readonly returnType: 'ListNodesResponse';
+            readonly isList: true;
+            readonly paginationType: 'offset';
+            readonly pageParamKey: 'page';
+            readonly listItemType: 'Node';
+            readonly isPrivate: false;
+            readonly description: '"';
+        }, {
+            readonly methodName: 'getNode';
+            readonly protoName: 'GetNode';
+            readonly paramsType: 'GetNodeRequest';
+            readonly returnType: 'Node';
+            readonly isList: false;
+            readonly paginationType: 'none';
+            readonly isPrivate: false;
+            readonly description: '"';
+            readonly hasWaiter: true;
+        }, {
+            readonly methodName: 'listVersions';
+            readonly protoName: 'ListVersions';
+            readonly paramsType: 'ListVersionsRequest';
+            readonly returnType: 'ListVersionsResponse';
+            readonly isList: false;
+            readonly paginationType: 'none';
+            readonly isPrivate: false;
+            readonly description: '"';
+        }, {
+            readonly methodName: 'getVersion';
+            readonly protoName: 'GetVersion';
+            readonly paramsType: 'GetVersionRequest';
+            readonly returnType: 'Version';
+            readonly isList: false;
+            readonly paginationType: 'none';
+            readonly isPrivate: false;
+            readonly description: '"';
+        }, {
+            readonly methodName: 'listClusterTypes';
+            readonly protoName: 'ListClusterTypes';
+            readonly paramsType: 'ListClusterTypesRequest';
+            readonly returnType: 'ListClusterTypesResponse';
+            readonly isList: true;
+            readonly paginationType: 'offset';
+            readonly pageParamKey: 'page';
+            readonly listItemType: 'ClusterType';
+            readonly isPrivate: false;
+            readonly description: '"';
+        }];
+    }];
+};
+export type QueriesMetadata = typeof queriesMetadata;