import * as pulumi from "@pulumi/pulumi";
import * as inputs from "../types/input";
import * as outputs from "../types/output";
/**
 * Provides a resource to manage vke node pool
 * ## Example Usage
 *
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as volcengine from "@pulumi/volcengine";
 * import * as volcengine from "@volcengine/pulumi";
 *
 * const fooZones = volcengine.ecs.getZones({});
 * const fooVpc = new volcengine.vpc.Vpc("fooVpc", {
 *     vpcName: "acc-test-vpc",
 *     cidrBlock: "172.16.0.0/16",
 * });
 * const fooSubnet = new volcengine.vpc.Subnet("fooSubnet", {
 *     subnetName: "acc-test-subnet",
 *     cidrBlock: "172.16.0.0/24",
 *     zoneId: fooZones.then(fooZones => fooZones.zones?.[0]?.id),
 *     vpcId: fooVpc.id,
 * });
 * const fooSecurityGroup = new volcengine.vpc.SecurityGroup("fooSecurityGroup", {
 *     securityGroupName: "acc-test-security-group",
 *     vpcId: fooVpc.id,
 * });
 * const fooImages = volcengine.ecs.getImages({
 *     nameRegex: "veLinux 1.0 CentOS Compatible 64 bit",
 * });
 * const fooCluster = new volcengine.vke.Cluster("fooCluster", {
 *     description: "created by terraform",
 *     projectName: "default",
 *     deleteProtectionEnabled: false,
 *     clusterConfig: {
 *         subnetIds: [fooSubnet.id],
 *         apiServerPublicAccessEnabled: true,
 *         apiServerPublicAccessConfig: {
 *             publicAccessNetworkConfig: {
 *                 billingType: "PostPaidByBandwidth",
 *                 bandwidth: 1,
 *             },
 *         },
 *         resourcePublicAccessDefaultEnabled: true,
 *     },
 *     podsConfig: {
 *         podNetworkMode: "VpcCniShared",
 *         vpcCniConfig: {
 *             subnetIds: [fooSubnet.id],
 *         },
 *     },
 *     servicesConfig: {
 *         serviceCidrsv4s: ["172.30.0.0/18"],
 *     },
 *     tags: [{
 *         key: "tf-k1",
 *         value: "tf-v1",
 *     }],
 * });
 * const fooNodePool = new volcengine.vke.NodePool("fooNodePool", {
 *     clusterId: fooCluster.id,
 *     autoScaling: {
 *         enabled: true,
 *         minReplicas: 0,
 *         maxReplicas: 5,
 *         desiredReplicas: 0,
 *         priority: 5,
 *         subnetPolicy: "ZoneBalance",
 *     },
 *     nodeConfig: {
 *         instanceTypeIds: ["ecs.g1ie.xlarge"],
 *         subnetIds: [fooSubnet.id],
 *         imageId: fooImages.then(fooImages => .filter(image => image.imageName == "veLinux 1.0 CentOS Compatible 64 bit").map(image => (image.imageId))[0]),
 *         systemVolume: {
 *             type: "ESSD_PL0",
 *             size: 80,
 *         },
 *         dataVolumes: [
 *             {
 *                 type: "ESSD_PL0",
 *                 size: 80,
 *                 mountPoint: "/tf1",
 *             },
 *             {
 *                 type: "ESSD_PL0",
 *                 size: 60,
 *                 mountPoint: "/tf2",
 *             },
 *         ],
 *         initializeScript: "ZWNobyBoZWxsbyB0ZXJyYWZvcm0h",
 *         security: {
 *             login: {
 *                 password: "UHdkMTIzNDU2",
 *             },
 *             securityStrategies: ["Hids"],
 *             securityGroupIds: [fooSecurityGroup.id],
 *         },
 *         additionalContainerStorageEnabled: false,
 *         instanceChargeType: "PostPaid",
 *         namePrefix: "acc-test",
 *         projectName: "default",
 *         ecsTags: [{
 *             key: "ecs_k1",
 *             value: "ecs_v1",
 *         }],
 *     },
 *     kubernetesConfig: {
 *         labels: [{
 *             key: "label1",
 *             value: "value1",
 *         }],
 *         taints: [{
 *             key: "taint-key/node-type",
 *             value: "taint-value",
 *             effect: "NoSchedule",
 *         }],
 *         cordon: true,
 *         autoSyncDisabled: false,
 *     },
 *     tags: [{
 *         key: "node-pool-k1",
 *         value: "node-pool-v1",
 *     }],
 * });
 * // add existing instances to a custom node pool
 * const fooInstance: volcengine.ecs.Instance[] = [];
 * for (const range = {value: 0}; range.value < 2; range.value++) {
 *     fooInstance.push(new volcengine.ecs.Instance(`fooInstance-${range.value}`, {
 *         instanceName: `acc-test-ecs-${range.value}`,
 *         hostName: "tf-acc-test",
 *         imageId: fooImages.then(fooImages => .filter(image => image.imageName == "veLinux 1.0 CentOS Compatible 64 bit").map(image => (image.imageId))[0]),
 *         instanceType: "ecs.g1ie.xlarge",
 *         password: "93f0cb0614Aab12",
 *         instanceChargeType: "PostPaid",
 *         systemVolumeType: "ESSD_PL0",
 *         systemVolumeSize: 50,
 *         dataVolumes: [{
 *             volumeType: "ESSD_PL0",
 *             size: 50,
 *             deleteWithInstance: true,
 *         }],
 *         subnetId: fooSubnet.id,
 *         securityGroupIds: [fooSecurityGroup.id],
 *         projectName: "default",
 *         tags: [{
 *             key: "k1",
 *             value: "v1",
 *         }],
 *     }));
 * }
 * const foo1 = new volcengine.vke.NodePool("foo1", {
 *     clusterId: fooCluster.id,
 *     instanceIds: fooInstance.map(__item => __item.id),
 *     keepInstanceName: true,
 *     nodeConfig: {
 *         instanceTypeIds: ["ecs.g1ie.xlarge"],
 *         subnetIds: [fooSubnet.id],
 *         imageId: fooImages.then(fooImages => .filter(image => image.imageName == "veLinux 1.0 CentOS Compatible 64 bit").map(image => (image.imageId))[0]),
 *         systemVolume: {
 *             type: "ESSD_PL0",
 *             size: 50,
 *         },
 *         dataVolumes: [{
 *             type: "ESSD_PL0",
 *             size: 50,
 *             mountPoint: "/tf1",
 *         }],
 *         initializeScript: "ZWNobyBoZWxsbyB0ZXJyYWZvcm0h",
 *         security: {
 *             login: {
 *                 password: "UHdkMTIzNDU2",
 *             },
 *             securityStrategies: ["Hids"],
 *             securityGroupIds: [fooSecurityGroup.id],
 *         },
 *         additionalContainerStorageEnabled: false,
 *         instanceChargeType: "PostPaid",
 *         namePrefix: "acc-test",
 *         ecsTags: [{
 *             key: "ecs_k1",
 *             value: "ecs_v1",
 *         }],
 *     },
 *     kubernetesConfig: {
 *         labels: [{
 *             key: "label1",
 *             value: "value1",
 *         }],
 *         taints: [{
 *             key: "taint-key/node-type",
 *             value: "taint-value",
 *             effect: "NoSchedule",
 *         }],
 *         cordon: true,
 *     },
 *     tags: [{
 *         key: "node-pool-k1",
 *         value: "node-pool-v1",
 *     }],
 * });
 * ```
 *
 * ## Import
 *
 * NodePool can be imported using the id, e.g.
 *
 * ```sh
 * $ pulumi import volcengine:vke/nodePool:NodePool default pcabe57vqtofgrbln3dp0
 * ```
 */
export declare class NodePool extends pulumi.CustomResource {
    /**
     * Get an existing NodePool resource's state with the given name, ID, and optional extra
     * properties used to qualify the lookup.
     *
     * @param name The _unique_ name of the resulting resource.
     * @param id The _unique_ provider ID of the resource to lookup.
     * @param state Any extra arguments used during the lookup.
     * @param opts Optional settings to control the behavior of the CustomResource.
     */
    static get(name: string, id: pulumi.Input<pulumi.ID>, state?: NodePoolState, opts?: pulumi.CustomResourceOptions): NodePool;
    /**
     * Returns true if the given object is an instance of NodePool.  This is designed to work even
     * when multiple copies of the Pulumi SDK have been loaded into the same process.
     */
    static isInstance(obj: any): obj is NodePool;
    /**
     * The node pool elastic scaling configuration information.
     */
    readonly autoScaling: pulumi.Output<outputs.vke.NodePoolAutoScaling>;
    /**
     * The ClientToken of NodePool.
     */
    readonly clientToken: pulumi.Output<string | undefined>;
    /**
     * The ClusterId of NodePool.
     */
    readonly clusterId: pulumi.Output<string | undefined>;
    /**
     * The list of existing ECS instance ids. Add existing instances with same type of security group under the same cluster VPC to the custom node pool.
     * Note that removing instance ids from the list will only remove the nodes from cluster and not release the ECS instances. But deleting node pool will release the ECS instances in it.
     * It is not recommended to use this field, it is recommended to use `volcengine.vke.Node` resource to add an existing instance to a custom node pool.
     */
    readonly instanceIds: pulumi.Output<string[] | undefined>;
    /**
     * Whether to keep instance name when adding an existing instance to a custom node pool, the value is `true` or `false`.
     * This field is valid only when adding new instances to the custom node pool.
     */
    readonly keepInstanceName: pulumi.Output<boolean | undefined>;
    /**
     * The KubernetesConfig of NodeConfig.
     */
    readonly kubernetesConfig: pulumi.Output<outputs.vke.NodePoolKubernetesConfig>;
    /**
     * The Management Config of NodePool.
     */
    readonly management: pulumi.Output<outputs.vke.NodePoolManagement>;
    /**
     * The Name of NodePool.
     */
    readonly name: pulumi.Output<string>;
    /**
     * The Config of NodePool.
     */
    readonly nodeConfig: pulumi.Output<outputs.vke.NodePoolNodeConfig>;
    /**
     * The NodeStatistics of NodeConfig.
     */
    readonly nodeStatistics: pulumi.Output<outputs.vke.NodePoolNodeStatistic[]>;
    /**
     * Tags.
     */
    readonly tags: pulumi.Output<outputs.vke.NodePoolTag[] | undefined>;
    /**
     * Create a NodePool resource with the given unique name, arguments, and options.
     *
     * @param name The _unique_ name of the resource.
     * @param args The arguments to use to populate this resource's properties.
     * @param opts A bag of options that control this resource's behavior.
     */
    constructor(name: string, args: NodePoolArgs, opts?: pulumi.CustomResourceOptions);
}
/**
 * Input properties used for looking up and filtering NodePool resources.
 */
export interface NodePoolState {
    /**
     * The node pool elastic scaling configuration information.
     */
    autoScaling?: pulumi.Input<inputs.vke.NodePoolAutoScaling>;
    /**
     * The ClientToken of NodePool.
     */
    clientToken?: pulumi.Input<string>;
    /**
     * The ClusterId of NodePool.
     */
    clusterId?: pulumi.Input<string>;
    /**
     * The list of existing ECS instance ids. Add existing instances with same type of security group under the same cluster VPC to the custom node pool.
     * Note that removing instance ids from the list will only remove the nodes from cluster and not release the ECS instances. But deleting node pool will release the ECS instances in it.
     * It is not recommended to use this field, it is recommended to use `volcengine.vke.Node` resource to add an existing instance to a custom node pool.
     */
    instanceIds?: pulumi.Input<pulumi.Input<string>[]>;
    /**
     * Whether to keep instance name when adding an existing instance to a custom node pool, the value is `true` or `false`.
     * This field is valid only when adding new instances to the custom node pool.
     */
    keepInstanceName?: pulumi.Input<boolean>;
    /**
     * The KubernetesConfig of NodeConfig.
     */
    kubernetesConfig?: pulumi.Input<inputs.vke.NodePoolKubernetesConfig>;
    /**
     * The Management Config of NodePool.
     */
    management?: pulumi.Input<inputs.vke.NodePoolManagement>;
    /**
     * The Name of NodePool.
     */
    name?: pulumi.Input<string>;
    /**
     * The Config of NodePool.
     */
    nodeConfig?: pulumi.Input<inputs.vke.NodePoolNodeConfig>;
    /**
     * The NodeStatistics of NodeConfig.
     */
    nodeStatistics?: pulumi.Input<pulumi.Input<inputs.vke.NodePoolNodeStatistic>[]>;
    /**
     * Tags.
     */
    tags?: pulumi.Input<pulumi.Input<inputs.vke.NodePoolTag>[]>;
}
/**
 * The set of arguments for constructing a NodePool resource.
 */
export interface NodePoolArgs {
    /**
     * The node pool elastic scaling configuration information.
     */
    autoScaling?: pulumi.Input<inputs.vke.NodePoolAutoScaling>;
    /**
     * The ClientToken of NodePool.
     */
    clientToken?: pulumi.Input<string>;
    /**
     * The ClusterId of NodePool.
     */
    clusterId?: pulumi.Input<string>;
    /**
     * The list of existing ECS instance ids. Add existing instances with same type of security group under the same cluster VPC to the custom node pool.
     * Note that removing instance ids from the list will only remove the nodes from cluster and not release the ECS instances. But deleting node pool will release the ECS instances in it.
     * It is not recommended to use this field, it is recommended to use `volcengine.vke.Node` resource to add an existing instance to a custom node pool.
     */
    instanceIds?: pulumi.Input<pulumi.Input<string>[]>;
    /**
     * Whether to keep instance name when adding an existing instance to a custom node pool, the value is `true` or `false`.
     * This field is valid only when adding new instances to the custom node pool.
     */
    keepInstanceName?: pulumi.Input<boolean>;
    /**
     * The KubernetesConfig of NodeConfig.
     */
    kubernetesConfig: pulumi.Input<inputs.vke.NodePoolKubernetesConfig>;
    /**
     * The Management Config of NodePool.
     */
    management?: pulumi.Input<inputs.vke.NodePoolManagement>;
    /**
     * The Name of NodePool.
     */
    name?: pulumi.Input<string>;
    /**
     * The Config of NodePool.
     */
    nodeConfig: pulumi.Input<inputs.vke.NodePoolNodeConfig>;
    /**
     * Tags.
     */
    tags?: pulumi.Input<pulumi.Input<inputs.vke.NodePoolTag>[]>;
}
