How to use the botocore.waiter.Waiter function in botocore

def test_can_create_waiter_from_client(self):
        waiter_name = 'WaiterName'
        waiter = create_waiter_with_client(
            waiter_name, self.waiter_model, self.client)
        self.assertIsInstance(waiter, Waiter)

from typing import Dict
from botocore.waiter import Waiter


class DistributionDeployed(Waiter):
    def wait(self, Id: str, WaiterConfig: Dict = None):
        pass


class InvalidationCompleted(Waiter):
    def wait(self, DistributionId: str, Id: str, WaiterConfig: Dict = None):
        pass


class StreamingDistributionDeployed(Waiter):
    def wait(self, Id: str, WaiterConfig: Dict = None):
        pass

from typing import Dict
from botocore.waiter import Waiter


class StreamExists(Waiter):
    def wait(self, StreamName: str, Limit: int = None, ExclusiveStartShardId: str = None, WaiterConfig: Dict = None):
        pass


class StreamNotExists(Waiter):
    def wait(self, StreamName: str, Limit: int = None, ExclusiveStartShardId: str = None, WaiterConfig: Dict = None):
        pass

class CacheClusterAvailable(Waiter):
    def wait(self, CacheClusterId: str = None, MaxRecords: int = None, Marker: str = None, ShowCacheNodeInfo: bool = None, ShowCacheClustersNotInReplicationGroups: bool = None, WaiterConfig: Dict = None):
        pass


class CacheClusterDeleted(Waiter):
    def wait(self, CacheClusterId: str = None, MaxRecords: int = None, Marker: str = None, ShowCacheNodeInfo: bool = None, ShowCacheClustersNotInReplicationGroups: bool = None, WaiterConfig: Dict = None):
        pass


class ReplicationGroupAvailable(Waiter):
    def wait(self, ReplicationGroupId: str = None, MaxRecords: int = None, Marker: str = None, WaiterConfig: Dict = None):
        pass


class ReplicationGroupDeleted(Waiter):
    def wait(self, ReplicationGroupId: str = None, MaxRecords: int = None, Marker: str = None, WaiterConfig: Dict = None):
        pass

class BucketExists(Waiter):
    def wait(self, Bucket: str, WaiterConfig: Dict = None):
        pass


class BucketNotExists(Waiter):
    def wait(self, Bucket: str, WaiterConfig: Dict = None):
        pass


class ObjectExists(Waiter):
    def wait(self, Bucket: str, Key: str, IfMatch: str = None, IfModifiedSince: datetime = None, IfNoneMatch: str = None, IfUnmodifiedSince: datetime = None, Range: str = None, VersionId: str = None, SSECustomerAlgorithm: str = None, SSECustomerKey: str = None, SSECustomerKeyMD5: str = None, RequestPayer: str = None, PartNumber: int = None, WaiterConfig: Dict = None):
        pass


class ObjectNotExists(Waiter):
    def wait(self, Bucket: str, Key: str, IfMatch: str = None, IfModifiedSince: datetime = None, IfNoneMatch: str = None, IfUnmodifiedSince: datetime = None, Range: str = None, VersionId: str = None, SSECustomerAlgorithm: str = None, SSECustomerKey: str = None, SSECustomerKeyMD5: str = None, RequestPayer: str = None, PartNumber: int = None, WaiterConfig: Dict = None):
        pass

class ExportTaskCancelled(Waiter):
    def wait(self, ExportTaskIds: List = None, WaiterConfig: Dict = None):
        pass


class ExportTaskCompleted(Waiter):
    def wait(self, ExportTaskIds: List = None, WaiterConfig: Dict = None):
        pass


class ImageAvailable(Waiter):
    def wait(self, ExecutableUsers: List = None, Filters: List = None, ImageIds: List = None, Owners: List = None, DryRun: bool = None, WaiterConfig: Dict = None):
        pass


class ImageExists(Waiter):
    def wait(self, ExecutableUsers: List = None, Filters: List = None, ImageIds: List = None, Owners: List = None, DryRun: bool = None, WaiterConfig: Dict = None):
        pass


class InstanceExists(Waiter):
    def wait(self, Filters: List = None, InstanceIds: List = None, DryRun: bool = None, MaxResults: int = None, NextToken: str = None, WaiterConfig: Dict = None):
        pass


class InstanceRunning(Waiter):
    def wait(self, Filters: List = None, InstanceIds: List = None, DryRun: bool = None, MaxResults: int = None, NextToken: str = None, WaiterConfig: Dict = None):
        pass


class InstanceStatusOk(Waiter):
    def wait(self, Filters: List = None, InstanceIds: List = None, MaxResults: int = None, NextToken: str = None, DryRun: bool = None, IncludeAllInstances: bool = None, WaiterConfig: Dict = None):

:type TableName: string
        :param TableName: **[REQUIRED]**
          The name of the table to describe.
        :type WaiterConfig: dict
        :param WaiterConfig:
          A dictionary that provides parameters to control waiting behavior.
          - **Delay** *(integer) --*
            The amount of time in seconds to wait between attempts. Default: 20
          - **MaxAttempts** *(integer) --*
            The maximum number of attempts to be made. Default: 25
        :returns: None
        """
        pass


class TableNotExists(Waiter):
    def wait(self, TableName: str, WaiterConfig: Dict = None):
        """
        Polls :py:meth:`DynamoDB.Client.describe_table` every 20 seconds until a successful state is reached. An error is returned after 25 failed checks.
        See also: `AWS API Documentation `_
        
        **Request Syntax**
        ::
          waiter.wait(
              TableName='string',
              WaiterConfig={
                  'Delay': 123,
                  'MaxAttempts': 123
              }
          )
        :type TableName: string
        :param TableName: **[REQUIRED]**

from typing import Dict
from botocore.waiter import Waiter


class BatchPredictionAvailable(Waiter):
    def wait(self, FilterVariable: str = None, EQ: str = None, GT: str = None, LT: str = None, GE: str = None, LE: str = None, NE: str = None, Prefix: str = None, SortOrder: str = None, NextToken: str = None, Limit: int = None, WaiterConfig: Dict = None):
        pass


class DataSourceAvailable(Waiter):
    def wait(self, FilterVariable: str = None, EQ: str = None, GT: str = None, LT: str = None, GE: str = None, LE: str = None, NE: str = None, Prefix: str = None, SortOrder: str = None, NextToken: str = None, Limit: int = None, WaiterConfig: Dict = None):
        pass


class EvaluationAvailable(Waiter):
    def wait(self, FilterVariable: str = None, EQ: str = None, GT: str = None, LT: str = None, GE: str = None, LE: str = None, NE: str = None, Prefix: str = None, SortOrder: str = None, NextToken: str = None, Limit: int = None, WaiterConfig: Dict = None):
        pass


class MLModelAvailable(Waiter):
    def wait(self, FilterVariable: str = None, EQ: str = None, GT: str = None, LT: str = None, GE: str = None, LE: str = None, NE: str = None, Prefix: str = None, SortOrder: str = None, NextToken: str = None, Limit: int = None, WaiterConfig: Dict = None):
        pass

from typing import Dict
from typing import List
from botocore.waiter import Waiter


class AlarmExists(Waiter):
    def wait(self, AlarmNames: List = None, AlarmNamePrefix: str = None, StateValue: str = None, ActionPrefix: str = None, MaxRecords: int = None, NextToken: str = None, WaiterConfig: Dict = None):
        """
        Polls :py:meth:`CloudWatch.Client.describe_alarms` every 5 seconds until a successful state is reached. An error is returned after 40 failed checks.
        See also: `AWS API Documentation `_
        
        **Request Syntax**
        ::
          waiter.wait(
              AlarmNames=[
                  'string',
              ],
              AlarmNamePrefix='string',
              StateValue='OK'|'ALARM'|'INSUFFICIENT_DATA',
              ActionPrefix='string',
              MaxRecords=123,
              NextToken='string',

    ('EC2', 'subnet_has_assign_ipv6'): lambda ec2: core_waiter.Waiter(
        'subnet_has_assign_ipv6',
        ec2_model('SubnetHasAssignIpv6'),
        core_waiter.NormalizedOperationMethod(
            ec2.describe_subnets
        )),