How to use the boto3.resources.collection.ResourceCollection function in boto3

    @classmethod
    def limit(cls, count: int = None) -> List['SamlProvider']:
        pass

    
    @classmethod
    def page_size(cls, count: int = None) -> List['SamlProvider']:
        pass

    
    @classmethod
    def pages(cls) -> List[base.ServiceResource]:
        pass


class server_certificates(ResourceCollection):
    
    @classmethod
    def all(cls) -> List['ServerCertificate']:
        pass

    
    @classmethod
    def filter(cls, PathPrefix: str = None, Marker: str = None, MaxItems: int = None) -> List['ServerCertificate']:
        pass

    
    @classmethod
    def iterator(cls) -> ResourceCollection:
        pass

    @classmethod
    def limit(cls, count: int = None) -> List['InternetGateway']:
        pass

    
    @classmethod
    def page_size(cls, count: int = None) -> List['InternetGateway']:
        pass

    
    @classmethod
    def pages(cls) -> List[base.ServiceResource]:
        pass


class key_pairs(ResourceCollection):
    
    @classmethod
    def all(cls) -> List['KeyPairInfo']:
        pass

    
    @classmethod
    def filter(cls, Filters: List = None, KeyNames: List = None, DryRun: bool = None) -> List['KeyPairInfo']:
        pass

    
    @classmethod
    def iterator(cls) -> ResourceCollection:
        pass

    @classmethod
    def limit(cls, count: int = None) -> List['Subnet']:
        pass

    
    @classmethod
    def page_size(cls, count: int = None) -> List['Subnet']:
        pass

    
    @classmethod
    def pages(cls) -> List[base.ServiceResource]:
        pass


class volumes(ResourceCollection):
    
    @classmethod
    def all(cls) -> List['Volume']:
        pass

    
    @classmethod
    def filter(cls, Filters: List = None, VolumeIds: List = None, DryRun: bool = None, MaxResults: int = None, NextToken: str = None) -> List['Volume']:
        pass

    
    @classmethod
    def iterator(cls) -> ResourceCollection:
        pass

    @classmethod
    def limit(cls, count: int = None) -> List['DhcpOptions']:
        pass

    
    @classmethod
    def page_size(cls, count: int = None) -> List['DhcpOptions']:
        pass

    
    @classmethod
    def pages(cls) -> List[base.ServiceResource]:
        pass


class images(ResourceCollection):
    
    @classmethod
    def all(cls) -> List['Image']:
        pass

    
    @classmethod
    def filter(cls, ExecutableUsers: List = None, Filters: List = None, ImageIds: List = None, Owners: List = None, DryRun: bool = None) -> List['Image']:
        pass

    
    @classmethod
    def iterator(cls) -> ResourceCollection:
        pass

    @classmethod
    def limit(cls, count: int = None) -> List['ServerCertificate']:
        pass

    
    @classmethod
    def page_size(cls, count: int = None) -> List['ServerCertificate']:
        pass

    
    @classmethod
    def pages(cls) -> List[base.ServiceResource]:
        pass


class users(ResourceCollection):
    
    @classmethod
    def all(cls) -> List['User']:
        pass

    
    @classmethod
    def filter(cls, PathPrefix: str = None, Marker: str = None, MaxItems: int = None) -> List['User']:
        pass

    
    @classmethod
    def iterator(cls) -> ResourceCollection:
        pass

pass

    def reload(self):
        pass

    def remove_permission(self, Label: str):
        pass

    def set_attributes(self, AttributeName: str, AttributeValue: str = None):
        pass

    def subscribe(self, Protocol: str, Endpoint: str = None, Attributes: Dict = None, ReturnSubscriptionArn: bool = None) -> 'Subscription':
        pass


class platform_applications(ResourceCollection):
    
    @classmethod
    def all(cls) -> List['PlatformApplication']:
        pass

    
    @classmethod
    def filter(cls, NextToken: str = None) -> List['PlatformApplication']:
        pass

    
    @classmethod
    def iterator(cls) -> ResourceCollection:
        pass

pass

    def get_available_subresources(self) -> List[str]:
        pass

    def load(self):
        pass

    def release(self, PublicIp: str = None, DryRun: bool = None):
        pass

    def reload(self):
        pass


class classic_addresses(ResourceCollection):
    
    @classmethod
    def all(cls) -> List['ClassicAddress']:
        pass

    
    @classmethod
    def filter(cls, PublicIps: List = None, AllocationIds: List = None, DryRun: bool = None) -> List['ClassicAddress']:
        pass

    
    @classmethod
    def iterator(cls) -> ResourceCollection:
        pass

# Add the documentation to the collection class's methods
        self._load_documented_collection_methods(
            attrs=attrs, resource_name=resource_name,
            collection_model=collection_model,
            service_model=service_context.service_model,
            event_emitter=event_emitter,
            base_class=ResourceCollection)

        if service_context.service_name == resource_name:
            cls_name = '{0}.{1}Collection'.format(
                service_context.service_name, collection_name)
        else:
            cls_name = '{0}.{1}.{2}Collection'.format(
                service_context.service_name, resource_name, collection_name)

        collection_cls = type(str(cls_name), (ResourceCollection,),
                              attrs)

        # Add the documentation to the collection manager's methods
        self._load_documented_collection_methods(
            attrs=attrs, resource_name=resource_name,
            collection_model=collection_model,
            service_model=service_context.service_model,
            event_emitter=event_emitter,
            base_class=CollectionManager)
        attrs['_collection_cls'] = collection_cls
        cls_name += 'Manager'

        return type(str(cls_name), (CollectionManager,), attrs)

drift_information: Dict
    stack_name: str
    logical_id: str

    def get_available_subresources(self) -> List[str]:
        """
        Returns a list of all the available sub-resources for this
        Resource.
        :returns: A list containing the name of each sub-resource for this
            resource
        :rtype: list of str
        """
        pass


class stacks(ResourceCollection):
    
    @classmethod
    def all(cls) -> List['Stack']:
        """
        Creates an iterable of all Stack resources in the collection.
        See also: `AWS API Documentation `_
        
        **Request Syntax**
        ::
          stack_iterator = cloudformation.stacks.all()
        :rtype: list(:py:class:`cloudformation.Stack`)
        :returns: A list of Stack resources
        """
        pass

of collections, including when remote service requests are performed.

    :type collection_model: :py:class:`~boto3.resources.model.Collection`
    :param model: Collection model

    :type parent: :py:class:`~boto3.resources.base.ServiceResource`
    :param parent: The collection's parent resource

    :type factory: :py:class:`~boto3.resources.factory.ResourceFactory`
    :param factory: The resource factory to create new resources

    :type service_context: :py:class:`~boto3.utils.ServiceContext`
    :param service_context: Context about the AWS service
    """
    # The class to use when creating an iterator
    _collection_cls = ResourceCollection

    def __init__(self, collection_model, parent, factory, service_context):
        self._model = collection_model
        operation_name = self._model.request.operation
        self._parent = parent

        search_path = collection_model.resource.path
        self._handler = ResourceHandler(
            search_path=search_path, factory=factory,
            resource_model=collection_model.resource,
            service_context=service_context,
            operation_name=operation_name
        )

    def __repr__(self):
        return '{0}({1}, {2})'.format(