How to use the botocore.paginate.Paginator function in botocore

class DescribeAlarms(Paginator):
    def paginate(self, AlarmNames: List = None, AlarmNamePrefix: str = None, StateValue: str = None, ActionPrefix: str = None, PaginationConfig: Dict = None) -> Dict:
        pass


class GetMetricData(Paginator):
    def paginate(self, MetricDataQueries: List, StartTime: datetime, EndTime: datetime, ScanBy: str = None, PaginationConfig: Dict = None) -> Dict:
        pass


class ListDashboards(Paginator):
    def paginate(self, DashboardNamePrefix: str = None, PaginationConfig: Dict = None) -> Dict:
        pass


class ListMetrics(Paginator):
    def paginate(self, Namespace: str = None, MetricName: str = None, Dimensions: List = None, PaginationConfig: Dict = None) -> Dict:
        pass

:type PaginationConfig: dict
        :param PaginationConfig:
          A dictionary that provides parameters to control pagination.
          - **MaxItems** *(integer) --*
            The total number of items to return. If the total number of items available is more than the value specified in max-items then a ``NextToken`` will be provided in the output that you can use to resume pagination.
          - **PageSize** *(integer) --*
            The size of each page.
          - **StartingToken** *(string) --*
            A token to specify where to start paginating. This is the ``NextToken`` from a previous response.
        :rtype: dict
        :returns:
        """
        pass


class DescribeReplicationSubnetGroups(Paginator):
    def paginate(self, Filters: List = None, PaginationConfig: Dict = None) -> Dict:
        """
        Creates an iterator that will paginate through responses from :py:meth:`DatabaseMigrationService.Client.describe_replication_subnet_groups`.
        See also: `AWS API Documentation `_
        
        **Request Syntax**
        ::
          response_iterator = paginator.paginate(
              Filters=[
                  {
                      'Name': 'string',
                      'Values': [
                          'string',
                      ]
                  },
              ],

class GetInstances(Paginator):
    def paginate(self, PaginationConfig: Dict = None) -> Dict:
        pass


class GetKeyPairs(Paginator):
    def paginate(self, PaginationConfig: Dict = None) -> Dict:
        pass


class GetLoadBalancers(Paginator):
    def paginate(self, PaginationConfig: Dict = None) -> Dict:
        pass


class GetOperations(Paginator):
    def paginate(self, PaginationConfig: Dict = None) -> Dict:
        pass


class GetRelationalDatabaseBlueprints(Paginator):
    def paginate(self, PaginationConfig: Dict = None) -> Dict:
        pass


class GetRelationalDatabaseBundles(Paginator):
    def paginate(self, PaginationConfig: Dict = None) -> Dict:
        pass


class GetRelationalDatabaseEvents(Paginator):
    def paginate(self, relationalDatabaseName: str, durationInMinutes: int = None, PaginationConfig: Dict = None) -> Dict:

def get_protections_paginator(client):
    return Paginator(
        client.list_protections,
        {'input_token': 'NextToken', 'output_token': 'NextToken', 'result_key': 'Protections'},
        client.meta.service_model.operation_model('ListProtections'))

:type PaginationConfig: dict
        :param PaginationConfig:
          A dictionary that provides parameters to control pagination.
          - **MaxItems** *(integer) --*
            The total number of items to return. If the total number of items available is more than the value specified in max-items then a ``NextToken`` will be provided in the output that you can use to resume pagination.
          - **PageSize** *(integer) --*
            The size of each page.
          - **StartingToken** *(string) --*
            A token to specify where to start paginating. This is the ``NextToken`` from a previous response.
        :rtype: dict
        :returns:
        """
        pass


class SearchProfiles(Paginator):
    def paginate(self, Filters: List = None, SortCriteria: List = None, PaginationConfig: Dict = None) -> Dict:
        """
        Creates an iterator that will paginate through responses from :py:meth:`AlexaForBusiness.Client.search_profiles`.
        See also: `AWS API Documentation `_
        
        **Request Syntax**
        ::
          response_iterator = paginator.paginate(
              Filters=[
                  {
                      'Key': 'string',
                      'Values': [
                          'string',
                      ]
                  },
              ],

from typing import Dict
from datetime import datetime
from typing import List
from botocore.paginate import Paginator


class DescribeAggregateComplianceByConfigRules(Paginator):
    def paginate(self, ConfigurationAggregatorName: str, Filters: Dict = None, PaginationConfig: Dict = None) -> Dict:
        pass


class DescribeAggregationAuthorizations(Paginator):
    def paginate(self, PaginationConfig: Dict = None) -> Dict:
        pass


class DescribeComplianceByConfigRule(Paginator):
    def paginate(self, ConfigRuleNames: List = None, ComplianceTypes: List = None, PaginationConfig: Dict = None) -> Dict:
        pass


class DescribeComplianceByResource(Paginator):
    def paginate(self, ResourceType: str = None, ResourceId: str = None, ComplianceTypes: List = None, Limit: int = None, PaginationConfig: Dict = None) -> Dict:
        pass


class DescribeConfigRuleEvaluationStatus(Paginator):
    def paginate(self, ConfigRuleNames: List = None, PaginationConfig: Dict = None) -> Dict:

class ListOrganizations(Paginator):
    def paginate(self, PaginationConfig: Dict = None) -> Dict:
        pass


class ListResourceDelegates(Paginator):
    def paginate(self, OrganizationId: str, ResourceId: str, PaginationConfig: Dict = None) -> Dict:
        pass


class ListResources(Paginator):
    def paginate(self, OrganizationId: str, PaginationConfig: Dict = None) -> Dict:
        pass


class ListUsers(Paginator):
    def paginate(self, OrganizationId: str, PaginationConfig: Dict = None) -> Dict:
        pass

:type PaginationConfig: dict
        :param PaginationConfig:
          A dictionary that provides parameters to control pagination.
          - **MaxItems** *(integer) --*
            The total number of items to return. If the total number of items available is more than the value specified in max-items then a ``NextToken`` will be provided in the output that you can use to resume pagination.
          - **PageSize** *(integer) --*
            The size of each page.
          - **StartingToken** *(string) --*
            A token to specify where to start paginating. This is the ``NextToken`` from a previous response.
        :rtype: dict
        :returns:
        """
        pass


class DescribeDirectConnectGatewayAttachments(Paginator):
    def paginate(self, directConnectGatewayId: str = None, virtualInterfaceId: str = None, PaginationConfig: Dict = None) -> Dict:
        """
        Creates an iterator that will paginate through responses from :py:meth:`DirectConnect.Client.describe_direct_connect_gateway_attachments`.
        See also: `AWS API Documentation `_
        
        **Request Syntax**
        ::
          response_iterator = paginator.paginate(
              directConnectGatewayId='string',
              virtualInterfaceId='string',
              PaginationConfig={
                  'MaxItems': 123,
                  'PageSize': 123,
                  'StartingToken': 'string'
              }
          )

:type PaginationConfig: dict
        :param PaginationConfig:
          A dictionary that provides parameters to control pagination.
          - **MaxItems** *(integer) --*
            The total number of items to return. If the total number of items available is more than the value specified in max-items then a ``NextToken`` will be provided in the output that you can use to resume pagination.
          - **PageSize** *(integer) --*
            The size of each page.
          - **StartingToken** *(string) --*
            A token to specify where to start paginating. This is the ``NextToken`` from a previous response.
        :rtype: dict
        :returns:
        """
        pass


class ListConfigurations(Paginator):
    def paginate(self, configurationType: str, filters: List = None, orderBy: List = None, PaginationConfig: Dict = None) -> Dict:
        """
        Creates an iterator that will paginate through responses from :py:meth:`ApplicationDiscoveryService.Client.list_configurations`.
        See also: `AWS API Documentation `_
        
        **Request Syntax**
        ::
          response_iterator = paginator.paginate(
              configurationType='SERVER'|'PROCESS'|'CONNECTION'|'APPLICATION',
              filters=[
                  {
                      'name': 'string',
                      'values': [
                          'string',
                      ],
                      'condition': 'string'

from typing import Dict
from typing import List
from datetime import datetime
from botocore.paginate import Paginator


class GetMetricData(Paginator):
    def paginate(self, InstanceId: str, StartTime: datetime, EndTime: datetime, Filters: Dict, HistoricalMetrics: List, Groupings: List = None, PaginationConfig: Dict = None) -> Dict:
        pass


class ListRoutingProfiles(Paginator):
    def paginate(self, InstanceId: str, PaginationConfig: Dict = None) -> Dict:
        pass


class ListSecurityProfiles(Paginator):
    def paginate(self, InstanceId: str, PaginationConfig: Dict = None) -> Dict:
        pass


class ListUserHierarchyGroups(Paginator):
    def paginate(self, InstanceId: str, PaginationConfig: Dict = None) -> Dict:
        pass


class ListUsers(Paginator):
    def paginate(self, InstanceId: str, PaginationConfig: Dict = None) -> Dict: