@volcengine/pulumi 0.0.14 → 0.0.16

package/vke/nodes.d.ts

@@ -8,23 +8,140 @@ import * as outputs from "../types/output";
  * ```typescript
  * import * as pulumi from "@pulumi/pulumi";
  * import * as volcengine from "@pulumi/volcengine";
+ * import * as volcengine from "@volcengine/pulumi";
  *
- * const default = volcengine.vke.Nodes({
- *     clusterIds: [
- *         "c123",
- *         "c456",
- *     ],
- *     ids: ["ncaa3e5mrsferqkomi190"],
- *     statuses: [
- *         {
- *             conditionsType: "Progressing",
- *             phase: "Creating",
+ * const fooZones = volcengine.ecs.Zones({});
+ * 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.Images({
+ *     nameRegex: "veLinux 1.0 CentOS兼容版 64位",
+ * });
+ * const fooCluster = new volcengine.vke.Cluster("fooCluster", {
+ *     description: "created by terraform",
+ *     deleteProtectionEnabled: false,
+ *     clusterConfig: {
+ *         subnetIds: [fooSubnet.id],
+ *         apiServerPublicAccessEnabled: true,
+ *         apiServerPublicAccessConfig: {
+ *             publicAccessNetworkConfig: {
+ *                 billingType: "PostPaidByBandwidth",
+ *                 bandwidth: 1,
+ *             },
  *         },
- *         {
- *             conditionsType: "Progressing123",
- *             phase: "Creating123",
+ *         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: false,
+ *     },
+ *     nodeConfig: {
+ *         instanceTypeIds: ["ecs.g1ie.xlarge"],
+ *         subnetIds: [fooSubnet.id],
+ *         imageId: fooImages.then(fooImages => .filter(image => image.imageName == "veLinux 1.0 CentOS兼容版 64位").map(image => (image.imageId))[0]),
+ *         systemVolume: {
+ *             type: "ESSD_PL0",
+ *             size: 50,
+ *         },
+ *         dataVolumes: [{
+ *             type: "ESSD_PL0",
+ *             size: 50,
+ *             mountPoint: "/tf",
+ *         }],
+ *         initializeScript: "ZWNobyBoZWxsbyB0ZXJyYWZvcm0h",
+ *         security: {
+ *             login: {
+ *                 password: "UHdkMTIzNDU2",
+ *             },
+ *             securityStrategies: ["Hids"],
+ *             securityGroupIds: [fooSecurityGroup.id],
+ *         },
+ *         additionalContainerStorageEnabled: true,
+ *         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",
+ *     }],
+ * });
+ * 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兼容版 64位").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 fooNode: volcengine.vke.Node[] = [];
+ * for (const range = {value: 0}; range.value < 2; range.value++) {
+ *     fooNode.push(new volcengine.vke.Node(`fooNode-${range.value}`, {
+ *         clusterId: fooCluster.id,
+ *         instanceId: fooInstance[range.value].id,
+ *         nodePoolId: fooNodePool.id,
+ *     }));
+ * }
+ * const fooNodes = volcengine.vke.NodesOutput({
+ *     ids: fooNode.map(__item => __item.id),
  * });
  * ```
  */
@@ -109,23 +226,140 @@ export interface NodesResult {
  * ```typescript
  * import * as pulumi from "@pulumi/pulumi";
  * import * as volcengine from "@pulumi/volcengine";
+ * import * as volcengine from "@volcengine/pulumi";
  *
- * const default = volcengine.vke.Nodes({
- *     clusterIds: [
- *         "c123",
- *         "c456",
- *     ],
- *     ids: ["ncaa3e5mrsferqkomi190"],
- *     statuses: [
- *         {
- *             conditionsType: "Progressing",
- *             phase: "Creating",
+ * const fooZones = volcengine.ecs.Zones({});
+ * 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.Images({
+ *     nameRegex: "veLinux 1.0 CentOS兼容版 64位",
+ * });
+ * const fooCluster = new volcengine.vke.Cluster("fooCluster", {
+ *     description: "created by terraform",
+ *     deleteProtectionEnabled: false,
+ *     clusterConfig: {
+ *         subnetIds: [fooSubnet.id],
+ *         apiServerPublicAccessEnabled: true,
+ *         apiServerPublicAccessConfig: {
+ *             publicAccessNetworkConfig: {
+ *                 billingType: "PostPaidByBandwidth",
+ *                 bandwidth: 1,
+ *             },
  *         },
- *         {
- *             conditionsType: "Progressing123",
- *             phase: "Creating123",
+ *         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: false,
+ *     },
+ *     nodeConfig: {
+ *         instanceTypeIds: ["ecs.g1ie.xlarge"],
+ *         subnetIds: [fooSubnet.id],
+ *         imageId: fooImages.then(fooImages => .filter(image => image.imageName == "veLinux 1.0 CentOS兼容版 64位").map(image => (image.imageId))[0]),
+ *         systemVolume: {
+ *             type: "ESSD_PL0",
+ *             size: 50,
+ *         },
+ *         dataVolumes: [{
+ *             type: "ESSD_PL0",
+ *             size: 50,
+ *             mountPoint: "/tf",
+ *         }],
+ *         initializeScript: "ZWNobyBoZWxsbyB0ZXJyYWZvcm0h",
+ *         security: {
+ *             login: {
+ *                 password: "UHdkMTIzNDU2",
+ *             },
+ *             securityStrategies: ["Hids"],
+ *             securityGroupIds: [fooSecurityGroup.id],
+ *         },
+ *         additionalContainerStorageEnabled: true,
+ *         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",
+ *     }],
+ * });
+ * 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兼容版 64位").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 fooNode: volcengine.vke.Node[] = [];
+ * for (const range = {value: 0}; range.value < 2; range.value++) {
+ *     fooNode.push(new volcengine.vke.Node(`fooNode-${range.value}`, {
+ *         clusterId: fooCluster.id,
+ *         instanceId: fooInstance[range.value].id,
+ *         nodePoolId: fooNodePool.id,
+ *     }));
+ * }
+ * const fooNodes = volcengine.vke.NodesOutput({
+ *     ids: fooNode.map(__item => __item.id),
  * });
  * ```
  */

package/vke/nodes.js

@@ -12,23 +12,140 @@ const utilities = require("../utilities");
  * ```typescript
  * import * as pulumi from "@pulumi/pulumi";
  * import * as volcengine from "@pulumi/volcengine";
+ * import * as volcengine from "@volcengine/pulumi";
  *
- * const default = volcengine.vke.Nodes({
- *     clusterIds: [
- *         "c123",
- *         "c456",
- *     ],
- *     ids: ["ncaa3e5mrsferqkomi190"],
- *     statuses: [
- *         {
- *             conditionsType: "Progressing",
- *             phase: "Creating",
+ * const fooZones = volcengine.ecs.Zones({});
+ * 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.Images({
+ *     nameRegex: "veLinux 1.0 CentOS兼容版 64位",
+ * });
+ * const fooCluster = new volcengine.vke.Cluster("fooCluster", {
+ *     description: "created by terraform",
+ *     deleteProtectionEnabled: false,
+ *     clusterConfig: {
+ *         subnetIds: [fooSubnet.id],
+ *         apiServerPublicAccessEnabled: true,
+ *         apiServerPublicAccessConfig: {
+ *             publicAccessNetworkConfig: {
+ *                 billingType: "PostPaidByBandwidth",
+ *                 bandwidth: 1,
+ *             },
  *         },
- *         {
- *             conditionsType: "Progressing123",
- *             phase: "Creating123",
+ *         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: false,
+ *     },
+ *     nodeConfig: {
+ *         instanceTypeIds: ["ecs.g1ie.xlarge"],
+ *         subnetIds: [fooSubnet.id],
+ *         imageId: fooImages.then(fooImages => .filter(image => image.imageName == "veLinux 1.0 CentOS兼容版 64位").map(image => (image.imageId))[0]),
+ *         systemVolume: {
+ *             type: "ESSD_PL0",
+ *             size: 50,
+ *         },
+ *         dataVolumes: [{
+ *             type: "ESSD_PL0",
+ *             size: 50,
+ *             mountPoint: "/tf",
+ *         }],
+ *         initializeScript: "ZWNobyBoZWxsbyB0ZXJyYWZvcm0h",
+ *         security: {
+ *             login: {
+ *                 password: "UHdkMTIzNDU2",
+ *             },
+ *             securityStrategies: ["Hids"],
+ *             securityGroupIds: [fooSecurityGroup.id],
+ *         },
+ *         additionalContainerStorageEnabled: true,
+ *         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",
+ *     }],
+ * });
+ * 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兼容版 64位").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 fooNode: volcengine.vke.Node[] = [];
+ * for (const range = {value: 0}; range.value < 2; range.value++) {
+ *     fooNode.push(new volcengine.vke.Node(`fooNode-${range.value}`, {
+ *         clusterId: fooCluster.id,
+ *         instanceId: fooInstance[range.value].id,
+ *         nodePoolId: fooNodePool.id,
+ *     }));
+ * }
+ * const fooNodes = volcengine.vke.NodesOutput({
+ *     ids: fooNode.map(__item => __item.id),
  * });
  * ```
  */
@@ -55,23 +172,140 @@ exports.nodes = nodes;
  * ```typescript
  * import * as pulumi from "@pulumi/pulumi";
  * import * as volcengine from "@pulumi/volcengine";
+ * import * as volcengine from "@volcengine/pulumi";
  *
- * const default = volcengine.vke.Nodes({
- *     clusterIds: [
- *         "c123",
- *         "c456",
- *     ],
- *     ids: ["ncaa3e5mrsferqkomi190"],
- *     statuses: [
- *         {
- *             conditionsType: "Progressing",
- *             phase: "Creating",
+ * const fooZones = volcengine.ecs.Zones({});
+ * 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.Images({
+ *     nameRegex: "veLinux 1.0 CentOS兼容版 64位",
+ * });
+ * const fooCluster = new volcengine.vke.Cluster("fooCluster", {
+ *     description: "created by terraform",
+ *     deleteProtectionEnabled: false,
+ *     clusterConfig: {
+ *         subnetIds: [fooSubnet.id],
+ *         apiServerPublicAccessEnabled: true,
+ *         apiServerPublicAccessConfig: {
+ *             publicAccessNetworkConfig: {
+ *                 billingType: "PostPaidByBandwidth",
+ *                 bandwidth: 1,
+ *             },
  *         },
- *         {
- *             conditionsType: "Progressing123",
- *             phase: "Creating123",
+ *         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: false,
+ *     },
+ *     nodeConfig: {
+ *         instanceTypeIds: ["ecs.g1ie.xlarge"],
+ *         subnetIds: [fooSubnet.id],
+ *         imageId: fooImages.then(fooImages => .filter(image => image.imageName == "veLinux 1.0 CentOS兼容版 64位").map(image => (image.imageId))[0]),
+ *         systemVolume: {
+ *             type: "ESSD_PL0",
+ *             size: 50,
+ *         },
+ *         dataVolumes: [{
+ *             type: "ESSD_PL0",
+ *             size: 50,
+ *             mountPoint: "/tf",
+ *         }],
+ *         initializeScript: "ZWNobyBoZWxsbyB0ZXJyYWZvcm0h",
+ *         security: {
+ *             login: {
+ *                 password: "UHdkMTIzNDU2",
+ *             },
+ *             securityStrategies: ["Hids"],
+ *             securityGroupIds: [fooSecurityGroup.id],
+ *         },
+ *         additionalContainerStorageEnabled: true,
+ *         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",
+ *     }],
+ * });
+ * 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兼容版 64位").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 fooNode: volcengine.vke.Node[] = [];
+ * for (const range = {value: 0}; range.value < 2; range.value++) {
+ *     fooNode.push(new volcengine.vke.Node(`fooNode-${range.value}`, {
+ *         clusterId: fooCluster.id,
+ *         instanceId: fooInstance[range.value].id,
+ *         nodePoolId: fooNodePool.id,
+ *     }));
+ * }
+ * const fooNodes = volcengine.vke.NodesOutput({
+ *     ids: fooNode.map(__item => __item.id),
  * });
  * ```
  */

package/vke/nodes.js.map

@@ -1 +1 @@
-{"version":3,"file":"nodes.js","sourceRoot":"","sources":["../../vke/nodes.ts"],"names":[],"mappings":";AAAA,wFAAwF;AACxF,iFAAiF;;;AAEjF,yCAAyC;AAGzC,0CAA0C;AAE1C;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,SAAgB,KAAK,CAAC,IAAgB,EAAE,IAA2B;IAC/D,IAAI,GAAG,IAAI,IAAI,EAAE,CAAC;IAElB,IAAI,GAAG,MAAM,CAAC,YAAY,CAAC,SAAS,CAAC,oBAAoB,EAAE,EAAE,IAAI,IAAI,EAAE,CAAC,CAAC;IACzE,OAAO,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,4BAA4B,EAAE;QACvD,YAAY,EAAE,IAAI,CAAC,UAAU;QAC7B,mBAAmB,EAAE,IAAI,CAAC,iBAAiB;QAC3C,KAAK,EAAE,IAAI,CAAC,GAAG;QACf,MAAM,EAAE,IAAI,CAAC,IAAI;QACjB,WAAW,EAAE,IAAI,CAAC,SAAS;QAC3B,aAAa,EAAE,IAAI,CAAC,WAAW;QAC/B,YAAY,EAAE,IAAI,CAAC,UAAU;QAC7B,UAAU,EAAE,IAAI,CAAC,QAAQ;QACzB,SAAS,EAAE,IAAI,CAAC,OAAO;KAC1B,EAAE,IAAI,CAAC,CAAC;AACb,CAAC;AAfD,sBAeC;AA4ED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,SAAgB,WAAW,CAAC,IAAsB,EAAE,IAA2B;IAC3E,OAAO,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC,CAAC,CAAM,EAAE,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAA;AAChE,CAAC;AAFD,kCAEC"}
+{"version":3,"file":"nodes.js","sourceRoot":"","sources":["../../vke/nodes.ts"],"names":[],"mappings":";AAAA,wFAAwF;AACxF,iFAAiF;;;AAEjF,yCAAyC;AAGzC,0CAA0C;AAE1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+IG;AACH,SAAgB,KAAK,CAAC,IAAgB,EAAE,IAA2B;IAC/D,IAAI,GAAG,IAAI,IAAI,EAAE,CAAC;IAElB,IAAI,GAAG,MAAM,CAAC,YAAY,CAAC,SAAS,CAAC,oBAAoB,EAAE,EAAE,IAAI,IAAI,EAAE,CAAC,CAAC;IACzE,OAAO,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,4BAA4B,EAAE;QACvD,YAAY,EAAE,IAAI,CAAC,UAAU;QAC7B,mBAAmB,EAAE,IAAI,CAAC,iBAAiB;QAC3C,KAAK,EAAE,IAAI,CAAC,GAAG;QACf,MAAM,EAAE,IAAI,CAAC,IAAI;QACjB,WAAW,EAAE,IAAI,CAAC,SAAS;QAC3B,aAAa,EAAE,IAAI,CAAC,WAAW;QAC/B,YAAY,EAAE,IAAI,CAAC,UAAU;QAC7B,UAAU,EAAE,IAAI,CAAC,QAAQ;QACzB,SAAS,EAAE,IAAI,CAAC,OAAO;KAC1B,EAAE,IAAI,CAAC,CAAC;AACb,CAAC;AAfD,sBAeC;AA4ED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+IG;AACH,SAAgB,WAAW,CAAC,IAAsB,EAAE,IAA2B;IAC3E,OAAO,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC,CAAC,CAAM,EAAE,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAA;AAChE,CAAC;AAFD,kCAEC"}