@aws-sdk/client-medialive 3.645.0 → 3.650.0

package/dist-es/waiters/index.js

@@ -1,7 +1,12 @@
 export * from "./waitForChannelCreated";
 export * from "./waitForChannelDeleted";
+export * from "./waitForChannelPlacementGroupAssigned";
+export * from "./waitForChannelPlacementGroupDeleted";
+export * from "./waitForChannelPlacementGroupUnassigned";
 export * from "./waitForChannelRunning";
 export * from "./waitForChannelStopped";
+export * from "./waitForClusterCreated";
+export * from "./waitForClusterDeleted";
 export * from "./waitForInputAttached";
 export * from "./waitForInputDeleted";
 export * from "./waitForInputDetached";
@@ -9,6 +14,8 @@ export * from "./waitForMultiplexCreated";
 export * from "./waitForMultiplexDeleted";
 export * from "./waitForMultiplexRunning";
 export * from "./waitForMultiplexStopped";
+export * from "./waitForNodeDeregistered";
+export * from "./waitForNodeRegistered";
 export * from "./waitForSignalMapCreated";
 export * from "./waitForSignalMapMonitorDeleted";
 export * from "./waitForSignalMapMonitorDeployed";

package/dist-es/waiters/waitForChannelPlacementGroupAssigned.js

@@ -0,0 +1,43 @@
+import { checkExceptions, createWaiter, WaiterState } from "@smithy/util-waiter";
+import { DescribeChannelPlacementGroupCommand, } from "../commands/DescribeChannelPlacementGroupCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new DescribeChannelPlacementGroupCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                return result.State;
+            };
+            if (returnComparator() === "ASSIGNED") {
+                return { state: WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.State;
+            };
+            if (returnComparator() === "ASSIGNING") {
+                return { state: WaiterState.RETRY, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+        if (exception.name && exception.name == "InternalServerErrorException") {
+            return { state: WaiterState.RETRY, reason };
+        }
+    }
+    return { state: WaiterState.RETRY, reason };
+};
+export const waitForChannelPlacementGroupAssigned = async (params, input) => {
+    const serviceDefaults = { minDelay: 3, maxDelay: 120 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilChannelPlacementGroupAssigned = async (params, input) => {
+    const serviceDefaults = { minDelay: 3, maxDelay: 120 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};

package/dist-es/waiters/waitForChannelPlacementGroupDeleted.js

@@ -0,0 +1,43 @@
+import { checkExceptions, createWaiter, WaiterState } from "@smithy/util-waiter";
+import { DescribeChannelPlacementGroupCommand, } from "../commands/DescribeChannelPlacementGroupCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new DescribeChannelPlacementGroupCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                return result.State;
+            };
+            if (returnComparator() === "DELETED") {
+                return { state: WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.State;
+            };
+            if (returnComparator() === "DELETING") {
+                return { state: WaiterState.RETRY, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+        if (exception.name && exception.name == "InternalServerErrorException") {
+            return { state: WaiterState.RETRY, reason };
+        }
+    }
+    return { state: WaiterState.RETRY, reason };
+};
+export const waitForChannelPlacementGroupDeleted = async (params, input) => {
+    const serviceDefaults = { minDelay: 5, maxDelay: 120 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilChannelPlacementGroupDeleted = async (params, input) => {
+    const serviceDefaults = { minDelay: 5, maxDelay: 120 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};

package/dist-es/waiters/waitForChannelPlacementGroupUnassigned.js

@@ -0,0 +1,43 @@
+import { checkExceptions, createWaiter, WaiterState } from "@smithy/util-waiter";
+import { DescribeChannelPlacementGroupCommand, } from "../commands/DescribeChannelPlacementGroupCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new DescribeChannelPlacementGroupCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                return result.State;
+            };
+            if (returnComparator() === "UNASSIGNED") {
+                return { state: WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.State;
+            };
+            if (returnComparator() === "UNASSIGNING") {
+                return { state: WaiterState.RETRY, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+        if (exception.name && exception.name == "InternalServerErrorException") {
+            return { state: WaiterState.RETRY, reason };
+        }
+    }
+    return { state: WaiterState.RETRY, reason };
+};
+export const waitForChannelPlacementGroupUnassigned = async (params, input) => {
+    const serviceDefaults = { minDelay: 5, maxDelay: 120 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilChannelPlacementGroupUnassigned = async (params, input) => {
+    const serviceDefaults = { minDelay: 5, maxDelay: 120 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};

package/dist-es/waiters/waitForClusterCreated.js

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

package/dist-es/waiters/waitForClusterDeleted.js

@@ -0,0 +1,43 @@
+import { checkExceptions, createWaiter, WaiterState } from "@smithy/util-waiter";
+import { DescribeClusterCommand } from "../commands/DescribeClusterCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new DescribeClusterCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                return result.State;
+            };
+            if (returnComparator() === "DELETED") {
+                return { state: WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.State;
+            };
+            if (returnComparator() === "DELETING") {
+                return { state: WaiterState.RETRY, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+        if (exception.name && exception.name == "InternalServerErrorException") {
+            return { state: WaiterState.RETRY, reason };
+        }
+    }
+    return { state: WaiterState.RETRY, reason };
+};
+export const waitForClusterDeleted = async (params, input) => {
+    const serviceDefaults = { minDelay: 5, maxDelay: 120 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilClusterDeleted = async (params, input) => {
+    const serviceDefaults = { minDelay: 5, maxDelay: 120 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};

package/dist-es/waiters/waitForNodeDeregistered.js

@@ -0,0 +1,52 @@
+import { checkExceptions, createWaiter, WaiterState } from "@smithy/util-waiter";
+import { DescribeNodeCommand } from "../commands/DescribeNodeCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new DescribeNodeCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                return result.State;
+            };
+            if (returnComparator() === "DEREGISTERED") {
+                return { state: WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.State;
+            };
+            if (returnComparator() === "DEREGISTERING") {
+                return { state: WaiterState.RETRY, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.State;
+            };
+            if (returnComparator() === "DRAINING") {
+                return { state: WaiterState.RETRY, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+        if (exception.name && exception.name == "InternalServerErrorException") {
+            return { state: WaiterState.RETRY, reason };
+        }
+    }
+    return { state: WaiterState.RETRY, reason };
+};
+export const waitForNodeDeregistered = async (params, input) => {
+    const serviceDefaults = { minDelay: 5, maxDelay: 120 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilNodeDeregistered = async (params, input) => {
+    const serviceDefaults = { minDelay: 5, maxDelay: 120 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};

package/dist-es/waiters/waitForNodeRegistered.js

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