import * as HttpClient from "effect/unstable/http/HttpClient";
import * as S from "effect/Schema";
import * as API from "../client/api.ts";
import * as T from "../traits.ts";
import type { Credentials } from "../credentials.ts";
import type { CommonErrors } from "../errors.ts";
import type { Region } from "../region.ts";
export type PositiveInteger = number;
export interface CancelGremlinQueryInput {
    queryId: string;
}
export declare const CancelGremlinQueryInput: S.Schema<CancelGremlinQueryInput>;
export interface CancelGremlinQueryOutput {
    status?: string;
}
export declare const CancelGremlinQueryOutput: S.Schema<CancelGremlinQueryOutput>;
export interface CancelLoaderJobInput {
    loadId: string;
}
export declare const CancelLoaderJobInput: S.Schema<CancelLoaderJobInput>;
export interface CancelLoaderJobOutput {
    status?: string;
}
export declare const CancelLoaderJobOutput: S.Schema<CancelLoaderJobOutput>;
export interface CancelMLDataProcessingJobInput {
    id: string;
    neptuneIamRoleArn?: string;
    clean?: boolean;
}
export declare const CancelMLDataProcessingJobInput: S.Schema<CancelMLDataProcessingJobInput>;
export interface CancelMLDataProcessingJobOutput {
    status?: string;
}
export declare const CancelMLDataProcessingJobOutput: S.Schema<CancelMLDataProcessingJobOutput>;
export interface CancelMLModelTrainingJobInput {
    id: string;
    neptuneIamRoleArn?: string;
    clean?: boolean;
}
export declare const CancelMLModelTrainingJobInput: S.Schema<CancelMLModelTrainingJobInput>;
export interface CancelMLModelTrainingJobOutput {
    status?: string;
}
export declare const CancelMLModelTrainingJobOutput: S.Schema<CancelMLModelTrainingJobOutput>;
export interface CancelMLModelTransformJobInput {
    id: string;
    neptuneIamRoleArn?: string;
    clean?: boolean;
}
export declare const CancelMLModelTransformJobInput: S.Schema<CancelMLModelTransformJobInput>;
export interface CancelMLModelTransformJobOutput {
    status?: string;
}
export declare const CancelMLModelTransformJobOutput: S.Schema<CancelMLModelTransformJobOutput>;
export interface CancelOpenCypherQueryInput {
    queryId: string;
    silent?: boolean;
}
export declare const CancelOpenCypherQueryInput: S.Schema<CancelOpenCypherQueryInput>;
export interface CancelOpenCypherQueryOutput {
    status?: string;
    payload?: boolean;
}
export declare const CancelOpenCypherQueryOutput: S.Schema<CancelOpenCypherQueryOutput>;
export interface CreateMLEndpointInput {
    id?: string;
    mlModelTrainingJobId?: string;
    mlModelTransformJobId?: string;
    update?: boolean;
    neptuneIamRoleArn?: string;
    modelName?: string;
    instanceType?: string;
    instanceCount?: number;
    volumeEncryptionKMSKey?: string;
}
export declare const CreateMLEndpointInput: S.Schema<CreateMLEndpointInput>;
export interface CreateMLEndpointOutput {
    id?: string;
    arn?: string;
    creationTimeInMillis?: number;
}
export declare const CreateMLEndpointOutput: S.Schema<CreateMLEndpointOutput>;
export interface DeleteMLEndpointInput {
    id: string;
    neptuneIamRoleArn?: string;
    clean?: boolean;
}
export declare const DeleteMLEndpointInput: S.Schema<DeleteMLEndpointInput>;
export interface DeleteMLEndpointOutput {
    status?: string;
}
export declare const DeleteMLEndpointOutput: S.Schema<DeleteMLEndpointOutput>;
export interface DeletePropertygraphStatisticsRequest {
}
export declare const DeletePropertygraphStatisticsRequest: S.Schema<DeletePropertygraphStatisticsRequest>;
export interface DeleteStatisticsValueMap {
    active?: boolean;
    statisticsId?: string;
}
export declare const DeleteStatisticsValueMap: S.Schema<DeleteStatisticsValueMap>;
export interface DeletePropertygraphStatisticsOutput {
    statusCode?: number;
    status?: string;
    payload?: DeleteStatisticsValueMap;
}
export declare const DeletePropertygraphStatisticsOutput: S.Schema<DeletePropertygraphStatisticsOutput>;
export interface DeleteSparqlStatisticsRequest {
}
export declare const DeleteSparqlStatisticsRequest: S.Schema<DeleteSparqlStatisticsRequest>;
export interface DeleteSparqlStatisticsOutput {
    statusCode?: number;
    status?: string;
    payload?: DeleteStatisticsValueMap;
}
export declare const DeleteSparqlStatisticsOutput: S.Schema<DeleteSparqlStatisticsOutput>;
export type Action = "initiateDatabaseReset" | "performDatabaseReset" | (string & {});
export declare const Action: S.String;
export interface ExecuteFastResetInput {
    action: Action;
    token?: string;
}
export declare const ExecuteFastResetInput: S.Schema<ExecuteFastResetInput>;
export interface FastResetToken {
    token?: string;
}
export declare const FastResetToken: S.Schema<FastResetToken>;
export interface ExecuteFastResetOutput {
    status: string;
    payload?: FastResetToken;
}
export declare const ExecuteFastResetOutput: S.Schema<ExecuteFastResetOutput>;
export interface ExecuteGremlinExplainQueryInput {
    gremlinQuery: string;
}
export declare const ExecuteGremlinExplainQueryInput: S.Schema<ExecuteGremlinExplainQueryInput>;
export interface ExecuteGremlinExplainQueryOutput {
    output?: T.StreamingOutputBody;
}
export declare const ExecuteGremlinExplainQueryOutput: S.Schema<ExecuteGremlinExplainQueryOutput>;
export interface ExecuteGremlinProfileQueryInput {
    gremlinQuery: string;
    results?: boolean;
    chop?: number;
    serializer?: string;
    indexOps?: boolean;
}
export declare const ExecuteGremlinProfileQueryInput: S.Schema<ExecuteGremlinProfileQueryInput>;
export interface ExecuteGremlinProfileQueryOutput {
    output?: T.StreamingOutputBody;
}
export declare const ExecuteGremlinProfileQueryOutput: S.Schema<ExecuteGremlinProfileQueryOutput>;
export interface ExecuteGremlinQueryInput {
    gremlinQuery: string;
    serializer?: string;
}
export declare const ExecuteGremlinQueryInput: S.Schema<ExecuteGremlinQueryInput>;
export interface GremlinQueryStatusAttributes {
    message?: string;
    code?: number;
    attributes?: any;
}
export declare const GremlinQueryStatusAttributes: S.Schema<GremlinQueryStatusAttributes>;
export interface ExecuteGremlinQueryOutput {
    requestId?: string;
    status?: GremlinQueryStatusAttributes;
    result?: any;
    meta?: any;
}
export declare const ExecuteGremlinQueryOutput: S.Schema<ExecuteGremlinQueryOutput>;
export type OpenCypherExplainMode = "static" | "dynamic" | "details" | (string & {});
export declare const OpenCypherExplainMode: S.String;
export interface ExecuteOpenCypherExplainQueryInput {
    openCypherQuery: string;
    parameters?: string;
    explainMode: OpenCypherExplainMode;
}
export declare const ExecuteOpenCypherExplainQueryInput: S.Schema<ExecuteOpenCypherExplainQueryInput>;
export interface ExecuteOpenCypherExplainQueryOutput {
    results: Uint8Array;
}
export declare const ExecuteOpenCypherExplainQueryOutput: S.Schema<ExecuteOpenCypherExplainQueryOutput>;
export interface ExecuteOpenCypherQueryInput {
    openCypherQuery: string;
    parameters?: string;
}
export declare const ExecuteOpenCypherQueryInput: S.Schema<ExecuteOpenCypherQueryInput>;
export interface ExecuteOpenCypherQueryOutput {
    results: any;
}
export declare const ExecuteOpenCypherQueryOutput: S.Schema<ExecuteOpenCypherQueryOutput>;
export interface GetEngineStatusRequest {
}
export declare const GetEngineStatusRequest: S.Schema<GetEngineStatusRequest>;
export interface QueryLanguageVersion {
    version: string;
}
export declare const QueryLanguageVersion: S.Schema<QueryLanguageVersion>;
export type StringValuedMap = {
    [key: string]: string | undefined;
};
export declare const StringValuedMap: S.$Record<S.String, S.optional<S.String>>;
export type DocumentValuedMap = {
    [key: string]: any | undefined;
};
export declare const DocumentValuedMap: S.$Record<S.String, S.optional<S.Any>>;
export interface GetEngineStatusOutput {
    status?: string;
    startTime?: string;
    dbEngineVersion?: string;
    role?: string;
    dfeQueryEngine?: string;
    gremlin?: QueryLanguageVersion;
    sparql?: QueryLanguageVersion;
    opencypher?: QueryLanguageVersion;
    labMode?: {
        [key: string]: string | undefined;
    };
    rollingBackTrxCount?: number;
    rollingBackTrxEarliestStartTime?: string;
    features?: {
        [key: string]: any | undefined;
    };
    settings?: {
        [key: string]: string | undefined;
    };
}
export declare const GetEngineStatusOutput: S.Schema<GetEngineStatusOutput>;
export interface GetGremlinQueryStatusInput {
    queryId: string;
}
export declare const GetGremlinQueryStatusInput: S.Schema<GetGremlinQueryStatusInput>;
export interface QueryEvalStats {
    waited?: number;
    elapsed?: number;
    cancelled?: boolean;
    subqueries?: any;
}
export declare const QueryEvalStats: S.Schema<QueryEvalStats>;
export interface GetGremlinQueryStatusOutput {
    queryId?: string;
    queryString?: string;
    queryEvalStats?: QueryEvalStats;
}
export declare const GetGremlinQueryStatusOutput: S.Schema<GetGremlinQueryStatusOutput>;
export interface GetLoaderJobStatusInput {
    loadId: string;
    details?: boolean;
    errors?: boolean;
    page?: number;
    errorsPerPage?: number;
}
export declare const GetLoaderJobStatusInput: S.Schema<GetLoaderJobStatusInput>;
export interface GetLoaderJobStatusOutput {
    status: string;
    payload: any;
}
export declare const GetLoaderJobStatusOutput: S.Schema<GetLoaderJobStatusOutput>;
export interface GetMLDataProcessingJobInput {
    id: string;
    neptuneIamRoleArn?: string;
}
export declare const GetMLDataProcessingJobInput: S.Schema<GetMLDataProcessingJobInput>;
export interface MlResourceDefinition {
    name?: string;
    arn?: string;
    status?: string;
    outputLocation?: string;
    failureReason?: string;
    cloudwatchLogUrl?: string;
}
export declare const MlResourceDefinition: S.Schema<MlResourceDefinition>;
export interface GetMLDataProcessingJobOutput {
    status?: string;
    id?: string;
    processingJob?: MlResourceDefinition;
}
export declare const GetMLDataProcessingJobOutput: S.Schema<GetMLDataProcessingJobOutput>;
export interface GetMLEndpointInput {
    id: string;
    neptuneIamRoleArn?: string;
}
export declare const GetMLEndpointInput: S.Schema<GetMLEndpointInput>;
export interface MlConfigDefinition {
    name?: string;
    arn?: string;
}
export declare const MlConfigDefinition: S.Schema<MlConfigDefinition>;
export interface GetMLEndpointOutput {
    status?: string;
    id?: string;
    endpoint?: MlResourceDefinition;
    endpointConfig?: MlConfigDefinition;
}
export declare const GetMLEndpointOutput: S.Schema<GetMLEndpointOutput>;
export interface GetMLModelTrainingJobInput {
    id: string;
    neptuneIamRoleArn?: string;
}
export declare const GetMLModelTrainingJobInput: S.Schema<GetMLModelTrainingJobInput>;
export type MlModels = MlConfigDefinition[];
export declare const MlModels: S.$Array<S.Schema<MlConfigDefinition>>;
export interface GetMLModelTrainingJobOutput {
    status?: string;
    id?: string;
    processingJob?: MlResourceDefinition;
    hpoJob?: MlResourceDefinition;
    modelTransformJob?: MlResourceDefinition;
    mlModels?: MlConfigDefinition[];
}
export declare const GetMLModelTrainingJobOutput: S.Schema<GetMLModelTrainingJobOutput>;
export interface GetMLModelTransformJobInput {
    id: string;
    neptuneIamRoleArn?: string;
}
export declare const GetMLModelTransformJobInput: S.Schema<GetMLModelTransformJobInput>;
export type Models = MlConfigDefinition[];
export declare const Models: S.$Array<S.Schema<MlConfigDefinition>>;
export interface GetMLModelTransformJobOutput {
    status?: string;
    id?: string;
    baseProcessingJob?: MlResourceDefinition;
    remoteModelTransformJob?: MlResourceDefinition;
    models?: MlConfigDefinition[];
}
export declare const GetMLModelTransformJobOutput: S.Schema<GetMLModelTransformJobOutput>;
export interface GetOpenCypherQueryStatusInput {
    queryId: string;
}
export declare const GetOpenCypherQueryStatusInput: S.Schema<GetOpenCypherQueryStatusInput>;
export interface GetOpenCypherQueryStatusOutput {
    queryId?: string;
    queryString?: string;
    queryEvalStats?: QueryEvalStats;
}
export declare const GetOpenCypherQueryStatusOutput: S.Schema<GetOpenCypherQueryStatusOutput>;
export interface GetPropertygraphStatisticsRequest {
}
export declare const GetPropertygraphStatisticsRequest: S.Schema<GetPropertygraphStatisticsRequest>;
export interface StatisticsSummary {
    signatureCount?: number;
    instanceCount?: number;
    predicateCount?: number;
}
export declare const StatisticsSummary: S.Schema<StatisticsSummary>;
export interface Statistics {
    autoCompute?: boolean;
    active?: boolean;
    statisticsId?: string;
    date?: Date;
    note?: string;
    signatureInfo?: StatisticsSummary;
}
export declare const Statistics: S.Schema<Statistics>;
export interface GetPropertygraphStatisticsOutput {
    status: string;
    payload: Statistics;
}
export declare const GetPropertygraphStatisticsOutput: S.Schema<GetPropertygraphStatisticsOutput>;
export type IteratorType = "AT_SEQUENCE_NUMBER" | "AFTER_SEQUENCE_NUMBER" | "TRIM_HORIZON" | "LATEST" | (string & {});
export declare const IteratorType: S.String;
export type Encoding = "gzip" | (string & {});
export declare const Encoding: S.String;
export interface GetPropertygraphStreamInput {
    limit?: number;
    iteratorType?: IteratorType;
    commitNum?: number;
    opNum?: number;
    encoding?: Encoding;
}
export declare const GetPropertygraphStreamInput: S.Schema<GetPropertygraphStreamInput>;
export interface PropertygraphData {
    id: string;
    type: string;
    key: string;
    value: any;
    from?: string;
    to?: string;
}
export declare const PropertygraphData: S.Schema<PropertygraphData>;
export interface PropertygraphRecord {
    commitTimestampInMillis: number;
    eventId: {
        [key: string]: string | undefined;
    };
    data: PropertygraphData;
    op: string;
    isLastOp?: boolean;
}
export declare const PropertygraphRecord: S.Schema<PropertygraphRecord>;
export type PropertygraphRecordsList = PropertygraphRecord[];
export declare const PropertygraphRecordsList: S.$Array<S.Schema<PropertygraphRecord>>;
export interface GetPropertygraphStreamOutput {
    lastEventId: {
        [key: string]: string | undefined;
    };
    lastTrxTimestampInMillis: number;
    format: string;
    records: PropertygraphRecord[];
    totalRecords: number;
}
export declare const GetPropertygraphStreamOutput: S.Schema<GetPropertygraphStreamOutput>;
export type GraphSummaryType = "basic" | "detailed" | (string & {});
export declare const GraphSummaryType: S.String;
export interface GetPropertygraphSummaryInput {
    mode?: GraphSummaryType;
}
export declare const GetPropertygraphSummaryInput: S.Schema<GetPropertygraphSummaryInput>;
export type NodeLabels = string[];
export declare const NodeLabels: S.$Array<S.String>;
export type EdgeLabels = string[];
export declare const EdgeLabels: S.$Array<S.String>;
export type LongValuedMap = {
    [key: string]: number | undefined;
};
export declare const LongValuedMap: S.$Record<S.String, S.optional<S.Number>>;
export type LongValuedMapList = {
    [key: string]: number | undefined;
}[];
export declare const LongValuedMapList: S.$Array<S.$Record<S.String, S.optional<S.Number>>>;
export type NodeProperties = string[];
export declare const NodeProperties: S.$Array<S.String>;
export type OutgoingEdgeLabels = string[];
export declare const OutgoingEdgeLabels: S.$Array<S.String>;
export interface NodeStructure {
    count?: number;
    nodeProperties?: string[];
    distinctOutgoingEdgeLabels?: string[];
}
export declare const NodeStructure: S.Schema<NodeStructure>;
export type NodeStructures = NodeStructure[];
export declare const NodeStructures: S.$Array<S.Schema<NodeStructure>>;
export type EdgeProperties = string[];
export declare const EdgeProperties: S.$Array<S.String>;
export interface EdgeStructure {
    count?: number;
    edgeProperties?: string[];
}
export declare const EdgeStructure: S.Schema<EdgeStructure>;
export type EdgeStructures = EdgeStructure[];
export declare const EdgeStructures: S.$Array<S.Schema<EdgeStructure>>;
export interface PropertygraphSummary {
    numNodes?: number;
    numEdges?: number;
    numNodeLabels?: number;
    numEdgeLabels?: number;
    nodeLabels?: string[];
    edgeLabels?: string[];
    numNodeProperties?: number;
    numEdgeProperties?: number;
    nodeProperties?: {
        [key: string]: number | undefined;
    }[];
    edgeProperties?: {
        [key: string]: number | undefined;
    }[];
    totalNodePropertyValues?: number;
    totalEdgePropertyValues?: number;
    nodeStructures?: NodeStructure[];
    edgeStructures?: EdgeStructure[];
}
export declare const PropertygraphSummary: S.Schema<PropertygraphSummary>;
export interface PropertygraphSummaryValueMap {
    version?: string;
    lastStatisticsComputationTime?: Date;
    graphSummary?: PropertygraphSummary;
}
export declare const PropertygraphSummaryValueMap: S.Schema<PropertygraphSummaryValueMap>;
export interface GetPropertygraphSummaryOutput {
    statusCode?: number;
    payload?: PropertygraphSummaryValueMap;
}
export declare const GetPropertygraphSummaryOutput: S.Schema<GetPropertygraphSummaryOutput>;
export interface GetRDFGraphSummaryInput {
    mode?: GraphSummaryType;
}
export declare const GetRDFGraphSummaryInput: S.Schema<GetRDFGraphSummaryInput>;
export type Classes = string[];
export declare const Classes: S.$Array<S.String>;
export type Predicates = string[];
export declare const Predicates: S.$Array<S.String>;
export interface SubjectStructure {
    count?: number;
    predicates?: string[];
}
export declare const SubjectStructure: S.Schema<SubjectStructure>;
export type SubjectStructures = SubjectStructure[];
export declare const SubjectStructures: S.$Array<S.Schema<SubjectStructure>>;
export interface RDFGraphSummary {
    numDistinctSubjects?: number;
    numDistinctPredicates?: number;
    numQuads?: number;
    numClasses?: number;
    classes?: string[];
    predicates?: {
        [key: string]: number | undefined;
    }[];
    subjectStructures?: SubjectStructure[];
}
export declare const RDFGraphSummary: S.Schema<RDFGraphSummary>;
export interface RDFGraphSummaryValueMap {
    version?: string;
    lastStatisticsComputationTime?: Date;
    graphSummary?: RDFGraphSummary;
}
export declare const RDFGraphSummaryValueMap: S.Schema<RDFGraphSummaryValueMap>;
export interface GetRDFGraphSummaryOutput {
    statusCode?: number;
    payload?: RDFGraphSummaryValueMap;
}
export declare const GetRDFGraphSummaryOutput: S.Schema<GetRDFGraphSummaryOutput>;
export interface GetSparqlStatisticsRequest {
}
export declare const GetSparqlStatisticsRequest: S.Schema<GetSparqlStatisticsRequest>;
export interface GetSparqlStatisticsOutput {
    status: string;
    payload: Statistics;
}
export declare const GetSparqlStatisticsOutput: S.Schema<GetSparqlStatisticsOutput>;
export interface GetSparqlStreamInput {
    limit?: number;
    iteratorType?: IteratorType;
    commitNum?: number;
    opNum?: number;
    encoding?: Encoding;
}
export declare const GetSparqlStreamInput: S.Schema<GetSparqlStreamInput>;
export interface SparqlData {
    stmt: string;
}
export declare const SparqlData: S.Schema<SparqlData>;
export interface SparqlRecord {
    commitTimestampInMillis: number;
    eventId: {
        [key: string]: string | undefined;
    };
    data: SparqlData;
    op: string;
    isLastOp?: boolean;
}
export declare const SparqlRecord: S.Schema<SparqlRecord>;
export type SparqlRecordsList = SparqlRecord[];
export declare const SparqlRecordsList: S.$Array<S.Schema<SparqlRecord>>;
export interface GetSparqlStreamOutput {
    lastEventId: {
        [key: string]: string | undefined;
    };
    lastTrxTimestampInMillis: number;
    format: string;
    records: SparqlRecord[];
    totalRecords: number;
}
export declare const GetSparqlStreamOutput: S.Schema<GetSparqlStreamOutput>;
export interface ListGremlinQueriesInput {
    includeWaiting?: boolean;
}
export declare const ListGremlinQueriesInput: S.Schema<ListGremlinQueriesInput>;
export interface GremlinQueryStatus {
    queryId?: string;
    queryString?: string;
    queryEvalStats?: QueryEvalStats;
}
export declare const GremlinQueryStatus: S.Schema<GremlinQueryStatus>;
export type GremlinQueries = GremlinQueryStatus[];
export declare const GremlinQueries: S.$Array<S.Schema<GremlinQueryStatus>>;
export interface ListGremlinQueriesOutput {
    acceptedQueryCount?: number;
    runningQueryCount?: number;
    queries?: GremlinQueryStatus[];
}
export declare const ListGremlinQueriesOutput: S.Schema<ListGremlinQueriesOutput>;
export interface ListLoaderJobsInput {
    limit?: number;
    includeQueuedLoads?: boolean;
}
export declare const ListLoaderJobsInput: S.Schema<ListLoaderJobsInput>;
export type StringList = string[];
export declare const StringList: S.$Array<S.String>;
export interface LoaderIdResult {
    loadIds?: string[];
}
export declare const LoaderIdResult: S.Schema<LoaderIdResult>;
export interface ListLoaderJobsOutput {
    status: string;
    payload: LoaderIdResult;
}
export declare const ListLoaderJobsOutput: S.Schema<ListLoaderJobsOutput>;
export interface ListMLDataProcessingJobsInput {
    maxItems?: number;
    neptuneIamRoleArn?: string;
}
export declare const ListMLDataProcessingJobsInput: S.Schema<ListMLDataProcessingJobsInput>;
export interface ListMLDataProcessingJobsOutput {
    ids?: string[];
}
export declare const ListMLDataProcessingJobsOutput: S.Schema<ListMLDataProcessingJobsOutput>;
export interface ListMLEndpointsInput {
    maxItems?: number;
    neptuneIamRoleArn?: string;
}
export declare const ListMLEndpointsInput: S.Schema<ListMLEndpointsInput>;
export interface ListMLEndpointsOutput {
    ids?: string[];
}
export declare const ListMLEndpointsOutput: S.Schema<ListMLEndpointsOutput>;
export interface ListMLModelTrainingJobsInput {
    maxItems?: number;
    neptuneIamRoleArn?: string;
}
export declare const ListMLModelTrainingJobsInput: S.Schema<ListMLModelTrainingJobsInput>;
export interface ListMLModelTrainingJobsOutput {
    ids?: string[];
}
export declare const ListMLModelTrainingJobsOutput: S.Schema<ListMLModelTrainingJobsOutput>;
export interface ListMLModelTransformJobsInput {
    maxItems?: number;
    neptuneIamRoleArn?: string;
}
export declare const ListMLModelTransformJobsInput: S.Schema<ListMLModelTransformJobsInput>;
export interface ListMLModelTransformJobsOutput {
    ids?: string[];
}
export declare const ListMLModelTransformJobsOutput: S.Schema<ListMLModelTransformJobsOutput>;
export interface ListOpenCypherQueriesInput {
    includeWaiting?: boolean;
}
export declare const ListOpenCypherQueriesInput: S.Schema<ListOpenCypherQueriesInput>;
export type OpenCypherQueries = GremlinQueryStatus[];
export declare const OpenCypherQueries: S.$Array<S.Schema<GremlinQueryStatus>>;
export interface ListOpenCypherQueriesOutput {
    acceptedQueryCount?: number;
    runningQueryCount?: number;
    queries?: GremlinQueryStatus[];
}
export declare const ListOpenCypherQueriesOutput: S.Schema<ListOpenCypherQueriesOutput>;
export type StatisticsAutoGenerationMode = "disableAutoCompute" | "enableAutoCompute" | "refresh" | (string & {});
export declare const StatisticsAutoGenerationMode: S.String;
export interface ManagePropertygraphStatisticsInput {
    mode?: StatisticsAutoGenerationMode;
}
export declare const ManagePropertygraphStatisticsInput: S.Schema<ManagePropertygraphStatisticsInput>;
export interface RefreshStatisticsIdMap {
    statisticsId?: string;
}
export declare const RefreshStatisticsIdMap: S.Schema<RefreshStatisticsIdMap>;
export interface ManagePropertygraphStatisticsOutput {
    status: string;
    payload?: RefreshStatisticsIdMap;
}
export declare const ManagePropertygraphStatisticsOutput: S.Schema<ManagePropertygraphStatisticsOutput>;
export interface ManageSparqlStatisticsInput {
    mode?: StatisticsAutoGenerationMode;
}
export declare const ManageSparqlStatisticsInput: S.Schema<ManageSparqlStatisticsInput>;
export interface ManageSparqlStatisticsOutput {
    status: string;
    payload?: RefreshStatisticsIdMap;
}
export declare const ManageSparqlStatisticsOutput: S.Schema<ManageSparqlStatisticsOutput>;
export type Format = "csv" | "opencypher" | "ntriples" | "nquads" | "rdfxml" | "turtle" | (string & {});
export declare const Format: S.String;
export type S3BucketRegion = "us-east-1" | "us-east-2" | "us-west-1" | "us-west-2" | "ca-central-1" | "sa-east-1" | "eu-north-1" | "eu-west-1" | "eu-west-2" | "eu-west-3" | "eu-central-1" | "me-south-1" | "af-south-1" | "ap-east-1" | "ap-northeast-1" | "ap-northeast-2" | "ap-southeast-1" | "ap-southeast-2" | "ap-south-1" | "cn-north-1" | "cn-northwest-1" | "us-gov-west-1" | "us-gov-east-1" | "ca-west-1" | "eu-south-2" | "il-central-1" | "me-central-1" | "ap-northeast-3" | "ap-southeast-3" | "ap-southeast-4" | "ap-southeast-5" | "ap-southeast-7" | "mx-central-1" | "ap-east-2" | "ap-south-2" | "eu-central-2" | (string & {});
export declare const S3BucketRegion: S.String;
export type Mode = "RESUME" | "NEW" | "AUTO" | (string & {});
export declare const Mode: S.String;
export type Parallelism = "LOW" | "MEDIUM" | "HIGH" | "OVERSUBSCRIBE" | (string & {});
export declare const Parallelism: S.String;
export interface StartLoaderJobInput {
    source: string;
    format: Format;
    s3BucketRegion: S3BucketRegion;
    iamRoleArn: string;
    mode?: Mode;
    failOnError?: boolean;
    parallelism?: Parallelism;
    parserConfiguration?: {
        [key: string]: string | undefined;
    };
    updateSingleCardinalityProperties?: boolean;
    queueRequest?: boolean;
    dependencies?: string[];
    userProvidedEdgeIds?: boolean;
    edgeOnlyLoad?: boolean;
}
export declare const StartLoaderJobInput: S.Schema<StartLoaderJobInput>;
export interface StartLoaderJobOutput {
    status: string;
    payload: {
        [key: string]: string | undefined;
    };
}
export declare const StartLoaderJobOutput: S.Schema<StartLoaderJobOutput>;
export interface StartMLDataProcessingJobInput {
    id?: string;
    previousDataProcessingJobId?: string;
    inputDataS3Location: string;
    processedDataS3Location: string;
    sagemakerIamRoleArn?: string;
    neptuneIamRoleArn?: string;
    processingInstanceType?: string;
    processingInstanceVolumeSizeInGB?: number;
    processingTimeOutInSeconds?: number;
    modelType?: string;
    configFileName?: string;
    subnets?: string[];
    securityGroupIds?: string[];
    volumeEncryptionKMSKey?: string;
    s3OutputEncryptionKMSKey?: string;
}
export declare const StartMLDataProcessingJobInput: S.Schema<StartMLDataProcessingJobInput>;
export interface StartMLDataProcessingJobOutput {
    id?: string;
    arn?: string;
    creationTimeInMillis?: number;
}
export declare const StartMLDataProcessingJobOutput: S.Schema<StartMLDataProcessingJobOutput>;
export interface CustomModelTrainingParameters {
    sourceS3DirectoryPath: string;
    trainingEntryPointScript?: string;
    transformEntryPointScript?: string;
}
export declare const CustomModelTrainingParameters: S.Schema<CustomModelTrainingParameters>;
export interface StartMLModelTrainingJobInput {
    id?: string;
    previousModelTrainingJobId?: string;
    dataProcessingJobId: string;
    trainModelS3Location: string;
    sagemakerIamRoleArn?: string;
    neptuneIamRoleArn?: string;
    baseProcessingInstanceType?: string;
    trainingInstanceType?: string;
    trainingInstanceVolumeSizeInGB?: number;
    trainingTimeOutInSeconds?: number;
    maxHPONumberOfTrainingJobs?: number;
    maxHPOParallelTrainingJobs?: number;
    subnets?: string[];
    securityGroupIds?: string[];
    volumeEncryptionKMSKey?: string;
    s3OutputEncryptionKMSKey?: string;
    enableManagedSpotTraining?: boolean;
    customModelTrainingParameters?: CustomModelTrainingParameters;
}
export declare const StartMLModelTrainingJobInput: S.Schema<StartMLModelTrainingJobInput>;
export interface StartMLModelTrainingJobOutput {
    id?: string;
    arn?: string;
    creationTimeInMillis?: number;
}
export declare const StartMLModelTrainingJobOutput: S.Schema<StartMLModelTrainingJobOutput>;
export interface CustomModelTransformParameters {
    sourceS3DirectoryPath: string;
    transformEntryPointScript?: string;
}
export declare const CustomModelTransformParameters: S.Schema<CustomModelTransformParameters>;
export interface StartMLModelTransformJobInput {
    id?: string;
    dataProcessingJobId?: string;
    mlModelTrainingJobId?: string;
    trainingJobName?: string;
    modelTransformOutputS3Location: string;
    sagemakerIamRoleArn?: string;
    neptuneIamRoleArn?: string;
    customModelTransformParameters?: CustomModelTransformParameters;
    baseProcessingInstanceType?: string;
    baseProcessingInstanceVolumeSizeInGB?: number;
    subnets?: string[];
    securityGroupIds?: string[];
    volumeEncryptionKMSKey?: string;
    s3OutputEncryptionKMSKey?: string;
}
export declare const StartMLModelTransformJobInput: S.Schema<StartMLModelTransformJobInput>;
export interface StartMLModelTransformJobOutput {
    id?: string;
    arn?: string;
    creationTimeInMillis?: number;
}
export declare const StartMLModelTransformJobOutput: S.Schema<StartMLModelTransformJobOutput>;
declare const BadRequestException_base: S.Class<BadRequestException, S.TaggedStruct<"BadRequestException", {
    readonly detailedMessage: S.String;
    readonly requestId: S.String;
    readonly code: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class BadRequestException extends BadRequestException_base {
}
declare const ClientTimeoutException_base: S.Class<ClientTimeoutException, S.TaggedStruct<"ClientTimeoutException", {
    readonly detailedMessage: S.String;
    readonly requestId: S.String;
    readonly code: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        TimeoutError: true;
    };
}) & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        RetryableError: true;
    };
});
export declare class ClientTimeoutException extends ClientTimeoutException_base {
}
declare const ConcurrentModificationException_base: S.Class<ConcurrentModificationException, S.TaggedStruct<"ConcurrentModificationException", {
    readonly detailedMessage: S.String;
    readonly requestId: S.String;
    readonly code: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ServerError: true;
    };
}) & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        RetryableError: true;
    };
});
export declare class ConcurrentModificationException extends ConcurrentModificationException_base {
}
declare const ConstraintViolationException_base: S.Class<ConstraintViolationException, S.TaggedStruct<"ConstraintViolationException", {
    readonly detailedMessage: S.String;
    readonly requestId: S.String;
    readonly code: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
}) & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        RetryableError: true;
    };
});
export declare class ConstraintViolationException extends ConstraintViolationException_base {
}
declare const FailureByQueryException_base: S.Class<FailureByQueryException, S.TaggedStruct<"FailureByQueryException", {
    readonly detailedMessage: S.String;
    readonly requestId: S.String;
    readonly code: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ServerError: true;
    };
}) & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        RetryableError: true;
    };
});
export declare class FailureByQueryException extends FailureByQueryException_base {
}
declare const IllegalArgumentException_base: S.Class<IllegalArgumentException, S.TaggedStruct<"IllegalArgumentException", {
    readonly detailedMessage: S.String;
    readonly requestId: S.String;
    readonly code: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class IllegalArgumentException extends IllegalArgumentException_base {
}
declare const InvalidArgumentException_base: S.Class<InvalidArgumentException, S.TaggedStruct<"InvalidArgumentException", {
    readonly detailedMessage: S.String;
    readonly requestId: S.String;
    readonly code: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class InvalidArgumentException extends InvalidArgumentException_base {
}
declare const InvalidParameterException_base: S.Class<InvalidParameterException, S.TaggedStruct<"InvalidParameterException", {
    readonly detailedMessage: S.String;
    readonly requestId: S.String;
    readonly code: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class InvalidParameterException extends InvalidParameterException_base {
}
declare const MissingParameterException_base: S.Class<MissingParameterException, S.TaggedStruct<"MissingParameterException", {
    readonly detailedMessage: S.String;
    readonly requestId: S.String;
    readonly code: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class MissingParameterException extends MissingParameterException_base {
}
declare const ParsingException_base: S.Class<ParsingException, S.TaggedStruct<"ParsingException", {
    readonly detailedMessage: S.String;
    readonly requestId: S.String;
    readonly code: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class ParsingException extends ParsingException_base {
}
declare const PreconditionsFailedException_base: S.Class<PreconditionsFailedException, S.TaggedStruct<"PreconditionsFailedException", {
    readonly detailedMessage: S.String;
    readonly requestId: S.String;
    readonly code: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class PreconditionsFailedException extends PreconditionsFailedException_base {
}
declare const TimeLimitExceededException_base: S.Class<TimeLimitExceededException, S.TaggedStruct<"TimeLimitExceededException", {
    readonly detailedMessage: S.String;
    readonly requestId: S.String;
    readonly code: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ServerError: true;
    };
}) & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        RetryableError: true;
    };
});
export declare class TimeLimitExceededException extends TimeLimitExceededException_base {
}
declare const TooManyRequestsException_base: S.Class<TooManyRequestsException, S.TaggedStruct<"TooManyRequestsException", {
    readonly detailedMessage: S.String;
    readonly requestId: S.String;
    readonly code: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ThrottlingError: true;
    };
}) & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        RetryableError: true;
    };
});
export declare class TooManyRequestsException extends TooManyRequestsException_base {
}
declare const UnsupportedOperationException_base: S.Class<UnsupportedOperationException, S.TaggedStruct<"UnsupportedOperationException", {
    readonly detailedMessage: S.String;
    readonly requestId: S.String;
    readonly code: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class UnsupportedOperationException extends UnsupportedOperationException_base {
}
declare const BulkLoadIdNotFoundException_base: S.Class<BulkLoadIdNotFoundException, S.TaggedStruct<"BulkLoadIdNotFoundException", {
    readonly detailedMessage: S.String;
    readonly requestId: S.String;
    readonly code: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
}) & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        RetryableError: true;
    };
});
export declare class BulkLoadIdNotFoundException extends BulkLoadIdNotFoundException_base {
}
declare const InternalFailureException_base: S.Class<InternalFailureException, S.TaggedStruct<"InternalFailureException", {
    readonly detailedMessage: S.String;
    readonly requestId: S.String;
    readonly code: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ServerError: true;
    };
});
export declare class InternalFailureException extends InternalFailureException_base {
}
declare const LoadUrlAccessDeniedException_base: S.Class<LoadUrlAccessDeniedException, S.TaggedStruct<"LoadUrlAccessDeniedException", {
    readonly detailedMessage: S.String;
    readonly requestId: S.String;
    readonly code: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
}) & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        AuthError: true;
    };
});
export declare class LoadUrlAccessDeniedException extends LoadUrlAccessDeniedException_base {
}
declare const MLResourceNotFoundException_base: S.Class<MLResourceNotFoundException, S.TaggedStruct<"MLResourceNotFoundException", {
    readonly detailedMessage: S.String;
    readonly requestId: S.String;
    readonly code: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class MLResourceNotFoundException extends MLResourceNotFoundException_base {
}
declare const InvalidNumericDataException_base: S.Class<InvalidNumericDataException, S.TaggedStruct<"InvalidNumericDataException", {
    readonly detailedMessage: S.String;
    readonly requestId: S.String;
    readonly code: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class InvalidNumericDataException extends InvalidNumericDataException_base {
}
declare const AccessDeniedException_base: S.Class<AccessDeniedException, S.TaggedStruct<"AccessDeniedException", {
    readonly detailedMessage: S.String;
    readonly requestId: S.String;
    readonly code: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        AuthError: true;
    };
});
export declare class AccessDeniedException extends AccessDeniedException_base {
}
declare const ReadOnlyViolationException_base: S.Class<ReadOnlyViolationException, S.TaggedStruct<"ReadOnlyViolationException", {
    readonly detailedMessage: S.String;
    readonly requestId: S.String;
    readonly code: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class ReadOnlyViolationException extends ReadOnlyViolationException_base {
}
declare const StatisticsNotAvailableException_base: S.Class<StatisticsNotAvailableException, S.TaggedStruct<"StatisticsNotAvailableException", {
    readonly detailedMessage: S.String;
    readonly requestId: S.String;
    readonly code: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class StatisticsNotAvailableException extends StatisticsNotAvailableException_base {
}
declare const MethodNotAllowedException_base: S.Class<MethodNotAllowedException, S.TaggedStruct<"MethodNotAllowedException", {
    readonly detailedMessage: S.String;
    readonly requestId: S.String;
    readonly code: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class MethodNotAllowedException extends MethodNotAllowedException_base {
}
declare const ServerShutdownException_base: S.Class<ServerShutdownException, S.TaggedStruct<"ServerShutdownException", {
    readonly detailedMessage: S.String;
    readonly requestId: S.String;
    readonly code: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ServerError: true;
    };
});
export declare class ServerShutdownException extends ServerShutdownException_base {
}
declare const CancelledByUserException_base: S.Class<CancelledByUserException, S.TaggedStruct<"CancelledByUserException", {
    readonly detailedMessage: S.String;
    readonly requestId: S.String;
    readonly code: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ServerError: true;
    };
});
export declare class CancelledByUserException extends CancelledByUserException_base {
}
declare const MalformedQueryException_base: S.Class<MalformedQueryException, S.TaggedStruct<"MalformedQueryException", {
    readonly detailedMessage: S.String;
    readonly requestId: S.String;
    readonly code: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class MalformedQueryException extends MalformedQueryException_base {
}
declare const MemoryLimitExceededException_base: S.Class<MemoryLimitExceededException, S.TaggedStruct<"MemoryLimitExceededException", {
    readonly detailedMessage: S.String;
    readonly requestId: S.String;
    readonly code: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ServerError: true;
    };
}) & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        RetryableError: true;
    };
});
export declare class MemoryLimitExceededException extends MemoryLimitExceededException_base {
}
declare const QueryLimitExceededException_base: S.Class<QueryLimitExceededException, S.TaggedStruct<"QueryLimitExceededException", {
    readonly detailedMessage: S.String;
    readonly requestId: S.String;
    readonly code: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ServerError: true;
    };
}) & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        RetryableError: true;
    };
});
export declare class QueryLimitExceededException extends QueryLimitExceededException_base {
}
declare const QueryLimitException_base: S.Class<QueryLimitException, S.TaggedStruct<"QueryLimitException", {
    readonly detailedMessage: S.String;
    readonly requestId: S.String;
    readonly code: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class QueryLimitException extends QueryLimitException_base {
}
declare const QueryTooLargeException_base: S.Class<QueryTooLargeException, S.TaggedStruct<"QueryTooLargeException", {
    readonly detailedMessage: S.String;
    readonly requestId: S.String;
    readonly code: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class QueryTooLargeException extends QueryTooLargeException_base {
}
declare const ExpiredStreamException_base: S.Class<ExpiredStreamException, S.TaggedStruct<"ExpiredStreamException", {
    readonly detailedMessage: S.String;
    readonly requestId: S.String;
    readonly code: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class ExpiredStreamException extends ExpiredStreamException_base {
}
declare const StreamRecordsNotFoundException_base: S.Class<StreamRecordsNotFoundException, S.TaggedStruct<"StreamRecordsNotFoundException", {
    readonly detailedMessage: S.String;
    readonly requestId: S.String;
    readonly code: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class StreamRecordsNotFoundException extends StreamRecordsNotFoundException_base {
}
declare const ThrottlingException_base: S.Class<ThrottlingException, S.TaggedStruct<"ThrottlingException", {
    readonly detailedMessage: S.String;
    readonly requestId: S.String;
    readonly code: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ServerError: true;
    };
}) & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        RetryableError: true;
    };
});
export declare class ThrottlingException extends ThrottlingException_base {
}
declare const S3Exception_base: S.Class<S3Exception, S.TaggedStruct<"S3Exception", {
    readonly detailedMessage: S.String;
    readonly requestId: S.String;
    readonly code: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
}) & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        RetryableError: true;
    };
});
export declare class S3Exception extends S3Exception_base {
}
export type CancelGremlinQueryError = BadRequestException | ClientTimeoutException | ConcurrentModificationException | ConstraintViolationException | FailureByQueryException | IllegalArgumentException | InvalidArgumentException | InvalidParameterException | MissingParameterException | ParsingException | PreconditionsFailedException | TimeLimitExceededException | TooManyRequestsException | UnsupportedOperationException | CommonErrors;
/**
 * Cancels a Gremlin query. See Gremlin query cancellation for more information.
 *
 * When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:CancelQuery IAM action in that cluster.
 */
export declare const cancelGremlinQuery: API.OperationMethod<CancelGremlinQueryInput, CancelGremlinQueryOutput, CancelGremlinQueryError, Credentials | Region | HttpClient.HttpClient>;
export type CancelLoaderJobError = BadRequestException | BulkLoadIdNotFoundException | ClientTimeoutException | ConstraintViolationException | IllegalArgumentException | InternalFailureException | InvalidArgumentException | InvalidParameterException | LoadUrlAccessDeniedException | MissingParameterException | PreconditionsFailedException | TooManyRequestsException | UnsupportedOperationException | CommonErrors;
/**
 * Cancels a specified load job. This is an HTTP `DELETE` request. See Neptune Loader Get-Status API for more information.
 *
 * When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:CancelLoaderJob IAM action in that cluster..
 */
export declare const cancelLoaderJob: API.OperationMethod<CancelLoaderJobInput, CancelLoaderJobOutput, CancelLoaderJobError, Credentials | Region | HttpClient.HttpClient>;
export type CancelMLDataProcessingJobError = BadRequestException | ClientTimeoutException | ConstraintViolationException | IllegalArgumentException | InvalidArgumentException | InvalidParameterException | MissingParameterException | MLResourceNotFoundException | PreconditionsFailedException | TooManyRequestsException | UnsupportedOperationException | CommonErrors;
/**
 * Cancels a Neptune ML data processing job. See The `dataprocessing` command.
 *
 * When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:CancelMLDataProcessingJob IAM action in that cluster.
 */
export declare const cancelMLDataProcessingJob: API.OperationMethod<CancelMLDataProcessingJobInput, CancelMLDataProcessingJobOutput, CancelMLDataProcessingJobError, Credentials | Region | HttpClient.HttpClient>;
export type CancelMLModelTrainingJobError = BadRequestException | ClientTimeoutException | ConstraintViolationException | IllegalArgumentException | InvalidArgumentException | InvalidParameterException | MissingParameterException | MLResourceNotFoundException | PreconditionsFailedException | TooManyRequestsException | UnsupportedOperationException | CommonErrors;
/**
 * Cancels a Neptune ML model training job. See Model training using the `modeltraining` command.
 *
 * When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:CancelMLModelTrainingJob IAM action in that cluster.
 */
export declare const cancelMLModelTrainingJob: API.OperationMethod<CancelMLModelTrainingJobInput, CancelMLModelTrainingJobOutput, CancelMLModelTrainingJobError, Credentials | Region | HttpClient.HttpClient>;
export type CancelMLModelTransformJobError = BadRequestException | ClientTimeoutException | ConstraintViolationException | IllegalArgumentException | InvalidArgumentException | InvalidParameterException | MissingParameterException | MLResourceNotFoundException | PreconditionsFailedException | TooManyRequestsException | UnsupportedOperationException | CommonErrors;
/**
 * Cancels a specified model transform job. See Use a trained model to generate new model artifacts.
 *
 * When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:CancelMLModelTransformJob IAM action in that cluster.
 */
export declare const cancelMLModelTransformJob: API.OperationMethod<CancelMLModelTransformJobInput, CancelMLModelTransformJobOutput, CancelMLModelTransformJobError, Credentials | Region | HttpClient.HttpClient>;
export type CancelOpenCypherQueryError = BadRequestException | ClientTimeoutException | ConcurrentModificationException | ConstraintViolationException | FailureByQueryException | IllegalArgumentException | InvalidArgumentException | InvalidNumericDataException | InvalidParameterException | MissingParameterException | ParsingException | PreconditionsFailedException | TimeLimitExceededException | TooManyRequestsException | UnsupportedOperationException | CommonErrors;
/**
 * Cancels a specified openCypher query. See Neptune openCypher status endpoint for more information.
 *
 * When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:CancelQuery IAM action in that cluster.
 */
export declare const cancelOpenCypherQuery: API.OperationMethod<CancelOpenCypherQueryInput, CancelOpenCypherQueryOutput, CancelOpenCypherQueryError, Credentials | Region | HttpClient.HttpClient>;
export type CreateMLEndpointError = BadRequestException | ClientTimeoutException | ConstraintViolationException | IllegalArgumentException | InvalidArgumentException | InvalidParameterException | MissingParameterException | MLResourceNotFoundException | PreconditionsFailedException | TooManyRequestsException | UnsupportedOperationException | CommonErrors;
/**
 * Creates a new Neptune ML inference endpoint that lets you query one specific model that the model-training process constructed. See Managing inference endpoints using the endpoints command.
 *
 * When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:CreateMLEndpoint IAM action in that cluster.
 */
export declare const createMLEndpoint: API.OperationMethod<CreateMLEndpointInput, CreateMLEndpointOutput, CreateMLEndpointError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteMLEndpointError = BadRequestException | ClientTimeoutException | ConstraintViolationException | IllegalArgumentException | InvalidArgumentException | InvalidParameterException | MissingParameterException | MLResourceNotFoundException | PreconditionsFailedException | TooManyRequestsException | UnsupportedOperationException | CommonErrors;
/**
 * Cancels the creation of a Neptune ML inference endpoint. See Managing inference endpoints using the endpoints command.
 *
 * When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:DeleteMLEndpoint IAM action in that cluster.
 */
export declare const deleteMLEndpoint: API.OperationMethod<DeleteMLEndpointInput, DeleteMLEndpointOutput, DeleteMLEndpointError, Credentials | Region | HttpClient.HttpClient>;
export type DeletePropertygraphStatisticsError = AccessDeniedException | BadRequestException | ClientTimeoutException | ConstraintViolationException | IllegalArgumentException | InvalidArgumentException | InvalidParameterException | MissingParameterException | PreconditionsFailedException | ReadOnlyViolationException | StatisticsNotAvailableException | TooManyRequestsException | UnsupportedOperationException | CommonErrors;
/**
 * Deletes statistics for Gremlin and openCypher (property graph) data.
 *
 * When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:DeleteStatistics IAM action in that cluster.
 */
export declare const deletePropertygraphStatistics: API.OperationMethod<DeletePropertygraphStatisticsRequest, DeletePropertygraphStatisticsOutput, DeletePropertygraphStatisticsError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteSparqlStatisticsError = AccessDeniedException | BadRequestException | ClientTimeoutException | ConstraintViolationException | IllegalArgumentException | InvalidArgumentException | InvalidParameterException | MissingParameterException | PreconditionsFailedException | ReadOnlyViolationException | StatisticsNotAvailableException | TooManyRequestsException | UnsupportedOperationException | CommonErrors;
/**
 * Deletes SPARQL statistics
 *
 * When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:DeleteStatistics IAM action in that cluster.
 */
export declare const deleteSparqlStatistics: API.OperationMethod<DeleteSparqlStatisticsRequest, DeleteSparqlStatisticsOutput, DeleteSparqlStatisticsError, Credentials | Region | HttpClient.HttpClient>;
export type ExecuteFastResetError = AccessDeniedException | ClientTimeoutException | ConstraintViolationException | IllegalArgumentException | InvalidArgumentException | InvalidParameterException | MethodNotAllowedException | MissingParameterException | PreconditionsFailedException | ReadOnlyViolationException | ServerShutdownException | TooManyRequestsException | UnsupportedOperationException | CommonErrors;
/**
 * The fast reset REST API lets you reset a Neptune graph quicky and easily, removing all of its data.
 *
 * Neptune fast reset is a two-step process. First you call `ExecuteFastReset` with `action` set to `initiateDatabaseReset`. This returns a UUID token which you then include when calling `ExecuteFastReset` again with `action` set to `performDatabaseReset`. See Empty an Amazon Neptune DB cluster using the fast reset API.
 *
 * When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:ResetDatabase IAM action in that cluster.
 */
export declare const executeFastReset: API.OperationMethod<ExecuteFastResetInput, ExecuteFastResetOutput, ExecuteFastResetError, Credentials | Region | HttpClient.HttpClient>;
export type ExecuteGremlinExplainQueryError = BadRequestException | CancelledByUserException | ClientTimeoutException | ConcurrentModificationException | ConstraintViolationException | FailureByQueryException | IllegalArgumentException | InvalidArgumentException | InvalidParameterException | MalformedQueryException | MemoryLimitExceededException | MissingParameterException | ParsingException | PreconditionsFailedException | QueryLimitExceededException | QueryLimitException | QueryTooLargeException | TimeLimitExceededException | TooManyRequestsException | UnsupportedOperationException | CommonErrors;
/**
 * Executes a Gremlin Explain query.
 *
 * Amazon Neptune has added a Gremlin feature named `explain` that provides is a self-service tool for understanding the execution approach being taken by the Neptune engine for the query. You invoke it by adding an `explain` parameter to an HTTP call that submits a Gremlin query.
 *
 * The explain feature provides information about the logical structure of query execution plans. You can use this information to identify potential evaluation and execution bottlenecks and to tune your query, as explained in Tuning Gremlin queries. You can also use query hints to improve query execution plans.
 *
 * When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows one of the following IAM actions in that cluster, depending on the query:
 *
 * - neptune-db:ReadDataViaQuery
 *
 * - neptune-db:WriteDataViaQuery
 *
 * - neptune-db:DeleteDataViaQuery
 *
 * Note that the neptune-db:QueryLanguage:Gremlin IAM condition key can be used in the policy document to restrict the use of Gremlin queries (see Condition keys available in Neptune IAM data-access policy statements).
 */
export declare const executeGremlinExplainQuery: API.OperationMethod<ExecuteGremlinExplainQueryInput, ExecuteGremlinExplainQueryOutput, ExecuteGremlinExplainQueryError, Credentials | Region | HttpClient.HttpClient>;
export type ExecuteGremlinProfileQueryError = BadRequestException | CancelledByUserException | ClientTimeoutException | ConcurrentModificationException | ConstraintViolationException | FailureByQueryException | IllegalArgumentException | InvalidArgumentException | InvalidParameterException | MalformedQueryException | MemoryLimitExceededException | MissingParameterException | ParsingException | PreconditionsFailedException | QueryLimitExceededException | QueryLimitException | QueryTooLargeException | TimeLimitExceededException | TooManyRequestsException | UnsupportedOperationException | CommonErrors;
/**
 * Executes a Gremlin Profile query, which runs a specified traversal, collects various metrics about the run, and produces a profile report as output. See Gremlin profile API in Neptune for details.
 *
 * When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:ReadDataViaQuery IAM action in that cluster.
 *
 * Note that the neptune-db:QueryLanguage:Gremlin IAM condition key can be used in the policy document to restrict the use of Gremlin queries (see Condition keys available in Neptune IAM data-access policy statements).
 */
export declare const executeGremlinProfileQuery: API.OperationMethod<ExecuteGremlinProfileQueryInput, ExecuteGremlinProfileQueryOutput, ExecuteGremlinProfileQueryError, Credentials | Region | HttpClient.HttpClient>;
export type ExecuteGremlinQueryError = BadRequestException | CancelledByUserException | ClientTimeoutException | ConcurrentModificationException | ConstraintViolationException | FailureByQueryException | IllegalArgumentException | InvalidArgumentException | InvalidParameterException | MalformedQueryException | MemoryLimitExceededException | MissingParameterException | ParsingException | PreconditionsFailedException | QueryLimitExceededException | QueryLimitException | QueryTooLargeException | TimeLimitExceededException | TooManyRequestsException | UnsupportedOperationException | CommonErrors;
/**
 * This commands executes a Gremlin query. Amazon Neptune is compatible with Apache TinkerPop3 and Gremlin, so you can use the Gremlin traversal language to query the graph, as described under The Graph in the Apache TinkerPop3 documentation. More details can also be found in Accessing a Neptune graph with Gremlin.
 *
 * When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that enables one of the following IAM actions in that cluster, depending on the query:
 *
 * - neptune-db:ReadDataViaQuery
 *
 * - neptune-db:WriteDataViaQuery
 *
 * - neptune-db:DeleteDataViaQuery
 *
 * Note that the neptune-db:QueryLanguage:Gremlin IAM condition key can be used in the policy document to restrict the use of Gremlin queries (see Condition keys available in Neptune IAM data-access policy statements).
 */
export declare const executeGremlinQuery: API.OperationMethod<ExecuteGremlinQueryInput, ExecuteGremlinQueryOutput, ExecuteGremlinQueryError, Credentials | Region | HttpClient.HttpClient>;
export type ExecuteOpenCypherExplainQueryError = BadRequestException | CancelledByUserException | ClientTimeoutException | ConcurrentModificationException | ConstraintViolationException | FailureByQueryException | IllegalArgumentException | InvalidArgumentException | InvalidNumericDataException | InvalidParameterException | MalformedQueryException | MemoryLimitExceededException | MissingParameterException | ParsingException | PreconditionsFailedException | QueryLimitExceededException | QueryLimitException | QueryTooLargeException | TimeLimitExceededException | TooManyRequestsException | UnsupportedOperationException | CommonErrors;
/**
 * Executes an openCypher `explain` request. See The openCypher explain feature for more information.
 *
 * When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:ReadDataViaQuery IAM action in that cluster.
 *
 * Note that the neptune-db:QueryLanguage:OpenCypher IAM condition key can be used in the policy document to restrict the use of openCypher queries (see Condition keys available in Neptune IAM data-access policy statements).
 */
export declare const executeOpenCypherExplainQuery: API.OperationMethod<ExecuteOpenCypherExplainQueryInput, ExecuteOpenCypherExplainQueryOutput, ExecuteOpenCypherExplainQueryError, Credentials | Region | HttpClient.HttpClient>;
export type ExecuteOpenCypherQueryError = BadRequestException | CancelledByUserException | ClientTimeoutException | ConcurrentModificationException | ConstraintViolationException | FailureByQueryException | IllegalArgumentException | InvalidArgumentException | InvalidNumericDataException | InvalidParameterException | MalformedQueryException | MemoryLimitExceededException | MissingParameterException | ParsingException | PreconditionsFailedException | QueryLimitExceededException | QueryLimitException | QueryTooLargeException | TimeLimitExceededException | TooManyRequestsException | UnsupportedOperationException | CommonErrors;
/**
 * Executes an openCypher query. See Accessing the Neptune Graph with openCypher for more information.
 *
 * Neptune supports building graph applications using openCypher, which is currently one of the most popular query languages among developers working with graph databases. Developers, business analysts, and data scientists like openCypher's declarative, SQL-inspired syntax because it provides a familiar structure in which to querying property graphs.
 *
 * The openCypher language was originally developed by Neo4j, then open-sourced in 2015 and contributed to the openCypher project under an Apache 2 open-source license.
 *
 * Note that when invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows one of the following IAM actions in that cluster, depending on the query:
 *
 * - neptune-db:ReadDataViaQuery
 *
 * - neptune-db:WriteDataViaQuery
 *
 * - neptune-db:DeleteDataViaQuery
 *
 * Note also that the neptune-db:QueryLanguage:OpenCypher IAM condition key can be used in the policy document to restrict the use of openCypher queries (see Condition keys available in Neptune IAM data-access policy statements).
 */
export declare const executeOpenCypherQuery: API.OperationMethod<ExecuteOpenCypherQueryInput, ExecuteOpenCypherQueryOutput, ExecuteOpenCypherQueryError, Credentials | Region | HttpClient.HttpClient>;
export type GetEngineStatusError = ClientTimeoutException | ConstraintViolationException | IllegalArgumentException | InternalFailureException | InvalidArgumentException | PreconditionsFailedException | TooManyRequestsException | UnsupportedOperationException | CommonErrors;
/**
 * Retrieves the status of the graph database on the host.
 *
 * When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:GetEngineStatus IAM action in that cluster.
 */
export declare const getEngineStatus: API.OperationMethod<GetEngineStatusRequest, GetEngineStatusOutput, GetEngineStatusError, Credentials | Region | HttpClient.HttpClient>;
export type GetGremlinQueryStatusError = AccessDeniedException | BadRequestException | ClientTimeoutException | ConcurrentModificationException | ConstraintViolationException | FailureByQueryException | IllegalArgumentException | InvalidArgumentException | InvalidParameterException | MissingParameterException | ParsingException | PreconditionsFailedException | ReadOnlyViolationException | TimeLimitExceededException | TooManyRequestsException | UnsupportedOperationException | CommonErrors;
/**
 * Gets the status of a specified Gremlin query.
 *
 * When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:GetQueryStatus IAM action in that cluster.
 *
 * Note that the neptune-db:QueryLanguage:Gremlin IAM condition key can be used in the policy document to restrict the use of Gremlin queries (see Condition keys available in Neptune IAM data-access policy statements).
 */
export declare const getGremlinQueryStatus: API.OperationMethod<GetGremlinQueryStatusInput, GetGremlinQueryStatusOutput, GetGremlinQueryStatusError, Credentials | Region | HttpClient.HttpClient>;
export type GetLoaderJobStatusError = BadRequestException | BulkLoadIdNotFoundException | ClientTimeoutException | ConstraintViolationException | IllegalArgumentException | InternalFailureException | InvalidArgumentException | InvalidParameterException | LoadUrlAccessDeniedException | MissingParameterException | PreconditionsFailedException | TooManyRequestsException | UnsupportedOperationException | CommonErrors;
/**
 * Gets status information about a specified load job. Neptune keeps track of the most recent 1,024 bulk load jobs, and stores the last 10,000 error details per job.
 *
 * See Neptune Loader Get-Status API for more information.
 *
 * When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:GetLoaderJobStatus IAM action in that cluster..
 */
export declare const getLoaderJobStatus: API.OperationMethod<GetLoaderJobStatusInput, GetLoaderJobStatusOutput, GetLoaderJobStatusError, Credentials | Region | HttpClient.HttpClient>;
export type GetMLDataProcessingJobError = BadRequestException | ClientTimeoutException | ConstraintViolationException | IllegalArgumentException | InvalidArgumentException | InvalidParameterException | MissingParameterException | MLResourceNotFoundException | PreconditionsFailedException | TooManyRequestsException | UnsupportedOperationException | CommonErrors;
/**
 * Retrieves information about a specified data processing job. See The `dataprocessing` command.
 *
 * When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:neptune-db:GetMLDataProcessingJobStatus IAM action in that cluster.
 */
export declare const getMLDataProcessingJob: API.OperationMethod<GetMLDataProcessingJobInput, GetMLDataProcessingJobOutput, GetMLDataProcessingJobError, Credentials | Region | HttpClient.HttpClient>;
export type GetMLEndpointError = BadRequestException | ClientTimeoutException | ConstraintViolationException | IllegalArgumentException | InvalidArgumentException | InvalidParameterException | MissingParameterException | MLResourceNotFoundException | PreconditionsFailedException | TooManyRequestsException | UnsupportedOperationException | CommonErrors;
/**
 * Retrieves details about an inference endpoint. See Managing inference endpoints using the endpoints command.
 *
 * When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:GetMLEndpointStatus IAM action in that cluster.
 */
export declare const getMLEndpoint: API.OperationMethod<GetMLEndpointInput, GetMLEndpointOutput, GetMLEndpointError, Credentials | Region | HttpClient.HttpClient>;
export type GetMLModelTrainingJobError = BadRequestException | ClientTimeoutException | ConstraintViolationException | IllegalArgumentException | InvalidArgumentException | InvalidParameterException | MissingParameterException | MLResourceNotFoundException | PreconditionsFailedException | TooManyRequestsException | UnsupportedOperationException | CommonErrors;
/**
 * Retrieves information about a Neptune ML model training job. See Model training using the `modeltraining` command.
 *
 * When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:GetMLModelTrainingJobStatus IAM action in that cluster.
 */
export declare const getMLModelTrainingJob: API.OperationMethod<GetMLModelTrainingJobInput, GetMLModelTrainingJobOutput, GetMLModelTrainingJobError, Credentials | Region | HttpClient.HttpClient>;
export type GetMLModelTransformJobError = BadRequestException | ClientTimeoutException | ConstraintViolationException | IllegalArgumentException | InvalidArgumentException | InvalidParameterException | MissingParameterException | MLResourceNotFoundException | PreconditionsFailedException | TooManyRequestsException | UnsupportedOperationException | CommonErrors;
/**
 * Gets information about a specified model transform job. See Use a trained model to generate new model artifacts.
 *
 * When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:GetMLModelTransformJobStatus IAM action in that cluster.
 */
export declare const getMLModelTransformJob: API.OperationMethod<GetMLModelTransformJobInput, GetMLModelTransformJobOutput, GetMLModelTransformJobError, Credentials | Region | HttpClient.HttpClient>;
export type GetOpenCypherQueryStatusError = AccessDeniedException | BadRequestException | ClientTimeoutException | ConcurrentModificationException | ConstraintViolationException | FailureByQueryException | IllegalArgumentException | InvalidArgumentException | InvalidNumericDataException | InvalidParameterException | MissingParameterException | ParsingException | PreconditionsFailedException | ReadOnlyViolationException | TimeLimitExceededException | TooManyRequestsException | UnsupportedOperationException | CommonErrors;
/**
 * Retrieves the status of a specified openCypher query.
 *
 * When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:GetQueryStatus IAM action in that cluster.
 *
 * Note that the neptune-db:QueryLanguage:OpenCypher IAM condition key can be used in the policy document to restrict the use of openCypher queries (see Condition keys available in Neptune IAM data-access policy statements).
 */
export declare const getOpenCypherQueryStatus: API.OperationMethod<GetOpenCypherQueryStatusInput, GetOpenCypherQueryStatusOutput, GetOpenCypherQueryStatusError, Credentials | Region | HttpClient.HttpClient>;
export type GetPropertygraphStatisticsError = AccessDeniedException | BadRequestException | ClientTimeoutException | ConstraintViolationException | IllegalArgumentException | InvalidArgumentException | InvalidParameterException | MissingParameterException | PreconditionsFailedException | ReadOnlyViolationException | StatisticsNotAvailableException | TooManyRequestsException | UnsupportedOperationException | CommonErrors;
/**
 * Gets property graph statistics (Gremlin and openCypher).
 *
 * When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:GetStatisticsStatus IAM action in that cluster.
 */
export declare const getPropertygraphStatistics: API.OperationMethod<GetPropertygraphStatisticsRequest, GetPropertygraphStatisticsOutput, GetPropertygraphStatisticsError, Credentials | Region | HttpClient.HttpClient>;
export type GetPropertygraphStreamError = ClientTimeoutException | ConstraintViolationException | ExpiredStreamException | IllegalArgumentException | InvalidArgumentException | InvalidParameterException | MemoryLimitExceededException | PreconditionsFailedException | StreamRecordsNotFoundException | ThrottlingException | TooManyRequestsException | UnsupportedOperationException | CommonErrors;
/**
 * Gets a stream for a property graph.
 *
 * With the Neptune Streams feature, you can generate a complete sequence of change-log entries that record every change made to your graph data as it happens. `GetPropertygraphStream` lets you collect these change-log entries for a property graph.
 *
 * The Neptune streams feature needs to be enabled on your Neptune DBcluster. To enable streams, set the neptune_streams DB cluster parameter to `1`.
 *
 * See Capturing graph changes in real time using Neptune streams.
 *
 * When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:GetStreamRecords IAM action in that cluster.
 *
 * When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that enables one of the following IAM actions, depending on the query:
 *
 * Note that you can restrict property-graph queries using the following IAM context keys:
 *
 * - neptune-db:QueryLanguage:Gremlin
 *
 * - neptune-db:QueryLanguage:OpenCypher
 *
 * See Condition keys available in Neptune IAM data-access policy statements).
 */
export declare const getPropertygraphStream: API.OperationMethod<GetPropertygraphStreamInput, GetPropertygraphStreamOutput, GetPropertygraphStreamError, Credentials | Region | HttpClient.HttpClient>;
export type GetPropertygraphSummaryError = AccessDeniedException | BadRequestException | ClientTimeoutException | ConstraintViolationException | IllegalArgumentException | InvalidArgumentException | InvalidParameterException | MissingParameterException | PreconditionsFailedException | ReadOnlyViolationException | StatisticsNotAvailableException | TooManyRequestsException | UnsupportedOperationException | CommonErrors;
/**
 * Gets a graph summary for a property graph.
 *
 * When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:GetGraphSummary IAM action in that cluster.
 */
export declare const getPropertygraphSummary: API.OperationMethod<GetPropertygraphSummaryInput, GetPropertygraphSummaryOutput, GetPropertygraphSummaryError, Credentials | Region | HttpClient.HttpClient>;
export type GetRDFGraphSummaryError = AccessDeniedException | BadRequestException | ClientTimeoutException | ConstraintViolationException | IllegalArgumentException | InvalidArgumentException | InvalidParameterException | MissingParameterException | PreconditionsFailedException | ReadOnlyViolationException | StatisticsNotAvailableException | TooManyRequestsException | UnsupportedOperationException | CommonErrors;
/**
 * Gets a graph summary for an RDF graph.
 *
 * When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:GetGraphSummary IAM action in that cluster.
 */
export declare const getRDFGraphSummary: API.OperationMethod<GetRDFGraphSummaryInput, GetRDFGraphSummaryOutput, GetRDFGraphSummaryError, Credentials | Region | HttpClient.HttpClient>;
export type GetSparqlStatisticsError = AccessDeniedException | BadRequestException | ClientTimeoutException | ConstraintViolationException | IllegalArgumentException | InvalidArgumentException | InvalidParameterException | MissingParameterException | PreconditionsFailedException | ReadOnlyViolationException | StatisticsNotAvailableException | TooManyRequestsException | UnsupportedOperationException | CommonErrors;
/**
 * Gets RDF statistics (SPARQL).
 */
export declare const getSparqlStatistics: API.OperationMethod<GetSparqlStatisticsRequest, GetSparqlStatisticsOutput, GetSparqlStatisticsError, Credentials | Region | HttpClient.HttpClient>;
export type GetSparqlStreamError = ClientTimeoutException | ConstraintViolationException | ExpiredStreamException | IllegalArgumentException | InvalidArgumentException | InvalidParameterException | MemoryLimitExceededException | PreconditionsFailedException | StreamRecordsNotFoundException | ThrottlingException | TooManyRequestsException | UnsupportedOperationException | CommonErrors;
/**
 * Gets a stream for an RDF graph.
 *
 * With the Neptune Streams feature, you can generate a complete sequence of change-log entries that record every change made to your graph data as it happens. `GetSparqlStream` lets you collect these change-log entries for an RDF graph.
 *
 * The Neptune streams feature needs to be enabled on your Neptune DBcluster. To enable streams, set the neptune_streams DB cluster parameter to `1`.
 *
 * See Capturing graph changes in real time using Neptune streams.
 *
 * When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:GetStreamRecords IAM action in that cluster.
 *
 * Note that the neptune-db:QueryLanguage:Sparql IAM condition key can be used in the policy document to restrict the use of SPARQL queries (see Condition keys available in Neptune IAM data-access policy statements).
 */
export declare const getSparqlStream: API.OperationMethod<GetSparqlStreamInput, GetSparqlStreamOutput, GetSparqlStreamError, Credentials | Region | HttpClient.HttpClient>;
export type ListGremlinQueriesError = AccessDeniedException | BadRequestException | ClientTimeoutException | ConcurrentModificationException | ConstraintViolationException | FailureByQueryException | IllegalArgumentException | InvalidArgumentException | InvalidParameterException | MissingParameterException | ParsingException | PreconditionsFailedException | ReadOnlyViolationException | TimeLimitExceededException | TooManyRequestsException | UnsupportedOperationException | CommonErrors;
/**
 * Lists active Gremlin queries. See Gremlin query status API for details about the output.
 *
 * When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:GetQueryStatus IAM action in that cluster.
 *
 * Note that the neptune-db:QueryLanguage:Gremlin IAM condition key can be used in the policy document to restrict the use of Gremlin queries (see Condition keys available in Neptune IAM data-access policy statements).
 */
export declare const listGremlinQueries: API.OperationMethod<ListGremlinQueriesInput, ListGremlinQueriesOutput, ListGremlinQueriesError, Credentials | Region | HttpClient.HttpClient>;
export type ListLoaderJobsError = BadRequestException | BulkLoadIdNotFoundException | ClientTimeoutException | ConstraintViolationException | IllegalArgumentException | InternalFailureException | InvalidArgumentException | InvalidParameterException | LoadUrlAccessDeniedException | PreconditionsFailedException | TooManyRequestsException | UnsupportedOperationException | CommonErrors;
/**
 * Retrieves a list of the `loadIds` for all active loader jobs.
 *
 * When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:ListLoaderJobs IAM action in that cluster..
 */
export declare const listLoaderJobs: API.OperationMethod<ListLoaderJobsInput, ListLoaderJobsOutput, ListLoaderJobsError, Credentials | Region | HttpClient.HttpClient>;
export type ListMLDataProcessingJobsError = BadRequestException | ClientTimeoutException | ConstraintViolationException | IllegalArgumentException | InvalidArgumentException | InvalidParameterException | MissingParameterException | MLResourceNotFoundException | PreconditionsFailedException | TooManyRequestsException | UnsupportedOperationException | CommonErrors;
/**
 * Returns a list of Neptune ML data processing jobs. See Listing active data-processing jobs using the Neptune ML dataprocessing command.
 *
 * When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:ListMLDataProcessingJobs IAM action in that cluster.
 */
export declare const listMLDataProcessingJobs: API.OperationMethod<ListMLDataProcessingJobsInput, ListMLDataProcessingJobsOutput, ListMLDataProcessingJobsError, Credentials | Region | HttpClient.HttpClient>;
export type ListMLEndpointsError = BadRequestException | ClientTimeoutException | ConstraintViolationException | IllegalArgumentException | InvalidArgumentException | InvalidParameterException | MissingParameterException | MLResourceNotFoundException | PreconditionsFailedException | TooManyRequestsException | UnsupportedOperationException | CommonErrors;
/**
 * Lists existing inference endpoints. See Managing inference endpoints using the endpoints command.
 *
 * When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:ListMLEndpoints IAM action in that cluster.
 */
export declare const listMLEndpoints: API.OperationMethod<ListMLEndpointsInput, ListMLEndpointsOutput, ListMLEndpointsError, Credentials | Region | HttpClient.HttpClient>;
export type ListMLModelTrainingJobsError = BadRequestException | ClientTimeoutException | ConstraintViolationException | IllegalArgumentException | InvalidArgumentException | InvalidParameterException | MissingParameterException | MLResourceNotFoundException | PreconditionsFailedException | TooManyRequestsException | UnsupportedOperationException | CommonErrors;
/**
 * Lists Neptune ML model-training jobs. See Model training using the `modeltraining` command.
 *
 * When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:neptune-db:ListMLModelTrainingJobs IAM action in that cluster.
 */
export declare const listMLModelTrainingJobs: API.OperationMethod<ListMLModelTrainingJobsInput, ListMLModelTrainingJobsOutput, ListMLModelTrainingJobsError, Credentials | Region | HttpClient.HttpClient>;
export type ListMLModelTransformJobsError = BadRequestException | ClientTimeoutException | ConstraintViolationException | IllegalArgumentException | InvalidArgumentException | InvalidParameterException | MissingParameterException | MLResourceNotFoundException | PreconditionsFailedException | TooManyRequestsException | UnsupportedOperationException | CommonErrors;
/**
 * Returns a list of model transform job IDs. See Use a trained model to generate new model artifacts.
 *
 * When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:ListMLModelTransformJobs IAM action in that cluster.
 */
export declare const listMLModelTransformJobs: API.OperationMethod<ListMLModelTransformJobsInput, ListMLModelTransformJobsOutput, ListMLModelTransformJobsError, Credentials | Region | HttpClient.HttpClient>;
export type ListOpenCypherQueriesError = AccessDeniedException | BadRequestException | ClientTimeoutException | ConcurrentModificationException | ConstraintViolationException | FailureByQueryException | IllegalArgumentException | InvalidArgumentException | InvalidNumericDataException | InvalidParameterException | MissingParameterException | ParsingException | PreconditionsFailedException | ReadOnlyViolationException | TimeLimitExceededException | TooManyRequestsException | UnsupportedOperationException | CommonErrors;
/**
 * Lists active openCypher queries. See Neptune openCypher status endpoint for more information.
 *
 * When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:GetQueryStatus IAM action in that cluster.
 *
 * Note that the neptune-db:QueryLanguage:OpenCypher IAM condition key can be used in the policy document to restrict the use of openCypher queries (see Condition keys available in Neptune IAM data-access policy statements).
 */
export declare const listOpenCypherQueries: API.OperationMethod<ListOpenCypherQueriesInput, ListOpenCypherQueriesOutput, ListOpenCypherQueriesError, Credentials | Region | HttpClient.HttpClient>;
export type ManagePropertygraphStatisticsError = AccessDeniedException | BadRequestException | ClientTimeoutException | ConstraintViolationException | IllegalArgumentException | InvalidArgumentException | InvalidParameterException | MissingParameterException | PreconditionsFailedException | ReadOnlyViolationException | StatisticsNotAvailableException | TooManyRequestsException | UnsupportedOperationException | CommonErrors;
/**
 * Manages the generation and use of property graph statistics.
 *
 * When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:ManageStatistics IAM action in that cluster.
 */
export declare const managePropertygraphStatistics: API.OperationMethod<ManagePropertygraphStatisticsInput, ManagePropertygraphStatisticsOutput, ManagePropertygraphStatisticsError, Credentials | Region | HttpClient.HttpClient>;
export type ManageSparqlStatisticsError = AccessDeniedException | BadRequestException | ClientTimeoutException | ConstraintViolationException | IllegalArgumentException | InvalidArgumentException | InvalidParameterException | MissingParameterException | PreconditionsFailedException | ReadOnlyViolationException | StatisticsNotAvailableException | TooManyRequestsException | UnsupportedOperationException | CommonErrors;
/**
 * Manages the generation and use of RDF graph statistics.
 *
 * When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:ManageStatistics IAM action in that cluster.
 */
export declare const manageSparqlStatistics: API.OperationMethod<ManageSparqlStatisticsInput, ManageSparqlStatisticsOutput, ManageSparqlStatisticsError, Credentials | Region | HttpClient.HttpClient>;
export type StartLoaderJobError = BadRequestException | BulkLoadIdNotFoundException | ClientTimeoutException | ConstraintViolationException | IllegalArgumentException | InternalFailureException | InvalidArgumentException | InvalidParameterException | LoadUrlAccessDeniedException | MissingParameterException | PreconditionsFailedException | S3Exception | TooManyRequestsException | UnsupportedOperationException | CommonErrors;
/**
 * Starts a Neptune bulk loader job to load data from an Amazon S3 bucket into a Neptune DB instance. See Using the Amazon Neptune Bulk Loader to Ingest Data.
 *
 * When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:StartLoaderJob IAM action in that cluster.
 */
export declare const startLoaderJob: API.OperationMethod<StartLoaderJobInput, StartLoaderJobOutput, StartLoaderJobError, Credentials | Region | HttpClient.HttpClient>;
export type StartMLDataProcessingJobError = BadRequestException | ClientTimeoutException | ConstraintViolationException | IllegalArgumentException | InvalidArgumentException | InvalidParameterException | MissingParameterException | MLResourceNotFoundException | PreconditionsFailedException | TooManyRequestsException | UnsupportedOperationException | CommonErrors;
/**
 * Creates a new Neptune ML data processing job for processing the graph data exported from Neptune for training. See The `dataprocessing` command.
 *
 * When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:StartMLModelDataProcessingJob IAM action in that cluster.
 */
export declare const startMLDataProcessingJob: API.OperationMethod<StartMLDataProcessingJobInput, StartMLDataProcessingJobOutput, StartMLDataProcessingJobError, Credentials | Region | HttpClient.HttpClient>;
export type StartMLModelTrainingJobError = BadRequestException | ClientTimeoutException | ConstraintViolationException | IllegalArgumentException | InvalidArgumentException | InvalidParameterException | MissingParameterException | MLResourceNotFoundException | PreconditionsFailedException | TooManyRequestsException | UnsupportedOperationException | CommonErrors;
/**
 * Creates a new Neptune ML model training job. See Model training using the `modeltraining` command.
 *
 * When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:StartMLModelTrainingJob IAM action in that cluster.
 */
export declare const startMLModelTrainingJob: API.OperationMethod<StartMLModelTrainingJobInput, StartMLModelTrainingJobOutput, StartMLModelTrainingJobError, Credentials | Region | HttpClient.HttpClient>;
export type StartMLModelTransformJobError = BadRequestException | ClientTimeoutException | ConstraintViolationException | IllegalArgumentException | InvalidArgumentException | InvalidParameterException | MissingParameterException | MLResourceNotFoundException | PreconditionsFailedException | TooManyRequestsException | UnsupportedOperationException | CommonErrors;
/**
 * Creates a new model transform job. See Use a trained model to generate new model artifacts.
 *
 * When invoking this operation in a Neptune cluster that has IAM authentication enabled, the IAM user or role making the request must have a policy attached that allows the neptune-db:StartMLModelTransformJob IAM action in that cluster.
 */
export declare const startMLModelTransformJob: API.OperationMethod<StartMLModelTransformJobInput, StartMLModelTransformJobOutput, StartMLModelTransformJobError, Credentials | Region | HttpClient.HttpClient>;
export {};
//# sourceMappingURL=neptunedata.d.ts.map