@volcengine/pulumi 0.0.14 → 0.0.16

package/vke/nodePools.d.ts

@@ -8,10 +8,122 @@ 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 vkeTest = volcengine.vke.NodePools({
- *     clusterIds: ["ccabe57fqtofgrbln3dog"],
- *     name: "demo",
+ * 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: volcengine.vke.NodePool[] = [];
+ * for (const range = {value: 0}; range.value < 3; range.value++) {
+ *     fooNodePool.push(new volcengine.vke.NodePool(`fooNodePool-${range.value}`, {
+ *         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兼容版 64位").map(image => (image.imageId))[0]),
+ *             systemVolume: {
+ *                 type: "ESSD_PL0",
+ *                 size: 60,
+ *             },
+ *             dataVolumes: [
+ *                 {
+ *                     type: "ESSD_PL0",
+ *                     size: 60,
+ *                     mountPoint: "/tf1",
+ *                 },
+ *                 {
+ *                     type: "ESSD_PL0",
+ *                     size: 60,
+ *                     mountPoint: "/tf2",
+ *                 },
+ *             ],
+ *             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 fooNodePools = volcengine.vke.NodePoolsOutput({
+ *     ids: fooNodePool.map(__item => __item.id),
  * });
  * ```
  */
@@ -115,10 +227,122 @@ export interface NodePoolsResult {
  * ```typescript
  * import * as pulumi from "@pulumi/pulumi";
  * import * as volcengine from "@pulumi/volcengine";
+ * import * as volcengine from "@volcengine/pulumi";
  *
- * const vkeTest = volcengine.vke.NodePools({
- *     clusterIds: ["ccabe57fqtofgrbln3dog"],
- *     name: "demo",
+ * 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: volcengine.vke.NodePool[] = [];
+ * for (const range = {value: 0}; range.value < 3; range.value++) {
+ *     fooNodePool.push(new volcengine.vke.NodePool(`fooNodePool-${range.value}`, {
+ *         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兼容版 64位").map(image => (image.imageId))[0]),
+ *             systemVolume: {
+ *                 type: "ESSD_PL0",
+ *                 size: 60,
+ *             },
+ *             dataVolumes: [
+ *                 {
+ *                     type: "ESSD_PL0",
+ *                     size: 60,
+ *                     mountPoint: "/tf1",
+ *                 },
+ *                 {
+ *                     type: "ESSD_PL0",
+ *                     size: 60,
+ *                     mountPoint: "/tf2",
+ *                 },
+ *             ],
+ *             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 fooNodePools = volcengine.vke.NodePoolsOutput({
+ *     ids: fooNodePool.map(__item => __item.id),
  * });
  * ```
  */

package/vke/nodePools.js

@@ -12,10 +12,122 @@ const utilities = require("../utilities");
  * ```typescript
  * import * as pulumi from "@pulumi/pulumi";
  * import * as volcengine from "@pulumi/volcengine";
+ * import * as volcengine from "@volcengine/pulumi";
  *
- * const vkeTest = volcengine.vke.NodePools({
- *     clusterIds: ["ccabe57fqtofgrbln3dog"],
- *     name: "demo",
+ * 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: volcengine.vke.NodePool[] = [];
+ * for (const range = {value: 0}; range.value < 3; range.value++) {
+ *     fooNodePool.push(new volcengine.vke.NodePool(`fooNodePool-${range.value}`, {
+ *         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兼容版 64位").map(image => (image.imageId))[0]),
+ *             systemVolume: {
+ *                 type: "ESSD_PL0",
+ *                 size: 60,
+ *             },
+ *             dataVolumes: [
+ *                 {
+ *                     type: "ESSD_PL0",
+ *                     size: 60,
+ *                     mountPoint: "/tf1",
+ *                 },
+ *                 {
+ *                     type: "ESSD_PL0",
+ *                     size: 60,
+ *                     mountPoint: "/tf2",
+ *                 },
+ *             ],
+ *             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 fooNodePools = volcengine.vke.NodePoolsOutput({
+ *     ids: fooNodePool.map(__item => __item.id),
  * });
  * ```
  */
@@ -44,10 +156,122 @@ exports.nodePools = nodePools;
  * ```typescript
  * import * as pulumi from "@pulumi/pulumi";
  * import * as volcengine from "@pulumi/volcengine";
+ * import * as volcengine from "@volcengine/pulumi";
  *
- * const vkeTest = volcengine.vke.NodePools({
- *     clusterIds: ["ccabe57fqtofgrbln3dog"],
- *     name: "demo",
+ * 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: volcengine.vke.NodePool[] = [];
+ * for (const range = {value: 0}; range.value < 3; range.value++) {
+ *     fooNodePool.push(new volcengine.vke.NodePool(`fooNodePool-${range.value}`, {
+ *         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兼容版 64位").map(image => (image.imageId))[0]),
+ *             systemVolume: {
+ *                 type: "ESSD_PL0",
+ *                 size: 60,
+ *             },
+ *             dataVolumes: [
+ *                 {
+ *                     type: "ESSD_PL0",
+ *                     size: 60,
+ *                     mountPoint: "/tf1",
+ *                 },
+ *                 {
+ *                     type: "ESSD_PL0",
+ *                     size: 60,
+ *                     mountPoint: "/tf2",
+ *                 },
+ *             ],
+ *             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 fooNodePools = volcengine.vke.NodePoolsOutput({
+ *     ids: fooNodePool.map(__item => __item.id),
  * });
  * ```
  */

package/vke/nodePools.js.map

@@ -1 +1 @@
-{"version":3,"file":"nodePools.js","sourceRoot":"","sources":["../../vke/nodePools.ts"],"names":[],"mappings":";AAAA,wFAAwF;AACxF,iFAAiF;;;AAEjF,yCAAyC;AAGzC,0CAA0C;AAE1C;;;;;;;;;;;;;GAaG;AACH,SAAgB,SAAS,CAAC,IAAoB,EAAE,IAA2B;IACvE,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,oCAAoC,EAAE;QAC/D,oBAAoB,EAAE,IAAI,CAAC,kBAAkB;QAC7C,WAAW,EAAE,IAAI,CAAC,SAAS;QAC3B,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,YAAY,EAAE,IAAI,CAAC,UAAU;QAC7B,UAAU,EAAE,IAAI,CAAC,QAAQ;QACzB,MAAM,EAAE,IAAI,CAAC,IAAI;QACjB,mBAAmB,EAAE,IAAI,CAAC,iBAAiB;KAC9C,EAAE,IAAI,CAAC,CAAC;AACb,CAAC;AAjBD,8BAiBC;AA+FD;;;;;;;;;;;;;GAaG;AACH,SAAgB,eAAe,CAAC,IAA0B,EAAE,IAA2B;IACnF,OAAO,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC,CAAC,CAAM,EAAE,EAAE,CAAC,SAAS,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAA;AACpE,CAAC;AAFD,0CAEC"}
+{"version":3,"file":"nodePools.js","sourceRoot":"","sources":["../../vke/nodePools.ts"],"names":[],"mappings":";AAAA,wFAAwF;AACxF,iFAAiF;;;AAEjF,yCAAyC;AAGzC,0CAA0C;AAE1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6HG;AACH,SAAgB,SAAS,CAAC,IAAoB,EAAE,IAA2B;IACvE,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,oCAAoC,EAAE;QAC/D,oBAAoB,EAAE,IAAI,CAAC,kBAAkB;QAC7C,WAAW,EAAE,IAAI,CAAC,SAAS;QAC3B,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,YAAY,EAAE,IAAI,CAAC,UAAU;QAC7B,UAAU,EAAE,IAAI,CAAC,QAAQ;QACzB,MAAM,EAAE,IAAI,CAAC,IAAI;QACjB,mBAAmB,EAAE,IAAI,CAAC,iBAAiB;KAC9C,EAAE,IAAI,CAAC,CAAC;AACb,CAAC;AAjBD,8BAiBC;AA+FD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6HG;AACH,SAAgB,eAAe,CAAC,IAA0B,EAAE,IAA2B;IACnF,OAAO,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC,CAAC,CAAM,EAAE,EAAE,CAAC,SAAS,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAA;AACpE,CAAC;AAFD,0CAEC"}