@volcengine/pulumi 0.0.12 → 0.0.16

package/vke/nodes.js

@@ -12,32 +12,146 @@ const utilities = require("../utilities");
  * ```typescript
  * import * as pulumi from "@pulumi/pulumi";
  * import * as volcengine from "@pulumi/volcengine";
+ * import * as volcengine from "@volcengine/pulumi";
  *
- * const defaultNodes = pulumi.output(volcengine.vke.Nodes({
- *     clusterIds: [
- *         "c123",
- *         "c456",
- *     ],
- *     ids: ["ncaa3e5mrsferqkomi190"],
- *     statuses: [
- *         {
- *             conditionsType: "Progressing",
- *             phase: "Creating",
- *         },
- *         {
- *             conditionsType: "Progressing123",
- *             phase: "Creating123",
- *         },
- *     ],
- * }));
+ * 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,
+ *             },
+ *         },
+ *         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),
+ * });
  * ```
  */
 function nodes(args, opts) {
     args = args || {};
-    if (!opts) {
-        opts = {};
-    }
-    opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts);
+    opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {});
     return pulumi.runtime.invoke("volcengine:vke/nodes:Nodes", {
         "clusterIds": args.clusterIds,
         "createClientToken": args.createClientToken,
@@ -51,8 +165,152 @@ function nodes(args, opts) {
     }, opts);
 }
 exports.nodes = nodes;
+/**
+ * Use this data source to query detailed information of vke nodes
+ * ## 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.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,
+ *             },
+ *         },
+ *         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),
+ * });
+ * ```
+ */
 function nodesOutput(args, opts) {
-    return pulumi.output(args).apply(a => nodes(a, opts));
+    return pulumi.output(args).apply((a) => nodes(a, opts));
 }
 exports.nodesOutput = nodesOutput;
 //# sourceMappingURL=nodes.js.map

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;AAEzC,0CAA0C;AAE1C;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,SAAgB,KAAK,CAAC,IAAgB,EAAE,IAA2B;IAC/D,IAAI,GAAG,IAAI,IAAI,EAAE,CAAC;IAClB,IAAI,CAAC,IAAI,EAAE;QACP,IAAI,GAAG,EAAE,CAAA;KACZ;IAED,IAAI,GAAG,MAAM,CAAC,YAAY,CAAC,SAAS,CAAC,oBAAoB,EAAE,EAAE,IAAI,CAAC,CAAC;IACnE,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;AAlBD,sBAkBC;AA6ED,SAAgB,WAAW,CAAC,IAAsB,EAAE,IAA2B;IAC3E,OAAO,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAA;AACzD,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"}

package/vke/supportAddons.d.ts

@@ -1,5 +1,5 @@
 import * as pulumi from "@pulumi/pulumi";
-import { output as outputs } from "../types";
+import * as outputs from "../types/output";
 /**
  * Use this data source to query detailed information of vke support addons
  * ## Example Usage
@@ -8,10 +8,10 @@ import { output as outputs } from "../types";
  * import * as pulumi from "@pulumi/pulumi";
  * import * as volcengine from "@pulumi/volcengine";
  *
- * const defaultSupportAddons = pulumi.output(volcengine.vke.SupportAddons({
+ * const default = volcengine.vke.SupportAddons({
  *     categories: ["Monitor"],
  *     name: "metrics-server",
- * }));
+ * });
  * ```
  */
 export declare function supportAddons(args?: SupportAddonsArgs, opts?: pulumi.InvokeOptions): Promise<SupportAddonsResult>;
@@ -86,6 +86,20 @@ export interface SupportAddonsResult {
      */
     readonly totalCount: number;
 }
+/**
+ * Use this data source to query detailed information of vke support addons
+ * ## Example Usage
+ *
+ * ```typescript
+ * import * as pulumi from "@pulumi/pulumi";
+ * import * as volcengine from "@pulumi/volcengine";
+ *
+ * const default = volcengine.vke.SupportAddons({
+ *     categories: ["Monitor"],
+ *     name: "metrics-server",
+ * });
+ * ```
+ */
 export declare function supportAddonsOutput(args?: SupportAddonsOutputArgs, opts?: pulumi.InvokeOptions): pulumi.Output<SupportAddonsResult>;
 /**
  * A collection of arguments for invoking SupportAddons.

package/vke/supportAddons.js

@@ -13,18 +13,15 @@ const utilities = require("../utilities");
  * import * as pulumi from "@pulumi/pulumi";
  * import * as volcengine from "@pulumi/volcengine";
  *
- * const defaultSupportAddons = pulumi.output(volcengine.vke.SupportAddons({
+ * const default = volcengine.vke.SupportAddons({
  *     categories: ["Monitor"],
  *     name: "metrics-server",
- * }));
+ * });
  * ```
  */
 function supportAddons(args, opts) {
     args = args || {};
-    if (!opts) {
-        opts = {};
-    }
-    opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts);
+    opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {});
     return pulumi.runtime.invoke("volcengine:vke/supportAddons:SupportAddons", {
         "categories": args.categories,
         "deployModes": args.deployModes,
@@ -37,8 +34,22 @@ function supportAddons(args, opts) {
     }, opts);
 }
 exports.supportAddons = supportAddons;
+/**
+ * Use this data source to query detailed information of vke support addons
+ * ## Example Usage
+ *
+ * ```typescript
+ * import * as pulumi from "@pulumi/pulumi";
+ * import * as volcengine from "@pulumi/volcengine";
+ *
+ * const default = volcengine.vke.SupportAddons({
+ *     categories: ["Monitor"],
+ *     name: "metrics-server",
+ * });
+ * ```
+ */
 function supportAddonsOutput(args, opts) {
-    return pulumi.output(args).apply(a => supportAddons(a, opts));
+    return pulumi.output(args).apply((a) => supportAddons(a, opts));
 }
 exports.supportAddonsOutput = supportAddonsOutput;
 //# sourceMappingURL=supportAddons.js.map

package/vke/supportAddons.js.map

@@ -1 +1 @@
-{"version":3,"file":"supportAddons.js","sourceRoot":"","sources":["../../vke/supportAddons.ts"],"names":[],"mappings":";AAAA,wFAAwF;AACxF,iFAAiF;;;AAEjF,yCAAyC;AAEzC,0CAA0C;AAE1C;;;;;;;;;;;;;GAaG;AACH,SAAgB,aAAa,CAAC,IAAwB,EAAE,IAA2B;IAC/E,IAAI,GAAG,IAAI,IAAI,EAAE,CAAC;IAClB,IAAI,CAAC,IAAI,EAAE;QACP,IAAI,GAAG,EAAE,CAAA;KACZ;IAED,IAAI,GAAG,MAAM,CAAC,YAAY,CAAC,SAAS,CAAC,oBAAoB,EAAE,EAAE,IAAI,CAAC,CAAC;IACnE,OAAO,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,4CAA4C,EAAE;QACvE,YAAY,EAAE,IAAI,CAAC,UAAU;QAC7B,aAAa,EAAE,IAAI,CAAC,WAAW;QAC/B,iBAAiB,EAAE,IAAI,CAAC,eAAe;QACvC,oBAAoB,EAAE,IAAI,CAAC,kBAAkB;QAC7C,MAAM,EAAE,IAAI,CAAC,IAAI;QACjB,aAAa,EAAE,IAAI,CAAC,WAAW;QAC/B,YAAY,EAAE,IAAI,CAAC,UAAU;QAC7B,iBAAiB,EAAE,IAAI,CAAC,eAAe;KAC1C,EAAE,IAAI,CAAC,CAAC;AACb,CAAC;AAjBD,sCAiBC;AA2ED,SAAgB,mBAAmB,CAAC,IAA8B,EAAE,IAA2B;IAC3F,OAAO,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,aAAa,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAA;AACjE,CAAC;AAFD,kDAEC"}
+{"version":3,"file":"supportAddons.js","sourceRoot":"","sources":["../../vke/supportAddons.ts"],"names":[],"mappings":";AAAA,wFAAwF;AACxF,iFAAiF;;;AAEjF,yCAAyC;AAGzC,0CAA0C;AAE1C;;;;;;;;;;;;;GAaG;AACH,SAAgB,aAAa,CAAC,IAAwB,EAAE,IAA2B;IAC/E,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,4CAA4C,EAAE;QACvE,YAAY,EAAE,IAAI,CAAC,UAAU;QAC7B,aAAa,EAAE,IAAI,CAAC,WAAW;QAC/B,iBAAiB,EAAE,IAAI,CAAC,eAAe;QACvC,oBAAoB,EAAE,IAAI,CAAC,kBAAkB;QAC7C,MAAM,EAAE,IAAI,CAAC,IAAI;QACjB,aAAa,EAAE,IAAI,CAAC,WAAW;QAC/B,YAAY,EAAE,IAAI,CAAC,UAAU;QAC7B,iBAAiB,EAAE,IAAI,CAAC,eAAe;KAC1C,EAAE,IAAI,CAAC,CAAC;AACb,CAAC;AAdD,sCAcC;AA0ED;;;;;;;;;;;;;GAaG;AACH,SAAgB,mBAAmB,CAAC,IAA8B,EAAE,IAA2B;IAC3F,OAAO,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC,CAAC,CAAM,EAAE,EAAE,CAAC,aAAa,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAA;AACxE,CAAC;AAFD,kDAEC"}

package/vpc/index.d.ts

@@ -1,24 +1,72 @@
-export * from "./ipv6AddressBandwidth";
-export * from "./ipv6AddressBandwidths";
-export * from "./ipv6Addresses";
-export * from "./ipv6Gateway";
-export * from "./ipv6Gateways";
-export * from "./networkAcl";
-export * from "./networkAclAssociate";
-export * from "./networkAcls";
-export * from "./networkInterface";
-export * from "./networkInterfaceAttach";
-export * from "./networkInterfaces";
-export * from "./routeEntries";
-export * from "./routeEntry";
-export * from "./routeTable";
-export * from "./routeTableAssociate";
-export * from "./routeTables";
-export * from "./securityGroup";
-export * from "./securityGroupRule";
-export * from "./securityGroupRules";
-export * from "./securityGroups";
-export * from "./subnet";
-export * from "./subnets";
-export * from "./vpc";
-export * from "./vpcs";
+export { Ipv6AddressBandwidthArgs, Ipv6AddressBandwidthState } from "./ipv6AddressBandwidth";
+export type Ipv6AddressBandwidth = import("./ipv6AddressBandwidth").Ipv6AddressBandwidth;
+export declare const Ipv6AddressBandwidth: typeof import("./ipv6AddressBandwidth").Ipv6AddressBandwidth;
+export { Ipv6AddressBandwidthsArgs, Ipv6AddressBandwidthsResult, Ipv6AddressBandwidthsOutputArgs } from "./ipv6AddressBandwidths";
+export declare const ipv6AddressBandwidths: typeof import("./ipv6AddressBandwidths").ipv6AddressBandwidths;
+export declare const ipv6AddressBandwidthsOutput: typeof import("./ipv6AddressBandwidths").ipv6AddressBandwidthsOutput;
+export { Ipv6AddressesArgs, Ipv6AddressesResult, Ipv6AddressesOutputArgs } from "./ipv6Addresses";
+export declare const ipv6Addresses: typeof import("./ipv6Addresses").ipv6Addresses;
+export declare const ipv6AddressesOutput: typeof import("./ipv6Addresses").ipv6AddressesOutput;
+export { Ipv6GatewayArgs, Ipv6GatewayState } from "./ipv6Gateway";
+export type Ipv6Gateway = import("./ipv6Gateway").Ipv6Gateway;
+export declare const Ipv6Gateway: typeof import("./ipv6Gateway").Ipv6Gateway;
+export { Ipv6GatewaysArgs, Ipv6GatewaysResult, Ipv6GatewaysOutputArgs } from "./ipv6Gateways";
+export declare const ipv6Gateways: typeof import("./ipv6Gateways").ipv6Gateways;
+export declare const ipv6GatewaysOutput: typeof import("./ipv6Gateways").ipv6GatewaysOutput;
+export { NetworkAclArgs, NetworkAclState } from "./networkAcl";
+export type NetworkAcl = import("./networkAcl").NetworkAcl;
+export declare const NetworkAcl: typeof import("./networkAcl").NetworkAcl;
+export { NetworkAclAssociateArgs, NetworkAclAssociateState } from "./networkAclAssociate";
+export type NetworkAclAssociate = import("./networkAclAssociate").NetworkAclAssociate;
+export declare const NetworkAclAssociate: typeof import("./networkAclAssociate").NetworkAclAssociate;
+export { NetworkAclsArgs, NetworkAclsResult, NetworkAclsOutputArgs } from "./networkAcls";
+export declare const networkAcls: typeof import("./networkAcls").networkAcls;
+export declare const networkAclsOutput: typeof import("./networkAcls").networkAclsOutput;
+export { NetworkInterfaceArgs, NetworkInterfaceState } from "./networkInterface";
+export type NetworkInterface = import("./networkInterface").NetworkInterface;
+export declare const NetworkInterface: typeof import("./networkInterface").NetworkInterface;
+export { NetworkInterfaceAttachArgs, NetworkInterfaceAttachState } from "./networkInterfaceAttach";
+export type NetworkInterfaceAttach = import("./networkInterfaceAttach").NetworkInterfaceAttach;
+export declare const NetworkInterfaceAttach: typeof import("./networkInterfaceAttach").NetworkInterfaceAttach;
+export { NetworkInterfacesArgs, NetworkInterfacesResult, NetworkInterfacesOutputArgs } from "./networkInterfaces";
+export declare const networkInterfaces: typeof import("./networkInterfaces").networkInterfaces;
+export declare const networkInterfacesOutput: typeof import("./networkInterfaces").networkInterfacesOutput;
+export { RouteEntriesArgs, RouteEntriesResult, RouteEntriesOutputArgs } from "./routeEntries";
+export declare const routeEntries: typeof import("./routeEntries").routeEntries;
+export declare const routeEntriesOutput: typeof import("./routeEntries").routeEntriesOutput;
+export { RouteEntryArgs, RouteEntryState } from "./routeEntry";
+export type RouteEntry = import("./routeEntry").RouteEntry;
+export declare const RouteEntry: typeof import("./routeEntry").RouteEntry;
+export { RouteTableArgs, RouteTableState } from "./routeTable";
+export type RouteTable = import("./routeTable").RouteTable;
+export declare const RouteTable: typeof import("./routeTable").RouteTable;
+export { RouteTableAssociateArgs, RouteTableAssociateState } from "./routeTableAssociate";
+export type RouteTableAssociate = import("./routeTableAssociate").RouteTableAssociate;
+export declare const RouteTableAssociate: typeof import("./routeTableAssociate").RouteTableAssociate;
+export { RouteTablesArgs, RouteTablesResult, RouteTablesOutputArgs } from "./routeTables";
+export declare const routeTables: typeof import("./routeTables").routeTables;
+export declare const routeTablesOutput: typeof import("./routeTables").routeTablesOutput;
+export { SecurityGroupArgs, SecurityGroupState } from "./securityGroup";
+export type SecurityGroup = import("./securityGroup").SecurityGroup;
+export declare const SecurityGroup: typeof import("./securityGroup").SecurityGroup;
+export { SecurityGroupRuleArgs, SecurityGroupRuleState } from "./securityGroupRule";
+export type SecurityGroupRule = import("./securityGroupRule").SecurityGroupRule;
+export declare const SecurityGroupRule: typeof import("./securityGroupRule").SecurityGroupRule;
+export { SecurityGroupRulesArgs, SecurityGroupRulesResult, SecurityGroupRulesOutputArgs } from "./securityGroupRules";
+export declare const securityGroupRules: typeof import("./securityGroupRules").securityGroupRules;
+export declare const securityGroupRulesOutput: typeof import("./securityGroupRules").securityGroupRulesOutput;
+export { SecurityGroupsArgs, SecurityGroupsResult, SecurityGroupsOutputArgs } from "./securityGroups";
+export declare const securityGroups: typeof import("./securityGroups").securityGroups;
+export declare const securityGroupsOutput: typeof import("./securityGroups").securityGroupsOutput;
+export { SubnetArgs, SubnetState } from "./subnet";
+export type Subnet = import("./subnet").Subnet;
+export declare const Subnet: typeof import("./subnet").Subnet;
+export { SubnetsArgs, SubnetsResult, SubnetsOutputArgs } from "./subnets";
+export declare const subnets: typeof import("./subnets").subnets;
+export declare const subnetsOutput: typeof import("./subnets").subnetsOutput;
+export { VpcArgs, VpcState } from "./vpc";
+export type Vpc = import("./vpc").Vpc;
+export declare const Vpc: typeof import("./vpc").Vpc;
+export { VpcsArgs, VpcsResult, VpcsOutputArgs } from "./vpcs";
+export declare const vpcs: typeof import("./vpcs").vpcs;
+export declare const vpcsOutput: typeof import("./vpcs").vpcsOutput;