input: 
  from typing import Optional, List
  
  
  class sru:
      """
      Python API for KB SRU
  
      To use this API, create an instance of the "sru" class and call its "search" method.
      The method accepts a query string and optionally a collection name, start record number,
      maximum number of records to return, and record schema. The method returns a "response"
      object containing the results of the search. You can then use the various properties of 
      the "response" object to extract specific information from the search results, such as 
      titles, creators, and subjects.
  
      Example:
      >>> sru_instance = sru()
      >>> response = sru_instance.search("query_string", "collection_name", 1, 10, "schema_name")
      >>> titles = response.titles
      >>> print(titles)
      """
      def search(self, query: str, collection: Optional[str] = None, startrecord: int = 1, 
                 maximumrecords: int = 1, recordschema: Optional[str] = None) -> 'response':
          """
          Perform a search using the KB SRU API and return a response object.
  
          Args:
              query (str): The search query string.
              collection (str, optional): The name of the collection to search within. Defaults to None.
              startrecord (int, optional): The starting record number for the search. Defaults to 1.
              maximumrecords (int, optional): The maximum number of records to return. Defaults to 1.
              recordschema (str, optional): The schema to use for the records. Defaults to None.
  
          Returns:
              response: An instance of the response class containing the search results.
  
          Raises:
              Exception: If the specified collection is unknown or if no collection is specified.
          """
          pass  # Implementation details omitted for brevity
  
  class response:
      """
      Response object containing the results of a search performed using the sru class.
      
      Example:
      >>> sru_instance = sru()
      >>> response = sru_instance.search("query_string", "collection_name", 1, 10, "schema_name")
      >>> titles = response.titles
      >>> print(titles)
      """
      def __init__(self, record_data, sru_instance):
          self.record_data = record_data
          self.sru = sru_instance
  
      @property
      def titles(self) -> List[str]:
          """
          Return a list of titles from the search results.
  
          Example:
          >>> sru_instance = sru()
          >>> response = sru_instance.search("query_string", "collection_name", 1, 10, "schema_name")
          >>> titles = response.titles
          >>> print(titles)
          ['Title 1', 'Title 2']
          """
          pass  # Implementation details omitted for brevity
  
      @property
      def creators(self) -> List[str]:
          """
          Return a list of creators from the search results.
  
          Example:
          >>> sru_instance = sru()
          >>> response = sru_instance.search("query_string", "collection_name", 1, 10, "schema_name")
          >>> creators = response.creators
          >>> print(creators)
          ['Creator 1', 'Creator 2']
          """
          pass  # Implementation details omitted for brevity
  
      @property
      def subjects(self) -> List[str]:
          """
          Return a list of subjects from the search results.
  
          Example:
          >>> sru_instance = sru()
          >>> response = sru_instance.search("query_string", "collection_name", 1, 10, "schema_name")
          >>> subjects = response.subjects
          >>> print(subjects)
          ['Subject 1', 'Subject 2']
          """
          pass  # Implementation details omitted for brevity
  
output:     
          if collection is None:
              raise Exception("No collection specified")
          if collection not in self.known_collections:
              raise Exception("Unknown collection")
          
          # Simulate a search operation
          search_results = self._perform_search(query, collection, startrecord, maximumrecords, recordschema)
          
          return response(search_results, self)
  
      def _perform_search(self, query, collection, startrecord, maximumrecords, recordschema):
          # Simulate fetching data from an external API
          return {
              "titles": ["Title 1", "Title 2"],
              "creators": ["Creator 1", "Creator 2"],
              "subjects": ["Subject 1", "Subject 2"]
          }
  
      @property
      def titles(self) -> List[str]:
          return self.record_data.get("titles", [])
  
      @property
      def creators(self) -> List[str]:
          return self.record_data.get("creators", [])
  
      @property
      def subjects(self) -> List[str]:
          return self.record_data.get("subjects", [])
  