@aws-sdk/client-transcribe 3.965.0 → 3.967.0

package/dist-cjs/index.js

@@ -15,6 +15,7 @@ var httpAuthSchemeProvider = require('./auth/httpAuthSchemeProvider');
 var runtimeConfig = require('./runtimeConfig');
 var regionConfigResolver = require('@aws-sdk/region-config-resolver');
 var protocolHttp = require('@smithy/protocol-http');
+var utilWaiter = require('@smithy/util-waiter');
 
 const resolveClientEndpointParameters = (options) => {
     return Object.assign(options, {
@@ -1905,6 +1906,279 @@ const paginateListVocabularies = core.createPaginator(TranscribeClient, ListVoca
 
 const paginateListVocabularyFilters = core.createPaginator(TranscribeClient, ListVocabularyFiltersCommand, "NextToken", "NextToken", "MaxResults");
 
+const checkState$6 = async (client, input) => {
+    let reason;
+    try {
+        let result = await client.send(new DescribeLanguageModelCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                return result.LanguageModel.ModelStatus;
+            };
+            if (returnComparator() === "COMPLETED") {
+                return { state: utilWaiter.WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.LanguageModel.ModelStatus;
+            };
+            if (returnComparator() === "FAILED") {
+                return { state: utilWaiter.WaiterState.FAILURE, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+    }
+    return { state: utilWaiter.WaiterState.RETRY, reason };
+};
+const waitForLanguageModelCompleted = async (params, input) => {
+    const serviceDefaults = { minDelay: 120, maxDelay: 120 };
+    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$6);
+};
+const waitUntilLanguageModelCompleted = async (params, input) => {
+    const serviceDefaults = { minDelay: 120, maxDelay: 120 };
+    const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$6);
+    return utilWaiter.checkExceptions(result);
+};
+
+const checkState$5 = async (client, input) => {
+    let reason;
+    try {
+        let result = await client.send(new GetCallAnalyticsJobCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                return result.CallAnalyticsJob.CallAnalyticsJobStatus;
+            };
+            if (returnComparator() === "COMPLETED") {
+                return { state: utilWaiter.WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.CallAnalyticsJob.CallAnalyticsJobStatus;
+            };
+            if (returnComparator() === "FAILED") {
+                return { state: utilWaiter.WaiterState.FAILURE, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+    }
+    return { state: utilWaiter.WaiterState.RETRY, reason };
+};
+const waitForCallAnalyticsJobCompleted = async (params, input) => {
+    const serviceDefaults = { minDelay: 10, maxDelay: 120 };
+    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$5);
+};
+const waitUntilCallAnalyticsJobCompleted = async (params, input) => {
+    const serviceDefaults = { minDelay: 10, maxDelay: 120 };
+    const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$5);
+    return utilWaiter.checkExceptions(result);
+};
+
+const checkState$4 = async (client, input) => {
+    let reason;
+    try {
+        let result = await client.send(new GetMedicalScribeJobCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                return result.MedicalScribeJob.MedicalScribeJobStatus;
+            };
+            if (returnComparator() === "COMPLETED") {
+                return { state: utilWaiter.WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.MedicalScribeJob.MedicalScribeJobStatus;
+            };
+            if (returnComparator() === "FAILED") {
+                return { state: utilWaiter.WaiterState.FAILURE, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+    }
+    return { state: utilWaiter.WaiterState.RETRY, reason };
+};
+const waitForMedicalScribeJobCompleted = async (params, input) => {
+    const serviceDefaults = { minDelay: 10, maxDelay: 120 };
+    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$4);
+};
+const waitUntilMedicalScribeJobCompleted = async (params, input) => {
+    const serviceDefaults = { minDelay: 10, maxDelay: 120 };
+    const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$4);
+    return utilWaiter.checkExceptions(result);
+};
+
+const checkState$3 = async (client, input) => {
+    let reason;
+    try {
+        let result = await client.send(new GetMedicalTranscriptionJobCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                return result.MedicalTranscriptionJob.TranscriptionJobStatus;
+            };
+            if (returnComparator() === "COMPLETED") {
+                return { state: utilWaiter.WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.MedicalTranscriptionJob.TranscriptionJobStatus;
+            };
+            if (returnComparator() === "FAILED") {
+                return { state: utilWaiter.WaiterState.FAILURE, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+    }
+    return { state: utilWaiter.WaiterState.RETRY, reason };
+};
+const waitForMedicalTranscriptionJobCompleted = async (params, input) => {
+    const serviceDefaults = { minDelay: 10, maxDelay: 120 };
+    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$3);
+};
+const waitUntilMedicalTranscriptionJobCompleted = async (params, input) => {
+    const serviceDefaults = { minDelay: 10, maxDelay: 120 };
+    const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$3);
+    return utilWaiter.checkExceptions(result);
+};
+
+const checkState$2 = async (client, input) => {
+    let reason;
+    try {
+        let result = await client.send(new GetMedicalVocabularyCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                return result.VocabularyState;
+            };
+            if (returnComparator() === "READY") {
+                return { state: utilWaiter.WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.VocabularyState;
+            };
+            if (returnComparator() === "FAILED") {
+                return { state: utilWaiter.WaiterState.FAILURE, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+    }
+    return { state: utilWaiter.WaiterState.RETRY, reason };
+};
+const waitForMedicalVocabularyReady = async (params, input) => {
+    const serviceDefaults = { minDelay: 10, maxDelay: 120 };
+    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$2);
+};
+const waitUntilMedicalVocabularyReady = async (params, input) => {
+    const serviceDefaults = { minDelay: 10, maxDelay: 120 };
+    const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$2);
+    return utilWaiter.checkExceptions(result);
+};
+
+const checkState$1 = async (client, input) => {
+    let reason;
+    try {
+        let result = await client.send(new GetTranscriptionJobCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                return result.TranscriptionJob.TranscriptionJobStatus;
+            };
+            if (returnComparator() === "COMPLETED") {
+                return { state: utilWaiter.WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.TranscriptionJob.TranscriptionJobStatus;
+            };
+            if (returnComparator() === "FAILED") {
+                return { state: utilWaiter.WaiterState.FAILURE, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+    }
+    return { state: utilWaiter.WaiterState.RETRY, reason };
+};
+const waitForTranscriptionJobCompleted = async (params, input) => {
+    const serviceDefaults = { minDelay: 10, maxDelay: 120 };
+    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$1);
+};
+const waitUntilTranscriptionJobCompleted = async (params, input) => {
+    const serviceDefaults = { minDelay: 10, maxDelay: 120 };
+    const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$1);
+    return utilWaiter.checkExceptions(result);
+};
+
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        let result = await client.send(new GetVocabularyCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                return result.VocabularyState;
+            };
+            if (returnComparator() === "READY") {
+                return { state: utilWaiter.WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.VocabularyState;
+            };
+            if (returnComparator() === "FAILED") {
+                return { state: utilWaiter.WaiterState.FAILURE, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+    }
+    return { state: utilWaiter.WaiterState.RETRY, reason };
+};
+const waitForVocabularyReady = async (params, input) => {
+    const serviceDefaults = { minDelay: 10, maxDelay: 120 };
+    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+const waitUntilVocabularyReady = async (params, input) => {
+    const serviceDefaults = { minDelay: 10, maxDelay: 120 };
+    const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return utilWaiter.checkExceptions(result);
+};
+
 const BaseModelName = {
     NARROW_BAND: "NarrowBand",
     WIDE_BAND: "WideBand",
@@ -2426,3 +2700,17 @@ exports.paginateListMedicalVocabularies = paginateListMedicalVocabularies;
 exports.paginateListTranscriptionJobs = paginateListTranscriptionJobs;
 exports.paginateListVocabularies = paginateListVocabularies;
 exports.paginateListVocabularyFilters = paginateListVocabularyFilters;
+exports.waitForCallAnalyticsJobCompleted = waitForCallAnalyticsJobCompleted;
+exports.waitForLanguageModelCompleted = waitForLanguageModelCompleted;
+exports.waitForMedicalScribeJobCompleted = waitForMedicalScribeJobCompleted;
+exports.waitForMedicalTranscriptionJobCompleted = waitForMedicalTranscriptionJobCompleted;
+exports.waitForMedicalVocabularyReady = waitForMedicalVocabularyReady;
+exports.waitForTranscriptionJobCompleted = waitForTranscriptionJobCompleted;
+exports.waitForVocabularyReady = waitForVocabularyReady;
+exports.waitUntilCallAnalyticsJobCompleted = waitUntilCallAnalyticsJobCompleted;
+exports.waitUntilLanguageModelCompleted = waitUntilLanguageModelCompleted;
+exports.waitUntilMedicalScribeJobCompleted = waitUntilMedicalScribeJobCompleted;
+exports.waitUntilMedicalTranscriptionJobCompleted = waitUntilMedicalTranscriptionJobCompleted;
+exports.waitUntilMedicalVocabularyReady = waitUntilMedicalVocabularyReady;
+exports.waitUntilTranscriptionJobCompleted = waitUntilTranscriptionJobCompleted;
+exports.waitUntilVocabularyReady = waitUntilVocabularyReady;

package/dist-es/index.js

@@ -3,6 +3,7 @@ export * from "./Transcribe";
 export * from "./commands";
 export * from "./schemas/schemas_0";
 export * from "./pagination";
+export * from "./waiters";
 export * from "./models/enums";
 export * from "./models/errors";
 export * from "./models/models_0";

package/dist-es/waiters/index.js

@@ -0,0 +1,7 @@
+export * from "./waitForLanguageModelCompleted";
+export * from "./waitForCallAnalyticsJobCompleted";
+export * from "./waitForMedicalScribeJobCompleted";
+export * from "./waitForMedicalTranscriptionJobCompleted";
+export * from "./waitForMedicalVocabularyReady";
+export * from "./waitForTranscriptionJobCompleted";
+export * from "./waitForVocabularyReady";

package/dist-es/waiters/waitForCallAnalyticsJobCompleted.js

@@ -0,0 +1,40 @@
+import { checkExceptions, createWaiter, WaiterState } from "@smithy/util-waiter";
+import { GetCallAnalyticsJobCommand } from "../commands/GetCallAnalyticsJobCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        let result = await client.send(new GetCallAnalyticsJobCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                return result.CallAnalyticsJob.CallAnalyticsJobStatus;
+            };
+            if (returnComparator() === "COMPLETED") {
+                return { state: WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.CallAnalyticsJob.CallAnalyticsJobStatus;
+            };
+            if (returnComparator() === "FAILED") {
+                return { state: WaiterState.FAILURE, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+    }
+    return { state: WaiterState.RETRY, reason };
+};
+export const waitForCallAnalyticsJobCompleted = async (params, input) => {
+    const serviceDefaults = { minDelay: 10, maxDelay: 120 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilCallAnalyticsJobCompleted = async (params, input) => {
+    const serviceDefaults = { minDelay: 10, maxDelay: 120 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};

package/dist-es/waiters/waitForLanguageModelCompleted.js

@@ -0,0 +1,40 @@
+import { checkExceptions, createWaiter, WaiterState } from "@smithy/util-waiter";
+import { DescribeLanguageModelCommand, } from "../commands/DescribeLanguageModelCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        let result = await client.send(new DescribeLanguageModelCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                return result.LanguageModel.ModelStatus;
+            };
+            if (returnComparator() === "COMPLETED") {
+                return { state: WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.LanguageModel.ModelStatus;
+            };
+            if (returnComparator() === "FAILED") {
+                return { state: WaiterState.FAILURE, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+    }
+    return { state: WaiterState.RETRY, reason };
+};
+export const waitForLanguageModelCompleted = async (params, input) => {
+    const serviceDefaults = { minDelay: 120, maxDelay: 120 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilLanguageModelCompleted = async (params, input) => {
+    const serviceDefaults = { minDelay: 120, maxDelay: 120 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};

package/dist-es/waiters/waitForMedicalScribeJobCompleted.js

@@ -0,0 +1,40 @@
+import { checkExceptions, createWaiter, WaiterState } from "@smithy/util-waiter";
+import { GetMedicalScribeJobCommand } from "../commands/GetMedicalScribeJobCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        let result = await client.send(new GetMedicalScribeJobCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                return result.MedicalScribeJob.MedicalScribeJobStatus;
+            };
+            if (returnComparator() === "COMPLETED") {
+                return { state: WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.MedicalScribeJob.MedicalScribeJobStatus;
+            };
+            if (returnComparator() === "FAILED") {
+                return { state: WaiterState.FAILURE, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+    }
+    return { state: WaiterState.RETRY, reason };
+};
+export const waitForMedicalScribeJobCompleted = async (params, input) => {
+    const serviceDefaults = { minDelay: 10, maxDelay: 120 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilMedicalScribeJobCompleted = async (params, input) => {
+    const serviceDefaults = { minDelay: 10, maxDelay: 120 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};

package/dist-es/waiters/waitForMedicalTranscriptionJobCompleted.js

@@ -0,0 +1,40 @@
+import { checkExceptions, createWaiter, WaiterState } from "@smithy/util-waiter";
+import { GetMedicalTranscriptionJobCommand, } from "../commands/GetMedicalTranscriptionJobCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        let result = await client.send(new GetMedicalTranscriptionJobCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                return result.MedicalTranscriptionJob.TranscriptionJobStatus;
+            };
+            if (returnComparator() === "COMPLETED") {
+                return { state: WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.MedicalTranscriptionJob.TranscriptionJobStatus;
+            };
+            if (returnComparator() === "FAILED") {
+                return { state: WaiterState.FAILURE, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+    }
+    return { state: WaiterState.RETRY, reason };
+};
+export const waitForMedicalTranscriptionJobCompleted = async (params, input) => {
+    const serviceDefaults = { minDelay: 10, maxDelay: 120 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilMedicalTranscriptionJobCompleted = async (params, input) => {
+    const serviceDefaults = { minDelay: 10, maxDelay: 120 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};

package/dist-es/waiters/waitForMedicalVocabularyReady.js

@@ -0,0 +1,40 @@
+import { checkExceptions, createWaiter, WaiterState } from "@smithy/util-waiter";
+import { GetMedicalVocabularyCommand } from "../commands/GetMedicalVocabularyCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        let result = await client.send(new GetMedicalVocabularyCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                return result.VocabularyState;
+            };
+            if (returnComparator() === "READY") {
+                return { state: WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.VocabularyState;
+            };
+            if (returnComparator() === "FAILED") {
+                return { state: WaiterState.FAILURE, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+    }
+    return { state: WaiterState.RETRY, reason };
+};
+export const waitForMedicalVocabularyReady = async (params, input) => {
+    const serviceDefaults = { minDelay: 10, maxDelay: 120 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilMedicalVocabularyReady = async (params, input) => {
+    const serviceDefaults = { minDelay: 10, maxDelay: 120 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};

package/dist-es/waiters/waitForTranscriptionJobCompleted.js

@@ -0,0 +1,40 @@
+import { checkExceptions, createWaiter, WaiterState } from "@smithy/util-waiter";
+import { GetTranscriptionJobCommand } from "../commands/GetTranscriptionJobCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        let result = await client.send(new GetTranscriptionJobCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                return result.TranscriptionJob.TranscriptionJobStatus;
+            };
+            if (returnComparator() === "COMPLETED") {
+                return { state: WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.TranscriptionJob.TranscriptionJobStatus;
+            };
+            if (returnComparator() === "FAILED") {
+                return { state: WaiterState.FAILURE, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+    }
+    return { state: WaiterState.RETRY, reason };
+};
+export const waitForTranscriptionJobCompleted = async (params, input) => {
+    const serviceDefaults = { minDelay: 10, maxDelay: 120 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilTranscriptionJobCompleted = async (params, input) => {
+    const serviceDefaults = { minDelay: 10, maxDelay: 120 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};

package/dist-es/waiters/waitForVocabularyReady.js

@@ -0,0 +1,40 @@
+import { checkExceptions, createWaiter, WaiterState } from "@smithy/util-waiter";
+import { GetVocabularyCommand } from "../commands/GetVocabularyCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        let result = await client.send(new GetVocabularyCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                return result.VocabularyState;
+            };
+            if (returnComparator() === "READY") {
+                return { state: WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.VocabularyState;
+            };
+            if (returnComparator() === "FAILED") {
+                return { state: WaiterState.FAILURE, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+    }
+    return { state: WaiterState.RETRY, reason };
+};
+export const waitForVocabularyReady = async (params, input) => {
+    const serviceDefaults = { minDelay: 10, maxDelay: 120 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilVocabularyReady = async (params, input) => {
+    const serviceDefaults = { minDelay: 10, maxDelay: 120 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};

package/dist-types/index.d.ts

@@ -32,6 +32,7 @@ export type { TranscribeExtensionConfiguration } from "./extensionConfiguration"
 export * from "./commands";
 export * from "./schemas/schemas_0";
 export * from "./pagination";
+export * from "./waiters";
 export * from "./models/enums";
 export * from "./models/errors";
 export * from "./models/models_0";

package/dist-types/ts3.4/index.d.ts

@@ -6,6 +6,7 @@ export { TranscribeExtensionConfiguration } from "./extensionConfiguration";
 export * from "./commands";
 export * from "./schemas/schemas_0";
 export * from "./pagination";
+export * from "./waiters";
 export * from "./models/enums";
 export * from "./models/errors";
 export * from "./models/models_0";

package/dist-types/ts3.4/waiters/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./waitForLanguageModelCompleted";
+export * from "./waitForCallAnalyticsJobCompleted";
+export * from "./waitForMedicalScribeJobCompleted";
+export * from "./waitForMedicalTranscriptionJobCompleted";
+export * from "./waitForMedicalVocabularyReady";
+export * from "./waitForTranscriptionJobCompleted";
+export * from "./waitForVocabularyReady";

package/dist-types/ts3.4/waiters/waitForCallAnalyticsJobCompleted.d.ts

@@ -0,0 +1,11 @@
+import { WaiterConfiguration, WaiterResult } from "@smithy/util-waiter";
+import { GetCallAnalyticsJobCommandInput } from "../commands/GetCallAnalyticsJobCommand";
+import { TranscribeClient } from "../TranscribeClient";
+export declare const waitForCallAnalyticsJobCompleted: (
+  params: WaiterConfiguration<TranscribeClient>,
+  input: GetCallAnalyticsJobCommandInput
+) => Promise<WaiterResult>;
+export declare const waitUntilCallAnalyticsJobCompleted: (
+  params: WaiterConfiguration<TranscribeClient>,
+  input: GetCallAnalyticsJobCommandInput
+) => Promise<WaiterResult>;

package/dist-types/ts3.4/waiters/waitForLanguageModelCompleted.d.ts

@@ -0,0 +1,11 @@
+import { WaiterConfiguration, WaiterResult } from "@smithy/util-waiter";
+import { DescribeLanguageModelCommandInput } from "../commands/DescribeLanguageModelCommand";
+import { TranscribeClient } from "../TranscribeClient";
+export declare const waitForLanguageModelCompleted: (
+  params: WaiterConfiguration<TranscribeClient>,
+  input: DescribeLanguageModelCommandInput
+) => Promise<WaiterResult>;
+export declare const waitUntilLanguageModelCompleted: (
+  params: WaiterConfiguration<TranscribeClient>,
+  input: DescribeLanguageModelCommandInput
+) => Promise<WaiterResult>;

package/dist-types/ts3.4/waiters/waitForMedicalScribeJobCompleted.d.ts

@@ -0,0 +1,11 @@
+import { WaiterConfiguration, WaiterResult } from "@smithy/util-waiter";
+import { GetMedicalScribeJobCommandInput } from "../commands/GetMedicalScribeJobCommand";
+import { TranscribeClient } from "../TranscribeClient";
+export declare const waitForMedicalScribeJobCompleted: (
+  params: WaiterConfiguration<TranscribeClient>,
+  input: GetMedicalScribeJobCommandInput
+) => Promise<WaiterResult>;
+export declare const waitUntilMedicalScribeJobCompleted: (
+  params: WaiterConfiguration<TranscribeClient>,
+  input: GetMedicalScribeJobCommandInput
+) => Promise<WaiterResult>;

package/dist-types/ts3.4/waiters/waitForMedicalTranscriptionJobCompleted.d.ts

@@ -0,0 +1,11 @@
+import { WaiterConfiguration, WaiterResult } from "@smithy/util-waiter";
+import { GetMedicalTranscriptionJobCommandInput } from "../commands/GetMedicalTranscriptionJobCommand";
+import { TranscribeClient } from "../TranscribeClient";
+export declare const waitForMedicalTranscriptionJobCompleted: (
+  params: WaiterConfiguration<TranscribeClient>,
+  input: GetMedicalTranscriptionJobCommandInput
+) => Promise<WaiterResult>;
+export declare const waitUntilMedicalTranscriptionJobCompleted: (
+  params: WaiterConfiguration<TranscribeClient>,
+  input: GetMedicalTranscriptionJobCommandInput
+) => Promise<WaiterResult>;

package/dist-types/ts3.4/waiters/waitForMedicalVocabularyReady.d.ts

@@ -0,0 +1,11 @@
+import { WaiterConfiguration, WaiterResult } from "@smithy/util-waiter";
+import { GetMedicalVocabularyCommandInput } from "../commands/GetMedicalVocabularyCommand";
+import { TranscribeClient } from "../TranscribeClient";
+export declare const waitForMedicalVocabularyReady: (
+  params: WaiterConfiguration<TranscribeClient>,
+  input: GetMedicalVocabularyCommandInput
+) => Promise<WaiterResult>;
+export declare const waitUntilMedicalVocabularyReady: (
+  params: WaiterConfiguration<TranscribeClient>,
+  input: GetMedicalVocabularyCommandInput
+) => Promise<WaiterResult>;

package/dist-types/ts3.4/waiters/waitForTranscriptionJobCompleted.d.ts

@@ -0,0 +1,11 @@
+import { WaiterConfiguration, WaiterResult } from "@smithy/util-waiter";
+import { GetTranscriptionJobCommandInput } from "../commands/GetTranscriptionJobCommand";
+import { TranscribeClient } from "../TranscribeClient";
+export declare const waitForTranscriptionJobCompleted: (
+  params: WaiterConfiguration<TranscribeClient>,
+  input: GetTranscriptionJobCommandInput
+) => Promise<WaiterResult>;
+export declare const waitUntilTranscriptionJobCompleted: (
+  params: WaiterConfiguration<TranscribeClient>,
+  input: GetTranscriptionJobCommandInput
+) => Promise<WaiterResult>;

package/dist-types/ts3.4/waiters/waitForVocabularyReady.d.ts

@@ -0,0 +1,11 @@
+import { WaiterConfiguration, WaiterResult } from "@smithy/util-waiter";
+import { GetVocabularyCommandInput } from "../commands/GetVocabularyCommand";
+import { TranscribeClient } from "../TranscribeClient";
+export declare const waitForVocabularyReady: (
+  params: WaiterConfiguration<TranscribeClient>,
+  input: GetVocabularyCommandInput
+) => Promise<WaiterResult>;
+export declare const waitUntilVocabularyReady: (
+  params: WaiterConfiguration<TranscribeClient>,
+  input: GetVocabularyCommandInput
+) => Promise<WaiterResult>;

package/dist-types/waiters/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./waitForLanguageModelCompleted";
+export * from "./waitForCallAnalyticsJobCompleted";
+export * from "./waitForMedicalScribeJobCompleted";
+export * from "./waitForMedicalTranscriptionJobCompleted";
+export * from "./waitForMedicalVocabularyReady";
+export * from "./waitForTranscriptionJobCompleted";
+export * from "./waitForVocabularyReady";

package/dist-types/waiters/waitForCallAnalyticsJobCompleted.d.ts

@@ -0,0 +1,14 @@
+import { WaiterConfiguration, WaiterResult } from "@smithy/util-waiter";
+import { GetCallAnalyticsJobCommandInput } from "../commands/GetCallAnalyticsJobCommand";
+import { TranscribeClient } from "../TranscribeClient";
+/**
+ *
+ *  @deprecated Use waitUntilCallAnalyticsJobCompleted instead. waitForCallAnalyticsJobCompleted does not throw error in non-success cases.
+ */
+export declare const waitForCallAnalyticsJobCompleted: (params: WaiterConfiguration<TranscribeClient>, input: GetCallAnalyticsJobCommandInput) => Promise<WaiterResult>;
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to GetCallAnalyticsJobCommand for polling.
+ */
+export declare const waitUntilCallAnalyticsJobCompleted: (params: WaiterConfiguration<TranscribeClient>, input: GetCallAnalyticsJobCommandInput) => Promise<WaiterResult>;

package/dist-types/waiters/waitForLanguageModelCompleted.d.ts

@@ -0,0 +1,14 @@
+import { WaiterConfiguration, WaiterResult } from "@smithy/util-waiter";
+import { DescribeLanguageModelCommandInput } from "../commands/DescribeLanguageModelCommand";
+import { TranscribeClient } from "../TranscribeClient";
+/**
+ *
+ *  @deprecated Use waitUntilLanguageModelCompleted instead. waitForLanguageModelCompleted does not throw error in non-success cases.
+ */
+export declare const waitForLanguageModelCompleted: (params: WaiterConfiguration<TranscribeClient>, input: DescribeLanguageModelCommandInput) => Promise<WaiterResult>;
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to DescribeLanguageModelCommand for polling.
+ */
+export declare const waitUntilLanguageModelCompleted: (params: WaiterConfiguration<TranscribeClient>, input: DescribeLanguageModelCommandInput) => Promise<WaiterResult>;

package/dist-types/waiters/waitForMedicalScribeJobCompleted.d.ts

@@ -0,0 +1,14 @@
+import { WaiterConfiguration, WaiterResult } from "@smithy/util-waiter";
+import { GetMedicalScribeJobCommandInput } from "../commands/GetMedicalScribeJobCommand";
+import { TranscribeClient } from "../TranscribeClient";
+/**
+ *
+ *  @deprecated Use waitUntilMedicalScribeJobCompleted instead. waitForMedicalScribeJobCompleted does not throw error in non-success cases.
+ */
+export declare const waitForMedicalScribeJobCompleted: (params: WaiterConfiguration<TranscribeClient>, input: GetMedicalScribeJobCommandInput) => Promise<WaiterResult>;
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to GetMedicalScribeJobCommand for polling.
+ */
+export declare const waitUntilMedicalScribeJobCompleted: (params: WaiterConfiguration<TranscribeClient>, input: GetMedicalScribeJobCommandInput) => Promise<WaiterResult>;

package/dist-types/waiters/waitForMedicalTranscriptionJobCompleted.d.ts

@@ -0,0 +1,14 @@
+import { WaiterConfiguration, WaiterResult } from "@smithy/util-waiter";
+import { GetMedicalTranscriptionJobCommandInput } from "../commands/GetMedicalTranscriptionJobCommand";
+import { TranscribeClient } from "../TranscribeClient";
+/**
+ *
+ *  @deprecated Use waitUntilMedicalTranscriptionJobCompleted instead. waitForMedicalTranscriptionJobCompleted does not throw error in non-success cases.
+ */
+export declare const waitForMedicalTranscriptionJobCompleted: (params: WaiterConfiguration<TranscribeClient>, input: GetMedicalTranscriptionJobCommandInput) => Promise<WaiterResult>;
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to GetMedicalTranscriptionJobCommand for polling.
+ */
+export declare const waitUntilMedicalTranscriptionJobCompleted: (params: WaiterConfiguration<TranscribeClient>, input: GetMedicalTranscriptionJobCommandInput) => Promise<WaiterResult>;

package/dist-types/waiters/waitForMedicalVocabularyReady.d.ts

@@ -0,0 +1,14 @@
+import { WaiterConfiguration, WaiterResult } from "@smithy/util-waiter";
+import { GetMedicalVocabularyCommandInput } from "../commands/GetMedicalVocabularyCommand";
+import { TranscribeClient } from "../TranscribeClient";
+/**
+ *
+ *  @deprecated Use waitUntilMedicalVocabularyReady instead. waitForMedicalVocabularyReady does not throw error in non-success cases.
+ */
+export declare const waitForMedicalVocabularyReady: (params: WaiterConfiguration<TranscribeClient>, input: GetMedicalVocabularyCommandInput) => Promise<WaiterResult>;
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to GetMedicalVocabularyCommand for polling.
+ */
+export declare const waitUntilMedicalVocabularyReady: (params: WaiterConfiguration<TranscribeClient>, input: GetMedicalVocabularyCommandInput) => Promise<WaiterResult>;

package/dist-types/waiters/waitForTranscriptionJobCompleted.d.ts

@@ -0,0 +1,14 @@
+import { WaiterConfiguration, WaiterResult } from "@smithy/util-waiter";
+import { GetTranscriptionJobCommandInput } from "../commands/GetTranscriptionJobCommand";
+import { TranscribeClient } from "../TranscribeClient";
+/**
+ *
+ *  @deprecated Use waitUntilTranscriptionJobCompleted instead. waitForTranscriptionJobCompleted does not throw error in non-success cases.
+ */
+export declare const waitForTranscriptionJobCompleted: (params: WaiterConfiguration<TranscribeClient>, input: GetTranscriptionJobCommandInput) => Promise<WaiterResult>;
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to GetTranscriptionJobCommand for polling.
+ */
+export declare const waitUntilTranscriptionJobCompleted: (params: WaiterConfiguration<TranscribeClient>, input: GetTranscriptionJobCommandInput) => Promise<WaiterResult>;

package/dist-types/waiters/waitForVocabularyReady.d.ts

@@ -0,0 +1,14 @@
+import { WaiterConfiguration, WaiterResult } from "@smithy/util-waiter";
+import { GetVocabularyCommandInput } from "../commands/GetVocabularyCommand";
+import { TranscribeClient } from "../TranscribeClient";
+/**
+ *
+ *  @deprecated Use waitUntilVocabularyReady instead. waitForVocabularyReady does not throw error in non-success cases.
+ */
+export declare const waitForVocabularyReady: (params: WaiterConfiguration<TranscribeClient>, input: GetVocabularyCommandInput) => Promise<WaiterResult>;
+/**
+ *
+ *  @param params - Waiter configuration options.
+ *  @param input - The input to GetVocabularyCommand for polling.
+ */
+export declare const waitUntilVocabularyReady: (params: WaiterConfiguration<TranscribeClient>, input: GetVocabularyCommandInput) => Promise<WaiterResult>;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@aws-sdk/client-transcribe",
   "description": "AWS SDK for JavaScript Transcribe Client for Node.js, Browser and React Native",
-  "version": "3.965.0",
+  "version": "3.967.0",
   "scripts": {
     "build": "concurrently 'yarn:build:types' 'yarn:build:es' && yarn build:cjs",
     "build:cjs": "node ../../scripts/compilation/inline client-transcribe",
@@ -21,42 +21,43 @@
   "dependencies": {
     "@aws-crypto/sha256-browser": "5.2.0",
     "@aws-crypto/sha256-js": "5.2.0",
-    "@aws-sdk/core": "3.965.0",
-    "@aws-sdk/credential-provider-node": "3.965.0",
+    "@aws-sdk/core": "3.967.0",
+    "@aws-sdk/credential-provider-node": "3.967.0",
     "@aws-sdk/middleware-host-header": "3.965.0",
     "@aws-sdk/middleware-logger": "3.965.0",
     "@aws-sdk/middleware-recursion-detection": "3.965.0",
-    "@aws-sdk/middleware-user-agent": "3.965.0",
+    "@aws-sdk/middleware-user-agent": "3.967.0",
     "@aws-sdk/region-config-resolver": "3.965.0",
     "@aws-sdk/types": "3.965.0",
     "@aws-sdk/util-endpoints": "3.965.0",
     "@aws-sdk/util-user-agent-browser": "3.965.0",
-    "@aws-sdk/util-user-agent-node": "3.965.0",
+    "@aws-sdk/util-user-agent-node": "3.967.0",
     "@smithy/config-resolver": "^4.4.5",
-    "@smithy/core": "^3.20.0",
+    "@smithy/core": "^3.20.2",
     "@smithy/fetch-http-handler": "^5.3.8",
     "@smithy/hash-node": "^4.2.7",
     "@smithy/invalid-dependency": "^4.2.7",
     "@smithy/middleware-content-length": "^4.2.7",
-    "@smithy/middleware-endpoint": "^4.4.1",
-    "@smithy/middleware-retry": "^4.4.17",
+    "@smithy/middleware-endpoint": "^4.4.3",
+    "@smithy/middleware-retry": "^4.4.19",
     "@smithy/middleware-serde": "^4.2.8",
     "@smithy/middleware-stack": "^4.2.7",
     "@smithy/node-config-provider": "^4.3.7",
     "@smithy/node-http-handler": "^4.4.7",
     "@smithy/protocol-http": "^5.3.7",
-    "@smithy/smithy-client": "^4.10.2",
+    "@smithy/smithy-client": "^4.10.4",
     "@smithy/types": "^4.11.0",
     "@smithy/url-parser": "^4.2.7",
     "@smithy/util-base64": "^4.3.0",
     "@smithy/util-body-length-browser": "^4.2.0",
     "@smithy/util-body-length-node": "^4.2.1",
-    "@smithy/util-defaults-mode-browser": "^4.3.16",
-    "@smithy/util-defaults-mode-node": "^4.2.19",
+    "@smithy/util-defaults-mode-browser": "^4.3.18",
+    "@smithy/util-defaults-mode-node": "^4.2.21",
     "@smithy/util-endpoints": "^3.2.7",
     "@smithy/util-middleware": "^4.2.7",
     "@smithy/util-retry": "^4.2.7",
     "@smithy/util-utf8": "^4.2.0",
+    "@smithy/util-waiter": "^4.2.7",
     "tslib": "^2.6.2"
   },
   "devDependencies": {