export interface VectorSearchConfiguration {
    /** The number of dimensions. */
    dimension: number;
}
export interface NeptuneImportOptions {
    /** The path to an S3 bucket from which to import data. */
    s3ExportPath: string;
    /** The KMS key to use to encrypt data in the S3 bucket where the graph data is exported */
    s3ExportKmsKeyId: string;
    /** Neptune Analytics supports label-less vertices and no labels are assigned unless one is explicitly provided. Neptune assigns default labels when none is explicitly provided. When importing the data in */
    preserveDefaultVertexLabels?: boolean;
    /** Neptune Analytics currently does not support user defined edge ids. The edge ids are not imported by default. They are imported if preserveEdgeIds is set to true, and ids are stored as properties on t */
    preserveEdgeIds?: boolean;
}
export interface ExportFilter {
    /** Used to specify filters on a per-label basis for vertices. This allows you to control which vertex labels and properties are included in the export. */
    vertexFilter?: Record<string, any>;
    /** Used to specify filters on a per-label basis for edges. This allows you to control which edge labels and properties are included in the export. */
    edgeFilter?: Record<string, any>;
}
export interface CancelExportTaskInput {
    /** The unique identifier of the export task. */
    taskIdentifier: string;
}
export interface CancelImportTaskInput {
    /** The unique identifier of the import task. */
    taskIdentifier: string;
}
export interface CancelQueryInput {
    /** The unique identifier of the Neptune Analytics graph. */
    graphIdentifier: string;
    /** The unique identifier of the query to cancel. */
    queryId: string;
}
export interface CreateGraphInput {
    /** A name for the new Neptune Analytics graph to be created. 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 cont */
    graphName: string;
    /** The provisioned memory-optimized Neptune Capacity Units (m-NCUs) to use for the graph. Min = 16 */
    provisionedMemory: number;
    /** Indicates whether or not to enable deletion protection on the graph. The graph can’t be deleted when deletion protection is enabled. (true or false). */
    deletionProtection?: boolean;
    /** Specifies a KMS key to use to encrypt data in the new graph. */
    kmsKeyIdentifier?: string;
    /** Specifies whether or not the graph can be reachable over the internet. All access to graphs is IAM authenticated. (true to enable, or false to disable. */
    publicConnectivity?: boolean;
    /** The number of replicas in other AZs. Min =0, Max = 2, Default = 1. Additional charges equivalent to the m-NCUs selected for the graph apply for each replica. */
    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. */
    tags?: Record<string, string>;
    /** 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 */
    vectorSearchConfiguration?: VectorSearchConfiguration;
}
export interface CreateGraphSnapshotInput {
    /** The unique identifier of the Neptune Analytics graph. */
    graphIdentifier: string;
    /** The snapshot name. For example: my-snapshot-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 con */
    snapshotName: string;
    /** 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. */
    tags?: Record<string, string>;
}
export interface CreateGraphUsingImportTaskInput {
    /** A name for the new Neptune Analytics graph to be created. 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 cont */
    graphName: string;
    /** The ARN of the IAM role that will allow access to the data that is to be imported. */
    roleArn: string;
    /** A URL identifying to the location of the data to be imported. This can be an Amazon S3 path, or can point to a Neptune database endpoint or snapshot. */
    source: string;
    /** The method to handle blank nodes in the dataset. Currently, only convertToIri is supported, meaning blank nodes are converted to unique IRIs at load time. Must be provided when format is ntriples. For */
    blankNodeHandling?: 'convertToIri';
    /** Indicates whether or not to enable deletion protection on the graph. The graph can’t be deleted when deletion protection is enabled. (true or false). */
    deletionProtection?: boolean;
    /** If set to true, the task halts when an import error is encountered. If set to false, the task skips the data that caused the error and continues if possible. */
    failOnError?: boolean;
    /** Specifies the format of S3 data to be imported. Valid values are CSV, which identifies the Gremlin CSV format, OPEN_CYPHER, which identifies the openCypher load format, or ntriples, which identifies t */
    format?: 'CSV' | 'OPEN_CYPHER' | 'PARQUET' | 'NTRIPLES';
    /** Contains options for controlling the import process. For example, if the failOnError key is set to false, the import skips problem data and attempts to continue (whereas if set to true, the default, o */
    importOptions?: {
        neptune?: NeptuneImportOptions;
    };
    /** Specifies a KMS key to use to encrypt data imported into the new graph. */
    kmsKeyIdentifier?: string;
    /** The maximum provisioned memory-optimized Neptune Capacity Units (m-NCUs) to use for the graph. Default: 1024, or the approved upper limit for your account. If both the minimum and maximum values are s */
    maxProvisionedMemory?: number;
    /** The minimum provisioned memory-optimized Neptune Capacity Units (m-NCUs) to use for the graph. Default: 16 */
    minProvisionedMemory?: number;
    /** The parquet type of the import task. */
    parquetType?: 'COLUMNAR';
    /** Specifies whether or not the graph can be reachable over the internet. All access to graphs is IAM authenticated. (true to enable, or false to disable). */
    publicConnectivity?: boolean;
    /** The number of replicas in other AZs to provision on the new graph after import. Default = 0, Min = 0, Max = 2. Additional charges equivalent to the m-NCUs selected for the graph apply for each replica */
    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. */
    tags?: Record<string, string>;
    /** 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 */
    vectorSearchConfiguration?: VectorSearchConfiguration;
}
export interface CreatePrivateGraphEndpointInput {
    /** The unique identifier of the Neptune Analytics graph. */
    graphIdentifier: string;
    /** Subnets in which private graph endpoint ENIs are created. */
    subnetIds?: string[];
    /** The VPC in which the private graph endpoint needs to be created. */
    vpcId?: string;
    /** Security groups to be attached to the private graph endpoint. */
    vpcSecurityGroupIds?: string[];
}
export interface DeleteGraphInput {
    /** The unique identifier of the Neptune Analytics graph. */
    graphIdentifier: string;
    /** Determines whether a final graph snapshot is created before the graph is deleted. If true is specified, no graph snapshot is created. If false is specified, a graph snapshot is created before the grap */
    skipSnapshot: boolean;
}
export interface DeleteGraphSnapshotInput {
    /** ID of the graph snapshot to be deleted. */
    snapshotIdentifier: string;
}
export interface DeletePrivateGraphEndpointInput {
    /** The unique identifier of the Neptune Analytics graph. */
    graphIdentifier: string;
    /** The ID of the VPC where the private endpoint is located. */
    vpcId: string;
}
export interface ExecuteQueryInput {
    /** The unique identifier of the Neptune Analytics graph. */
    graphIdentifier: string;
    /** The query language the query is written in. Currently only openCypher is supported. */
    language: 'OPEN_CYPHER';
    /** The query string to be executed. */
    queryString: string;
    /** The explain mode parameter returns a query explain instead of the actual query results. A query explain can be used to gather insights about the query execution such as planning decisions, time spent  */
    explainMode?: 'STATIC' | 'DETAILS';
    /** The data parameters the query can use in JSON format. For example: {"name": "john", "age": 20}. (optional) */
    parameters?: Record<string, any>;
    /** Query plan cache is a feature that saves the query plan and reuses it on successive executions of the same query. This reduces query latency, and works for both READ and UPDATE queries. The plan cache */
    planCache?: 'ENABLED' | 'DISABLED' | 'AUTO';
    /** Specifies the query timeout duration, in milliseconds. (optional) */
    queryTimeoutMilliseconds?: number;
}
export interface GetExportTaskInput {
    /** The unique identifier of the export task. */
    taskIdentifier: string;
}
export interface GetGraphInput {
    /** The unique identifier of the Neptune Analytics graph. */
    graphIdentifier: string;
}
export interface GetGraphSnapshotInput {
    /** The ID of the snapshot to retrieve. */
    snapshotIdentifier: string;
}
export interface GetGraphSummaryInput {
    /** The unique identifier of the Neptune Analytics graph. */
    graphIdentifier: string;
    /** The summary mode can take one of two values: basic (the default), and detailed. */
    mode?: 'BASIC' | 'DETAILED';
}
export interface GetImportTaskInput {
    /** The unique identifier of the import task. */
    taskIdentifier: string;
}
export interface GetPrivateGraphEndpointInput {
    /** The unique identifier of the Neptune Analytics graph. */
    graphIdentifier: string;
    /** The ID of the VPC where the private endpoint is located. */
    vpcId: string;
}
export interface GetQueryInput {
    /** The unique identifier of the Neptune Analytics graph. */
    graphIdentifier: string;
    /** The ID of the query in question. */
    queryId: string;
}
export interface ListExportTasksInput {
    /** The unique identifier of the Neptune Analytics graph. */
    graphIdentifier?: string;
    /** The maximum number of export tasks to return. */
    maxResults?: number;
    /** Pagination token used to paginate input. */
    nextToken?: string;
}
export interface ListGraphsInput {
    /** The total number of records to return in the command's output. If the total number of records available is more than the value specified, nextToken is provided in the command's output. To resume pagin */
    maxResults?: number;
    /** Pagination token used to paginate output. When this value is provided as input, the service returns results from where the previous response left off. When this value is present in output, it indicate */
    nextToken?: string;
}
export interface ListGraphSnapshotsInput {
    /** The unique identifier of the Neptune Analytics graph. */
    graphIdentifier?: string;
    /** The total number of records to return in the command's output. If the total number of records available is more than the value specified, nextToken is provided in the command's output. To resume pagin */
    maxResults?: number;
    /** Pagination token used to paginate output. When this value is provided as input, the service returns results from where the previous response left off. When this value is present in output, it indicate */
    nextToken?: string;
}
export interface ListImportTasksInput {
    /** The total number of records to return in the command's output. If the total number of records available is more than the value specified, nextToken is provided in the command's output. To resume pagin */
    maxResults?: number;
    /** Pagination token used to paginate output. When this value is provided as input, the service returns results from where the previous response left off. When this value is present in output, it indicate */
    nextToken?: string;
}
export interface ListPrivateGraphEndpointsInput {
    /** The unique identifier of the Neptune Analytics graph. */
    graphIdentifier: string;
    /** The total number of records to return in the command's output. If the total number of records available is more than the value specified, nextToken is provided in the command's output. To resume pagin */
    maxResults?: number;
    /** Pagination token used to paginate output. When this value is provided as input, the service returns results from where the previous response left off. When this value is present in output, it indicate */
    nextToken?: string;
}
export interface ListQueriesInput {
    /** The unique identifier of the Neptune Analytics graph. */
    graphIdentifier: string;
    /** The maximum number of results to be fetched by the API. */
    maxResults: number;
    /** Filtered list of queries based on state. */
    state?: 'ALL' | 'RUNNING' | 'WAITING' | 'CANCELLING';
}
export interface ListTagsForResourceInput {
    /** The ARN of the resource. */
    resourceArn: string;
}
export interface ResetGraphInput {
    /** ID of the graph to reset. */
    graphIdentifier: string;
    /** Determines whether a final graph snapshot is created before the graph data is deleted. If set to true, no graph snapshot is created. If set to false, a graph snapshot is created before the data is del */
    skipSnapshot: boolean;
}
export interface RestoreGraphFromSnapshotInput {
    /** A name for the new Neptune Analytics graph to be created from the snapshot. The name must contain from 1 to 63 letters, numbers, or hyphens, and its first character must be a letter. It cannot end wit */
    graphName: string;
    /** The ID of the snapshot in question. */
    snapshotIdentifier: string;
    /** A value that indicates whether the graph has deletion protection enabled. The graph can't be deleted when deletion protection is enabled. */
    deletionProtection?: boolean;
    /** The provisioned memory-optimized Neptune Capacity Units (m-NCUs) to use for the graph. Min = 16 */
    provisionedMemory?: number;
    /** Specifies whether or not the graph can be reachable over the internet. All access to graphs is IAM authenticated. (true to enable, or false to disable). */
    publicConnectivity?: boolean;
    /** The number of replicas in other AZs. Min =0, Max = 2, Default =1 Additional charges equivalent to the m-NCUs selected for the graph apply for each replica. */
    replicaCount?: number;
    /** Adds metadata tags to the snapshot. These tags can also be used with cost allocation reporting, or used in a Condition statement in an IAM policy. */
    tags?: Record<string, string>;
}
export interface StartExportTaskInput {
    /** The Amazon S3 URI where data will be exported to. */
    destination: string;
    /** The format of the export task. */
    format: 'PARQUET' | 'CSV';
    /** The source graph identifier of the export task. */
    graphIdentifier: string;
    /** The KMS key identifier of the export task. */
    kmsKeyIdentifier: string;
    /** The ARN of the IAM role that will allow data to be exported to the destination. */
    roleArn: string;
    /** The export filter of the export task. */
    exportFilter?: ExportFilter;
    /** The parquet type of the export task. */
    parquetType?: 'COLUMNAR';
    /** Tags to be applied to the export task. */
    tags?: Record<string, string>;
}
export interface StartGraphInput {
    /** The unique identifier of the Neptune Analytics graph. */
    graphIdentifier: string;
}
export interface StartImportTaskInput {
    /** The unique identifier of the Neptune Analytics graph. */
    graphIdentifier: string;
    /** The ARN of the IAM role that will allow access to the data that is to be imported. */
    roleArn: string;
    /** A URL identifying the location of the data to be imported. This can be an Amazon S3 path, or can point to a Neptune database endpoint or snapshot. */
    source: string;
    /** The method to handle blank nodes in the dataset. Currently, only convertToIri is supported, meaning blank nodes are converted to unique IRIs at load time. Must be provided when format is ntriples. For */
    blankNodeHandling?: 'convertToIri';
    /** If set to true, the task halts when an import error is encountered. If set to false, the task skips the data that caused the error and continues if possible. */
    failOnError?: boolean;
    /** Specifies the format of Amazon S3 data to be imported. Valid values are CSV, which identifies the Gremlin CSV format or OPENCYPHER, which identifies the openCypher load format. */
    format?: 'CSV' | 'OPEN_CYPHER' | 'PARQUET' | 'NTRIPLES';
    importOptions?: {
        neptune?: NeptuneImportOptions;
    };
    /** The parquet type of the import task. */
    parquetType?: 'COLUMNAR';
}
export interface StopGraphInput {
    /** The unique identifier of the Neptune Analytics graph. */
    graphIdentifier: string;
}
export interface TagResourceInput {
    /** ARN of the resource for which tags need to be added. */
    resourceArn: string;
    /** The tags to be assigned to the Neptune Analytics resource. The tags are metadata that are specified as a list of key-value pairs: Key (string) – A key is the required name of the tag. The string value */
    tags: Record<string, string>;
}
export interface UntagResourceInput {
    /** ARN of the resource whose tag needs to be removed. */
    resourceArn: string;
    /** Tag keys for the tags to be removed. */
    tagKeys: string[];
}
export interface UpdateGraphInput {
    /** The unique identifier of the Neptune Analytics graph. */
    graphIdentifier: string;
    /** A value that indicates whether the graph has deletion protection enabled. The graph can't be deleted when deletion protection is enabled. */
    deletionProtection?: boolean;
    /** The provisioned memory-optimized Neptune Capacity Units (m-NCUs) to use for the graph. Min = 16 */
    provisionedMemory?: number;
    /** Specifies whether or not the graph can be reachable over the internet. All access to graphs is IAM authenticated. (true to enable, or false to disable. */
    publicConnectivity?: boolean;
}
/** Neptune Graph service binding for Step Functions SDK integrations. */
export declare class NeptuneGraph {
    constructor();
    cancelExportTask<T>(params: CancelExportTaskInput): Promise<T>;
    cancelImportTask<T>(params: CancelImportTaskInput): Promise<T>;
    cancelQuery<T>(params: CancelQueryInput): Promise<T>;
    createGraph<T>(params: CreateGraphInput): Promise<T>;
    createGraphSnapshot<T>(params: CreateGraphSnapshotInput): Promise<T>;
    createGraphUsingImportTask<T>(params: CreateGraphUsingImportTaskInput): Promise<T>;
    createPrivateGraphEndpoint<T>(params: CreatePrivateGraphEndpointInput): Promise<T>;
    deleteGraph<T>(params: DeleteGraphInput): Promise<T>;
    deleteGraphSnapshot<T>(params: DeleteGraphSnapshotInput): Promise<T>;
    deletePrivateGraphEndpoint<T>(params: DeletePrivateGraphEndpointInput): Promise<T>;
    executeQuery<T>(params: ExecuteQueryInput): Promise<T>;
    getExportTask<T>(params: GetExportTaskInput): Promise<T>;
    getGraph<T>(params: GetGraphInput): Promise<T>;
    getGraphSnapshot<T>(params: GetGraphSnapshotInput): Promise<T>;
    getGraphSummary<T>(params: GetGraphSummaryInput): Promise<T>;
    getImportTask<T>(params: GetImportTaskInput): Promise<T>;
    getPrivateGraphEndpoint<T>(params: GetPrivateGraphEndpointInput): Promise<T>;
    getQuery<T>(params: GetQueryInput): Promise<T>;
    listExportTasks<T>(params: ListExportTasksInput): Promise<T>;
    listGraphs<T>(params: ListGraphsInput): Promise<T>;
    listGraphSnapshots<T>(params: ListGraphSnapshotsInput): Promise<T>;
    listImportTasks<T>(params: ListImportTasksInput): Promise<T>;
    listPrivateGraphEndpoints<T>(params: ListPrivateGraphEndpointsInput): Promise<T>;
    listQueries<T>(params: ListQueriesInput): Promise<T>;
    listTagsForResource<T>(params: ListTagsForResourceInput): Promise<T>;
    resetGraph<T>(params: ResetGraphInput): Promise<T>;
    restoreGraphFromSnapshot<T>(params: RestoreGraphFromSnapshotInput): Promise<T>;
    startExportTask<T>(params: StartExportTaskInput): Promise<T>;
    startGraph<T>(params: StartGraphInput): Promise<T>;
    startImportTask<T>(params: StartImportTaskInput): Promise<T>;
    stopGraph<T>(params: StopGraphInput): Promise<T>;
    tagResource<T>(params: TagResourceInput): Promise<T>;
    untagResource<T>(params: UntagResourceInput): Promise<T>;
    updateGraph<T>(params: UpdateGraphInput): Promise<T>;
}
//# sourceMappingURL=NeptuneGraph.d.ts.map