@aws-sdk/client-mediaconnect 3.934.0 → 3.935.0

package/dist-es/waiters/index.js

@@ -1,3 +1,10 @@
 export * from "./waitForFlowActive";
 export * from "./waitForFlowDeleted";
 export * from "./waitForFlowStandby";
+export * from "./waitForInputActive";
+export * from "./waitForInputDeleted";
+export * from "./waitForInputStandby";
+export * from "./waitForOutputActive";
+export * from "./waitForOutputDeleted";
+export * from "./waitForOutputRouted";
+export * from "./waitForOutputStandby";

package/dist-es/waiters/waitForInputActive.js

@@ -0,0 +1,64 @@
+import { checkExceptions, createWaiter, WaiterState } from "@smithy/util-waiter";
+import { GetRouterInputCommand } from "../commands/GetRouterInputCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new GetRouterInputCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                return result.RouterInput.State;
+            };
+            if (returnComparator() === "ACTIVE") {
+                return { state: WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.RouterInput.State;
+            };
+            if (returnComparator() === "STARTING") {
+                return { state: WaiterState.RETRY, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.RouterInput.State;
+            };
+            if (returnComparator() === "UPDATING") {
+                return { state: WaiterState.RETRY, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.RouterInput.State;
+            };
+            if (returnComparator() === "ERROR") {
+                return { state: WaiterState.FAILURE, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+        if (exception.name && exception.name == "InternalServerErrorException") {
+            return { state: WaiterState.RETRY, reason };
+        }
+        if (exception.name && exception.name == "ServiceUnavailableException") {
+            return { state: WaiterState.RETRY, reason };
+        }
+    }
+    return { state: WaiterState.RETRY, reason };
+};
+export const waitForInputActive = async (params, input) => {
+    const serviceDefaults = { minDelay: 3, maxDelay: 120 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilInputActive = async (params, input) => {
+    const serviceDefaults = { minDelay: 3, maxDelay: 120 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};

package/dist-es/waiters/waitForInputDeleted.js

@@ -0,0 +1,49 @@
+import { checkExceptions, createWaiter, WaiterState } from "@smithy/util-waiter";
+import { GetRouterInputCommand } from "../commands/GetRouterInputCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new GetRouterInputCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                return result.RouterInput.State;
+            };
+            if (returnComparator() === "DELETING") {
+                return { state: WaiterState.RETRY, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.RouterInput.State;
+            };
+            if (returnComparator() === "ERROR") {
+                return { state: WaiterState.FAILURE, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+        if (exception.name && exception.name == "InternalServerErrorException") {
+            return { state: WaiterState.RETRY, reason };
+        }
+        if (exception.name && exception.name == "ServiceUnavailableException") {
+            return { state: WaiterState.RETRY, reason };
+        }
+        if (exception.name && exception.name == "NotFoundException") {
+            return { state: WaiterState.SUCCESS, reason };
+        }
+    }
+    return { state: WaiterState.RETRY, reason };
+};
+export const waitForInputDeleted = async (params, input) => {
+    const serviceDefaults = { minDelay: 3, maxDelay: 120 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilInputDeleted = async (params, input) => {
+    const serviceDefaults = { minDelay: 3, maxDelay: 120 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};

package/dist-es/waiters/waitForInputStandby.js

@@ -0,0 +1,55 @@
+import { checkExceptions, createWaiter, WaiterState } from "@smithy/util-waiter";
+import { GetRouterInputCommand } from "../commands/GetRouterInputCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new GetRouterInputCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                return result.RouterInput.State;
+            };
+            if (returnComparator() === "STANDBY") {
+                return { state: WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.RouterInput.State;
+            };
+            if (returnComparator() === "STOPPING") {
+                return { state: WaiterState.RETRY, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.RouterInput.State;
+            };
+            if (returnComparator() === "ERROR") {
+                return { state: WaiterState.FAILURE, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+        if (exception.name && exception.name == "InternalServerErrorException") {
+            return { state: WaiterState.RETRY, reason };
+        }
+        if (exception.name && exception.name == "ServiceUnavailableException") {
+            return { state: WaiterState.RETRY, reason };
+        }
+    }
+    return { state: WaiterState.RETRY, reason };
+};
+export const waitForInputStandby = async (params, input) => {
+    const serviceDefaults = { minDelay: 3, maxDelay: 120 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilInputStandby = async (params, input) => {
+    const serviceDefaults = { minDelay: 3, maxDelay: 120 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};

package/dist-es/waiters/waitForOutputActive.js

@@ -0,0 +1,64 @@
+import { checkExceptions, createWaiter, WaiterState } from "@smithy/util-waiter";
+import { GetRouterOutputCommand } from "../commands/GetRouterOutputCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new GetRouterOutputCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                return result.RouterOutput.State;
+            };
+            if (returnComparator() === "ACTIVE") {
+                return { state: WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.RouterOutput.State;
+            };
+            if (returnComparator() === "STARTING") {
+                return { state: WaiterState.RETRY, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.RouterOutput.State;
+            };
+            if (returnComparator() === "UPDATING") {
+                return { state: WaiterState.RETRY, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.RouterOutput.State;
+            };
+            if (returnComparator() === "ERROR") {
+                return { state: WaiterState.FAILURE, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+        if (exception.name && exception.name == "InternalServerErrorException") {
+            return { state: WaiterState.RETRY, reason };
+        }
+        if (exception.name && exception.name == "ServiceUnavailableException") {
+            return { state: WaiterState.RETRY, reason };
+        }
+    }
+    return { state: WaiterState.RETRY, reason };
+};
+export const waitForOutputActive = async (params, input) => {
+    const serviceDefaults = { minDelay: 3, maxDelay: 120 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilOutputActive = async (params, input) => {
+    const serviceDefaults = { minDelay: 3, maxDelay: 120 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};

package/dist-es/waiters/waitForOutputDeleted.js

@@ -0,0 +1,49 @@
+import { checkExceptions, createWaiter, WaiterState } from "@smithy/util-waiter";
+import { GetRouterOutputCommand } from "../commands/GetRouterOutputCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new GetRouterOutputCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                return result.RouterOutput.State;
+            };
+            if (returnComparator() === "DELETING") {
+                return { state: WaiterState.RETRY, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.RouterOutput.State;
+            };
+            if (returnComparator() === "ERROR") {
+                return { state: WaiterState.FAILURE, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+        if (exception.name && exception.name == "InternalServerErrorException") {
+            return { state: WaiterState.RETRY, reason };
+        }
+        if (exception.name && exception.name == "ServiceUnavailableException") {
+            return { state: WaiterState.RETRY, reason };
+        }
+        if (exception.name && exception.name == "NotFoundException") {
+            return { state: WaiterState.SUCCESS, reason };
+        }
+    }
+    return { state: WaiterState.RETRY, reason };
+};
+export const waitForOutputDeleted = async (params, input) => {
+    const serviceDefaults = { minDelay: 3, maxDelay: 120 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilOutputDeleted = async (params, input) => {
+    const serviceDefaults = { minDelay: 3, maxDelay: 120 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};

package/dist-es/waiters/waitForOutputRouted.js

@@ -0,0 +1,46 @@
+import { checkExceptions, createWaiter, WaiterState } from "@smithy/util-waiter";
+import { GetRouterOutputCommand } from "../commands/GetRouterOutputCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new GetRouterOutputCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                return result.RouterOutput.RoutedState;
+            };
+            if (returnComparator() === "ROUTED") {
+                return { state: WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.RouterOutput.RoutedState;
+            };
+            if (returnComparator() === "ROUTING") {
+                return { state: WaiterState.RETRY, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+        if (exception.name && exception.name == "InternalServerErrorException") {
+            return { state: WaiterState.RETRY, reason };
+        }
+        if (exception.name && exception.name == "ServiceUnavailableException") {
+            return { state: WaiterState.RETRY, reason };
+        }
+    }
+    return { state: WaiterState.RETRY, reason };
+};
+export const waitForOutputRouted = async (params, input) => {
+    const serviceDefaults = { minDelay: 3, maxDelay: 120 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilOutputRouted = async (params, input) => {
+    const serviceDefaults = { minDelay: 3, maxDelay: 120 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};

package/dist-es/waiters/waitForOutputStandby.js

@@ -0,0 +1,55 @@
+import { checkExceptions, createWaiter, WaiterState } from "@smithy/util-waiter";
+import { GetRouterOutputCommand } from "../commands/GetRouterOutputCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new GetRouterOutputCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                return result.RouterOutput.State;
+            };
+            if (returnComparator() === "STANDBY") {
+                return { state: WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.RouterOutput.State;
+            };
+            if (returnComparator() === "STOPPING") {
+                return { state: WaiterState.RETRY, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.RouterOutput.State;
+            };
+            if (returnComparator() === "ERROR") {
+                return { state: WaiterState.FAILURE, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+        if (exception.name && exception.name == "InternalServerErrorException") {
+            return { state: WaiterState.RETRY, reason };
+        }
+        if (exception.name && exception.name == "ServiceUnavailableException") {
+            return { state: WaiterState.RETRY, reason };
+        }
+    }
+    return { state: WaiterState.RETRY, reason };
+};
+export const waitForOutputStandby = async (params, input) => {
+    const serviceDefaults = { minDelay: 3, maxDelay: 120 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilOutputStandby = async (params, input) => {
+    const serviceDefaults = { minDelay: 3, maxDelay: 120 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};