import * as HttpClient from "effect/unstable/http/HttpClient";
import * as S from "effect/Schema";
import * as API from "../client/api.js";
import * as T from "../traits.js";
import * as C from "../category.js";
const svc = T.AwsApiService({
    sdkId: "neptunedata",
    serviceShapeName: "AmazonNeptuneDataplane",
});
const auth = T.AwsAuthSigv4({ name: "neptune-db" });
const ver = T.ServiceVersion("2023-08-01");
const proto = T.AwsProtocolsRestJson1();
const rules = T.EndpointResolver((p, _) => {
    const { Region, UseDualStack = false, UseFIPS = false, Endpoint } = p;
    const e = (u, p = {}, h = {}) => ({
        type: "endpoint",
        endpoint: { url: u, properties: p, headers: h },
    });
    const err = (m) => ({
        type: "error",
        message: m,
    });
    if (Endpoint != null) {
        if (UseFIPS === true) {
            return err("Invalid Configuration: FIPS and custom endpoint are not supported");
        }
        if (UseDualStack === true) {
            return err("Invalid Configuration: Dualstack and custom endpoint are not supported");
        }
        return e(Endpoint);
    }
    if (Region != null) {
        {
            const PartitionResult = _.partition(Region);
            if (PartitionResult != null && PartitionResult !== false) {
                if (UseFIPS === true && UseDualStack === true) {
                    if (true === _.getAttr(PartitionResult, "supportsFIPS") &&
                        true === _.getAttr(PartitionResult, "supportsDualStack")) {
                        return e(`https://neptune-db-fips.${Region}.${_.getAttr(PartitionResult, "dualStackDnsSuffix")}`);
                    }
                    return err("FIPS and DualStack are enabled, but this partition does not support one or both");
                }
                if (UseFIPS === true) {
                    if (_.getAttr(PartitionResult, "supportsFIPS") === true) {
                        return e(`https://neptune-db-fips.${Region}.${_.getAttr(PartitionResult, "dnsSuffix")}`);
                    }
                    return err("FIPS is enabled but this partition does not support FIPS");
                }
                if (UseDualStack === true) {
                    if (true === _.getAttr(PartitionResult, "supportsDualStack")) {
                        return e(`https://neptune-db.${Region}.${_.getAttr(PartitionResult, "dualStackDnsSuffix")}`);
                    }
                    return err("DualStack is enabled but this partition does not support DualStack");
                }
                return e(`https://neptune-db.${Region}.${_.getAttr(PartitionResult, "dnsSuffix")}`);
            }
        }
    }
    return err("Invalid Configuration: Missing Region");
});
export const CancelGremlinQueryInput = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ queryId: S.String.pipe(T.HttpLabel("queryId")) }).pipe(T.all(T.Http({ method: "DELETE", uri: "/gremlin/status/{queryId}" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "CancelGremlinQueryInput",
});
export const CancelGremlinQueryOutput = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ status: S.optional(S.String) })).annotate({
    identifier: "CancelGremlinQueryOutput",
});
export const CancelLoaderJobInput = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ loadId: S.String.pipe(T.HttpLabel("loadId")) }).pipe(T.all(T.Http({ method: "DELETE", uri: "/loader/{loadId}" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "CancelLoaderJobInput",
});
export const CancelLoaderJobOutput = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ status: S.optional(S.String) })).annotate({
    identifier: "CancelLoaderJobOutput",
});
export const CancelMLDataProcessingJobInput = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    id: S.String.pipe(T.HttpLabel("id")),
    neptuneIamRoleArn: S.optional(S.String).pipe(T.HttpQuery("neptuneIamRoleArn")),
    clean: S.optional(S.Boolean).pipe(T.HttpQuery("clean")),
}).pipe(T.all(T.Http({ method: "DELETE", uri: "/ml/dataprocessing/{id}" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "CancelMLDataProcessingJobInput",
});
export const CancelMLDataProcessingJobOutput = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ status: S.optional(S.String) })).annotate({
    identifier: "CancelMLDataProcessingJobOutput",
});
export const CancelMLModelTrainingJobInput = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    id: S.String.pipe(T.HttpLabel("id")),
    neptuneIamRoleArn: S.optional(S.String).pipe(T.HttpQuery("neptuneIamRoleArn")),
    clean: S.optional(S.Boolean).pipe(T.HttpQuery("clean")),
}).pipe(T.all(T.Http({ method: "DELETE", uri: "/ml/modeltraining/{id}" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "CancelMLModelTrainingJobInput",
});
export const CancelMLModelTrainingJobOutput = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ status: S.optional(S.String) })).annotate({
    identifier: "CancelMLModelTrainingJobOutput",
});
export const CancelMLModelTransformJobInput = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    id: S.String.pipe(T.HttpLabel("id")),
    neptuneIamRoleArn: S.optional(S.String).pipe(T.HttpQuery("neptuneIamRoleArn")),
    clean: S.optional(S.Boolean).pipe(T.HttpQuery("clean")),
}).pipe(T.all(T.Http({ method: "DELETE", uri: "/ml/modeltransform/{id}" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "CancelMLModelTransformJobInput",
});
export const CancelMLModelTransformJobOutput = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ status: S.optional(S.String) })).annotate({
    identifier: "CancelMLModelTransformJobOutput",
});
export const CancelOpenCypherQueryInput = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    queryId: S.String.pipe(T.HttpLabel("queryId")),
    silent: S.optional(S.Boolean).pipe(T.HttpQuery("silent")),
}).pipe(T.all(T.Http({ method: "DELETE", uri: "/opencypher/status/{queryId}" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "CancelOpenCypherQueryInput",
});
export const CancelOpenCypherQueryOutput = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ status: S.optional(S.String), payload: S.optional(S.Boolean) })).annotate({
    identifier: "CancelOpenCypherQueryOutput",
});
export const CreateMLEndpointInput = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    id: S.optional(S.String),
    mlModelTrainingJobId: S.optional(S.String),
    mlModelTransformJobId: S.optional(S.String),
    update: S.optional(S.Boolean),
    neptuneIamRoleArn: S.optional(S.String),
    modelName: S.optional(S.String),
    instanceType: S.optional(S.String),
    instanceCount: S.optional(S.Number),
    volumeEncryptionKMSKey: S.optional(S.String),
}).pipe(T.all(T.Http({ method: "POST", uri: "/ml/endpoints" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "CreateMLEndpointInput",
});
export const CreateMLEndpointOutput = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    id: S.optional(S.String),
    arn: S.optional(S.String),
    creationTimeInMillis: S.optional(S.Number),
})).annotate({
    identifier: "CreateMLEndpointOutput",
});
export const DeleteMLEndpointInput = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    id: S.String.pipe(T.HttpLabel("id")),
    neptuneIamRoleArn: S.optional(S.String).pipe(T.HttpQuery("neptuneIamRoleArn")),
    clean: S.optional(S.Boolean).pipe(T.HttpQuery("clean")),
}).pipe(T.all(T.Http({ method: "DELETE", uri: "/ml/endpoints/{id}" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DeleteMLEndpointInput",
});
export const DeleteMLEndpointOutput = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ status: S.optional(S.String) })).annotate({
    identifier: "DeleteMLEndpointOutput",
});
export const DeletePropertygraphStatisticsRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({}).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DeletePropertygraphStatisticsRequest",
});
export const DeleteStatisticsValueMap = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    active: S.optional(S.Boolean),
    statisticsId: S.optional(S.String),
})).annotate({
    identifier: "DeleteStatisticsValueMap",
});
export const DeletePropertygraphStatisticsOutput = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    statusCode: S.optional(S.Number).pipe(T.HttpResponseCode()),
    status: S.optional(S.String),
    payload: S.optional(DeleteStatisticsValueMap),
})).annotate({
    identifier: "DeletePropertygraphStatisticsOutput",
});
export const DeleteSparqlStatisticsRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({}).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DeleteSparqlStatisticsRequest",
});
export const DeleteSparqlStatisticsOutput = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    statusCode: S.optional(S.Number).pipe(T.HttpResponseCode()),
    status: S.optional(S.String),
    payload: S.optional(DeleteStatisticsValueMap),
})).annotate({
    identifier: "DeleteSparqlStatisticsOutput",
});
export const Action = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const ExecuteFastResetInput = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ action: Action, token: S.optional(S.String) }).pipe(T.all(T.Http({ method: "POST", uri: "/system" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ExecuteFastResetInput",
});
export const FastResetToken = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ token: S.optional(S.String) })).annotate({ identifier: "FastResetToken" });
export const ExecuteFastResetOutput = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ status: S.String, payload: S.optional(FastResetToken) })).annotate({
    identifier: "ExecuteFastResetOutput",
});
export const ExecuteGremlinExplainQueryInput = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ gremlinQuery: S.String })
    .pipe(S.encodeKeys({ gremlinQuery: "gremlin" }))
    .pipe(T.all(T.Http({ method: "POST", uri: "/gremlin/explain" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ExecuteGremlinExplainQueryInput",
});
export const ExecuteGremlinExplainQueryOutput = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ output: S.optional(T.StreamingOutput).pipe(T.HttpPayload()) })).annotate({
    identifier: "ExecuteGremlinExplainQueryOutput",
});
export const ExecuteGremlinProfileQueryInput = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    gremlinQuery: S.String,
    results: S.optional(S.Boolean),
    chop: S.optional(S.Number),
    serializer: S.optional(S.String),
    indexOps: S.optional(S.Boolean),
})
    .pipe(S.encodeKeys({
    gremlinQuery: "gremlin",
    results: "profile.results",
    chop: "profile.chop",
    serializer: "profile.serializer",
    indexOps: "profile.indexOps",
}))
    .pipe(T.all(T.Http({ method: "POST", uri: "/gremlin/profile" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ExecuteGremlinProfileQueryInput",
});
export const ExecuteGremlinProfileQueryOutput = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ output: S.optional(T.StreamingOutput).pipe(T.HttpPayload()) })).annotate({
    identifier: "ExecuteGremlinProfileQueryOutput",
});
export const ExecuteGremlinQueryInput = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    gremlinQuery: S.String,
    serializer: S.optional(S.String).pipe(T.HttpHeader("accept")),
})
    .pipe(S.encodeKeys({ gremlinQuery: "gremlin" }))
    .pipe(T.all(T.Http({ method: "POST", uri: "/gremlin" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ExecuteGremlinQueryInput",
});
export const GremlinQueryStatusAttributes = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    message: S.optional(S.String),
    code: S.optional(S.Number),
    attributes: S.optional(S.Any),
})).annotate({
    identifier: "GremlinQueryStatusAttributes",
});
export const ExecuteGremlinQueryOutput = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    requestId: S.optional(S.String),
    status: S.optional(GremlinQueryStatusAttributes),
    result: S.optional(S.Any),
    meta: S.optional(S.Any),
})).annotate({
    identifier: "ExecuteGremlinQueryOutput",
});
export const OpenCypherExplainMode = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const ExecuteOpenCypherExplainQueryInput = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    openCypherQuery: S.String,
    parameters: S.optional(S.String),
    explainMode: OpenCypherExplainMode,
})
    .pipe(S.encodeKeys({ openCypherQuery: "query", explainMode: "explain" }))
    .pipe(T.all(T.Http({ method: "POST", uri: "/opencypher/explain" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ExecuteOpenCypherExplainQueryInput",
});
export const ExecuteOpenCypherExplainQueryOutput = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ results: T.Blob.pipe(T.HttpPayload()) })).annotate({
    identifier: "ExecuteOpenCypherExplainQueryOutput",
});
export const ExecuteOpenCypherQueryInput = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ openCypherQuery: S.String, parameters: S.optional(S.String) })
    .pipe(S.encodeKeys({ openCypherQuery: "query" }))
    .pipe(T.all(T.Http({ method: "POST", uri: "/opencypher" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ExecuteOpenCypherQueryInput",
});
export const ExecuteOpenCypherQueryOutput = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ results: S.Any })).annotate({
    identifier: "ExecuteOpenCypherQueryOutput",
});
export const GetEngineStatusRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({}).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "GetEngineStatusRequest",
});
export const QueryLanguageVersion = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ version: S.String })).annotate({
    identifier: "QueryLanguageVersion",
});
export const StringValuedMap = /*@__PURE__*/ /*#__PURE__*/ S.Record(S.String, S.String.pipe(S.optional));
export const DocumentValuedMap = /*@__PURE__*/ /*#__PURE__*/ S.Record(S.String, S.Any.pipe(S.optional));
export const GetEngineStatusOutput = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    status: S.optional(S.String),
    startTime: S.optional(S.String),
    dbEngineVersion: S.optional(S.String),
    role: S.optional(S.String),
    dfeQueryEngine: S.optional(S.String),
    gremlin: S.optional(QueryLanguageVersion),
    sparql: S.optional(QueryLanguageVersion),
    opencypher: S.optional(QueryLanguageVersion),
    labMode: S.optional(StringValuedMap),
    rollingBackTrxCount: S.optional(S.Number),
    rollingBackTrxEarliestStartTime: S.optional(S.String),
    features: S.optional(DocumentValuedMap),
    settings: S.optional(StringValuedMap),
})).annotate({
    identifier: "GetEngineStatusOutput",
});
export const GetGremlinQueryStatusInput = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ queryId: S.String.pipe(T.HttpLabel("queryId")) }).pipe(T.all(T.Http({ method: "GET", uri: "/gremlin/status/{queryId}" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "GetGremlinQueryStatusInput",
});
export const QueryEvalStats = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    waited: S.optional(S.Number),
    elapsed: S.optional(S.Number),
    cancelled: S.optional(S.Boolean),
    subqueries: S.optional(S.Any),
})).annotate({ identifier: "QueryEvalStats" });
export const GetGremlinQueryStatusOutput = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    queryId: S.optional(S.String),
    queryString: S.optional(S.String),
    queryEvalStats: S.optional(QueryEvalStats),
})).annotate({
    identifier: "GetGremlinQueryStatusOutput",
});
export const GetLoaderJobStatusInput = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    loadId: S.String.pipe(T.HttpLabel("loadId")),
    details: S.optional(S.Boolean).pipe(T.HttpQuery("details")),
    errors: S.optional(S.Boolean).pipe(T.HttpQuery("errors")),
    page: S.optional(S.Number).pipe(T.HttpQuery("page")),
    errorsPerPage: S.optional(S.Number).pipe(T.HttpQuery("errorsPerPage")),
}).pipe(T.all(T.Http({ method: "GET", uri: "/loader/{loadId}" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "GetLoaderJobStatusInput",
});
export const GetLoaderJobStatusOutput = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ status: S.String, payload: S.Any })).annotate({
    identifier: "GetLoaderJobStatusOutput",
});
export const GetMLDataProcessingJobInput = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    id: S.String.pipe(T.HttpLabel("id")),
    neptuneIamRoleArn: S.optional(S.String).pipe(T.HttpQuery("neptuneIamRoleArn")),
}).pipe(T.all(T.Http({ method: "GET", uri: "/ml/dataprocessing/{id}" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "GetMLDataProcessingJobInput",
});
export const MlResourceDefinition = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    name: S.optional(S.String),
    arn: S.optional(S.String),
    status: S.optional(S.String),
    outputLocation: S.optional(S.String),
    failureReason: S.optional(S.String),
    cloudwatchLogUrl: S.optional(S.String),
})).annotate({
    identifier: "MlResourceDefinition",
});
export const GetMLDataProcessingJobOutput = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    status: S.optional(S.String),
    id: S.optional(S.String),
    processingJob: S.optional(MlResourceDefinition),
})).annotate({
    identifier: "GetMLDataProcessingJobOutput",
});
export const GetMLEndpointInput = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    id: S.String.pipe(T.HttpLabel("id")),
    neptuneIamRoleArn: S.optional(S.String).pipe(T.HttpQuery("neptuneIamRoleArn")),
}).pipe(T.all(T.Http({ method: "GET", uri: "/ml/endpoints/{id}" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "GetMLEndpointInput",
});
export const MlConfigDefinition = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ name: S.optional(S.String), arn: S.optional(S.String) })).annotate({
    identifier: "MlConfigDefinition",
});
export const GetMLEndpointOutput = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    status: S.optional(S.String),
    id: S.optional(S.String),
    endpoint: S.optional(MlResourceDefinition),
    endpointConfig: S.optional(MlConfigDefinition),
})).annotate({
    identifier: "GetMLEndpointOutput",
});
export const GetMLModelTrainingJobInput = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    id: S.String.pipe(T.HttpLabel("id")),
    neptuneIamRoleArn: S.optional(S.String).pipe(T.HttpQuery("neptuneIamRoleArn")),
}).pipe(T.all(T.Http({ method: "GET", uri: "/ml/modeltraining/{id}" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "GetMLModelTrainingJobInput",
});
export const MlModels = /*@__PURE__*/ /*#__PURE__*/ S.Array(MlConfigDefinition);
export const GetMLModelTrainingJobOutput = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    status: S.optional(S.String),
    id: S.optional(S.String),
    processingJob: S.optional(MlResourceDefinition),
    hpoJob: S.optional(MlResourceDefinition),
    modelTransformJob: S.optional(MlResourceDefinition),
    mlModels: S.optional(MlModels),
})).annotate({
    identifier: "GetMLModelTrainingJobOutput",
});
export const GetMLModelTransformJobInput = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    id: S.String.pipe(T.HttpLabel("id")),
    neptuneIamRoleArn: S.optional(S.String).pipe(T.HttpQuery("neptuneIamRoleArn")),
}).pipe(T.all(T.Http({ method: "GET", uri: "/ml/modeltransform/{id}" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "GetMLModelTransformJobInput",
});
export const Models = /*@__PURE__*/ /*#__PURE__*/ S.Array(MlConfigDefinition);
export const GetMLModelTransformJobOutput = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    status: S.optional(S.String),
    id: S.optional(S.String),
    baseProcessingJob: S.optional(MlResourceDefinition),
    remoteModelTransformJob: S.optional(MlResourceDefinition),
    models: S.optional(Models),
})).annotate({
    identifier: "GetMLModelTransformJobOutput",
});
export const GetOpenCypherQueryStatusInput = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ queryId: S.String.pipe(T.HttpLabel("queryId")) }).pipe(T.all(T.Http({ method: "GET", uri: "/opencypher/status/{queryId}" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "GetOpenCypherQueryStatusInput",
});
export const GetOpenCypherQueryStatusOutput = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    queryId: S.optional(S.String),
    queryString: S.optional(S.String),
    queryEvalStats: S.optional(QueryEvalStats),
})).annotate({
    identifier: "GetOpenCypherQueryStatusOutput",
});
export const GetPropertygraphStatisticsRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({}).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "GetPropertygraphStatisticsRequest",
});
export const StatisticsSummary = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    signatureCount: S.optional(S.Number),
    instanceCount: S.optional(S.Number),
    predicateCount: S.optional(S.Number),
})).annotate({
    identifier: "StatisticsSummary",
});
export const Statistics = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    autoCompute: S.optional(S.Boolean),
    active: S.optional(S.Boolean),
    statisticsId: S.optional(S.String),
    date: S.optional(T.DateFromString.pipe(T.TimestampFormat("date-time"))),
    note: S.optional(S.String),
    signatureInfo: S.optional(StatisticsSummary),
})).annotate({ identifier: "Statistics" });
export const GetPropertygraphStatisticsOutput = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ status: S.String, payload: Statistics })).annotate({
    identifier: "GetPropertygraphStatisticsOutput",
});
export const IteratorType = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const Encoding = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const GetPropertygraphStreamInput = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    limit: S.optional(S.Number).pipe(T.HttpQuery("limit")),
    iteratorType: S.optional(IteratorType).pipe(T.HttpQuery("iteratorType")),
    commitNum: S.optional(S.Number).pipe(T.HttpQuery("commitNum")),
    opNum: S.optional(S.Number).pipe(T.HttpQuery("opNum")),
    encoding: S.optional(Encoding).pipe(T.HttpHeader("Accept-Encoding")),
}).pipe(T.all(T.Http({ method: "GET", uri: "/propertygraph/stream" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "GetPropertygraphStreamInput",
});
export const PropertygraphData = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    id: S.String,
    type: S.String,
    key: S.String,
    value: S.Any,
    from: S.optional(S.String),
    to: S.optional(S.String),
})).annotate({
    identifier: "PropertygraphData",
});
export const PropertygraphRecord = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    commitTimestampInMillis: S.Number,
    eventId: StringValuedMap,
    data: PropertygraphData,
    op: S.String,
    isLastOp: S.optional(S.Boolean),
}).pipe(S.encodeKeys({ commitTimestampInMillis: "commitTimestamp" }))).annotate({
    identifier: "PropertygraphRecord",
});
export const PropertygraphRecordsList = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(PropertygraphRecord);
export const GetPropertygraphStreamOutput = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    lastEventId: StringValuedMap,
    lastTrxTimestampInMillis: S.Number,
    format: S.String,
    records: PropertygraphRecordsList,
    totalRecords: S.Number,
}).pipe(S.encodeKeys({ lastTrxTimestampInMillis: "lastTrxTimestamp" }))).annotate({
    identifier: "GetPropertygraphStreamOutput",
});
export const GraphSummaryType = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const GetPropertygraphSummaryInput = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    mode: S.optional(GraphSummaryType).pipe(T.HttpQuery("mode")),
}).pipe(T.all(T.Http({ method: "GET", uri: "/propertygraph/statistics/summary" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "GetPropertygraphSummaryInput",
});
export const NodeLabels = /*@__PURE__*/ /*#__PURE__*/ S.Array(S.String);
export const EdgeLabels = /*@__PURE__*/ /*#__PURE__*/ S.Array(S.String);
export const LongValuedMap = /*@__PURE__*/ /*#__PURE__*/ S.Record(S.String, S.Number.pipe(S.optional));
export const LongValuedMapList = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(LongValuedMap);
export const NodeProperties = /*@__PURE__*/ /*#__PURE__*/ S.Array(S.String);
export const OutgoingEdgeLabels = /*@__PURE__*/ /*#__PURE__*/ S.Array(S.String);
export const NodeStructure = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    count: S.optional(S.Number),
    nodeProperties: S.optional(NodeProperties),
    distinctOutgoingEdgeLabels: S.optional(OutgoingEdgeLabels),
})).annotate({ identifier: "NodeStructure" });
export const NodeStructures = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(NodeStructure);
export const EdgeProperties = /*@__PURE__*/ /*#__PURE__*/ S.Array(S.String);
export const EdgeStructure = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    count: S.optional(S.Number),
    edgeProperties: S.optional(EdgeProperties),
})).annotate({ identifier: "EdgeStructure" });
export const EdgeStructures = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(EdgeStructure);
export const PropertygraphSummary = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    numNodes: S.optional(S.Number),
    numEdges: S.optional(S.Number),
    numNodeLabels: S.optional(S.Number),
    numEdgeLabels: S.optional(S.Number),
    nodeLabels: S.optional(NodeLabels),
    edgeLabels: S.optional(EdgeLabels),
    numNodeProperties: S.optional(S.Number),
    numEdgeProperties: S.optional(S.Number),
    nodeProperties: S.optional(LongValuedMapList),
    edgeProperties: S.optional(LongValuedMapList),
    totalNodePropertyValues: S.optional(S.Number),
    totalEdgePropertyValues: S.optional(S.Number),
    nodeStructures: S.optional(NodeStructures),
    edgeStructures: S.optional(EdgeStructures),
})).annotate({
    identifier: "PropertygraphSummary",
});
export const PropertygraphSummaryValueMap = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    version: S.optional(S.String),
    lastStatisticsComputationTime: S.optional(T.DateFromString.pipe(T.TimestampFormat("date-time"))),
    graphSummary: S.optional(PropertygraphSummary),
})).annotate({
    identifier: "PropertygraphSummaryValueMap",
});
export const GetPropertygraphSummaryOutput = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    statusCode: S.optional(S.Number).pipe(T.HttpResponseCode()),
    payload: S.optional(PropertygraphSummaryValueMap),
})).annotate({
    identifier: "GetPropertygraphSummaryOutput",
});
export const GetRDFGraphSummaryInput = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    mode: S.optional(GraphSummaryType).pipe(T.HttpQuery("mode")),
}).pipe(T.all(T.Http({ method: "GET", uri: "/rdf/statistics/summary" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "GetRDFGraphSummaryInput",
});
export const Classes = /*@__PURE__*/ /*#__PURE__*/ S.Array(S.String);
export const Predicates = /*@__PURE__*/ /*#__PURE__*/ S.Array(S.String);
export const SubjectStructure = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ count: S.optional(S.Number), predicates: S.optional(Predicates) })).annotate({
    identifier: "SubjectStructure",
});
export const SubjectStructures = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(SubjectStructure);
export const RDFGraphSummary = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    numDistinctSubjects: S.optional(S.Number),
    numDistinctPredicates: S.optional(S.Number),
    numQuads: S.optional(S.Number),
    numClasses: S.optional(S.Number),
    classes: S.optional(Classes),
    predicates: S.optional(LongValuedMapList),
    subjectStructures: S.optional(SubjectStructures),
})).annotate({
    identifier: "RDFGraphSummary",
});
export const RDFGraphSummaryValueMap = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    version: S.optional(S.String),
    lastStatisticsComputationTime: S.optional(T.DateFromString.pipe(T.TimestampFormat("date-time"))),
    graphSummary: S.optional(RDFGraphSummary),
})).annotate({
    identifier: "RDFGraphSummaryValueMap",
});
export const GetRDFGraphSummaryOutput = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    statusCode: S.optional(S.Number).pipe(T.HttpResponseCode()),
    payload: S.optional(RDFGraphSummaryValueMap),
})).annotate({
    identifier: "GetRDFGraphSummaryOutput",
});
export const GetSparqlStatisticsRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({}).pipe(T.all(T.Http({ method: "POST", uri: "/" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "GetSparqlStatisticsRequest",
});
export const GetSparqlStatisticsOutput = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ status: S.String, payload: Statistics })).annotate({
    identifier: "GetSparqlStatisticsOutput",
});
export const GetSparqlStreamInput = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    limit: S.optional(S.Number).pipe(T.HttpQuery("limit")),
    iteratorType: S.optional(IteratorType).pipe(T.HttpQuery("iteratorType")),
    commitNum: S.optional(S.Number).pipe(T.HttpQuery("commitNum")),
    opNum: S.optional(S.Number).pipe(T.HttpQuery("opNum")),
    encoding: S.optional(Encoding).pipe(T.HttpHeader("Accept-Encoding")),
}).pipe(T.all(T.Http({ method: "GET", uri: "/sparql/stream" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "GetSparqlStreamInput",
});
export const SparqlData = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ stmt: S.String })).annotate({ identifier: "SparqlData" });
export const SparqlRecord = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    commitTimestampInMillis: S.Number,
    eventId: StringValuedMap,
    data: SparqlData,
    op: S.String,
    isLastOp: S.optional(S.Boolean),
}).pipe(S.encodeKeys({ commitTimestampInMillis: "commitTimestamp" }))).annotate({ identifier: "SparqlRecord" });
export const SparqlRecordsList = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(SparqlRecord);
export const GetSparqlStreamOutput = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    lastEventId: StringValuedMap,
    lastTrxTimestampInMillis: S.Number,
    format: S.String,
    records: SparqlRecordsList,
    totalRecords: S.Number,
}).pipe(S.encodeKeys({ lastTrxTimestampInMillis: "lastTrxTimestamp" }))).annotate({
    identifier: "GetSparqlStreamOutput",
});
export const ListGremlinQueriesInput = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    includeWaiting: S.optional(S.Boolean).pipe(T.HttpQuery("includeWaiting")),
}).pipe(T.all(T.Http({ method: "GET", uri: "/gremlin/status" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ListGremlinQueriesInput",
});
export const GremlinQueryStatus = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    queryId: S.optional(S.String),
    queryString: S.optional(S.String),
    queryEvalStats: S.optional(QueryEvalStats),
})).annotate({
    identifier: "GremlinQueryStatus",
});
export const GremlinQueries = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(GremlinQueryStatus);
export const ListGremlinQueriesOutput = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    acceptedQueryCount: S.optional(S.Number),
    runningQueryCount: S.optional(S.Number),
    queries: S.optional(GremlinQueries),
})).annotate({
    identifier: "ListGremlinQueriesOutput",
});
export const ListLoaderJobsInput = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    limit: S.optional(S.Number).pipe(T.HttpQuery("limit")),
    includeQueuedLoads: S.optional(S.Boolean).pipe(T.HttpQuery("includeQueuedLoads")),
}).pipe(T.all(T.Http({ method: "GET", uri: "/loader" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ListLoaderJobsInput",
});
export const StringList = /*@__PURE__*/ /*#__PURE__*/ S.Array(S.String);
export const LoaderIdResult = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ loadIds: S.optional(StringList) })).annotate({ identifier: "LoaderIdResult" });
export const ListLoaderJobsOutput = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ status: S.String, payload: LoaderIdResult })).annotate({
    identifier: "ListLoaderJobsOutput",
});
export const ListMLDataProcessingJobsInput = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    maxItems: S.optional(S.Number).pipe(T.HttpQuery("maxItems")),
    neptuneIamRoleArn: S.optional(S.String).pipe(T.HttpQuery("neptuneIamRoleArn")),
}).pipe(T.all(T.Http({ method: "GET", uri: "/ml/dataprocessing" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ListMLDataProcessingJobsInput",
});
export const ListMLDataProcessingJobsOutput = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ ids: S.optional(StringList) })).annotate({
    identifier: "ListMLDataProcessingJobsOutput",
});
export const ListMLEndpointsInput = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    maxItems: S.optional(S.Number).pipe(T.HttpQuery("maxItems")),
    neptuneIamRoleArn: S.optional(S.String).pipe(T.HttpQuery("neptuneIamRoleArn")),
}).pipe(T.all(T.Http({ method: "GET", uri: "/ml/endpoints" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ListMLEndpointsInput",
});
export const ListMLEndpointsOutput = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ ids: S.optional(StringList) })).annotate({
    identifier: "ListMLEndpointsOutput",
});
export const ListMLModelTrainingJobsInput = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    maxItems: S.optional(S.Number).pipe(T.HttpQuery("maxItems")),
    neptuneIamRoleArn: S.optional(S.String).pipe(T.HttpQuery("neptuneIamRoleArn")),
}).pipe(T.all(T.Http({ method: "GET", uri: "/ml/modeltraining" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ListMLModelTrainingJobsInput",
});
export const ListMLModelTrainingJobsOutput = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ ids: S.optional(StringList) })).annotate({
    identifier: "ListMLModelTrainingJobsOutput",
});
export const ListMLModelTransformJobsInput = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    maxItems: S.optional(S.Number).pipe(T.HttpQuery("maxItems")),
    neptuneIamRoleArn: S.optional(S.String).pipe(T.HttpQuery("neptuneIamRoleArn")),
}).pipe(T.all(T.Http({ method: "GET", uri: "/ml/modeltransform" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ListMLModelTransformJobsInput",
});
export const ListMLModelTransformJobsOutput = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ ids: S.optional(StringList) })).annotate({
    identifier: "ListMLModelTransformJobsOutput",
});
export const ListOpenCypherQueriesInput = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    includeWaiting: S.optional(S.Boolean).pipe(T.HttpQuery("includeWaiting")),
}).pipe(T.all(T.Http({ method: "GET", uri: "/opencypher/status" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ListOpenCypherQueriesInput",
});
export const OpenCypherQueries = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(GremlinQueryStatus);
export const ListOpenCypherQueriesOutput = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    acceptedQueryCount: S.optional(S.Number),
    runningQueryCount: S.optional(S.Number),
    queries: S.optional(OpenCypherQueries),
})).annotate({
    identifier: "ListOpenCypherQueriesOutput",
});
export const StatisticsAutoGenerationMode = 
/*@__PURE__*/ /*#__PURE__*/ S.String;
export const ManagePropertygraphStatisticsInput = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ mode: S.optional(StatisticsAutoGenerationMode) }).pipe(T.all(T.Http({ method: "POST", uri: "/propertygraph/statistics" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ManagePropertygraphStatisticsInput",
});
export const RefreshStatisticsIdMap = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ statisticsId: S.optional(S.String) })).annotate({
    identifier: "RefreshStatisticsIdMap",
});
export const ManagePropertygraphStatisticsOutput = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ status: S.String, payload: S.optional(RefreshStatisticsIdMap) })).annotate({
    identifier: "ManagePropertygraphStatisticsOutput",
});
export const ManageSparqlStatisticsInput = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ mode: S.optional(StatisticsAutoGenerationMode) }).pipe(T.all(T.Http({ method: "POST", uri: "/sparql/statistics" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ManageSparqlStatisticsInput",
});
export const ManageSparqlStatisticsOutput = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ status: S.String, payload: S.optional(RefreshStatisticsIdMap) })).annotate({
    identifier: "ManageSparqlStatisticsOutput",
});
export const Format = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const S3BucketRegion = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const Mode = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const Parallelism = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const StartLoaderJobInput = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    source: S.String,
    format: Format,
    s3BucketRegion: S3BucketRegion,
    iamRoleArn: S.String,
    mode: S.optional(Mode),
    failOnError: S.optional(S.Boolean),
    parallelism: S.optional(Parallelism),
    parserConfiguration: S.optional(StringValuedMap),
    updateSingleCardinalityProperties: S.optional(S.Boolean),
    queueRequest: S.optional(S.Boolean),
    dependencies: S.optional(StringList),
    userProvidedEdgeIds: S.optional(S.Boolean),
    edgeOnlyLoad: S.optional(S.Boolean),
})
    .pipe(S.encodeKeys({ s3BucketRegion: "region" }))
    .pipe(T.all(T.Http({ method: "POST", uri: "/loader" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "StartLoaderJobInput",
});
export const StartLoaderJobOutput = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ status: S.String, payload: StringValuedMap })).annotate({
    identifier: "StartLoaderJobOutput",
});
export const StartMLDataProcessingJobInput = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    id: S.optional(S.String),
    previousDataProcessingJobId: S.optional(S.String),
    inputDataS3Location: S.String,
    processedDataS3Location: S.String,
    sagemakerIamRoleArn: S.optional(S.String),
    neptuneIamRoleArn: S.optional(S.String),
    processingInstanceType: S.optional(S.String),
    processingInstanceVolumeSizeInGB: S.optional(S.Number),
    processingTimeOutInSeconds: S.optional(S.Number),
    modelType: S.optional(S.String),
    configFileName: S.optional(S.String),
    subnets: S.optional(StringList),
    securityGroupIds: S.optional(StringList),
    volumeEncryptionKMSKey: S.optional(S.String),
    s3OutputEncryptionKMSKey: S.optional(S.String),
}).pipe(T.all(T.Http({ method: "POST", uri: "/ml/dataprocessing" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "StartMLDataProcessingJobInput",
});
export const StartMLDataProcessingJobOutput = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    id: S.optional(S.String),
    arn: S.optional(S.String),
    creationTimeInMillis: S.optional(S.Number),
})).annotate({
    identifier: "StartMLDataProcessingJobOutput",
});
export const CustomModelTrainingParameters = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    sourceS3DirectoryPath: S.String,
    trainingEntryPointScript: S.optional(S.String),
    transformEntryPointScript: S.optional(S.String),
})).annotate({
    identifier: "CustomModelTrainingParameters",
});
export const StartMLModelTrainingJobInput = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    id: S.optional(S.String),
    previousModelTrainingJobId: S.optional(S.String),
    dataProcessingJobId: S.String,
    trainModelS3Location: S.String,
    sagemakerIamRoleArn: S.optional(S.String),
    neptuneIamRoleArn: S.optional(S.String),
    baseProcessingInstanceType: S.optional(S.String),
    trainingInstanceType: S.optional(S.String),
    trainingInstanceVolumeSizeInGB: S.optional(S.Number),
    trainingTimeOutInSeconds: S.optional(S.Number),
    maxHPONumberOfTrainingJobs: S.optional(S.Number),
    maxHPOParallelTrainingJobs: S.optional(S.Number),
    subnets: S.optional(StringList),
    securityGroupIds: S.optional(StringList),
    volumeEncryptionKMSKey: S.optional(S.String),
    s3OutputEncryptionKMSKey: S.optional(S.String),
    enableManagedSpotTraining: S.optional(S.Boolean),
    customModelTrainingParameters: S.optional(CustomModelTrainingParameters),
}).pipe(T.all(T.Http({ method: "POST", uri: "/ml/modeltraining" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "StartMLModelTrainingJobInput",
});
export const StartMLModelTrainingJobOutput = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    id: S.optional(S.String),
    arn: S.optional(S.String),
    creationTimeInMillis: S.optional(S.Number),
})).annotate({
    identifier: "StartMLModelTrainingJobOutput",
});
export const CustomModelTransformParameters = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    sourceS3DirectoryPath: S.String,
    transformEntryPointScript: S.optional(S.String),
})).annotate({
    identifier: "CustomModelTransformParameters",
});
export const StartMLModelTransformJobInput = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    id: S.optional(S.String),
    dataProcessingJobId: S.optional(S.String),
    mlModelTrainingJobId: S.optional(S.String),
    trainingJobName: S.optional(S.String),
    modelTransformOutputS3Location: S.String,
    sagemakerIamRoleArn: S.optional(S.String),
    neptuneIamRoleArn: S.optional(S.String),
    customModelTransformParameters: S.optional(CustomModelTransformParameters),
    baseProcessingInstanceType: S.optional(S.String),
    baseProcessingInstanceVolumeSizeInGB: S.optional(S.Number),
    subnets: S.optional(StringList),
    securityGroupIds: S.optional(StringList),
    volumeEncryptionKMSKey: S.optional(S.String),
    s3OutputEncryptionKMSKey: S.optional(S.String),
}).pipe(T.all(T.Http({ method: "POST", uri: "/ml/modeltransform" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "StartMLModelTransformJobInput",
});
export const StartMLModelTransformJobOutput = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    id: S.optional(S.String),
    arn: S.optional(S.String),
    creationTimeInMillis: S.optional(S.Number),
})).annotate({
    identifier: "StartMLModelTransformJobOutput",
});
//# Errors
export class BadRequestException extends S.TaggedErrorClass()("BadRequestException", { detailedMessage: S.String, requestId: S.String, code: S.String }).pipe(C.withBadRequestError) {
}
export class ClientTimeoutException extends S.TaggedErrorClass()("ClientTimeoutException", { detailedMessage: S.String, requestId: S.String, code: S.String }, T.Retryable()).pipe(C.withTimeoutError, C.withRetryableError) {
}
export class ConcurrentModificationException extends S.TaggedErrorClass()("ConcurrentModificationException", { detailedMessage: S.String, requestId: S.String, code: S.String }, T.Retryable()).pipe(C.withServerError, C.withRetryableError) {
}
export class ConstraintViolationException extends S.TaggedErrorClass()("ConstraintViolationException", { detailedMessage: S.String, requestId: S.String, code: S.String }, T.Retryable()).pipe(C.withBadRequestError, C.withRetryableError) {
}
export class FailureByQueryException extends S.TaggedErrorClass()("FailureByQueryException", { detailedMessage: S.String, requestId: S.String, code: S.String }, T.Retryable()).pipe(C.withServerError, C.withRetryableError) {
}
export class IllegalArgumentException extends S.TaggedErrorClass()("IllegalArgumentException", { detailedMessage: S.String, requestId: S.String, code: S.String }).pipe(C.withBadRequestError) {
}
export class InvalidArgumentException extends S.TaggedErrorClass()("InvalidArgumentException", { detailedMessage: S.String, requestId: S.String, code: S.String }).pipe(C.withBadRequestError) {
}
export class InvalidParameterException extends S.TaggedErrorClass()("InvalidParameterException", { detailedMessage: S.String, requestId: S.String, code: S.String }).pipe(C.withBadRequestError) {
}
export class MissingParameterException extends S.TaggedErrorClass()("MissingParameterException", { detailedMessage: S.String, requestId: S.String, code: S.String }).pipe(C.withBadRequestError) {
}
export class ParsingException extends S.TaggedErrorClass()("ParsingException", { detailedMessage: S.String, requestId: S.String, code: S.String }).pipe(C.withBadRequestError) {
}
export class PreconditionsFailedException extends S.TaggedErrorClass()("PreconditionsFailedException", { detailedMessage: S.String, requestId: S.String, code: S.String }).pipe(C.withBadRequestError) {
}
export class TimeLimitExceededException extends S.TaggedErrorClass()("TimeLimitExceededException", { detailedMessage: S.String, requestId: S.String, code: S.String }, T.Retryable()).pipe(C.withServerError, C.withRetryableError) {
}
export class TooManyRequestsException extends S.TaggedErrorClass()("TooManyRequestsException", { detailedMessage: S.String, requestId: S.String, code: S.String }, T.Retryable()).pipe(C.withThrottlingError, C.withRetryableError) {
}
export class UnsupportedOperationException extends S.TaggedErrorClass()("UnsupportedOperationException", { detailedMessage: S.String, requestId: S.String, code: S.String }).pipe(C.withBadRequestError) {
}
export class BulkLoadIdNotFoundException extends S.TaggedErrorClass()("BulkLoadIdNotFoundException", { detailedMessage: S.String, requestId: S.String, code: S.String }, T.Retryable()).pipe(C.withBadRequestError, C.withRetryableError) {
}
export class InternalFailureException extends S.TaggedErrorClass()("InternalFailureException", { detailedMessage: S.String, requestId: S.String, code: S.String }).pipe(C.withServerError) {
}
export class LoadUrlAccessDeniedException extends S.TaggedErrorClass()("LoadUrlAccessDeniedException", { detailedMessage: S.String, requestId: S.String, code: S.String }).pipe(C.withBadRequestError, C.withAuthError) {
}
export class MLResourceNotFoundException extends S.TaggedErrorClass()("MLResourceNotFoundException", { detailedMessage: S.String, requestId: S.String, code: S.String }).pipe(C.withBadRequestError) {
}
export class InvalidNumericDataException extends S.TaggedErrorClass()("InvalidNumericDataException", { detailedMessage: S.String, requestId: S.String, code: S.String }).pipe(C.withBadRequestError) {
}
export class AccessDeniedException extends S.TaggedErrorClass()("AccessDeniedException", { detailedMessage: S.String, requestId: S.String, code: S.String }).pipe(C.withAuthError) {
}
export class ReadOnlyViolationException extends S.TaggedErrorClass()("ReadOnlyViolationException", { detailedMessage: S.String, requestId: S.String, code: S.String }).pipe(C.withBadRequestError) {
}
export class StatisticsNotAvailableException extends S.TaggedErrorClass()("StatisticsNotAvailableException", { detailedMessage: S.String, requestId: S.String, code: S.String }).pipe(C.withBadRequestError) {
}
export class MethodNotAllowedException extends S.TaggedErrorClass()("MethodNotAllowedException", { detailedMessage: S.String, requestId: S.String, code: S.String }).pipe(C.withBadRequestError) {
}
export class ServerShutdownException extends S.TaggedErrorClass()("ServerShutdownException", { detailedMessage: S.String, requestId: S.String, code: S.String }).pipe(C.withServerError) {
}
export class CancelledByUserException extends S.TaggedErrorClass()("CancelledByUserException", { detailedMessage: S.String, requestId: S.String, code: S.String }).pipe(C.withServerError) {
}
export class MalformedQueryException extends S.TaggedErrorClass()("MalformedQueryException", { detailedMessage: S.String, requestId: S.String, code: S.String }).pipe(C.withBadRequestError) {
}
export class MemoryLimitExceededException extends S.TaggedErrorClass()("MemoryLimitExceededException", { detailedMessage: S.String, requestId: S.String, code: S.String }, T.Retryable()).pipe(C.withServerError, C.withRetryableError) {
}
export class QueryLimitExceededException extends S.TaggedErrorClass()("QueryLimitExceededException", { detailedMessage: S.String, requestId: S.String, code: S.String }, T.Retryable()).pipe(C.withServerError, C.withRetryableError) {
}
export class QueryLimitException extends S.TaggedErrorClass()("QueryLimitException", { detailedMessage: S.String, requestId: S.String, code: S.String }).pipe(C.withBadRequestError) {
}
export class QueryTooLargeException extends S.TaggedErrorClass()("QueryTooLargeException", { detailedMessage: S.String, requestId: S.String, code: S.String }).pipe(C.withBadRequestError) {
}
export class ExpiredStreamException extends S.TaggedErrorClass()("ExpiredStreamException", { detailedMessage: S.String, requestId: S.String, code: S.String }).pipe(C.withBadRequestError) {
}
export class StreamRecordsNotFoundException extends S.TaggedErrorClass()("StreamRecordsNotFoundException", { detailedMessage: S.String, requestId: S.String, code: S.String }).pipe(C.withBadRequestError) {
}
export class ThrottlingException extends S.TaggedErrorClass()("ThrottlingException", { detailedMessage: S.String, requestId: S.String, code: S.String }, T.Retryable()).pipe(C.withServerError, C.withRetryableError) {
}
export class S3Exception extends S.TaggedErrorClass()("S3Exception", { detailedMessage: S.String, requestId: S.String, code: S.String }, T.Retryable()).pipe(C.withBadRequestError, C.withRetryableError) {
}
/**
 * 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 const cancelGremlinQuery = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: CancelGremlinQueryInput,
    output: CancelGremlinQueryOutput,
    errors: [
        BadRequestException,
        ClientTimeoutException,
        ConcurrentModificationException,
        ConstraintViolationException,
        FailureByQueryException,
        IllegalArgumentException,
        InvalidArgumentException,
        InvalidParameterException,
        MissingParameterException,
        ParsingException,
        PreconditionsFailedException,
        TimeLimitExceededException,
        TooManyRequestsException,
        UnsupportedOperationException,
    ],
}));
/**
 * 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 const cancelLoaderJob = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: CancelLoaderJobInput,
    output: CancelLoaderJobOutput,
    errors: [
        BadRequestException,
        BulkLoadIdNotFoundException,
        ClientTimeoutException,
        ConstraintViolationException,
        IllegalArgumentException,
        InternalFailureException,
        InvalidArgumentException,
        InvalidParameterException,
        LoadUrlAccessDeniedException,
        MissingParameterException,
        PreconditionsFailedException,
        TooManyRequestsException,
        UnsupportedOperationException,
    ],
}));
/**
 * 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 const cancelMLDataProcessingJob = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: CancelMLDataProcessingJobInput,
    output: CancelMLDataProcessingJobOutput,
    errors: [
        BadRequestException,
        ClientTimeoutException,
        ConstraintViolationException,
        IllegalArgumentException,
        InvalidArgumentException,
        InvalidParameterException,
        MissingParameterException,
        MLResourceNotFoundException,
        PreconditionsFailedException,
        TooManyRequestsException,
        UnsupportedOperationException,
    ],
}));
/**
 * 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 const cancelMLModelTrainingJob = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: CancelMLModelTrainingJobInput,
    output: CancelMLModelTrainingJobOutput,
    errors: [
        BadRequestException,
        ClientTimeoutException,
        ConstraintViolationException,
        IllegalArgumentException,
        InvalidArgumentException,
        InvalidParameterException,
        MissingParameterException,
        MLResourceNotFoundException,
        PreconditionsFailedException,
        TooManyRequestsException,
        UnsupportedOperationException,
    ],
}));
/**
 * 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 const cancelMLModelTransformJob = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: CancelMLModelTransformJobInput,
    output: CancelMLModelTransformJobOutput,
    errors: [
        BadRequestException,
        ClientTimeoutException,
        ConstraintViolationException,
        IllegalArgumentException,
        InvalidArgumentException,
        InvalidParameterException,
        MissingParameterException,
        MLResourceNotFoundException,
        PreconditionsFailedException,
        TooManyRequestsException,
        UnsupportedOperationException,
    ],
}));
/**
 * 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 const cancelOpenCypherQuery = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: CancelOpenCypherQueryInput,
    output: CancelOpenCypherQueryOutput,
    errors: [
        BadRequestException,
        ClientTimeoutException,
        ConcurrentModificationException,
        ConstraintViolationException,
        FailureByQueryException,
        IllegalArgumentException,
        InvalidArgumentException,
        InvalidNumericDataException,
        InvalidParameterException,
        MissingParameterException,
        ParsingException,
        PreconditionsFailedException,
        TimeLimitExceededException,
        TooManyRequestsException,
        UnsupportedOperationException,
    ],
}));
/**
 * 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 const createMLEndpoint = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: CreateMLEndpointInput,
    output: CreateMLEndpointOutput,
    errors: [
        BadRequestException,
        ClientTimeoutException,
        ConstraintViolationException,
        IllegalArgumentException,
        InvalidArgumentException,
        InvalidParameterException,
        MissingParameterException,
        MLResourceNotFoundException,
        PreconditionsFailedException,
        TooManyRequestsException,
        UnsupportedOperationException,
    ],
}));
/**
 * 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 const deleteMLEndpoint = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DeleteMLEndpointInput,
    output: DeleteMLEndpointOutput,
    errors: [
        BadRequestException,
        ClientTimeoutException,
        ConstraintViolationException,
        IllegalArgumentException,
        InvalidArgumentException,
        InvalidParameterException,
        MissingParameterException,
        MLResourceNotFoundException,
        PreconditionsFailedException,
        TooManyRequestsException,
        UnsupportedOperationException,
    ],
}));
/**
 * 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 const deletePropertygraphStatistics = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DeletePropertygraphStatisticsRequest,
    output: DeletePropertygraphStatisticsOutput,
    errors: [
        AccessDeniedException,
        BadRequestException,
        ClientTimeoutException,
        ConstraintViolationException,
        IllegalArgumentException,
        InvalidArgumentException,
        InvalidParameterException,
        MissingParameterException,
        PreconditionsFailedException,
        ReadOnlyViolationException,
        StatisticsNotAvailableException,
        TooManyRequestsException,
        UnsupportedOperationException,
    ],
}));
/**
 * 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 const deleteSparqlStatistics = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DeleteSparqlStatisticsRequest,
    output: DeleteSparqlStatisticsOutput,
    errors: [
        AccessDeniedException,
        BadRequestException,
        ClientTimeoutException,
        ConstraintViolationException,
        IllegalArgumentException,
        InvalidArgumentException,
        InvalidParameterException,
        MissingParameterException,
        PreconditionsFailedException,
        ReadOnlyViolationException,
        StatisticsNotAvailableException,
        TooManyRequestsException,
        UnsupportedOperationException,
    ],
}));
/**
 * 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 const executeFastReset = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: ExecuteFastResetInput,
    output: ExecuteFastResetOutput,
    errors: [
        AccessDeniedException,
        ClientTimeoutException,
        ConstraintViolationException,
        IllegalArgumentException,
        InvalidArgumentException,
        InvalidParameterException,
        MethodNotAllowedException,
        MissingParameterException,
        PreconditionsFailedException,
        ReadOnlyViolationException,
        ServerShutdownException,
        TooManyRequestsException,
        UnsupportedOperationException,
    ],
}));
/**
 * 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 const executeGremlinExplainQuery = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: ExecuteGremlinExplainQueryInput,
    output: ExecuteGremlinExplainQueryOutput,
    errors: [
        BadRequestException,
        CancelledByUserException,
        ClientTimeoutException,
        ConcurrentModificationException,
        ConstraintViolationException,
        FailureByQueryException,
        IllegalArgumentException,
        InvalidArgumentException,
        InvalidParameterException,
        MalformedQueryException,
        MemoryLimitExceededException,
        MissingParameterException,
        ParsingException,
        PreconditionsFailedException,
        QueryLimitExceededException,
        QueryLimitException,
        QueryTooLargeException,
        TimeLimitExceededException,
        TooManyRequestsException,
        UnsupportedOperationException,
    ],
}));
/**
 * 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 const executeGremlinProfileQuery = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: ExecuteGremlinProfileQueryInput,
    output: ExecuteGremlinProfileQueryOutput,
    errors: [
        BadRequestException,
        CancelledByUserException,
        ClientTimeoutException,
        ConcurrentModificationException,
        ConstraintViolationException,
        FailureByQueryException,
        IllegalArgumentException,
        InvalidArgumentException,
        InvalidParameterException,
        MalformedQueryException,
        MemoryLimitExceededException,
        MissingParameterException,
        ParsingException,
        PreconditionsFailedException,
        QueryLimitExceededException,
        QueryLimitException,
        QueryTooLargeException,
        TimeLimitExceededException,
        TooManyRequestsException,
        UnsupportedOperationException,
    ],
}));
/**
 * 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 const executeGremlinQuery = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: ExecuteGremlinQueryInput,
    output: ExecuteGremlinQueryOutput,
    errors: [
        BadRequestException,
        CancelledByUserException,
        ClientTimeoutException,
        ConcurrentModificationException,
        ConstraintViolationException,
        FailureByQueryException,
        IllegalArgumentException,
        InvalidArgumentException,
        InvalidParameterException,
        MalformedQueryException,
        MemoryLimitExceededException,
        MissingParameterException,
        ParsingException,
        PreconditionsFailedException,
        QueryLimitExceededException,
        QueryLimitException,
        QueryTooLargeException,
        TimeLimitExceededException,
        TooManyRequestsException,
        UnsupportedOperationException,
    ],
}));
/**
 * 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 const executeOpenCypherExplainQuery = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: ExecuteOpenCypherExplainQueryInput,
    output: ExecuteOpenCypherExplainQueryOutput,
    errors: [
        BadRequestException,
        CancelledByUserException,
        ClientTimeoutException,
        ConcurrentModificationException,
        ConstraintViolationException,
        FailureByQueryException,
        IllegalArgumentException,
        InvalidArgumentException,
        InvalidNumericDataException,
        InvalidParameterException,
        MalformedQueryException,
        MemoryLimitExceededException,
        MissingParameterException,
        ParsingException,
        PreconditionsFailedException,
        QueryLimitExceededException,
        QueryLimitException,
        QueryTooLargeException,
        TimeLimitExceededException,
        TooManyRequestsException,
        UnsupportedOperationException,
    ],
}));
/**
 * 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 const executeOpenCypherQuery = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: ExecuteOpenCypherQueryInput,
    output: ExecuteOpenCypherQueryOutput,
    errors: [
        BadRequestException,
        CancelledByUserException,
        ClientTimeoutException,
        ConcurrentModificationException,
        ConstraintViolationException,
        FailureByQueryException,
        IllegalArgumentException,
        InvalidArgumentException,
        InvalidNumericDataException,
        InvalidParameterException,
        MalformedQueryException,
        MemoryLimitExceededException,
        MissingParameterException,
        ParsingException,
        PreconditionsFailedException,
        QueryLimitExceededException,
        QueryLimitException,
        QueryTooLargeException,
        TimeLimitExceededException,
        TooManyRequestsException,
        UnsupportedOperationException,
    ],
}));
/**
 * 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 const getEngineStatus = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: GetEngineStatusRequest,
    output: GetEngineStatusOutput,
    errors: [
        ClientTimeoutException,
        ConstraintViolationException,
        IllegalArgumentException,
        InternalFailureException,
        InvalidArgumentException,
        PreconditionsFailedException,
        TooManyRequestsException,
        UnsupportedOperationException,
    ],
}));
/**
 * 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 const getGremlinQueryStatus = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: GetGremlinQueryStatusInput,
    output: GetGremlinQueryStatusOutput,
    errors: [
        AccessDeniedException,
        BadRequestException,
        ClientTimeoutException,
        ConcurrentModificationException,
        ConstraintViolationException,
        FailureByQueryException,
        IllegalArgumentException,
        InvalidArgumentException,
        InvalidParameterException,
        MissingParameterException,
        ParsingException,
        PreconditionsFailedException,
        ReadOnlyViolationException,
        TimeLimitExceededException,
        TooManyRequestsException,
        UnsupportedOperationException,
    ],
}));
/**
 * 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 const getLoaderJobStatus = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: GetLoaderJobStatusInput,
    output: GetLoaderJobStatusOutput,
    errors: [
        BadRequestException,
        BulkLoadIdNotFoundException,
        ClientTimeoutException,
        ConstraintViolationException,
        IllegalArgumentException,
        InternalFailureException,
        InvalidArgumentException,
        InvalidParameterException,
        LoadUrlAccessDeniedException,
        MissingParameterException,
        PreconditionsFailedException,
        TooManyRequestsException,
        UnsupportedOperationException,
    ],
}));
/**
 * 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 const getMLDataProcessingJob = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: GetMLDataProcessingJobInput,
    output: GetMLDataProcessingJobOutput,
    errors: [
        BadRequestException,
        ClientTimeoutException,
        ConstraintViolationException,
        IllegalArgumentException,
        InvalidArgumentException,
        InvalidParameterException,
        MissingParameterException,
        MLResourceNotFoundException,
        PreconditionsFailedException,
        TooManyRequestsException,
        UnsupportedOperationException,
    ],
}));
/**
 * 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 const getMLEndpoint = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: GetMLEndpointInput,
    output: GetMLEndpointOutput,
    errors: [
        BadRequestException,
        ClientTimeoutException,
        ConstraintViolationException,
        IllegalArgumentException,
        InvalidArgumentException,
        InvalidParameterException,
        MissingParameterException,
        MLResourceNotFoundException,
        PreconditionsFailedException,
        TooManyRequestsException,
        UnsupportedOperationException,
    ],
}));
/**
 * 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 const getMLModelTrainingJob = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: GetMLModelTrainingJobInput,
    output: GetMLModelTrainingJobOutput,
    errors: [
        BadRequestException,
        ClientTimeoutException,
        ConstraintViolationException,
        IllegalArgumentException,
        InvalidArgumentException,
        InvalidParameterException,
        MissingParameterException,
        MLResourceNotFoundException,
        PreconditionsFailedException,
        TooManyRequestsException,
        UnsupportedOperationException,
    ],
}));
/**
 * 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 const getMLModelTransformJob = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: GetMLModelTransformJobInput,
    output: GetMLModelTransformJobOutput,
    errors: [
        BadRequestException,
        ClientTimeoutException,
        ConstraintViolationException,
        IllegalArgumentException,
        InvalidArgumentException,
        InvalidParameterException,
        MissingParameterException,
        MLResourceNotFoundException,
        PreconditionsFailedException,
        TooManyRequestsException,
        UnsupportedOperationException,
    ],
}));
/**
 * 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 const getOpenCypherQueryStatus = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: GetOpenCypherQueryStatusInput,
    output: GetOpenCypherQueryStatusOutput,
    errors: [
        AccessDeniedException,
        BadRequestException,
        ClientTimeoutException,
        ConcurrentModificationException,
        ConstraintViolationException,
        FailureByQueryException,
        IllegalArgumentException,
        InvalidArgumentException,
        InvalidNumericDataException,
        InvalidParameterException,
        MissingParameterException,
        ParsingException,
        PreconditionsFailedException,
        ReadOnlyViolationException,
        TimeLimitExceededException,
        TooManyRequestsException,
        UnsupportedOperationException,
    ],
}));
/**
 * 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 const getPropertygraphStatistics = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: GetPropertygraphStatisticsRequest,
    output: GetPropertygraphStatisticsOutput,
    errors: [
        AccessDeniedException,
        BadRequestException,
        ClientTimeoutException,
        ConstraintViolationException,
        IllegalArgumentException,
        InvalidArgumentException,
        InvalidParameterException,
        MissingParameterException,
        PreconditionsFailedException,
        ReadOnlyViolationException,
        StatisticsNotAvailableException,
        TooManyRequestsException,
        UnsupportedOperationException,
    ],
}));
/**
 * 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 const getPropertygraphStream = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: GetPropertygraphStreamInput,
    output: GetPropertygraphStreamOutput,
    errors: [
        ClientTimeoutException,
        ConstraintViolationException,
        ExpiredStreamException,
        IllegalArgumentException,
        InvalidArgumentException,
        InvalidParameterException,
        MemoryLimitExceededException,
        PreconditionsFailedException,
        StreamRecordsNotFoundException,
        ThrottlingException,
        TooManyRequestsException,
        UnsupportedOperationException,
    ],
}));
/**
 * 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 const getPropertygraphSummary = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: GetPropertygraphSummaryInput,
    output: GetPropertygraphSummaryOutput,
    errors: [
        AccessDeniedException,
        BadRequestException,
        ClientTimeoutException,
        ConstraintViolationException,
        IllegalArgumentException,
        InvalidArgumentException,
        InvalidParameterException,
        MissingParameterException,
        PreconditionsFailedException,
        ReadOnlyViolationException,
        StatisticsNotAvailableException,
        TooManyRequestsException,
        UnsupportedOperationException,
    ],
}));
/**
 * 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 const getRDFGraphSummary = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: GetRDFGraphSummaryInput,
    output: GetRDFGraphSummaryOutput,
    errors: [
        AccessDeniedException,
        BadRequestException,
        ClientTimeoutException,
        ConstraintViolationException,
        IllegalArgumentException,
        InvalidArgumentException,
        InvalidParameterException,
        MissingParameterException,
        PreconditionsFailedException,
        ReadOnlyViolationException,
        StatisticsNotAvailableException,
        TooManyRequestsException,
        UnsupportedOperationException,
    ],
}));
/**
 * Gets RDF statistics (SPARQL).
 */
export const getSparqlStatistics = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: GetSparqlStatisticsRequest,
    output: GetSparqlStatisticsOutput,
    errors: [
        AccessDeniedException,
        BadRequestException,
        ClientTimeoutException,
        ConstraintViolationException,
        IllegalArgumentException,
        InvalidArgumentException,
        InvalidParameterException,
        MissingParameterException,
        PreconditionsFailedException,
        ReadOnlyViolationException,
        StatisticsNotAvailableException,
        TooManyRequestsException,
        UnsupportedOperationException,
    ],
}));
/**
 * 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 const getSparqlStream = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: GetSparqlStreamInput,
    output: GetSparqlStreamOutput,
    errors: [
        ClientTimeoutException,
        ConstraintViolationException,
        ExpiredStreamException,
        IllegalArgumentException,
        InvalidArgumentException,
        InvalidParameterException,
        MemoryLimitExceededException,
        PreconditionsFailedException,
        StreamRecordsNotFoundException,
        ThrottlingException,
        TooManyRequestsException,
        UnsupportedOperationException,
    ],
}));
/**
 * 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 const listGremlinQueries = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: ListGremlinQueriesInput,
    output: ListGremlinQueriesOutput,
    errors: [
        AccessDeniedException,
        BadRequestException,
        ClientTimeoutException,
        ConcurrentModificationException,
        ConstraintViolationException,
        FailureByQueryException,
        IllegalArgumentException,
        InvalidArgumentException,
        InvalidParameterException,
        MissingParameterException,
        ParsingException,
        PreconditionsFailedException,
        ReadOnlyViolationException,
        TimeLimitExceededException,
        TooManyRequestsException,
        UnsupportedOperationException,
    ],
}));
/**
 * 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 const listLoaderJobs = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: ListLoaderJobsInput,
    output: ListLoaderJobsOutput,
    errors: [
        BadRequestException,
        BulkLoadIdNotFoundException,
        ClientTimeoutException,
        ConstraintViolationException,
        IllegalArgumentException,
        InternalFailureException,
        InvalidArgumentException,
        InvalidParameterException,
        LoadUrlAccessDeniedException,
        PreconditionsFailedException,
        TooManyRequestsException,
        UnsupportedOperationException,
    ],
}));
/**
 * 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 const listMLDataProcessingJobs = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: ListMLDataProcessingJobsInput,
    output: ListMLDataProcessingJobsOutput,
    errors: [
        BadRequestException,
        ClientTimeoutException,
        ConstraintViolationException,
        IllegalArgumentException,
        InvalidArgumentException,
        InvalidParameterException,
        MissingParameterException,
        MLResourceNotFoundException,
        PreconditionsFailedException,
        TooManyRequestsException,
        UnsupportedOperationException,
    ],
}));
/**
 * 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 const listMLEndpoints = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: ListMLEndpointsInput,
    output: ListMLEndpointsOutput,
    errors: [
        BadRequestException,
        ClientTimeoutException,
        ConstraintViolationException,
        IllegalArgumentException,
        InvalidArgumentException,
        InvalidParameterException,
        MissingParameterException,
        MLResourceNotFoundException,
        PreconditionsFailedException,
        TooManyRequestsException,
        UnsupportedOperationException,
    ],
}));
/**
 * 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 const listMLModelTrainingJobs = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: ListMLModelTrainingJobsInput,
    output: ListMLModelTrainingJobsOutput,
    errors: [
        BadRequestException,
        ClientTimeoutException,
        ConstraintViolationException,
        IllegalArgumentException,
        InvalidArgumentException,
        InvalidParameterException,
        MissingParameterException,
        MLResourceNotFoundException,
        PreconditionsFailedException,
        TooManyRequestsException,
        UnsupportedOperationException,
    ],
}));
/**
 * 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 const listMLModelTransformJobs = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: ListMLModelTransformJobsInput,
    output: ListMLModelTransformJobsOutput,
    errors: [
        BadRequestException,
        ClientTimeoutException,
        ConstraintViolationException,
        IllegalArgumentException,
        InvalidArgumentException,
        InvalidParameterException,
        MissingParameterException,
        MLResourceNotFoundException,
        PreconditionsFailedException,
        TooManyRequestsException,
        UnsupportedOperationException,
    ],
}));
/**
 * 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 const listOpenCypherQueries = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: ListOpenCypherQueriesInput,
    output: ListOpenCypherQueriesOutput,
    errors: [
        AccessDeniedException,
        BadRequestException,
        ClientTimeoutException,
        ConcurrentModificationException,
        ConstraintViolationException,
        FailureByQueryException,
        IllegalArgumentException,
        InvalidArgumentException,
        InvalidNumericDataException,
        InvalidParameterException,
        MissingParameterException,
        ParsingException,
        PreconditionsFailedException,
        ReadOnlyViolationException,
        TimeLimitExceededException,
        TooManyRequestsException,
        UnsupportedOperationException,
    ],
}));
/**
 * 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 const managePropertygraphStatistics = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: ManagePropertygraphStatisticsInput,
    output: ManagePropertygraphStatisticsOutput,
    errors: [
        AccessDeniedException,
        BadRequestException,
        ClientTimeoutException,
        ConstraintViolationException,
        IllegalArgumentException,
        InvalidArgumentException,
        InvalidParameterException,
        MissingParameterException,
        PreconditionsFailedException,
        ReadOnlyViolationException,
        StatisticsNotAvailableException,
        TooManyRequestsException,
        UnsupportedOperationException,
    ],
}));
/**
 * 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 const manageSparqlStatistics = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: ManageSparqlStatisticsInput,
    output: ManageSparqlStatisticsOutput,
    errors: [
        AccessDeniedException,
        BadRequestException,
        ClientTimeoutException,
        ConstraintViolationException,
        IllegalArgumentException,
        InvalidArgumentException,
        InvalidParameterException,
        MissingParameterException,
        PreconditionsFailedException,
        ReadOnlyViolationException,
        StatisticsNotAvailableException,
        TooManyRequestsException,
        UnsupportedOperationException,
    ],
}));
/**
 * 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 const startLoaderJob = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: StartLoaderJobInput,
    output: StartLoaderJobOutput,
    errors: [
        BadRequestException,
        BulkLoadIdNotFoundException,
        ClientTimeoutException,
        ConstraintViolationException,
        IllegalArgumentException,
        InternalFailureException,
        InvalidArgumentException,
        InvalidParameterException,
        LoadUrlAccessDeniedException,
        MissingParameterException,
        PreconditionsFailedException,
        S3Exception,
        TooManyRequestsException,
        UnsupportedOperationException,
    ],
}));
/**
 * 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 const startMLDataProcessingJob = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: StartMLDataProcessingJobInput,
    output: StartMLDataProcessingJobOutput,
    errors: [
        BadRequestException,
        ClientTimeoutException,
        ConstraintViolationException,
        IllegalArgumentException,
        InvalidArgumentException,
        InvalidParameterException,
        MissingParameterException,
        MLResourceNotFoundException,
        PreconditionsFailedException,
        TooManyRequestsException,
        UnsupportedOperationException,
    ],
}));
/**
 * 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 const startMLModelTrainingJob = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: StartMLModelTrainingJobInput,
    output: StartMLModelTrainingJobOutput,
    errors: [
        BadRequestException,
        ClientTimeoutException,
        ConstraintViolationException,
        IllegalArgumentException,
        InvalidArgumentException,
        InvalidParameterException,
        MissingParameterException,
        MLResourceNotFoundException,
        PreconditionsFailedException,
        TooManyRequestsException,
        UnsupportedOperationException,
    ],
}));
/**
 * 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 const startMLModelTransformJob = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: StartMLModelTransformJobInput,
    output: StartMLModelTransformJobOutput,
    errors: [
        BadRequestException,
        ClientTimeoutException,
        ConstraintViolationException,
        IllegalArgumentException,
        InvalidArgumentException,
        InvalidParameterException,
        MissingParameterException,
        MLResourceNotFoundException,
        PreconditionsFailedException,
        TooManyRequestsException,
        UnsupportedOperationException,
    ],
}));
//# sourceMappingURL=neptunedata.js.map