import * as Comprehend from "@alchemy.run/aws/Comprehend";
import * as IAM from "@alchemy.run/aws/IAM";
import * as Lambda from "@alchemy.run/aws/Lambda";
import * as S3 from "@alchemy.run/aws/S3";
import * as Duration from "effect/Duration";
import * as Effect from "effect/Effect";
import { HttpServerRequest } from "effect/http/HttpServerRequest";
import * as HttpServerResponse from "effect/http/HttpServerResponse";
import * as Layer from "effect/Layer";
import * as Schedule from "effect/Schedule";
import path from "pathe";
const main = path.resolve(import.meta.dirname, "handler.ts");
// Deterministic fixture names (bucket names are account-global; this suite
// owns them in the testing account).
export const FIXTURE_BUCKET_NAME = "alchemy-test-comprehend-bindings";
// Well-formed-but-nonexistent job id used to drive the typed
// JobNotFoundException paths. An IAM gap would surface AccessDeniedException
// (a 500 through the handler's orDie), so a typed not-found tag proves the
// grant end-to-end.
const BOGUS_JOB_ID = "00000000000000000000000000000000";
// An S3 URI that fails Comprehend's server-side pattern validation — drives
// the Start*Job bindings through their typed ValidationException path
// without actually starting (and paying for) an async job per family.
const INVALID_S3_URI = "invalid-uri";
export class ComprehendTestFunction extends Lambda.Function<Lambda.Function>()(
"ComprehendTestFunction",
) {}
export default ComprehendTestFunction.make(
{
main,
functionUrl: true,
// The sentiment job lifecycle route retries StartSentimentDetectionJob
// through fresh-role IAM propagation (bounded ~40s).
timeout: Duration.seconds(120),
},
Effect.gen(function* () {
const bucket = yield* S3.Bucket("ComprehendInputBucket", {
bucketName: FIXTURE_BUCKET_NAME,
forceDestroy: true,
});
// The role Amazon Comprehend assumes to read input documents and write
// job results for the Start*Job bindings.
const dataAccessRole = yield* IAM.Role("ComprehendDataAccessRole", {
assumeRolePolicyDocument: {
Version: "2012-10-17",
Statement: [
{
Effect: "Allow",
Principal: { Service: "comprehend.amazonaws.com" },
Action: ["sts:AssumeRole"],
},
],
},
inlinePolicies: {
s3Access: {
Version: "2012-10-17",
Statement: [
{
Effect: "Allow",
Action: ["s3:GetObject", "s3:ListBucket", "s3:PutObject"],
Resource: [
`arn:aws:s3:::${FIXTURE_BUCKET_NAME}`,
`arn:aws:s3:::${FIXTURE_BUCKET_NAME}/*`,
],
},
],
},
},
});
// Used by /classify-document to build a well-formed same-account
// endpoint ARN (a cross-account ARN returns NotAuthorizedException
// instead of the typed ResourceUnavailableException).
const roleArn = yield* dataAccessRole.roleArn;
const putObject = yield* S3.PutObject(bucket);
// --- real-time analysis bindings ---
const detectDominantLanguage = yield* Comprehend.DetectDominantLanguage();
const detectEntities = yield* Comprehend.DetectEntities();
const detectKeyPhrases = yield* Comprehend.DetectKeyPhrases();
const detectPiiEntities = yield* Comprehend.DetectPiiEntities();
const detectSentiment = yield* Comprehend.DetectSentiment();
const detectSyntax = yield* Comprehend.DetectSyntax();
const detectTargetedSentiment = yield* Comprehend.DetectTargetedSentiment();
const detectToxicContent = yield* Comprehend.DetectToxicContent();
const containsPiiEntities = yield* Comprehend.ContainsPiiEntities();
const classifyDocument = yield* Comprehend.ClassifyDocument();
// --- batch real-time analysis bindings ---
const batchDetectDominantLanguage = yield* Comprehend.BatchDetectDominantLanguage();
const batchDetectEntities = yield* Comprehend.BatchDetectEntities();
const batchDetectKeyPhrases = yield* Comprehend.BatchDetectKeyPhrases();
const batchDetectSentiment = yield* Comprehend.BatchDetectSentiment();
const batchDetectSyntax = yield* Comprehend.BatchDetectSyntax();
const batchDetectTargetedSentiment = yield* Comprehend.BatchDetectTargetedSentiment();
// --- async job bindings (role injection + PassRole grant) ---
const startDocumentClassificationJob =
yield* Comprehend.StartDocumentClassificationJob(dataAccessRole);
const startDominantLanguageDetectionJob =
yield* Comprehend.StartDominantLanguageDetectionJob(dataAccessRole);
const startEntitiesDetectionJob = yield* Comprehend.StartEntitiesDetectionJob(dataAccessRole);
const startEventsDetectionJob = yield* Comprehend.StartEventsDetectionJob(dataAccessRole);
const startKeyPhrasesDetectionJob =
yield* Comprehend.StartKeyPhrasesDetectionJob(dataAccessRole);
const startPiiEntitiesDetectionJob =
yield* Comprehend.StartPiiEntitiesDetectionJob(dataAccessRole);
const startSentimentDetectionJob = yield* Comprehend.StartSentimentDetectionJob(dataAccessRole);
const startTargetedSentimentDetectionJob =
yield* Comprehend.StartTargetedSentimentDetectionJob(dataAccessRole);
const startTopicsDetectionJob = yield* Comprehend.StartTopicsDetectionJob(dataAccessRole);
const describeDocumentClassificationJob = yield* Comprehend.DescribeDocumentClassificationJob();
const describeDominantLanguageDetectionJob =
yield* Comprehend.DescribeDominantLanguageDetectionJob();
const describeEntitiesDetectionJob = yield* Comprehend.DescribeEntitiesDetectionJob();
const describeEventsDetectionJob = yield* Comprehend.DescribeEventsDetectionJob();
const describeKeyPhrasesDetectionJob = yield* Comprehend.DescribeKeyPhrasesDetectionJob();
const describePiiEntitiesDetectionJob = yield* Comprehend.DescribePiiEntitiesDetectionJob();
const describeSentimentDetectionJob = yield* Comprehend.DescribeSentimentDetectionJob();
const describeTargetedSentimentDetectionJob =
yield* Comprehend.DescribeTargetedSentimentDetectionJob();
const describeTopicsDetectionJob = yield* Comprehend.DescribeTopicsDetectionJob();
const listDocumentClassificationJobs = yield* Comprehend.ListDocumentClassificationJobs();
const listDominantLanguageDetectionJobs = yield* Comprehend.ListDominantLanguageDetectionJobs();
const listEntitiesDetectionJobs = yield* Comprehend.ListEntitiesDetectionJobs();
const listEventsDetectionJobs = yield* Comprehend.ListEventsDetectionJobs();
const listKeyPhrasesDetectionJobs = yield* Comprehend.ListKeyPhrasesDetectionJobs();
const listPiiEntitiesDetectionJobs = yield* Comprehend.ListPiiEntitiesDetectionJobs();
const listSentimentDetectionJobs = yield* Comprehend.ListSentimentDetectionJobs();
const listTargetedSentimentDetectionJobs =
yield* Comprehend.ListTargetedSentimentDetectionJobs();
const listTopicsDetectionJobs = yield* Comprehend.ListTopicsDetectionJobs();
const stopDominantLanguageDetectionJob = yield* Comprehend.StopDominantLanguageDetectionJob();
const stopEntitiesDetectionJob = yield* Comprehend.StopEntitiesDetectionJob();
const stopEventsDetectionJob = yield* Comprehend.StopEventsDetectionJob();
const stopKeyPhrasesDetectionJob = yield* Comprehend.StopKeyPhrasesDetectionJob();
const stopPiiEntitiesDetectionJob = yield* Comprehend.StopPiiEntitiesDetectionJob();
const stopSentimentDetectionJob = yield* Comprehend.StopSentimentDetectionJob();
const stopTargetedSentimentDetectionJob = yield* Comprehend.StopTargetedSentimentDetectionJob();
const PII_TEXT = "My name is Jane Doe and my email address is jane@example.com.";
const REVIEW_TEXT = "I love this product, it works wonderfully!";
const BATCH_TEXTS = [
"I love this product, it works wonderfully!",
"The delivery was late and the box arrived damaged.",
];
const jobInput = {
InputDataConfig: {
S3Uri: `s3://${FIXTURE_BUCKET_NAME}/comprehend-input/`,
InputFormat: "ONE_DOC_PER_LINE" as const,
},
OutputDataConfig: {
S3Uri: `s3://${FIXTURE_BUCKET_NAME}/comprehend-output/`,
},
};
const invalidJobInput = {
InputDataConfig: { S3Uri: INVALID_S3_URI },
OutputDataConfig: { S3Uri: INVALID_S3_URI },
};
return {
fetch: Effect.gen(function* () {
const request = yield* HttpServerRequest;
const url = new URL(request.originalUrl);
const pathname = url.pathname;
// Cheap readiness route — no Comprehend call.
if (request.method === "GET" && pathname === "/ping") {
return yield* HttpServerResponse.json({ ok: true });
}
// One route drives every single-document real-time binding.
if (request.method === "GET" && pathname === "/detect-all") {
const language = yield* detectDominantLanguage({
Text: "Bob ordered two sandwiches yesterday.",
});
const entities = yield* detectEntities({
Text: "Bob moved to Seattle in 2017.",
LanguageCode: "en",
});
const keyPhrases = yield* detectKeyPhrases({
Text: "The quarterly earnings report exceeded analyst expectations.",
LanguageCode: "en",
});
const pii = yield* detectPiiEntities({
Text: PII_TEXT,
LanguageCode: "en",
});
const sentiment = yield* detectSentiment({
Text: REVIEW_TEXT,
LanguageCode: "en",
});
const syntax = yield* detectSyntax({
Text: "The cat sat on the mat.",
LanguageCode: "en",
});
const targeted = yield* detectTargetedSentiment({
Text: "The screen is gorgeous but the battery is disappointing.",
LanguageCode: "en",
});
const toxic = yield* detectToxicContent({
TextSegments: [{ Text: "You are a wonderful person." }],
LanguageCode: "en",
});
const piiLabels = yield* containsPiiEntities({
Text: PII_TEXT,
LanguageCode: "en",
});
return yield* HttpServerResponse.json({
languageCode: language.Languages?.[0]?.LanguageCode,
entityTypes: (entities.Entities ?? []).map((e) => e.Type),
keyPhraseCount: (keyPhrases.KeyPhrases ?? []).length,
piiTypes: (pii.Entities ?? []).map((e) => e.Type),
sentiment: sentiment.Sentiment,
syntaxTags: (syntax.SyntaxTokens ?? []).map((t) => t.PartOfSpeech?.Tag),
targetedEntityCount: (targeted.Entities ?? []).length,
toxicity: toxic.ResultList?.[0]?.Toxicity,
piiLabels: (piiLabels.Labels ?? []).map((l) => l.Name),
});
}
// One route drives every batch real-time binding.
if (request.method === "GET" && pathname === "/batch-all") {
const language = yield* batchDetectDominantLanguage({
TextList: BATCH_TEXTS,
});
const entities = yield* batchDetectEntities({
TextList: ["Bob moved to Seattle in 2017."],
LanguageCode: "en",
});
const keyPhrases = yield* batchDetectKeyPhrases({
TextList: BATCH_TEXTS,
LanguageCode: "en",
});
const sentiment = yield* batchDetectSentiment({
TextList: BATCH_TEXTS,
LanguageCode: "en",
});
const syntax = yield* batchDetectSyntax({
TextList: ["The cat sat on the mat."],
LanguageCode: "en",
});
const targeted = yield* batchDetectTargetedSentiment({
TextList: ["The screen is gorgeous but the battery is bad."],
LanguageCode: "en",
});
return yield* HttpServerResponse.json({
languageResults: (language.ResultList ?? []).length,
firstLanguage: language.ResultList?.[0]?.Languages?.[0]?.LanguageCode,
entityResults: (entities.ResultList ?? []).length,
keyPhraseResults: (keyPhrases.ResultList ?? []).length,
sentimentResults: (sentiment.ResultList ?? []).length,
firstSentiment: sentiment.ResultList?.[0]?.Sentiment,
syntaxResults: (syntax.ResultList ?? []).length,
targetedResults: (targeted.ResultList ?? []).length,
});
}
// ClassifyDocument requires a trained custom endpoint; a well-formed
// same-account ARN that doesn't exist drives the typed
// ResourceUnavailableException path end-to-end (proving IAM + call
// plumbing without a multi-hour classifier training run).
if (request.method === "GET" && pathname === "/classify-document") {
const region = yield* Effect.sync(() => process.env.AWS_REGION);
const account = (yield* roleArn).split(":")[4];
const tag = yield* classifyDocument({
Text: "Subject: your invoice for March is attached",
EndpointArn: `arn:aws:comprehend:${region}:${account}:document-classifier-endpoint/alchemy-nonexistent`,
}).pipe(
Effect.map(() => "Classified"),
Effect.catchTag(
["ResourceUnavailableException", "InvalidRequestException", "NotAuthorizedException"],
(e) => Effect.succeed(e._tag),
),
);
return yield* HttpServerResponse.json({ tag });
}
// One route drives all nine List*Jobs bindings.
if (request.method === "GET" && pathname === "/jobs/list-all") {
const counts = {
documentClassification: (
(yield* listDocumentClassificationJobs({ MaxResults: 5 }))
.DocumentClassificationJobPropertiesList ?? []
).length,
dominantLanguage: (
(yield* listDominantLanguageDetectionJobs({ MaxResults: 5 }))
.DominantLanguageDetectionJobPropertiesList ?? []
).length,
entities: (
(yield* listEntitiesDetectionJobs({ MaxResults: 5 }))
.EntitiesDetectionJobPropertiesList ?? []
).length,
events: (
(yield* listEventsDetectionJobs({ MaxResults: 5 }))
.EventsDetectionJobPropertiesList ?? []
).length,
keyPhrases: (
(yield* listKeyPhrasesDetectionJobs({ MaxResults: 5 }))
.KeyPhrasesDetectionJobPropertiesList ?? []
).length,
piiEntities: (
(yield* listPiiEntitiesDetectionJobs({ MaxResults: 5 }))
.PiiEntitiesDetectionJobPropertiesList ?? []
).length,
sentiment: (
(yield* listSentimentDetectionJobs({ MaxResults: 5 }))
.SentimentDetectionJobPropertiesList ?? []
).length,
targetedSentiment: (
(yield* listTargetedSentimentDetectionJobs({ MaxResults: 5 }))
.TargetedSentimentDetectionJobPropertiesList ?? []
).length,
topics: (
(yield* listTopicsDetectionJobs({ MaxResults: 5 }))
.TopicsDetectionJobPropertiesList ?? []
).length,
};
return yield* HttpServerResponse.json(counts);
}
// One route drives all nine Describe*Job bindings through their
// typed JobNotFoundException path.
if (request.method === "GET" && pathname === "/jobs/describe-not-found-all") {
const probe = { JobId: BOGUS_JOB_ID };
const tags = {
documentClassification: yield* describeDocumentClassificationJob(probe).pipe(
Effect.map(() => "Found"),
Effect.catchTag("JobNotFoundException", (e) => Effect.succeed(e._tag)),
),
dominantLanguage: yield* describeDominantLanguageDetectionJob(probe).pipe(
Effect.map(() => "Found"),
Effect.catchTag("JobNotFoundException", (e) => Effect.succeed(e._tag)),
),
entities: yield* describeEntitiesDetectionJob(probe).pipe(
Effect.map(() => "Found"),
Effect.catchTag("JobNotFoundException", (e) => Effect.succeed(e._tag)),
),
events: yield* describeEventsDetectionJob(probe).pipe(
Effect.map(() => "Found"),
Effect.catchTag(["JobNotFoundException", "NotAuthorizedException"], (e) =>
Effect.succeed(e._tag),
),
),
keyPhrases: yield* describeKeyPhrasesDetectionJob(probe).pipe(
Effect.map(() => "Found"),
Effect.catchTag("JobNotFoundException", (e) => Effect.succeed(e._tag)),
),
piiEntities: yield* describePiiEntitiesDetectionJob(probe).pipe(
Effect.map(() => "Found"),
Effect.catchTag("JobNotFoundException", (e) => Effect.succeed(e._tag)),
),
sentiment: yield* describeSentimentDetectionJob(probe).pipe(
Effect.map(() => "Found"),
Effect.catchTag("JobNotFoundException", (e) => Effect.succeed(e._tag)),
),
targetedSentiment: yield* describeTargetedSentimentDetectionJob(probe).pipe(
Effect.map(() => "Found"),
Effect.catchTag("JobNotFoundException", (e) => Effect.succeed(e._tag)),
),
topics: yield* describeTopicsDetectionJob(probe).pipe(
Effect.map(() => "Found"),
Effect.catchTag("JobNotFoundException", (e) => Effect.succeed(e._tag)),
),
};
return yield* HttpServerResponse.json(tags);
}
// One route drives all seven Stop*Job bindings through their typed
// JobNotFoundException path.
if (request.method === "POST" && pathname === "/jobs/stop-not-found-all") {
const probe = { JobId: BOGUS_JOB_ID };
const tags = {
dominantLanguage: yield* stopDominantLanguageDetectionJob(probe).pipe(
Effect.map(() => "Stopped"),
Effect.catchTag("JobNotFoundException", (e) => Effect.succeed(e._tag)),
),
entities: yield* stopEntitiesDetectionJob(probe).pipe(
Effect.map(() => "Stopped"),
Effect.catchTag("JobNotFoundException", (e) => Effect.succeed(e._tag)),
),
// Events detection is closed to new customers — the account
// surfaces the (patched) typed NotAuthorizedException instead of
// JobNotFoundException.
events: yield* stopEventsDetectionJob(probe).pipe(
Effect.map(() => "Stopped"),
Effect.catchTag(["JobNotFoundException", "NotAuthorizedException"], (e) =>
Effect.succeed(e._tag),
),
),
keyPhrases: yield* stopKeyPhrasesDetectionJob(probe).pipe(
Effect.map(() => "Stopped"),
Effect.catchTag("JobNotFoundException", (e) => Effect.succeed(e._tag)),
),
piiEntities: yield* stopPiiEntitiesDetectionJob(probe).pipe(
Effect.map(() => "Stopped"),
Effect.catchTag("JobNotFoundException", (e) => Effect.succeed(e._tag)),
),
sentiment: yield* stopSentimentDetectionJob(probe).pipe(
Effect.map(() => "Stopped"),
Effect.catchTag("JobNotFoundException", (e) => Effect.succeed(e._tag)),
),
targetedSentiment: yield* stopTargetedSentimentDetectionJob(probe).pipe(
Effect.map(() => "Stopped"),
Effect.catchTag("JobNotFoundException", (e) => Effect.succeed(e._tag)),
),
};
return yield* HttpServerResponse.json(tags);
}
// Drives the eight non-sentiment Start*Job bindings through
// Comprehend's server-side ValidationException (invalid S3 URI) —
// a real runtime call proving role injection + IAM without paying
// for eight async jobs. Sentiment gets the real lifecycle below.
if (request.method === "POST" && pathname === "/jobs/start-invalid-all") {
const region = yield* Effect.sync(() => process.env.AWS_REGION);
const account = (yield* roleArn).split(":")[4];
const tags = {
documentClassification: yield* startDocumentClassificationJob({
...invalidJobInput,
DocumentClassifierArn: `arn:aws:comprehend:${region}:${account}:document-classifier/alchemy-nonexistent`,
}).pipe(
Effect.map(() => "Started"),
Effect.catchTag(
["ValidationException", "InvalidRequestException", "ResourceNotFoundException"],
(e) => Effect.succeed(e._tag),
),
),
dominantLanguage: yield* startDominantLanguageDetectionJob(invalidJobInput).pipe(
Effect.map(() => "Started"),
Effect.catchTag(["ValidationException", "InvalidRequestException"], (e) =>
Effect.succeed(e._tag),
),
),
entities: yield* startEntitiesDetectionJob({
...invalidJobInput,
LanguageCode: "en",
}).pipe(
Effect.map(() => "Started"),
Effect.catchTag(["ValidationException", "InvalidRequestException"], (e) =>
Effect.succeed(e._tag),
),
),
events: yield* startEventsDetectionJob({
...invalidJobInput,
LanguageCode: "en",
TargetEventTypes: ["BANKRUPTCY"],
}).pipe(
Effect.map(() => "Started"),
Effect.catchTag(
["ValidationException", "InvalidRequestException", "NotAuthorizedException"],
(e) => Effect.succeed(e._tag),
),
),
keyPhrases: yield* startKeyPhrasesDetectionJob({
...invalidJobInput,
LanguageCode: "en",
}).pipe(
Effect.map(() => "Started"),
Effect.catchTag(["ValidationException", "InvalidRequestException"], (e) =>
Effect.succeed(e._tag),
),
),
piiEntities: yield* startPiiEntitiesDetectionJob({
...invalidJobInput,
Mode: "ONLY_OFFSETS",
LanguageCode: "en",
}).pipe(
Effect.map(() => "Started"),
Effect.catchTag(["ValidationException", "InvalidRequestException"], (e) =>
Effect.succeed(e._tag),
),
),
targetedSentiment: yield* startTargetedSentimentDetectionJob({
...invalidJobInput,
LanguageCode: "en",
}).pipe(
Effect.map(() => "Started"),
Effect.catchTag(["ValidationException", "InvalidRequestException"], (e) =>
Effect.succeed(e._tag),
),
),
topics: yield* startTopicsDetectionJob(invalidJobInput).pipe(
Effect.map(() => "Started"),
Effect.catchTag(["ValidationException", "InvalidRequestException"], (e) =>
Effect.succeed(e._tag),
),
),
};
return yield* HttpServerResponse.json(tags);
}
// Full real lifecycle for the sentiment job family: seed the input
// object, start a real async job, describe it, then stop it.
if (request.method === "POST" && pathname === "/jobs/sentiment/lifecycle") {
yield* putObject({
Key: "comprehend-input/reviews.txt",
Body: "I love this product, it works wonderfully!\nThe delivery was late and the box arrived damaged.\n",
ContentType: "text/plain",
});
// A freshly created data-access role can take a few seconds to
// become assumable by Comprehend — surfaced as
// InvalidRequestException. Bounded retry (8 × 5s).
const started = yield* startSentimentDetectionJob({
...jobInput,
JobName: "alchemy-comprehend-bindings-lifecycle",
LanguageCode: "en",
}).pipe(
Effect.retry({
while: (e): boolean => e._tag === "InvalidRequestException",
schedule: Schedule.spaced("5 seconds"),
times: 8,
}),
);
const jobId = started.JobId ?? "";
const described = yield* describeSentimentDetectionJob({
JobId: jobId,
});
const stopped = yield* stopSentimentDetectionJob({ JobId: jobId });
return yield* HttpServerResponse.json({
jobId,
startStatus: started.JobStatus,
describedStatus: described.SentimentDetectionJobProperties?.JobStatus,
stopStatus: stopped.JobStatus,
});
}
return yield* HttpServerResponse.json(
{ error: "Not found", method: request.method, pathname },
{ status: 404 },
);
}).pipe(Effect.orDie),
};
}).pipe(
Effect.provide(
Layer.mergeAll(
S3.PutObjectHttp,
Comprehend.DetectDominantLanguageHttp,
Comprehend.DetectEntitiesHttp,
Comprehend.DetectKeyPhrasesHttp,
Comprehend.DetectPiiEntitiesHttp,
Comprehend.DetectSentimentHttp,
Comprehend.DetectSyntaxHttp,
Comprehend.DetectTargetedSentimentHttp,
Comprehend.DetectToxicContentHttp,
Comprehend.ContainsPiiEntitiesHttp,
Comprehend.ClassifyDocumentHttp,
Comprehend.BatchDetectDominantLanguageHttp,
Comprehend.BatchDetectEntitiesHttp,
Comprehend.BatchDetectKeyPhrasesHttp,
Comprehend.BatchDetectSentimentHttp,
Comprehend.BatchDetectSyntaxHttp,
Comprehend.BatchDetectTargetedSentimentHttp,
Comprehend.StartDocumentClassificationJobHttp,
Comprehend.StartDominantLanguageDetectionJobHttp,
Comprehend.StartEntitiesDetectionJobHttp,
Comprehend.StartEventsDetectionJobHttp,
Comprehend.StartKeyPhrasesDetectionJobHttp,
Comprehend.StartPiiEntitiesDetectionJobHttp,
Comprehend.StartSentimentDetectionJobHttp,
Comprehend.StartTargetedSentimentDetectionJobHttp,
Comprehend.StartTopicsDetectionJobHttp,
Comprehend.DescribeDocumentClassificationJobHttp,
Comprehend.DescribeDominantLanguageDetectionJobHttp,
Comprehend.DescribeEntitiesDetectionJobHttp,
Comprehend.DescribeEventsDetectionJobHttp,
Comprehend.DescribeKeyPhrasesDetectionJobHttp,
Comprehend.DescribePiiEntitiesDetectionJobHttp,
Comprehend.DescribeSentimentDetectionJobHttp,
Comprehend.DescribeTargetedSentimentDetectionJobHttp,
Comprehend.DescribeTopicsDetectionJobHttp,
Comprehend.ListDocumentClassificationJobsHttp,
Comprehend.ListDominantLanguageDetectionJobsHttp,
Comprehend.ListEntitiesDetectionJobsHttp,
Comprehend.ListEventsDetectionJobsHttp,
Comprehend.ListKeyPhrasesDetectionJobsHttp,
Comprehend.ListPiiEntitiesDetectionJobsHttp,
Comprehend.ListSentimentDetectionJobsHttp,
Comprehend.ListTargetedSentimentDetectionJobsHttp,
Comprehend.ListTopicsDetectionJobsHttp,
Comprehend.StopDominantLanguageDetectionJobHttp,
Comprehend.StopEntitiesDetectionJobHttp,
Comprehend.StopEventsDetectionJobHttp,
Comprehend.StopKeyPhrasesDetectionJobHttp,
Comprehend.StopPiiEntitiesDetectionJobHttp,
Comprehend.StopSentimentDetectionJobHttp,
Comprehend.StopTargetedSentimentDetectionJobHttp,
),
),
),
);