@aws-cdk/cfn-property-mixins 2.243.0

package/lib/services/aws-neptune/cfn-props-mixins.generated.js

@@ -0,0 +1,375 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CfnEventSubscriptionPropsMixin = exports.CfnDBSubnetGroupPropsMixin = exports.CfnDBParameterGroupPropsMixin = exports.CfnDBInstancePropsMixin = exports.CfnDBClusterParameterGroupPropsMixin = exports.CfnDBClusterPropsMixin = void 0;
+const jsiiDeprecationWarnings = require("../../../.warnings.jsii.js");
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+/* eslint-disable @stylistic/max-len, eol-last */
+const cdk = require("aws-cdk-lib/core");
+const service = require("aws-cdk-lib/aws-neptune");
+/**
+ * The `AWS::Neptune::DBCluster` resource creates an Amazon Neptune DB cluster. Neptune is a fully managed graph database.
+ *
+ * > Currently, you can create this resource only in AWS Regions in which Amazon Neptune is supported.
+ *
+ * If no `DeletionPolicy` is set for `AWS::Neptune::DBCluster` resources, the default deletion behavior is that the entire volume will be deleted without a snapshot. To retain a backup of the volume, the `DeletionPolicy` should be set to `Snapshot` . For more information about how CloudFormation deletes resources, see [DeletionPolicy Attribute](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-attribute-deletionpolicy.html) .
+ *
+ * You can use `AWS::Neptune::DBCluster.DeletionProtection` to help guard against unintended deletion of your DB cluster.
+ *
+ * @cloudformationResource AWS::Neptune::DBCluster
+ * @mixin true
+ * @stability external
+ * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-neptune-dbcluster.html
+ */
+class CfnDBClusterPropsMixin extends cdk.Mixin {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/cfn-property-mixins.aws_neptune.CfnDBClusterPropsMixin", version: "2.243.0" };
+    static CFN_PROPERTY_KEYS = ["associatedRoles", "availabilityZones", "backupRetentionPeriod", "copyTagsToSnapshot", "dbClusterIdentifier", "dbClusterParameterGroupName", "dbInstanceParameterGroupName", "dbPort", "dbSubnetGroupName", "deletionProtection", "enableCloudwatchLogsExports", "engineVersion", "iamAuthEnabled", "kmsKeyId", "preferredBackupWindow", "preferredMaintenanceWindow", "restoreToTime", "restoreType", "serverlessScalingConfiguration", "snapshotIdentifier", "sourceDbClusterIdentifier", "storageEncrypted", "tags", "useLatestRestorableTime", "vpcSecurityGroupIds"];
+    props;
+    strategy;
+    /**
+     * Create a mixin to apply properties to `AWS::Neptune::DBCluster`.
+     *
+     * @param props L1 properties to apply
+     * @param options Mixin options
+     */
+    constructor(props, options = {}) {
+        super();
+        try {
+            jsiiDeprecationWarnings._aws_cdk_cfn_property_mixins_aws_neptune_CfnDBClusterMixinProps(props);
+            jsiiDeprecationWarnings._aws_cdk_cfn_property_mixins_CfnPropertyMixinOptions(options);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, CfnDBClusterPropsMixin);
+            }
+            throw error;
+        }
+        this.props = {
+            ...props,
+            ...flattenCfnDBClusterMixinProps(props)
+        };
+        this.strategy = (options.strategy ?? cdk.PropertyMergeStrategy.combine());
+    }
+    /**
+     * Check if this mixin supports the given construct
+     */
+    supports(construct) {
+        return (cdk.CfnResource.isCfnResource(construct) && service.CfnDBCluster.isCfnDBCluster(construct));
+    }
+    /**
+     * Apply the mixin properties to the construct
+     */
+    applyTo(construct) {
+        if (this.supports(construct)) {
+            this.strategy.apply(construct, this.props, CfnDBClusterPropsMixin.CFN_PROPERTY_KEYS);
+        }
+    }
+}
+exports.CfnDBClusterPropsMixin = CfnDBClusterPropsMixin;
+// @ts-ignore TS6133
+function flattenCfnDBClusterPropsMixinDBClusterRoleProperty(props) {
+    if (cdk.isResolvableObject(props))
+        return props;
+    return {
+        featureName: (!props.featureName ? undefined : props.featureName),
+        roleArn: (!props.roleArn ? undefined : cdk.getRefProperty(props.roleArn?.roleRef, 'roleArn') ?? cdk.ensureStringOrUndefined(props.roleArn, "roleArn", "iam.IRoleRef | string"))
+    };
+}
+// @ts-ignore TS6133
+function flattenCfnDBClusterMixinProps(props) {
+    const ret = {};
+    if ((props.associatedRoles !== undefined))
+        ret.associatedRoles = (cdk.isResolvableObject(props.associatedRoles) ? props.associatedRoles : cdk.mapArrayInPlace(props.associatedRoles, (item) => flattenCfnDBClusterPropsMixinDBClusterRoleProperty(item)));
+    if ((props.kmsKeyId !== undefined))
+        ret.kmsKeyId = cdk.getRefProperty(props.kmsKeyId?.keyRef, 'keyArn') ?? cdk.getRefProperty(props.kmsKeyId?.keyRef, 'keyId') ?? cdk.ensureStringOrUndefined(props.kmsKeyId, "kmsKeyId", "kms.IKeyRef | string");
+    if ((props.vpcSecurityGroupIds !== undefined))
+        ret.vpcSecurityGroupIds = cdk.mapArrayInPlace(props.vpcSecurityGroupIds, (item) => cdk.getRefProperty(item?.securityGroupRef, 'securityGroupId') ?? cdk.ensureStringOrUndefined(item, "vpcSecurityGroupIds", "ec2.ISecurityGroupRef | string"));
+    return ret;
+}
+/**
+ * The `AWS::Neptune::DBClusterParameterGroup` resource creates a new Amazon Neptune DB cluster parameter group.
+ *
+ * > Applying a parameter group to a DB cluster might require instances to reboot, resulting in a database outage while the instances reboot. > If you provide a custom `DBClusterParameterGroup` that you associate with the `DBCluster` , it is best to specify an `EngineVersion` property in the `DBCluster` . That `EngineVersion` needs to be compatible with the value of the `Family` property in the `DBClusterParameterGroup` .
+ *
+ * @cloudformationResource AWS::Neptune::DBClusterParameterGroup
+ * @mixin true
+ * @stability external
+ * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-neptune-dbclusterparametergroup.html
+ */
+class CfnDBClusterParameterGroupPropsMixin extends cdk.Mixin {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/cfn-property-mixins.aws_neptune.CfnDBClusterParameterGroupPropsMixin", version: "2.243.0" };
+    static CFN_PROPERTY_KEYS = ["description", "family", "name", "parameters", "tags"];
+    props;
+    strategy;
+    /**
+     * Create a mixin to apply properties to `AWS::Neptune::DBClusterParameterGroup`.
+     *
+     * @param props L1 properties to apply
+     * @param options Mixin options
+     */
+    constructor(props, options = {}) {
+        super();
+        try {
+            jsiiDeprecationWarnings._aws_cdk_cfn_property_mixins_aws_neptune_CfnDBClusterParameterGroupMixinProps(props);
+            jsiiDeprecationWarnings._aws_cdk_cfn_property_mixins_CfnPropertyMixinOptions(options);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, CfnDBClusterParameterGroupPropsMixin);
+            }
+            throw error;
+        }
+        this.props = props;
+        this.strategy = (options.strategy ?? cdk.PropertyMergeStrategy.combine());
+    }
+    /**
+     * Check if this mixin supports the given construct
+     */
+    supports(construct) {
+        return (cdk.CfnResource.isCfnResource(construct) && service.CfnDBClusterParameterGroup.isCfnDBClusterParameterGroup(construct));
+    }
+    /**
+     * Apply the mixin properties to the construct
+     */
+    applyTo(construct) {
+        if (this.supports(construct)) {
+            this.strategy.apply(construct, this.props, CfnDBClusterParameterGroupPropsMixin.CFN_PROPERTY_KEYS);
+        }
+    }
+}
+exports.CfnDBClusterParameterGroupPropsMixin = CfnDBClusterParameterGroupPropsMixin;
+/**
+ * The `AWS::Neptune::DBInstance` type creates an Amazon Neptune DB instance.
+ *
+ * *Updating DB Instances*
+ *
+ * You can set a deletion policy for your DB instance to control how CloudFormation handles the instance when the stack is deleted. For Neptune DB instances, you can choose to *retain* the instance, to *delete* the instance, or to *create a snapshot* of the instance. The default CloudFormation behavior depends on the `DBClusterIdentifier` property:
+ *
+ * - For `AWS::Neptune::DBInstance` resources that don't specify the `DBClusterIdentifier` property, CloudFormation saves a snapshot of the DB instance.
+ * - For `AWS::Neptune::DBInstance` resources that do specify the `DBClusterIdentifier` property, CloudFormation deletes the DB instance.
+ *
+ * *Deleting DB Instances*
+ *
+ * > If a DB instance is deleted or replaced during an update, CloudFormation deletes all automated snapshots. However, it retains manual DB snapshots. During an update that requires replacement, you can apply a stack policy to prevent DB instances from being replaced.
+ *
+ * When properties labeled *Update requires: Replacement* are updated, CloudFormation first creates a replacement DB instance, changes references from other dependent resources to point to the replacement DB instance, and finally deletes the old DB instance.
+ *
+ * > We highly recommend that you take a snapshot of the database before updating the stack. If you don't, you lose the data when CloudFormation replaces your DB instance. To preserve your data, perform the following procedure:
+ * >
+ * > - Deactivate any applications that are using the DB instance so that there's no activity on the DB instance.
+ * > - Create a snapshot of the DB instance.
+ * > - If you want to restore your instance using a DB snapshot, modify the updated template with your DB instance changes and add the `DBSnapshotIdentifier` property with the ID of the DB snapshot that you want to use.
+ * > - Update the stack.
+ *
+ * @cloudformationResource AWS::Neptune::DBInstance
+ * @mixin true
+ * @stability external
+ * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-neptune-dbinstance.html
+ */
+class CfnDBInstancePropsMixin extends cdk.Mixin {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/cfn-property-mixins.aws_neptune.CfnDBInstancePropsMixin", version: "2.243.0" };
+    static CFN_PROPERTY_KEYS = ["allowMajorVersionUpgrade", "autoMinorVersionUpgrade", "availabilityZone", "dbClusterIdentifier", "dbInstanceClass", "dbInstanceIdentifier", "dbParameterGroupName", "dbSnapshotIdentifier", "dbSubnetGroupName", "preferredMaintenanceWindow", "publiclyAccessible", "tags"];
+    props;
+    strategy;
+    /**
+     * Create a mixin to apply properties to `AWS::Neptune::DBInstance`.
+     *
+     * @param props L1 properties to apply
+     * @param options Mixin options
+     */
+    constructor(props, options = {}) {
+        super();
+        try {
+            jsiiDeprecationWarnings._aws_cdk_cfn_property_mixins_aws_neptune_CfnDBInstanceMixinProps(props);
+            jsiiDeprecationWarnings._aws_cdk_cfn_property_mixins_CfnPropertyMixinOptions(options);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, CfnDBInstancePropsMixin);
+            }
+            throw error;
+        }
+        this.props = props;
+        this.strategy = (options.strategy ?? cdk.PropertyMergeStrategy.combine());
+    }
+    /**
+     * Check if this mixin supports the given construct
+     */
+    supports(construct) {
+        return (cdk.CfnResource.isCfnResource(construct) && service.CfnDBInstance.isCfnDBInstance(construct));
+    }
+    /**
+     * Apply the mixin properties to the construct
+     */
+    applyTo(construct) {
+        if (this.supports(construct)) {
+            this.strategy.apply(construct, this.props, CfnDBInstancePropsMixin.CFN_PROPERTY_KEYS);
+        }
+    }
+}
+exports.CfnDBInstancePropsMixin = CfnDBInstancePropsMixin;
+/**
+ * `AWS::Neptune::DBParameterGroup` creates a new DB parameter group.
+ *
+ * This type can be declared in a template and referenced in the `DBParameterGroupName` parameter of `AWS::Neptune::DBInstance` .
+ *
+ * > Applying a parameter group to a DB instance might require the instance to reboot, resulting in a database outage for the duration of the reboot. > If you provide a custom `DBParameterGroup` that you associate with `DBInstance` , it is best to specify an `EngineVersion` property in `DBCluster` . That `EngineVersion` needs to be compatible with the value of the `Family` property in the `DBParameterGroup` .
+ *
+ * A DB parameter group is initially created with the default parameters for the database engine used by the DB instance. To provide custom values for any of the parameters, you must modify the group after creating it using *ModifyDBParameterGroup* . Once you've created a DB parameter group, you need to associate it with your DB instance using *ModifyDBInstance* . When you associate a new DB parameter group with a running DB instance, you need to reboot the DB instance without failover for the new DB parameter group and associated settings to take effect.
+ *
+ * > After you create a DB parameter group, you should wait at least 5 minutes before creating your first DB instance that uses that DB parameter group as the default parameter group. This allows Amazon Neptune to fully complete the create action before the parameter group is used as the default for a new DB instance. This is especially important for parameters that are critical when creating the default database for a DB instance, such as the character set for the default database defined by the `character_set_database` parameter. You can use the *Parameter Groups* option of the Amazon Neptune console or the *DescribeDBParameters* command to verify that your DB parameter group has been created or modified.
+ *
+ * @cloudformationResource AWS::Neptune::DBParameterGroup
+ * @mixin true
+ * @stability external
+ * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-neptune-dbparametergroup.html
+ */
+class CfnDBParameterGroupPropsMixin extends cdk.Mixin {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/cfn-property-mixins.aws_neptune.CfnDBParameterGroupPropsMixin", version: "2.243.0" };
+    static CFN_PROPERTY_KEYS = ["description", "family", "name", "parameters", "tags"];
+    props;
+    strategy;
+    /**
+     * Create a mixin to apply properties to `AWS::Neptune::DBParameterGroup`.
+     *
+     * @param props L1 properties to apply
+     * @param options Mixin options
+     */
+    constructor(props, options = {}) {
+        super();
+        try {
+            jsiiDeprecationWarnings._aws_cdk_cfn_property_mixins_aws_neptune_CfnDBParameterGroupMixinProps(props);
+            jsiiDeprecationWarnings._aws_cdk_cfn_property_mixins_CfnPropertyMixinOptions(options);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, CfnDBParameterGroupPropsMixin);
+            }
+            throw error;
+        }
+        this.props = props;
+        this.strategy = (options.strategy ?? cdk.PropertyMergeStrategy.combine());
+    }
+    /**
+     * Check if this mixin supports the given construct
+     */
+    supports(construct) {
+        return (cdk.CfnResource.isCfnResource(construct) && service.CfnDBParameterGroup.isCfnDBParameterGroup(construct));
+    }
+    /**
+     * Apply the mixin properties to the construct
+     */
+    applyTo(construct) {
+        if (this.supports(construct)) {
+            this.strategy.apply(construct, this.props, CfnDBParameterGroupPropsMixin.CFN_PROPERTY_KEYS);
+        }
+    }
+}
+exports.CfnDBParameterGroupPropsMixin = CfnDBParameterGroupPropsMixin;
+/**
+ * The `AWS::Neptune::DBSubnetGroup` type creates an Amazon Neptune DB subnet group.
+ *
+ * Subnet groups must contain at least two subnets in two different Availability Zones in the same AWS Region.
+ *
+ * @cloudformationResource AWS::Neptune::DBSubnetGroup
+ * @mixin true
+ * @stability external
+ * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-neptune-dbsubnetgroup.html
+ */
+class CfnDBSubnetGroupPropsMixin extends cdk.Mixin {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/cfn-property-mixins.aws_neptune.CfnDBSubnetGroupPropsMixin", version: "2.243.0" };
+    static CFN_PROPERTY_KEYS = ["dbSubnetGroupDescription", "dbSubnetGroupName", "subnetIds", "tags"];
+    props;
+    strategy;
+    /**
+     * Create a mixin to apply properties to `AWS::Neptune::DBSubnetGroup`.
+     *
+     * @param props L1 properties to apply
+     * @param options Mixin options
+     */
+    constructor(props, options = {}) {
+        super();
+        try {
+            jsiiDeprecationWarnings._aws_cdk_cfn_property_mixins_aws_neptune_CfnDBSubnetGroupMixinProps(props);
+            jsiiDeprecationWarnings._aws_cdk_cfn_property_mixins_CfnPropertyMixinOptions(options);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, CfnDBSubnetGroupPropsMixin);
+            }
+            throw error;
+        }
+        this.props = props;
+        this.strategy = (options.strategy ?? cdk.PropertyMergeStrategy.combine());
+    }
+    /**
+     * Check if this mixin supports the given construct
+     */
+    supports(construct) {
+        return (cdk.CfnResource.isCfnResource(construct) && service.CfnDBSubnetGroup.isCfnDBSubnetGroup(construct));
+    }
+    /**
+     * Apply the mixin properties to the construct
+     */
+    applyTo(construct) {
+        if (this.supports(construct)) {
+            this.strategy.apply(construct, this.props, CfnDBSubnetGroupPropsMixin.CFN_PROPERTY_KEYS);
+        }
+    }
+}
+exports.CfnDBSubnetGroupPropsMixin = CfnDBSubnetGroupPropsMixin;
+/**
+ * Creates an event notification subscription.
+ *
+ * This action requires a topic ARN (Amazon Resource Name) created by either the Neptune console, the SNS console, or the SNS API. To obtain an ARN with SNS, you must create a topic in Amazon SNS and subscribe to the topic. The ARN is displayed in the SNS console.
+ *
+ * You can specify the type of source (SourceType) you want to be notified of, provide a list of Neptune sources (SourceIds) that triggers the events, and provide a list of event categories (EventCategories) for events you want to be notified of. For example, you can specify SourceType = db-instance, SourceIds = mydbinstance1, mydbinstance2 and EventCategories = Availability, Backup.
+ *
+ * If you specify both the SourceType and SourceIds, such as SourceType = db-instance and SourceIdentifier = myDBInstance1, you are notified of all the db-instance events for the specified source. If you specify a SourceType but do not specify a SourceIdentifier, you receive notice of the events for that source type for all your Neptune sources. If you do not specify either the SourceType nor the SourceIdentifier, you are notified of events generated from all Neptune sources belonging to your customer account.
+ *
+ * @cloudformationResource AWS::Neptune::EventSubscription
+ * @mixin true
+ * @stability external
+ * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-neptune-eventsubscription.html
+ */
+class CfnEventSubscriptionPropsMixin extends cdk.Mixin {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/cfn-property-mixins.aws_neptune.CfnEventSubscriptionPropsMixin", version: "2.243.0" };
+    static CFN_PROPERTY_KEYS = ["enabled", "eventCategories", "snsTopicArn", "sourceIds", "sourceType", "subscriptionName", "tags"];
+    props;
+    strategy;
+    /**
+     * Create a mixin to apply properties to `AWS::Neptune::EventSubscription`.
+     *
+     * @param props L1 properties to apply
+     * @param options Mixin options
+     */
+    constructor(props, options = {}) {
+        super();
+        try {
+            jsiiDeprecationWarnings._aws_cdk_cfn_property_mixins_aws_neptune_CfnEventSubscriptionMixinProps(props);
+            jsiiDeprecationWarnings._aws_cdk_cfn_property_mixins_CfnPropertyMixinOptions(options);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, CfnEventSubscriptionPropsMixin);
+            }
+            throw error;
+        }
+        this.props = props;
+        this.strategy = (options.strategy ?? cdk.PropertyMergeStrategy.combine());
+    }
+    /**
+     * Check if this mixin supports the given construct
+     */
+    supports(construct) {
+        return (cdk.CfnResource.isCfnResource(construct) && service.CfnEventSubscription.isCfnEventSubscription(construct));
+    }
+    /**
+     * Apply the mixin properties to the construct
+     */
+    applyTo(construct) {
+        if (this.supports(construct)) {
+            this.strategy.apply(construct, this.props, CfnEventSubscriptionPropsMixin.CFN_PROPERTY_KEYS);
+        }
+    }
+}
+exports.CfnEventSubscriptionPropsMixin = CfnEventSubscriptionPropsMixin;

package/lib/services/aws-neptune/index.d.ts

@@ -0,0 +1 @@
+export * from './cfn-props-mixins.generated';

package/lib/services/aws-neptune/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./cfn-props-mixins.generated"), exports);

package/lib/services/aws-neptunegraph/.jsiirc.json

@@ -0,0 +1,13 @@
+{
+  "targets": {
+    "java": {
+      "package": "software.amazon.awscdk.cfnpropertymixins.services.neptunegraph"
+    },
+    "dotnet": {
+      "namespace": "Amazon.CDK.CfnPropertyMixins.AWS.NeptuneGraph"
+    },
+    "python": {
+      "module": "aws_cdk.cfn_property_mixins.aws_neptunegraph"
+    }
+  }
+}

package/lib/services/aws-neptunegraph/cfn-props-mixins.generated.d.ts

@@ -0,0 +1,189 @@
+import * as cdk from "aws-cdk-lib/core";
+import * as constructs from "constructs";
+import * as mixins from "../../mixins";
+import * as service from "aws-cdk-lib/aws-neptunegraph";
+/**
+ * The `AWS ::NeptuneGraph::Graph` resource creates an  graph.
+ *
+ * is a memory-optimized graph database engine for analytics. For more information, see [](https://docs.aws.amazon.com/neptune-analytics/latest/userguide/what-is-neptune-analytics.html) .
+ *
+ * You can use `AWS ::NeptuneGraph::Graph.DeletionProtection` to help guard against unintended deletion of your graph.
+ *
+ * @cloudformationResource AWS::NeptuneGraph::Graph
+ * @mixin true
+ * @stability external
+ * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-neptunegraph-graph.html
+ */
+export declare class CfnGraphPropsMixin extends cdk.Mixin implements constructs.IMixin {
+    protected static readonly CFN_PROPERTY_KEYS: Array<string>;
+    protected readonly props: CfnGraphMixinProps;
+    protected readonly strategy: cdk.IMergeStrategy;
+    /**
+     * Create a mixin to apply properties to `AWS::NeptuneGraph::Graph`.
+     *
+     * @param props L1 properties to apply
+     * @param options Mixin options
+     */
+    constructor(props: CfnGraphMixinProps, options?: mixins.CfnPropertyMixinOptions);
+    /**
+     * Check if this mixin supports the given construct
+     */
+    supports(construct: constructs.IConstruct): construct is service.CfnGraph;
+    /**
+     * Apply the mixin properties to the construct
+     */
+    applyTo(construct: constructs.IConstruct): void;
+}
+export declare namespace CfnGraphPropsMixin {
+    /**
+     * The vector-search configuration for the graph, which specifies the vector dimension to use in the vector index, if any.
+     *
+     * @struct
+     * @stability external
+     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-neptunegraph-graph-vectorsearchconfiguration.html
+     */
+    interface VectorSearchConfigurationProperty {
+        /**
+         * The number of dimensions.
+         *
+         * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-neptunegraph-graph-vectorsearchconfiguration.html#cfn-neptunegraph-graph-vectorsearchconfiguration-vectorsearchdimension
+         */
+        readonly vectorSearchDimension?: number;
+    }
+}
+/**
+ * Properties for CfnGraphPropsMixin
+ *
+ * @struct
+ * @stability external
+ * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-neptunegraph-graph.html
+ */
+export interface CfnGraphMixinProps {
+    /**
+     * A value that indicates whether the graph has deletion protection enabled.
+     *
+     * The graph can't be deleted when deletion protection is enabled.
+     *
+     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-neptunegraph-graph.html#cfn-neptunegraph-graph-deletionprotection
+     */
+    readonly deletionProtection?: boolean | cdk.IResolvable;
+    /**
+     * The graph name. For example: `my-graph-1` .
+     *
+     * The name must contain from 1 to 63 letters, numbers, or hyphens, and its first character must be a letter. It cannot end with a hyphen or contain two consecutive hyphens.
+     *
+     * If you don't specify a graph name, a unique graph name is generated for you using the prefix `graph-for` , followed by a combination of `Stack Name` and a `UUID` .
+     *
+     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-neptunegraph-graph.html#cfn-neptunegraph-graph-graphname
+     */
+    readonly graphName?: string;
+    /**
+     * The provisioned memory-optimized Neptune Capacity Units (m-NCUs) to use for the graph.
+     *
+     * Min = 16
+     *
+     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-neptunegraph-graph.html#cfn-neptunegraph-graph-provisionedmemory
+     */
+    readonly provisionedMemory?: number;
+    /**
+     * Specifies whether or not the graph can be reachable over the internet. All access to graphs is IAM authenticated.
+     *
+     * When the graph is publicly available, its domain name system (DNS) endpoint resolves to the public IP address from the internet. When the graph isn't publicly available, you need to create a `PrivateGraphEndpoint` in a given VPC to ensure the DNS name resolves to a private IP address that is reachable from the VPC.
+     *
+     * Default: If not specified, the default value is false.
+     *
+     * > If enabling public connectivity for the first time, there will be a delay while it is enabled.
+     *
+     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-neptunegraph-graph.html#cfn-neptunegraph-graph-publicconnectivity
+     */
+    readonly publicConnectivity?: boolean | cdk.IResolvable;
+    /**
+     * The number of replicas in other AZs.
+     *
+     * Default: If not specified, the default value is 1.
+     *
+     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-neptunegraph-graph.html#cfn-neptunegraph-graph-replicacount
+     */
+    readonly replicaCount?: number;
+    /**
+     * Adds metadata tags to the new graph.
+     *
+     * These tags can also be used with cost allocation reporting, or used in a Condition statement in an IAM policy.
+     *
+     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-neptunegraph-graph.html#cfn-neptunegraph-graph-tags
+     */
+    readonly tags?: Array<cdk.CfnTag>;
+    /**
+     * Specifies the number of dimensions for vector embeddings that will be loaded into the graph.
+     *
+     * The value is specified as `dimension=` value. Max = 65,535
+     *
+     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-neptunegraph-graph.html#cfn-neptunegraph-graph-vectorsearchconfiguration
+     */
+    readonly vectorSearchConfiguration?: cdk.IResolvable | CfnGraphPropsMixin.VectorSearchConfigurationProperty;
+}
+/**
+ * Create a private graph endpoint to allow private access from to the graph from within a VPC.
+ *
+ * You can attach security groups to the private graph endpoint.
+ *
+ * > VPC endpoint charges apply.
+ *
+ * @cloudformationResource AWS::NeptuneGraph::PrivateGraphEndpoint
+ * @mixin true
+ * @stability external
+ * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-neptunegraph-privategraphendpoint.html
+ */
+export declare class CfnPrivateGraphEndpointPropsMixin extends cdk.Mixin implements constructs.IMixin {
+    protected static readonly CFN_PROPERTY_KEYS: Array<string>;
+    protected readonly props: CfnPrivateGraphEndpointMixinProps;
+    protected readonly strategy: cdk.IMergeStrategy;
+    /**
+     * Create a mixin to apply properties to `AWS::NeptuneGraph::PrivateGraphEndpoint`.
+     *
+     * @param props L1 properties to apply
+     * @param options Mixin options
+     */
+    constructor(props: CfnPrivateGraphEndpointMixinProps, options?: mixins.CfnPropertyMixinOptions);
+    /**
+     * Check if this mixin supports the given construct
+     */
+    supports(construct: constructs.IConstruct): construct is service.CfnPrivateGraphEndpoint;
+    /**
+     * Apply the mixin properties to the construct
+     */
+    applyTo(construct: constructs.IConstruct): void;
+}
+/**
+ * Properties for CfnPrivateGraphEndpointPropsMixin
+ *
+ * @struct
+ * @stability external
+ * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-neptunegraph-privategraphendpoint.html
+ */
+export interface CfnPrivateGraphEndpointMixinProps {
+    /**
+     * The unique identifier of the Neptune Analytics graph.
+     *
+     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-neptunegraph-privategraphendpoint.html#cfn-neptunegraph-privategraphendpoint-graphidentifier
+     */
+    readonly graphIdentifier?: string;
+    /**
+     * Security groups to be attached to the private graph endpoint..
+     *
+     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-neptunegraph-privategraphendpoint.html#cfn-neptunegraph-privategraphendpoint-securitygroupids
+     */
+    readonly securityGroupIds?: Array<string>;
+    /**
+     * Subnets in which private graph endpoint ENIs are created.
+     *
+     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-neptunegraph-privategraphendpoint.html#cfn-neptunegraph-privategraphendpoint-subnetids
+     */
+    readonly subnetIds?: Array<string>;
+    /**
+     * The VPC in which the private graph endpoint needs to be created.
+     *
+     * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-neptunegraph-privategraphendpoint.html#cfn-neptunegraph-privategraphendpoint-vpcid
+     */
+    readonly vpcId?: string;
+}