kaggle 1.7.4.2__py3-none-any.whl → 1.8.0__py3-none-any.whl

kagglesdk/search/types/search_api_service.py

@@ -0,0 +1,2435 @@
+from datetime import datetime
+import enum
+from kagglesdk.competitions.types.competition import RewardTypeId
+from kagglesdk.competitions.types.competition_enums import HostSegment
+from kagglesdk.competitions.types.search_competitions import SearchCompetitionsOrderBy, SearchCompetitionsProfileVisibility, SearchCompetitionsRole, SearchCompetitionsStatus
+from kagglesdk.datasets.types.dataset_enums import DatasetFileType, DatasetFileTypeGroup, DatasetLicenseGroup, DatasetSizeGroup
+from kagglesdk.datasets.types.search_datasets import SearchDatasetsOrderBy
+from kagglesdk.discussions.types.search_discussions import SearchDiscussionsDocumentType, SearchDiscussionsOrderBy, SearchDiscussionsSourceType, SearchDiscussionsTopicType, WriteUpInclusionType
+from kagglesdk.discussions.types.writeup_enums import WriteUpType
+from kagglesdk.kaggle_object import *
+from kagglesdk.kernels.types.search_kernels import SearchKernelsOrderBy
+from kagglesdk.models.types.search_models import SearchModelsOrderBy
+from kagglesdk.search.types.search_content_shared import ListSearchContentRangeFilter
+from kagglesdk.search.types.search_enums import DocumentType, ListSearchContentOrderBy, OwnerType, PrivacyFilter
+from kagglesdk.search.types.search_service import WriteUpItemInfo
+from kagglesdk.users.types.progression_service import UserAchievementType
+from kagglesdk.users.types.search_users import SearchUsersOrderBy
+from kagglesdk.users.types.users_enums import UserAchievementTier
+from typing import Optional, List
+
+class ApiListType(enum.Enum):
+  """Based on kaggle.search.ListType"""
+  API_LIST_TYPE_UNSPECIFIED = 0
+  API_LIST_TYPE_YOUR_WORK = 1
+
+class ApiOrganizationCard(KaggleObject):
+  r"""
+  Based on kaggle.users.OrganizationCard
+
+  Attributes:
+    name (str)
+    id (int)
+    thumbnail_image_url (str)
+    slug (str)
+  """
+
+  def __init__(self):
+    self._name = ""
+    self._id = 0
+    self._thumbnail_image_url = ""
+    self._slug = ""
+    self._freeze()
+
+  @property
+  def name(self) -> str:
+    return self._name
+
+  @name.setter
+  def name(self, name: str):
+    if name is None:
+      del self.name
+      return
+    if not isinstance(name, str):
+      raise TypeError('name must be of type str')
+    self._name = name
+
+  @property
+  def id(self) -> int:
+    return self._id
+
+  @id.setter
+  def id(self, id: int):
+    if id is None:
+      del self.id
+      return
+    if not isinstance(id, int):
+      raise TypeError('id must be of type int')
+    self._id = id
+
+  @property
+  def thumbnail_image_url(self) -> str:
+    return self._thumbnail_image_url
+
+  @thumbnail_image_url.setter
+  def thumbnail_image_url(self, thumbnail_image_url: str):
+    if thumbnail_image_url is None:
+      del self.thumbnail_image_url
+      return
+    if not isinstance(thumbnail_image_url, str):
+      raise TypeError('thumbnail_image_url must be of type str')
+    self._thumbnail_image_url = thumbnail_image_url
+
+  @property
+  def slug(self) -> str:
+    return self._slug
+
+  @slug.setter
+  def slug(self, slug: str):
+    if slug is None:
+      del self.slug
+      return
+    if not isinstance(slug, str):
+      raise TypeError('slug must be of type str')
+    self._slug = slug
+
+
+class ApiSearchCompetitionsDocument(KaggleObject):
+  r"""
+  Based on kaggle.competitions.SearchCompetitionsDocument
+
+  Attributes:
+    host_segment (HostSegment)
+      The host segment of the Competition
+    deadline (datetime)
+      The deadline of the Competition
+    team_count (int)
+      The total number of teams participating in the Competition
+    team_rank (int)
+      The rank of the current user's team on the Competition
+    is_environment_evaluation (bool)
+      Whether the Competition has an environment evaluation
+    prize_type (RewardTypeId)
+      The prize/award type of the Competition
+    prize_value (float)
+      The prize/award value of the Competition
+    is_launched (bool)
+      Whether the competition has launched (even if it's ended)
+    owner_user_has_joined (bool)
+      Whether the owner user (profile user, then current user) has joined the
+      competition
+    is_limited_participation (bool)
+      Whether the competition is a limited participation competition
+    only_allow_kernel_submissions (bool)
+      Whether only kernel submissions are allowed
+  """
+
+  def __init__(self):
+    self._host_segment = HostSegment.HOST_SEGMENT_UNSPECIFIED
+    self._deadline = None
+    self._team_count = 0
+    self._team_rank = None
+    self._is_environment_evaluation = False
+    self._prize_type = RewardTypeId.REWARD_TYPE_ID_UNSPECIFIED
+    self._prize_value = None
+    self._is_launched = False
+    self._owner_user_has_joined = False
+    self._is_limited_participation = False
+    self._only_allow_kernel_submissions = False
+    self._freeze()
+
+  @property
+  def host_segment(self) -> 'HostSegment':
+    """The host segment of the Competition"""
+    return self._host_segment
+
+  @host_segment.setter
+  def host_segment(self, host_segment: 'HostSegment'):
+    if host_segment is None:
+      del self.host_segment
+      return
+    if not isinstance(host_segment, HostSegment):
+      raise TypeError('host_segment must be of type HostSegment')
+    self._host_segment = host_segment
+
+  @property
+  def deadline(self) -> datetime:
+    """The deadline of the Competition"""
+    return self._deadline
+
+  @deadline.setter
+  def deadline(self, deadline: datetime):
+    if deadline is None:
+      del self.deadline
+      return
+    if not isinstance(deadline, datetime):
+      raise TypeError('deadline must be of type datetime')
+    self._deadline = deadline
+
+  @property
+  def team_count(self) -> int:
+    """The total number of teams participating in the Competition"""
+    return self._team_count
+
+  @team_count.setter
+  def team_count(self, team_count: int):
+    if team_count is None:
+      del self.team_count
+      return
+    if not isinstance(team_count, int):
+      raise TypeError('team_count must be of type int')
+    self._team_count = team_count
+
+  @property
+  def team_rank(self) -> int:
+    """The rank of the current user's team on the Competition"""
+    return self._team_rank or 0
+
+  @team_rank.setter
+  def team_rank(self, team_rank: Optional[int]):
+    if team_rank is None:
+      del self.team_rank
+      return
+    if not isinstance(team_rank, int):
+      raise TypeError('team_rank must be of type int')
+    self._team_rank = team_rank
+
+  @property
+  def is_environment_evaluation(self) -> bool:
+    """Whether the Competition has an environment evaluation"""
+    return self._is_environment_evaluation
+
+  @is_environment_evaluation.setter
+  def is_environment_evaluation(self, is_environment_evaluation: bool):
+    if is_environment_evaluation is None:
+      del self.is_environment_evaluation
+      return
+    if not isinstance(is_environment_evaluation, bool):
+      raise TypeError('is_environment_evaluation must be of type bool')
+    self._is_environment_evaluation = is_environment_evaluation
+
+  @property
+  def prize_type(self) -> 'RewardTypeId':
+    """The prize/award type of the Competition"""
+    return self._prize_type
+
+  @prize_type.setter
+  def prize_type(self, prize_type: 'RewardTypeId'):
+    if prize_type is None:
+      del self.prize_type
+      return
+    if not isinstance(prize_type, RewardTypeId):
+      raise TypeError('prize_type must be of type RewardTypeId')
+    self._prize_type = prize_type
+
+  @property
+  def prize_value(self) -> float:
+    """The prize/award value of the Competition"""
+    return self._prize_value or 0.0
+
+  @prize_value.setter
+  def prize_value(self, prize_value: Optional[float]):
+    if prize_value is None:
+      del self.prize_value
+      return
+    if not isinstance(prize_value, float):
+      raise TypeError('prize_value must be of type float')
+    self._prize_value = prize_value
+
+  @property
+  def is_launched(self) -> bool:
+    """Whether the competition has launched (even if it's ended)"""
+    return self._is_launched
+
+  @is_launched.setter
+  def is_launched(self, is_launched: bool):
+    if is_launched is None:
+      del self.is_launched
+      return
+    if not isinstance(is_launched, bool):
+      raise TypeError('is_launched must be of type bool')
+    self._is_launched = is_launched
+
+  @property
+  def owner_user_has_joined(self) -> bool:
+    r"""
+    Whether the owner user (profile user, then current user) has joined the
+    competition
+    """
+    return self._owner_user_has_joined
+
+  @owner_user_has_joined.setter
+  def owner_user_has_joined(self, owner_user_has_joined: bool):
+    if owner_user_has_joined is None:
+      del self.owner_user_has_joined
+      return
+    if not isinstance(owner_user_has_joined, bool):
+      raise TypeError('owner_user_has_joined must be of type bool')
+    self._owner_user_has_joined = owner_user_has_joined
+
+  @property
+  def is_limited_participation(self) -> bool:
+    """Whether the competition is a limited participation competition"""
+    return self._is_limited_participation
+
+  @is_limited_participation.setter
+  def is_limited_participation(self, is_limited_participation: bool):
+    if is_limited_participation is None:
+      del self.is_limited_participation
+      return
+    if not isinstance(is_limited_participation, bool):
+      raise TypeError('is_limited_participation must be of type bool')
+    self._is_limited_participation = is_limited_participation
+
+  @property
+  def only_allow_kernel_submissions(self) -> bool:
+    """Whether only kernel submissions are allowed"""
+    return self._only_allow_kernel_submissions
+
+  @only_allow_kernel_submissions.setter
+  def only_allow_kernel_submissions(self, only_allow_kernel_submissions: bool):
+    if only_allow_kernel_submissions is None:
+      del self.only_allow_kernel_submissions
+      return
+    if not isinstance(only_allow_kernel_submissions, bool):
+      raise TypeError('only_allow_kernel_submissions must be of type bool')
+    self._only_allow_kernel_submissions = only_allow_kernel_submissions
+
+
+class ApiSearchCompetitionsFilters(KaggleObject):
+  r"""
+  Based on kaggle.competitions.SearchCompetitionsFilters
+
+  Attributes:
+    role (SearchCompetitionsRole)
+      The Competition role used to filter the documents
+    status (SearchCompetitionsStatus)
+      The Competition status used to filter the documents
+    profile_visibility (SearchCompetitionsProfileVisibility)
+      Competition visibility status on user profile
+    earned_medal (bool)
+      Whether to return documents that the owner_user_id earned a medal for.
+  """
+
+  def __init__(self):
+    self._role = SearchCompetitionsRole.SEARCH_COMPETITIONS_ROLE_ANY
+    self._status = SearchCompetitionsStatus.SEARCH_COMPETITIONS_STATUS_ANY
+    self._profile_visibility = SearchCompetitionsProfileVisibility.SEARCH_COMPETITIONS_PROFILE_VISIBILITY_ANY
+    self._earned_medal = None
+    self._freeze()
+
+  @property
+  def role(self) -> 'SearchCompetitionsRole':
+    """The Competition role used to filter the documents"""
+    return self._role
+
+  @role.setter
+  def role(self, role: 'SearchCompetitionsRole'):
+    if role is None:
+      del self.role
+      return
+    if not isinstance(role, SearchCompetitionsRole):
+      raise TypeError('role must be of type SearchCompetitionsRole')
+    self._role = role
+
+  @property
+  def status(self) -> 'SearchCompetitionsStatus':
+    """The Competition status used to filter the documents"""
+    return self._status
+
+  @status.setter
+  def status(self, status: 'SearchCompetitionsStatus'):
+    if status is None:
+      del self.status
+      return
+    if not isinstance(status, SearchCompetitionsStatus):
+      raise TypeError('status must be of type SearchCompetitionsStatus')
+    self._status = status
+
+  @property
+  def profile_visibility(self) -> 'SearchCompetitionsProfileVisibility':
+    """Competition visibility status on user profile"""
+    return self._profile_visibility
+
+  @profile_visibility.setter
+  def profile_visibility(self, profile_visibility: 'SearchCompetitionsProfileVisibility'):
+    if profile_visibility is None:
+      del self.profile_visibility
+      return
+    if not isinstance(profile_visibility, SearchCompetitionsProfileVisibility):
+      raise TypeError('profile_visibility must be of type SearchCompetitionsProfileVisibility')
+    self._profile_visibility = profile_visibility
+
+  @property
+  def earned_medal(self) -> bool:
+    """Whether to return documents that the owner_user_id earned a medal for."""
+    return self._earned_medal or False
+
+  @earned_medal.setter
+  def earned_medal(self, earned_medal: Optional[bool]):
+    if earned_medal is None:
+      del self.earned_medal
+      return
+    if not isinstance(earned_medal, bool):
+      raise TypeError('earned_medal must be of type bool')
+    self._earned_medal = earned_medal
+
+
+class ApiSearchDatasetsDocument(KaggleObject):
+  r"""
+  Based on kaggle.datasets.SearchDatasetsDocument
+
+  Attributes:
+    usability_rating (float)
+      The usability rating of the Dataset
+    file_count (int)
+      How many files the Dataset has
+    file_types (DatasetFileType)
+      The file types of all the files in the Dataset
+    size (int)
+      The size of the Dataset
+  """
+
+  def __init__(self):
+    self._usability_rating = 0.0
+    self._file_count = 0
+    self._file_types = []
+    self._size = 0
+    self._freeze()
+
+  @property
+  def usability_rating(self) -> float:
+    """The usability rating of the Dataset"""
+    return self._usability_rating
+
+  @usability_rating.setter
+  def usability_rating(self, usability_rating: float):
+    if usability_rating is None:
+      del self.usability_rating
+      return
+    if not isinstance(usability_rating, float):
+      raise TypeError('usability_rating must be of type float')
+    self._usability_rating = usability_rating
+
+  @property
+  def file_count(self) -> int:
+    """How many files the Dataset has"""
+    return self._file_count
+
+  @file_count.setter
+  def file_count(self, file_count: int):
+    if file_count is None:
+      del self.file_count
+      return
+    if not isinstance(file_count, int):
+      raise TypeError('file_count must be of type int')
+    self._file_count = file_count
+
+  @property
+  def file_types(self) -> Optional[List['DatasetFileType']]:
+    """The file types of all the files in the Dataset"""
+    return self._file_types
+
+  @file_types.setter
+  def file_types(self, file_types: Optional[List['DatasetFileType']]):
+    if file_types is None:
+      del self.file_types
+      return
+    if not isinstance(file_types, list):
+      raise TypeError('file_types must be of type list')
+    if not all([isinstance(t, DatasetFileType) for t in file_types]):
+      raise TypeError('file_types must contain only items of type DatasetFileType')
+    self._file_types = file_types
+
+  @property
+  def size(self) -> int:
+    """The size of the Dataset"""
+    return self._size
+
+  @size.setter
+  def size(self, size: int):
+    if size is None:
+      del self.size
+      return
+    if not isinstance(size, int):
+      raise TypeError('size must be of type int')
+    self._size = size
+
+
+class ApiSearchDatasetsFilters(KaggleObject):
+  r"""
+  Based on kaggle.datasets.SearchDiscussionsFilters
+
+  Attributes:
+    file_type (DatasetFileTypeGroup)
+      The file types used to filter the documents
+    license_group (DatasetLicenseGroup)
+      The license groups used to filter the documents
+    size (DatasetSizeGroup)
+      The dataset size range used to filter the documents
+    earned_medal (bool)
+      Whether to return documents that the owner_user_id earned a medal for.
+  """
+
+  def __init__(self):
+    self._file_type = DatasetFileTypeGroup.DATASET_FILE_TYPE_GROUP_ALL
+    self._license_group = None
+    self._size = None
+    self._earned_medal = None
+    self._freeze()
+
+  @property
+  def file_type(self) -> 'DatasetFileTypeGroup':
+    """The file types used to filter the documents"""
+    return self._file_type
+
+  @file_type.setter
+  def file_type(self, file_type: 'DatasetFileTypeGroup'):
+    if file_type is None:
+      del self.file_type
+      return
+    if not isinstance(file_type, DatasetFileTypeGroup):
+      raise TypeError('file_type must be of type DatasetFileTypeGroup')
+    self._file_type = file_type
+
+  @property
+  def license_group(self) -> 'DatasetLicenseGroup':
+    """The license groups used to filter the documents"""
+    return self._license_group or DatasetLicenseGroup.DATASET_LICENSE_GROUP_ALL
+
+  @license_group.setter
+  def license_group(self, license_group: Optional['DatasetLicenseGroup']):
+    if license_group is None:
+      del self.license_group
+      return
+    if not isinstance(license_group, DatasetLicenseGroup):
+      raise TypeError('license_group must be of type DatasetLicenseGroup')
+    self._license_group = license_group
+
+  @property
+  def size(self) -> 'DatasetSizeGroup':
+    """The dataset size range used to filter the documents"""
+    return self._size or DatasetSizeGroup.DATASET_SIZE_GROUP_ALL
+
+  @size.setter
+  def size(self, size: Optional['DatasetSizeGroup']):
+    if size is None:
+      del self.size
+      return
+    if not isinstance(size, DatasetSizeGroup):
+      raise TypeError('size must be of type DatasetSizeGroup')
+    self._size = size
+
+  @property
+  def earned_medal(self) -> bool:
+    """Whether to return documents that the owner_user_id earned a medal for."""
+    return self._earned_medal or False
+
+  @earned_medal.setter
+  def earned_medal(self, earned_medal: Optional[bool]):
+    if earned_medal is None:
+      del self.earned_medal
+      return
+    if not isinstance(earned_medal, bool):
+      raise TypeError('earned_medal must be of type bool')
+    self._earned_medal = earned_medal
+
+
+class ApiSearchDiscussionsDocument(KaggleObject):
+  r"""
+  Based on kaggle.discussions.SearchDiscussionsDocument
+
+  Attributes:
+    new_comment_url (str)
+    message_stripped (str)
+      The message of the topic/comment, stripped of HTML (at time of index)
+    message_markdown (str)
+      The markdown for the message of the topic/comment
+    forum_name (str)
+      The name of the parent forum
+    forum_url (str)
+      The URL for the parent forum
+    source_type (SearchDiscussionsSourceType)
+      The source type of the comment
+    topic_type (SearchDiscussionsTopicType)
+      The type of topic returned
+    type (SearchDiscussionsDocumentType)
+      The type of document returned
+    write_up_metadata (WriteUpItemInfo)
+      If the document is a WriteUp, extra WriteUp-specific data
+      is provided
+  """
+
+  def __init__(self):
+    self._new_comment_url = None
+    self._message_stripped = ""
+    self._message_markdown = None
+    self._forum_name = ""
+    self._forum_url = None
+    self._source_type = SearchDiscussionsSourceType.SEARCH_DISCUSSIONS_SOURCE_TYPE_UNSPECIFIED
+    self._topic_type = SearchDiscussionsTopicType.SEARCH_DISCUSSIONS_TOPIC_TYPE_UNSPECIFIED
+    self._type = SearchDiscussionsDocumentType.SEARCH_DISCUSSIONS_DOCUMENT_TYPE_UNSPECIFIED
+    self._write_up_metadata = None
+    self._freeze()
+
+  @property
+  def new_comment_url(self) -> str:
+    return self._new_comment_url or ""
+
+  @new_comment_url.setter
+  def new_comment_url(self, new_comment_url: Optional[str]):
+    if new_comment_url is None:
+      del self.new_comment_url
+      return
+    if not isinstance(new_comment_url, str):
+      raise TypeError('new_comment_url must be of type str')
+    self._new_comment_url = new_comment_url
+
+  @property
+  def message_stripped(self) -> str:
+    """The message of the topic/comment, stripped of HTML (at time of index)"""
+    return self._message_stripped
+
+  @message_stripped.setter
+  def message_stripped(self, message_stripped: str):
+    if message_stripped is None:
+      del self.message_stripped
+      return
+    if not isinstance(message_stripped, str):
+      raise TypeError('message_stripped must be of type str')
+    self._message_stripped = message_stripped
+
+  @property
+  def message_markdown(self) -> str:
+    """The markdown for the message of the topic/comment"""
+    return self._message_markdown or ""
+
+  @message_markdown.setter
+  def message_markdown(self, message_markdown: Optional[str]):
+    if message_markdown is None:
+      del self.message_markdown
+      return
+    if not isinstance(message_markdown, str):
+      raise TypeError('message_markdown must be of type str')
+    self._message_markdown = message_markdown
+
+  @property
+  def forum_name(self) -> str:
+    """The name of the parent forum"""
+    return self._forum_name
+
+  @forum_name.setter
+  def forum_name(self, forum_name: str):
+    if forum_name is None:
+      del self.forum_name
+      return
+    if not isinstance(forum_name, str):
+      raise TypeError('forum_name must be of type str')
+    self._forum_name = forum_name
+
+  @property
+  def forum_url(self) -> str:
+    """The URL for the parent forum"""
+    return self._forum_url or ""
+
+  @forum_url.setter
+  def forum_url(self, forum_url: Optional[str]):
+    if forum_url is None:
+      del self.forum_url
+      return
+    if not isinstance(forum_url, str):
+      raise TypeError('forum_url must be of type str')
+    self._forum_url = forum_url
+
+  @property
+  def source_type(self) -> 'SearchDiscussionsSourceType':
+    """The source type of the comment"""
+    return self._source_type
+
+  @source_type.setter
+  def source_type(self, source_type: 'SearchDiscussionsSourceType'):
+    if source_type is None:
+      del self.source_type
+      return
+    if not isinstance(source_type, SearchDiscussionsSourceType):
+      raise TypeError('source_type must be of type SearchDiscussionsSourceType')
+    self._source_type = source_type
+
+  @property
+  def topic_type(self) -> 'SearchDiscussionsTopicType':
+    """The type of topic returned"""
+    return self._topic_type
+
+  @topic_type.setter
+  def topic_type(self, topic_type: 'SearchDiscussionsTopicType'):
+    if topic_type is None:
+      del self.topic_type
+      return
+    if not isinstance(topic_type, SearchDiscussionsTopicType):
+      raise TypeError('topic_type must be of type SearchDiscussionsTopicType')
+    self._topic_type = topic_type
+
+  @property
+  def type(self) -> 'SearchDiscussionsDocumentType':
+    """The type of document returned"""
+    return self._type
+
+  @type.setter
+  def type(self, type: 'SearchDiscussionsDocumentType'):
+    if type is None:
+      del self.type
+      return
+    if not isinstance(type, SearchDiscussionsDocumentType):
+      raise TypeError('type must be of type SearchDiscussionsDocumentType')
+    self._type = type
+
+  @property
+  def write_up_metadata(self) -> Optional['WriteUpItemInfo']:
+    r"""
+    If the document is a WriteUp, extra WriteUp-specific data
+    is provided
+    """
+    return self._write_up_metadata or None
+
+  @write_up_metadata.setter
+  def write_up_metadata(self, write_up_metadata: Optional[Optional['WriteUpItemInfo']]):
+    if write_up_metadata is None:
+      del self.write_up_metadata
+      return
+    if not isinstance(write_up_metadata, WriteUpItemInfo):
+      raise TypeError('write_up_metadata must be of type WriteUpItemInfo')
+    self._write_up_metadata = write_up_metadata
+
+
+class ApiSearchDiscussionsFilters(KaggleObject):
+  r"""
+  Based on kaggle.discussions.SearchDiscussionsFilters
+
+  Attributes:
+    source_type (SearchDiscussionsSourceType)
+      The discussion source type used to filter the documents
+    only_new_comments (bool)
+      Show only topics with new comments
+    write_up_inclusion_type (WriteUpInclusionType)
+      Determines whether or not WriteUps should be included
+    write_up_types (WriteUpType)
+      Filters on WriteUp type
+  """
+
+  def __init__(self):
+    self._source_type = SearchDiscussionsSourceType.SEARCH_DISCUSSIONS_SOURCE_TYPE_UNSPECIFIED
+    self._only_new_comments = False
+    self._write_up_inclusion_type = WriteUpInclusionType.WRITE_UP_INCLUSION_TYPE_UNSPECIFIED
+    self._write_up_types = []
+    self._freeze()
+
+  @property
+  def source_type(self) -> 'SearchDiscussionsSourceType':
+    """The discussion source type used to filter the documents"""
+    return self._source_type
+
+  @source_type.setter
+  def source_type(self, source_type: 'SearchDiscussionsSourceType'):
+    if source_type is None:
+      del self.source_type
+      return
+    if not isinstance(source_type, SearchDiscussionsSourceType):
+      raise TypeError('source_type must be of type SearchDiscussionsSourceType')
+    self._source_type = source_type
+
+  @property
+  def only_new_comments(self) -> bool:
+    """Show only topics with new comments"""
+    return self._only_new_comments
+
+  @only_new_comments.setter
+  def only_new_comments(self, only_new_comments: bool):
+    if only_new_comments is None:
+      del self.only_new_comments
+      return
+    if not isinstance(only_new_comments, bool):
+      raise TypeError('only_new_comments must be of type bool')
+    self._only_new_comments = only_new_comments
+
+  @property
+  def write_up_inclusion_type(self) -> 'WriteUpInclusionType':
+    """Determines whether or not WriteUps should be included"""
+    return self._write_up_inclusion_type
+
+  @write_up_inclusion_type.setter
+  def write_up_inclusion_type(self, write_up_inclusion_type: 'WriteUpInclusionType'):
+    if write_up_inclusion_type is None:
+      del self.write_up_inclusion_type
+      return
+    if not isinstance(write_up_inclusion_type, WriteUpInclusionType):
+      raise TypeError('write_up_inclusion_type must be of type WriteUpInclusionType')
+    self._write_up_inclusion_type = write_up_inclusion_type
+
+  @property
+  def write_up_types(self) -> Optional[List['WriteUpType']]:
+    """Filters on WriteUp type"""
+    return self._write_up_types
+
+  @write_up_types.setter
+  def write_up_types(self, write_up_types: Optional[List['WriteUpType']]):
+    if write_up_types is None:
+      del self.write_up_types
+      return
+    if not isinstance(write_up_types, list):
+      raise TypeError('write_up_types must be of type list')
+    if not all([isinstance(t, WriteUpType) for t in write_up_types]):
+      raise TypeError('write_up_types must contain only items of type WriteUpType')
+    self._write_up_types = write_up_types
+
+
+class ApiSearchKernelsDocument(KaggleObject):
+  r"""
+  Based on kaggle.kernels.SearchKernelsDocument
+
+  Attributes:
+    session_id (int)
+      The session ID of the Kernel
+    has_linked_submission (bool)
+      Whether the Kernel has a linked submission
+    datasource_is_private (bool)
+      Whether the datasource is private
+    best_public_score (float)
+      The best public score of the Kernel's submission
+    is_draft (bool)
+      Whether the Kernel is a draft
+  """
+
+  def __init__(self):
+    self._session_id = None
+    self._has_linked_submission = False
+    self._datasource_is_private = False
+    self._best_public_score = 0.0
+    self._is_draft = False
+    self._freeze()
+
+  @property
+  def session_id(self) -> int:
+    """The session ID of the Kernel"""
+    return self._session_id or 0
+
+  @session_id.setter
+  def session_id(self, session_id: Optional[int]):
+    if session_id is None:
+      del self.session_id
+      return
+    if not isinstance(session_id, int):
+      raise TypeError('session_id must be of type int')
+    self._session_id = session_id
+
+  @property
+  def has_linked_submission(self) -> bool:
+    """Whether the Kernel has a linked submission"""
+    return self._has_linked_submission
+
+  @has_linked_submission.setter
+  def has_linked_submission(self, has_linked_submission: bool):
+    if has_linked_submission is None:
+      del self.has_linked_submission
+      return
+    if not isinstance(has_linked_submission, bool):
+      raise TypeError('has_linked_submission must be of type bool')
+    self._has_linked_submission = has_linked_submission
+
+  @property
+  def datasource_is_private(self) -> bool:
+    """Whether the datasource is private"""
+    return self._datasource_is_private
+
+  @datasource_is_private.setter
+  def datasource_is_private(self, datasource_is_private: bool):
+    if datasource_is_private is None:
+      del self.datasource_is_private
+      return
+    if not isinstance(datasource_is_private, bool):
+      raise TypeError('datasource_is_private must be of type bool')
+    self._datasource_is_private = datasource_is_private
+
+  @property
+  def best_public_score(self) -> float:
+    """The best public score of the Kernel's submission"""
+    return self._best_public_score
+
+  @best_public_score.setter
+  def best_public_score(self, best_public_score: float):
+    if best_public_score is None:
+      del self.best_public_score
+      return
+    if not isinstance(best_public_score, float):
+      raise TypeError('best_public_score must be of type float')
+    self._best_public_score = best_public_score
+
+  @property
+  def is_draft(self) -> bool:
+    """Whether the Kernel is a draft"""
+    return self._is_draft
+
+  @is_draft.setter
+  def is_draft(self, is_draft: bool):
+    if is_draft is None:
+      del self.is_draft
+      return
+    if not isinstance(is_draft, bool):
+      raise TypeError('is_draft must be of type bool')
+    self._is_draft = is_draft
+
+
+class ApiSearchKernelsFilters(KaggleObject):
+  r"""
+  Based on kaggle.kernels.SearchKernelsFilters
+
+  Attributes:
+    language (str)
+      The Kernel language used to filter documents
+    earned_medal (bool)
+      Whether to return documents that the owner_user_id earned a medal for.
+  """
+
+  def __init__(self):
+    self._language = None
+    self._earned_medal = None
+    self._freeze()
+
+  @property
+  def language(self) -> str:
+    """The Kernel language used to filter documents"""
+    return self._language or ""
+
+  @language.setter
+  def language(self, language: Optional[str]):
+    if language is None:
+      del self.language
+      return
+    if not isinstance(language, str):
+      raise TypeError('language must be of type str')
+    self._language = language
+
+  @property
+  def earned_medal(self) -> bool:
+    """Whether to return documents that the owner_user_id earned a medal for."""
+    return self._earned_medal or False
+
+  @earned_medal.setter
+  def earned_medal(self, earned_medal: Optional[bool]):
+    if earned_medal is None:
+      del self.earned_medal
+      return
+    if not isinstance(earned_medal, bool):
+      raise TypeError('earned_medal must be of type bool')
+    self._earned_medal = earned_medal
+
+
+class ApiSearchModelsDocument(KaggleObject):
+  r"""
+  Based on kaggle.models.SearchModelsDocument
+
+  Attributes:
+    instance_count (int)
+      The total number of instances in the Model
+    notebook_count (int)
+      The total number of notebooks in the Model
+  """
+
+  def __init__(self):
+    self._instance_count = 0
+    self._notebook_count = 0
+    self._freeze()
+
+  @property
+  def instance_count(self) -> int:
+    """The total number of instances in the Model"""
+    return self._instance_count
+
+  @instance_count.setter
+  def instance_count(self, instance_count: int):
+    if instance_count is None:
+      del self.instance_count
+      return
+    if not isinstance(instance_count, int):
+      raise TypeError('instance_count must be of type int')
+    self._instance_count = instance_count
+
+  @property
+  def notebook_count(self) -> int:
+    """The total number of notebooks in the Model"""
+    return self._notebook_count
+
+  @notebook_count.setter
+  def notebook_count(self, notebook_count: int):
+    if notebook_count is None:
+      del self.notebook_count
+      return
+    if not isinstance(notebook_count, int):
+      raise TypeError('notebook_count must be of type int')
+    self._notebook_count = notebook_count
+
+
+class ApiSearchModelsFilters(KaggleObject):
+  r"""
+  Based on kaggle.models.SearchModelsFilters
+
+  Attributes:
+    size (ListSearchContentRangeFilter)
+      The size of the Model used to filter the documents
+  """
+
+  def __init__(self):
+    self._size = None
+    self._freeze()
+
+  @property
+  def size(self) -> Optional['ListSearchContentRangeFilter']:
+    """The size of the Model used to filter the documents"""
+    return self._size
+
+  @size.setter
+  def size(self, size: Optional['ListSearchContentRangeFilter']):
+    if size is None:
+      del self.size
+      return
+    if not isinstance(size, ListSearchContentRangeFilter):
+      raise TypeError('size must be of type ListSearchContentRangeFilter')
+    self._size = size
+
+
+class ApiSearchUsersDocument(KaggleObject):
+  r"""
+  Based on kaggle.users.SearchUsersDocument
+
+  Attributes:
+    grandmaster_tier_level (int)
+      User's GM tier level. Tier levels are awarded starting at GM. All
+      users who are not GM will have a tier level of 0.
+    user_location (str)
+      User location string, if location sharing is opted-in. In the format:
+      'city, region, country'.
+    occupation_organization_name (str)
+      Occupation organization name as indicated on the user's profile.
+    competition_ranking (int)
+      Current ranking for the user in the competition achievement type.
+    competition_points (int)
+      Current points for the user in the competition achievement type.
+    kernel_ranking (int)
+      Current ranking for the user in the kernel achievement type.
+    kernel_points (int)
+      Current points for the user in the kernel achievement type.
+    dataset_ranking (int)
+      Current ranking for the user in dataset achievement type.
+    dataset_points (int)
+      Current points for the user in the dataset achievement type.
+  """
+
+  def __init__(self):
+    self._grandmaster_tier_level = 0
+    self._user_location = None
+    self._occupation_organization_name = None
+    self._competition_ranking = None
+    self._competition_points = None
+    self._kernel_ranking = None
+    self._kernel_points = None
+    self._dataset_ranking = None
+    self._dataset_points = None
+    self._freeze()
+
+  @property
+  def grandmaster_tier_level(self) -> int:
+    r"""
+    User's GM tier level. Tier levels are awarded starting at GM. All
+    users who are not GM will have a tier level of 0.
+    """
+    return self._grandmaster_tier_level
+
+  @grandmaster_tier_level.setter
+  def grandmaster_tier_level(self, grandmaster_tier_level: int):
+    if grandmaster_tier_level is None:
+      del self.grandmaster_tier_level
+      return
+    if not isinstance(grandmaster_tier_level, int):
+      raise TypeError('grandmaster_tier_level must be of type int')
+    self._grandmaster_tier_level = grandmaster_tier_level
+
+  @property
+  def user_location(self) -> str:
+    r"""
+    User location string, if location sharing is opted-in. In the format:
+    'city, region, country'.
+    """
+    return self._user_location or ""
+
+  @user_location.setter
+  def user_location(self, user_location: Optional[str]):
+    if user_location is None:
+      del self.user_location
+      return
+    if not isinstance(user_location, str):
+      raise TypeError('user_location must be of type str')
+    self._user_location = user_location
+
+  @property
+  def occupation_organization_name(self) -> str:
+    """Occupation organization name as indicated on the user's profile."""
+    return self._occupation_organization_name or ""
+
+  @occupation_organization_name.setter
+  def occupation_organization_name(self, occupation_organization_name: Optional[str]):
+    if occupation_organization_name is None:
+      del self.occupation_organization_name
+      return
+    if not isinstance(occupation_organization_name, str):
+      raise TypeError('occupation_organization_name must be of type str')
+    self._occupation_organization_name = occupation_organization_name
+
+  @property
+  def competition_ranking(self) -> int:
+    """Current ranking for the user in the competition achievement type."""
+    return self._competition_ranking or 0
+
+  @competition_ranking.setter
+  def competition_ranking(self, competition_ranking: Optional[int]):
+    if competition_ranking is None:
+      del self.competition_ranking
+      return
+    if not isinstance(competition_ranking, int):
+      raise TypeError('competition_ranking must be of type int')
+    self._competition_ranking = competition_ranking
+
+  @property
+  def competition_points(self) -> int:
+    """Current points for the user in the competition achievement type."""
+    return self._competition_points or 0
+
+  @competition_points.setter
+  def competition_points(self, competition_points: Optional[int]):
+    if competition_points is None:
+      del self.competition_points
+      return
+    if not isinstance(competition_points, int):
+      raise TypeError('competition_points must be of type int')
+    self._competition_points = competition_points
+
+  @property
+  def kernel_ranking(self) -> int:
+    """Current ranking for the user in the kernel achievement type."""
+    return self._kernel_ranking or 0
+
+  @kernel_ranking.setter
+  def kernel_ranking(self, kernel_ranking: Optional[int]):
+    if kernel_ranking is None:
+      del self.kernel_ranking
+      return
+    if not isinstance(kernel_ranking, int):
+      raise TypeError('kernel_ranking must be of type int')
+    self._kernel_ranking = kernel_ranking
+
+  @property
+  def kernel_points(self) -> int:
+    """Current points for the user in the kernel achievement type."""
+    return self._kernel_points or 0
+
+  @kernel_points.setter
+  def kernel_points(self, kernel_points: Optional[int]):
+    if kernel_points is None:
+      del self.kernel_points
+      return
+    if not isinstance(kernel_points, int):
+      raise TypeError('kernel_points must be of type int')
+    self._kernel_points = kernel_points
+
+  @property
+  def dataset_ranking(self) -> int:
+    """Current ranking for the user in dataset achievement type."""
+    return self._dataset_ranking or 0
+
+  @dataset_ranking.setter
+  def dataset_ranking(self, dataset_ranking: Optional[int]):
+    if dataset_ranking is None:
+      del self.dataset_ranking
+      return
+    if not isinstance(dataset_ranking, int):
+      raise TypeError('dataset_ranking must be of type int')
+    self._dataset_ranking = dataset_ranking
+
+  @property
+  def dataset_points(self) -> int:
+    """Current points for the user in the dataset achievement type."""
+    return self._dataset_points or 0
+
+  @dataset_points.setter
+  def dataset_points(self, dataset_points: Optional[int]):
+    if dataset_points is None:
+      del self.dataset_points
+      return
+    if not isinstance(dataset_points, int):
+      raise TypeError('dataset_points must be of type int')
+    self._dataset_points = dataset_points
+
+
+class ApiSearchUsersFilters(KaggleObject):
+  r"""
+  Based on kaggle.users.SearchUsersFilters
+
+  Attributes:
+    user_locations (str)
+      Filter to users that have one of the the specified locations. Expects the
+      format: 'city, region, country' for each.
+    tier (UserAchievementTier)
+      Filter to users that have the specified performance tier.
+    user_ids (int)
+      Filter to users based on the provided user ids.
+    require_ranking_for_type (UserAchievementType)
+      Filter to users that have points for the specified type.
+    occupation_organization_names (str)
+      Filter to users that have one of the provided occupation organization names
+      indicated on their user profile, i.e. http://screen/3N68JKC4hocxWmn. Note:
+      This is *not* the same thing as a Kaggle Organization, such as
+      kaggle.com/organizations/google.
+    grandmaster_level (ListSearchContentRangeFilter)
+      Filter to users that have the specified range of Grandmaster tier level.
+  """
+
+  def __init__(self):
+    self._user_locations = []
+    self._tier = None
+    self._user_ids = []
+    self._require_ranking_for_type = None
+    self._occupation_organization_names = []
+    self._grandmaster_level = None
+    self._freeze()
+
+  @property
+  def user_locations(self) -> Optional[List[str]]:
+    r"""
+    Filter to users that have one of the the specified locations. Expects the
+    format: 'city, region, country' for each.
+    """
+    return self._user_locations
+
+  @user_locations.setter
+  def user_locations(self, user_locations: Optional[List[str]]):
+    if user_locations is None:
+      del self.user_locations
+      return
+    if not isinstance(user_locations, list):
+      raise TypeError('user_locations must be of type list')
+    if not all([isinstance(t, str) for t in user_locations]):
+      raise TypeError('user_locations must contain only items of type str')
+    self._user_locations = user_locations
+
+  @property
+  def tier(self) -> 'UserAchievementTier':
+    """Filter to users that have the specified performance tier."""
+    return self._tier or UserAchievementTier.NOVICE
+
+  @tier.setter
+  def tier(self, tier: Optional['UserAchievementTier']):
+    if tier is None:
+      del self.tier
+      return
+    if not isinstance(tier, UserAchievementTier):
+      raise TypeError('tier must be of type UserAchievementTier')
+    self._tier = tier
+
+  @property
+  def user_ids(self) -> Optional[List[int]]:
+    """Filter to users based on the provided user ids."""
+    return self._user_ids
+
+  @user_ids.setter
+  def user_ids(self, user_ids: Optional[List[int]]):
+    if user_ids is None:
+      del self.user_ids
+      return
+    if not isinstance(user_ids, list):
+      raise TypeError('user_ids must be of type list')
+    if not all([isinstance(t, int) for t in user_ids]):
+      raise TypeError('user_ids must contain only items of type int')
+    self._user_ids = user_ids
+
+  @property
+  def require_ranking_for_type(self) -> 'UserAchievementType':
+    """Filter to users that have points for the specified type."""
+    return self._require_ranking_for_type or UserAchievementType.USER_ACHIEVEMENT_TYPE_UNSPECIFIED
+
+  @require_ranking_for_type.setter
+  def require_ranking_for_type(self, require_ranking_for_type: Optional['UserAchievementType']):
+    if require_ranking_for_type is None:
+      del self.require_ranking_for_type
+      return
+    if not isinstance(require_ranking_for_type, UserAchievementType):
+      raise TypeError('require_ranking_for_type must be of type UserAchievementType')
+    self._require_ranking_for_type = require_ranking_for_type
+
+  @property
+  def occupation_organization_names(self) -> Optional[List[str]]:
+    r"""
+    Filter to users that have one of the provided occupation organization names
+    indicated on their user profile, i.e. http://screen/3N68JKC4hocxWmn. Note:
+    This is *not* the same thing as a Kaggle Organization, such as
+    kaggle.com/organizations/google.
+    """
+    return self._occupation_organization_names
+
+  @occupation_organization_names.setter
+  def occupation_organization_names(self, occupation_organization_names: Optional[List[str]]):
+    if occupation_organization_names is None:
+      del self.occupation_organization_names
+      return
+    if not isinstance(occupation_organization_names, list):
+      raise TypeError('occupation_organization_names must be of type list')
+    if not all([isinstance(t, str) for t in occupation_organization_names]):
+      raise TypeError('occupation_organization_names must contain only items of type str')
+    self._occupation_organization_names = occupation_organization_names
+
+  @property
+  def grandmaster_level(self) -> Optional['ListSearchContentRangeFilter']:
+    """Filter to users that have the specified range of Grandmaster tier level."""
+    return self._grandmaster_level
+
+  @grandmaster_level.setter
+  def grandmaster_level(self, grandmaster_level: Optional['ListSearchContentRangeFilter']):
+    if grandmaster_level is None:
+      del self.grandmaster_level
+      return
+    if not isinstance(grandmaster_level, ListSearchContentRangeFilter):
+      raise TypeError('grandmaster_level must be of type ListSearchContentRangeFilter')
+    self._grandmaster_level = grandmaster_level
+
+
+class ApiUserAvatar(KaggleObject):
+  r"""
+  Based on kaggle.users.UserAvatar
+
+  Attributes:
+    id (int)
+      ID for the given user
+    display_name (str)
+      Display name for the given user
+    thumbnail_url (str)
+      Thumbnail URL for the given user
+    url (str)
+      Profile URL for the given user
+    user_name (str)
+      User name for the given user
+    progression_opt_out (bool)
+      True if the user is opted out of the progression system.
+    tier (UserAchievementTier)
+      Tier for the given user
+  """
+
+  def __init__(self):
+    self._id = 0
+    self._display_name = None
+    self._thumbnail_url = None
+    self._url = None
+    self._user_name = None
+    self._progression_opt_out = None
+    self._tier = UserAchievementTier.NOVICE
+    self._freeze()
+
+  @property
+  def id(self) -> int:
+    """ID for the given user"""
+    return self._id
+
+  @id.setter
+  def id(self, id: int):
+    if id is None:
+      del self.id
+      return
+    if not isinstance(id, int):
+      raise TypeError('id must be of type int')
+    self._id = id
+
+  @property
+  def display_name(self) -> str:
+    """Display name for the given user"""
+    return self._display_name or ""
+
+  @display_name.setter
+  def display_name(self, display_name: Optional[str]):
+    if display_name is None:
+      del self.display_name
+      return
+    if not isinstance(display_name, str):
+      raise TypeError('display_name must be of type str')
+    self._display_name = display_name
+
+  @property
+  def thumbnail_url(self) -> str:
+    """Thumbnail URL for the given user"""
+    return self._thumbnail_url or ""
+
+  @thumbnail_url.setter
+  def thumbnail_url(self, thumbnail_url: Optional[str]):
+    if thumbnail_url is None:
+      del self.thumbnail_url
+      return
+    if not isinstance(thumbnail_url, str):
+      raise TypeError('thumbnail_url must be of type str')
+    self._thumbnail_url = thumbnail_url
+
+  @property
+  def url(self) -> str:
+    """Profile URL for the given user"""
+    return self._url or ""
+
+  @url.setter
+  def url(self, url: Optional[str]):
+    if url is None:
+      del self.url
+      return
+    if not isinstance(url, str):
+      raise TypeError('url must be of type str')
+    self._url = url
+
+  @property
+  def user_name(self) -> str:
+    """User name for the given user"""
+    return self._user_name or ""
+
+  @user_name.setter
+  def user_name(self, user_name: Optional[str]):
+    if user_name is None:
+      del self.user_name
+      return
+    if not isinstance(user_name, str):
+      raise TypeError('user_name must be of type str')
+    self._user_name = user_name
+
+  @property
+  def progression_opt_out(self) -> bool:
+    """True if the user is opted out of the progression system."""
+    return self._progression_opt_out or False
+
+  @progression_opt_out.setter
+  def progression_opt_out(self, progression_opt_out: Optional[bool]):
+    if progression_opt_out is None:
+      del self.progression_opt_out
+      return
+    if not isinstance(progression_opt_out, bool):
+      raise TypeError('progression_opt_out must be of type bool')
+    self._progression_opt_out = progression_opt_out
+
+  @property
+  def tier(self) -> 'UserAchievementTier':
+    """Tier for the given user"""
+    return self._tier
+
+  @tier.setter
+  def tier(self, tier: 'UserAchievementTier'):
+    if tier is None:
+      del self.tier
+      return
+    if not isinstance(tier, UserAchievementTier):
+      raise TypeError('tier must be of type UserAchievementTier')
+    self._tier = tier
+
+
+class ListEntitiesDocument(KaggleObject):
+  r"""
+  Based on kaggle.search.ListSearchContentDocument
+
+  Attributes:
+    id (int)
+      The DB ID (i.e. the PK from the table) of the document
+    document_type (DocumentType)
+      The type of content of the document
+    title (str)
+      The canonical title of the document
+    image_url (str)
+      The thumbnail URL of the document
+    create_time (datetime)
+      The canonical creation time of the document; May mean different things
+      between content types
+    update_time (datetime)
+      The canonical update time of the document; May be different between content
+      types
+    is_private (bool)
+      Whether the content is marked as private
+    votes (int)
+      The total votes (or score, if downvotes are supported) for the document
+    owner_user (ApiUserAvatar)
+    owner_organization (ApiOrganizationCard)
+    competition_document (ApiSearchCompetitionsDocument)
+    dataset_document (ApiSearchDatasetsDocument)
+    kernel_document (ApiSearchKernelsDocument)
+    model_document (ApiSearchModelsDocument)
+    discussion_document (ApiSearchDiscussionsDocument)
+    user_document (ApiSearchUsersDocument)
+    slug (str)
+      The slug of the document (which may be close to the url)
+  """
+
+  def __init__(self):
+    self._id = 0
+    self._document_type = DocumentType.DOCUMENT_TYPE_UNSPECIFIED
+    self._title = ""
+    self._image_url = ""
+    self._create_time = None
+    self._update_time = None
+    self._is_private = None
+    self._votes = None
+    self._owner_user = None
+    self._owner_organization = None
+    self._competition_document = None
+    self._dataset_document = None
+    self._kernel_document = None
+    self._model_document = None
+    self._discussion_document = None
+    self._user_document = None
+    self._slug = None
+    self._freeze()
+
+  @property
+  def id(self) -> int:
+    """The DB ID (i.e. the PK from the table) of the document"""
+    return self._id
+
+  @id.setter
+  def id(self, id: int):
+    if id is None:
+      del self.id
+      return
+    if not isinstance(id, int):
+      raise TypeError('id must be of type int')
+    self._id = id
+
+  @property
+  def document_type(self) -> 'DocumentType':
+    """The type of content of the document"""
+    return self._document_type
+
+  @document_type.setter
+  def document_type(self, document_type: 'DocumentType'):
+    if document_type is None:
+      del self.document_type
+      return
+    if not isinstance(document_type, DocumentType):
+      raise TypeError('document_type must be of type DocumentType')
+    self._document_type = document_type
+
+  @property
+  def title(self) -> str:
+    """The canonical title of the document"""
+    return self._title
+
+  @title.setter
+  def title(self, title: str):
+    if title is None:
+      del self.title
+      return
+    if not isinstance(title, str):
+      raise TypeError('title must be of type str')
+    self._title = title
+
+  @property
+  def image_url(self) -> str:
+    """The thumbnail URL of the document"""
+    return self._image_url
+
+  @image_url.setter
+  def image_url(self, image_url: str):
+    if image_url is None:
+      del self.image_url
+      return
+    if not isinstance(image_url, str):
+      raise TypeError('image_url must be of type str')
+    self._image_url = image_url
+
+  @property
+  def create_time(self) -> datetime:
+    r"""
+    The canonical creation time of the document; May mean different things
+    between content types
+    """
+    return self._create_time
+
+  @create_time.setter
+  def create_time(self, create_time: datetime):
+    if create_time is None:
+      del self.create_time
+      return
+    if not isinstance(create_time, datetime):
+      raise TypeError('create_time must be of type datetime')
+    self._create_time = create_time
+
+  @property
+  def update_time(self) -> datetime:
+    r"""
+    The canonical update time of the document; May be different between content
+    types
+    """
+    return self._update_time or None
+
+  @update_time.setter
+  def update_time(self, update_time: Optional[datetime]):
+    if update_time is None:
+      del self.update_time
+      return
+    if not isinstance(update_time, datetime):
+      raise TypeError('update_time must be of type datetime')
+    self._update_time = update_time
+
+  @property
+  def is_private(self) -> bool:
+    """Whether the content is marked as private"""
+    return self._is_private or False
+
+  @is_private.setter
+  def is_private(self, is_private: Optional[bool]):
+    if is_private is None:
+      del self.is_private
+      return
+    if not isinstance(is_private, bool):
+      raise TypeError('is_private must be of type bool')
+    self._is_private = is_private
+
+  @property
+  def votes(self) -> int:
+    """The total votes (or score, if downvotes are supported) for the document"""
+    return self._votes or 0
+
+  @votes.setter
+  def votes(self, votes: Optional[int]):
+    if votes is None:
+      del self.votes
+      return
+    if not isinstance(votes, int):
+      raise TypeError('votes must be of type int')
+    self._votes = votes
+
+  @property
+  def owner_user(self) -> Optional['ApiUserAvatar']:
+    return self._owner_user or None
+
+  @owner_user.setter
+  def owner_user(self, owner_user: Optional['ApiUserAvatar']):
+    if owner_user is None:
+      del self.owner_user
+      return
+    if not isinstance(owner_user, ApiUserAvatar):
+      raise TypeError('owner_user must be of type ApiUserAvatar')
+    del self.owner_organization
+    self._owner_user = owner_user
+
+  @property
+  def owner_organization(self) -> Optional['ApiOrganizationCard']:
+    return self._owner_organization or None
+
+  @owner_organization.setter
+  def owner_organization(self, owner_organization: Optional['ApiOrganizationCard']):
+    if owner_organization is None:
+      del self.owner_organization
+      return
+    if not isinstance(owner_organization, ApiOrganizationCard):
+      raise TypeError('owner_organization must be of type ApiOrganizationCard')
+    del self.owner_user
+    self._owner_organization = owner_organization
+
+  @property
+  def competition_document(self) -> Optional['ApiSearchCompetitionsDocument']:
+    return self._competition_document or None
+
+  @competition_document.setter
+  def competition_document(self, competition_document: Optional['ApiSearchCompetitionsDocument']):
+    if competition_document is None:
+      del self.competition_document
+      return
+    if not isinstance(competition_document, ApiSearchCompetitionsDocument):
+      raise TypeError('competition_document must be of type ApiSearchCompetitionsDocument')
+    del self.dataset_document
+    del self.kernel_document
+    del self.model_document
+    del self.discussion_document
+    del self.user_document
+    self._competition_document = competition_document
+
+  @property
+  def dataset_document(self) -> Optional['ApiSearchDatasetsDocument']:
+    return self._dataset_document or None
+
+  @dataset_document.setter
+  def dataset_document(self, dataset_document: Optional['ApiSearchDatasetsDocument']):
+    if dataset_document is None:
+      del self.dataset_document
+      return
+    if not isinstance(dataset_document, ApiSearchDatasetsDocument):
+      raise TypeError('dataset_document must be of type ApiSearchDatasetsDocument')
+    del self.competition_document
+    del self.kernel_document
+    del self.model_document
+    del self.discussion_document
+    del self.user_document
+    self._dataset_document = dataset_document
+
+  @property
+  def kernel_document(self) -> Optional['ApiSearchKernelsDocument']:
+    return self._kernel_document or None
+
+  @kernel_document.setter
+  def kernel_document(self, kernel_document: Optional['ApiSearchKernelsDocument']):
+    if kernel_document is None:
+      del self.kernel_document
+      return
+    if not isinstance(kernel_document, ApiSearchKernelsDocument):
+      raise TypeError('kernel_document must be of type ApiSearchKernelsDocument')
+    del self.competition_document
+    del self.dataset_document
+    del self.model_document
+    del self.discussion_document
+    del self.user_document
+    self._kernel_document = kernel_document
+
+  @property
+  def model_document(self) -> Optional['ApiSearchModelsDocument']:
+    return self._model_document or None
+
+  @model_document.setter
+  def model_document(self, model_document: Optional['ApiSearchModelsDocument']):
+    if model_document is None:
+      del self.model_document
+      return
+    if not isinstance(model_document, ApiSearchModelsDocument):
+      raise TypeError('model_document must be of type ApiSearchModelsDocument')
+    del self.competition_document
+    del self.dataset_document
+    del self.kernel_document
+    del self.discussion_document
+    del self.user_document
+    self._model_document = model_document
+
+  @property
+  def discussion_document(self) -> Optional['ApiSearchDiscussionsDocument']:
+    return self._discussion_document or None
+
+  @discussion_document.setter
+  def discussion_document(self, discussion_document: Optional['ApiSearchDiscussionsDocument']):
+    if discussion_document is None:
+      del self.discussion_document
+      return
+    if not isinstance(discussion_document, ApiSearchDiscussionsDocument):
+      raise TypeError('discussion_document must be of type ApiSearchDiscussionsDocument')
+    del self.competition_document
+    del self.dataset_document
+    del self.kernel_document
+    del self.model_document
+    del self.user_document
+    self._discussion_document = discussion_document
+
+  @property
+  def user_document(self) -> Optional['ApiSearchUsersDocument']:
+    return self._user_document or None
+
+  @user_document.setter
+  def user_document(self, user_document: Optional['ApiSearchUsersDocument']):
+    if user_document is None:
+      del self.user_document
+      return
+    if not isinstance(user_document, ApiSearchUsersDocument):
+      raise TypeError('user_document must be of type ApiSearchUsersDocument')
+    del self.competition_document
+    del self.dataset_document
+    del self.kernel_document
+    del self.model_document
+    del self.discussion_document
+    self._user_document = user_document
+
+  @property
+  def slug(self) -> str:
+    """The slug of the document (which may be close to the url)"""
+    return self._slug or ""
+
+  @slug.setter
+  def slug(self, slug: Optional[str]):
+    if slug is None:
+      del self.slug
+      return
+    if not isinstance(slug, str):
+      raise TypeError('slug must be of type str')
+    self._slug = slug
+
+
+class ListEntitiesFilters(KaggleObject):
+  r"""
+   Based on kaggle.search.ListSearchContentFilters
+
+  Attributes:
+    query (str)
+      The free-text query the user entered to filter results
+    list_type (ApiListType)
+      The type of list being requested
+    privacy (PrivacyFilter)
+      The privacy filter to apply
+    owner_type (OwnerType)
+      The owner type filter to apply
+    document_types (DocumentType)
+      The document type filter to apply
+    competition_filters (ApiSearchCompetitionsFilters)
+      The set of Competition filters to filter the documents
+    dataset_filters (ApiSearchDatasetsFilters)
+      The set of Dataset filters to filter the documents
+    discussion_filters (ApiSearchDiscussionsFilters)
+      The set of Discussion filters to filter the documents
+    kernel_filters (ApiSearchKernelsFilters)
+      The set of Kernel filters to filter the documents
+    model_filters (ApiSearchModelsFilters)
+      The set of Model filters to filter the documents
+    user_filters (ApiSearchUsersFilters)
+      The set of User filters to filter the documents
+  """
+
+  def __init__(self):
+    self._query = ""
+    self._list_type = ApiListType.API_LIST_TYPE_UNSPECIFIED
+    self._privacy = PrivacyFilter.ALL
+    self._owner_type = OwnerType.OWNER_TYPE_UNSPECIFIED
+    self._document_types = []
+    self._competition_filters = None
+    self._dataset_filters = None
+    self._discussion_filters = None
+    self._kernel_filters = None
+    self._model_filters = None
+    self._user_filters = None
+    self._freeze()
+
+  @property
+  def query(self) -> str:
+    """The free-text query the user entered to filter results"""
+    return self._query
+
+  @query.setter
+  def query(self, query: str):
+    if query is None:
+      del self.query
+      return
+    if not isinstance(query, str):
+      raise TypeError('query must be of type str')
+    self._query = query
+
+  @property
+  def list_type(self) -> 'ApiListType':
+    """The type of list being requested"""
+    return self._list_type
+
+  @list_type.setter
+  def list_type(self, list_type: 'ApiListType'):
+    if list_type is None:
+      del self.list_type
+      return
+    if not isinstance(list_type, ApiListType):
+      raise TypeError('list_type must be of type ApiListType')
+    self._list_type = list_type
+
+  @property
+  def privacy(self) -> 'PrivacyFilter':
+    """The privacy filter to apply"""
+    return self._privacy
+
+  @privacy.setter
+  def privacy(self, privacy: 'PrivacyFilter'):
+    if privacy is None:
+      del self.privacy
+      return
+    if not isinstance(privacy, PrivacyFilter):
+      raise TypeError('privacy must be of type PrivacyFilter')
+    self._privacy = privacy
+
+  @property
+  def owner_type(self) -> 'OwnerType':
+    """The owner type filter to apply"""
+    return self._owner_type
+
+  @owner_type.setter
+  def owner_type(self, owner_type: 'OwnerType'):
+    if owner_type is None:
+      del self.owner_type
+      return
+    if not isinstance(owner_type, OwnerType):
+      raise TypeError('owner_type must be of type OwnerType')
+    self._owner_type = owner_type
+
+  @property
+  def document_types(self) -> Optional[List['DocumentType']]:
+    """The document type filter to apply"""
+    return self._document_types
+
+  @document_types.setter
+  def document_types(self, document_types: Optional[List['DocumentType']]):
+    if document_types is None:
+      del self.document_types
+      return
+    if not isinstance(document_types, list):
+      raise TypeError('document_types must be of type list')
+    if not all([isinstance(t, DocumentType) for t in document_types]):
+      raise TypeError('document_types must contain only items of type DocumentType')
+    self._document_types = document_types
+
+  @property
+  def competition_filters(self) -> Optional['ApiSearchCompetitionsFilters']:
+    """The set of Competition filters to filter the documents"""
+    return self._competition_filters
+
+  @competition_filters.setter
+  def competition_filters(self, competition_filters: Optional['ApiSearchCompetitionsFilters']):
+    if competition_filters is None:
+      del self.competition_filters
+      return
+    if not isinstance(competition_filters, ApiSearchCompetitionsFilters):
+      raise TypeError('competition_filters must be of type ApiSearchCompetitionsFilters')
+    self._competition_filters = competition_filters
+
+  @property
+  def dataset_filters(self) -> Optional['ApiSearchDatasetsFilters']:
+    """The set of Dataset filters to filter the documents"""
+    return self._dataset_filters
+
+  @dataset_filters.setter
+  def dataset_filters(self, dataset_filters: Optional['ApiSearchDatasetsFilters']):
+    if dataset_filters is None:
+      del self.dataset_filters
+      return
+    if not isinstance(dataset_filters, ApiSearchDatasetsFilters):
+      raise TypeError('dataset_filters must be of type ApiSearchDatasetsFilters')
+    self._dataset_filters = dataset_filters
+
+  @property
+  def discussion_filters(self) -> Optional['ApiSearchDiscussionsFilters']:
+    """The set of Discussion filters to filter the documents"""
+    return self._discussion_filters
+
+  @discussion_filters.setter
+  def discussion_filters(self, discussion_filters: Optional['ApiSearchDiscussionsFilters']):
+    if discussion_filters is None:
+      del self.discussion_filters
+      return
+    if not isinstance(discussion_filters, ApiSearchDiscussionsFilters):
+      raise TypeError('discussion_filters must be of type ApiSearchDiscussionsFilters')
+    self._discussion_filters = discussion_filters
+
+  @property
+  def kernel_filters(self) -> Optional['ApiSearchKernelsFilters']:
+    """The set of Kernel filters to filter the documents"""
+    return self._kernel_filters
+
+  @kernel_filters.setter
+  def kernel_filters(self, kernel_filters: Optional['ApiSearchKernelsFilters']):
+    if kernel_filters is None:
+      del self.kernel_filters
+      return
+    if not isinstance(kernel_filters, ApiSearchKernelsFilters):
+      raise TypeError('kernel_filters must be of type ApiSearchKernelsFilters')
+    self._kernel_filters = kernel_filters
+
+  @property
+  def model_filters(self) -> Optional['ApiSearchModelsFilters']:
+    """The set of Model filters to filter the documents"""
+    return self._model_filters
+
+  @model_filters.setter
+  def model_filters(self, model_filters: Optional['ApiSearchModelsFilters']):
+    if model_filters is None:
+      del self.model_filters
+      return
+    if not isinstance(model_filters, ApiSearchModelsFilters):
+      raise TypeError('model_filters must be of type ApiSearchModelsFilters')
+    self._model_filters = model_filters
+
+  @property
+  def user_filters(self) -> Optional['ApiSearchUsersFilters']:
+    """The set of User filters to filter the documents"""
+    return self._user_filters
+
+  @user_filters.setter
+  def user_filters(self, user_filters: Optional['ApiSearchUsersFilters']):
+    if user_filters is None:
+      del self.user_filters
+      return
+    if not isinstance(user_filters, ApiSearchUsersFilters):
+      raise TypeError('user_filters must be of type ApiSearchUsersFilters')
+    self._user_filters = user_filters
+
+
+class ListEntitiesRequest(KaggleObject):
+  r"""
+  Attributes:
+    filters (ListEntitiesFilters)
+      Canonical filters to apply to the search
+    canonical_order_by (ListSearchContentOrderBy)
+      Canonical order to apply to the results
+    competitions_order_by (SearchCompetitionsOrderBy)
+      Competitions order to apply to the results
+    datasets_order_by (SearchDatasetsOrderBy)
+      Datasets order to apply to the results
+    kernels_order_by (SearchKernelsOrderBy)
+      Kernels order to apply to the results
+    models_order_by (SearchModelsOrderBy)
+      Models order to apply to the results
+    discussions_order_by (SearchDiscussionsOrderBy)
+      Discussions order to apply to the results
+    users_order_by (SearchUsersOrderBy)
+      Users order to apply to the results
+    page_token (str)
+      Page token for paging (see aip.dev/158)
+    page_size (int)
+      Number of documents per page to return
+    skip (int)
+      How many results to skip
+  """
+
+  def __init__(self):
+    self._filters = None
+    self._canonical_order_by = None
+    self._competitions_order_by = None
+    self._datasets_order_by = None
+    self._kernels_order_by = None
+    self._models_order_by = None
+    self._discussions_order_by = None
+    self._users_order_by = None
+    self._page_token = ""
+    self._page_size = 0
+    self._skip = 0
+    self._freeze()
+
+  @property
+  def filters(self) -> Optional['ListEntitiesFilters']:
+    """Canonical filters to apply to the search"""
+    return self._filters
+
+  @filters.setter
+  def filters(self, filters: Optional['ListEntitiesFilters']):
+    if filters is None:
+      del self.filters
+      return
+    if not isinstance(filters, ListEntitiesFilters):
+      raise TypeError('filters must be of type ListEntitiesFilters')
+    self._filters = filters
+
+  @property
+  def canonical_order_by(self) -> 'ListSearchContentOrderBy':
+    """Canonical order to apply to the results"""
+    return self._canonical_order_by or ListSearchContentOrderBy.LIST_SEARCH_CONTENT_ORDER_BY_UNSPECIFIED
+
+  @canonical_order_by.setter
+  def canonical_order_by(self, canonical_order_by: 'ListSearchContentOrderBy'):
+    if canonical_order_by is None:
+      del self.canonical_order_by
+      return
+    if not isinstance(canonical_order_by, ListSearchContentOrderBy):
+      raise TypeError('canonical_order_by must be of type ListSearchContentOrderBy')
+    del self.competitions_order_by
+    del self.datasets_order_by
+    del self.kernels_order_by
+    del self.models_order_by
+    del self.discussions_order_by
+    del self.users_order_by
+    self._canonical_order_by = canonical_order_by
+
+  @property
+  def competitions_order_by(self) -> 'SearchCompetitionsOrderBy':
+    """Competitions order to apply to the results"""
+    return self._competitions_order_by or SearchCompetitionsOrderBy.SEARCH_COMPETITIONS_ORDER_BY_UNSPECIFIED
+
+  @competitions_order_by.setter
+  def competitions_order_by(self, competitions_order_by: 'SearchCompetitionsOrderBy'):
+    if competitions_order_by is None:
+      del self.competitions_order_by
+      return
+    if not isinstance(competitions_order_by, SearchCompetitionsOrderBy):
+      raise TypeError('competitions_order_by must be of type SearchCompetitionsOrderBy')
+    del self.canonical_order_by
+    del self.datasets_order_by
+    del self.kernels_order_by
+    del self.models_order_by
+    del self.discussions_order_by
+    del self.users_order_by
+    self._competitions_order_by = competitions_order_by
+
+  @property
+  def datasets_order_by(self) -> 'SearchDatasetsOrderBy':
+    """Datasets order to apply to the results"""
+    return self._datasets_order_by or SearchDatasetsOrderBy.SEARCH_DATASETS_ORDER_BY_UNSPECIFIED
+
+  @datasets_order_by.setter
+  def datasets_order_by(self, datasets_order_by: 'SearchDatasetsOrderBy'):
+    if datasets_order_by is None:
+      del self.datasets_order_by
+      return
+    if not isinstance(datasets_order_by, SearchDatasetsOrderBy):
+      raise TypeError('datasets_order_by must be of type SearchDatasetsOrderBy')
+    del self.canonical_order_by
+    del self.competitions_order_by
+    del self.kernels_order_by
+    del self.models_order_by
+    del self.discussions_order_by
+    del self.users_order_by
+    self._datasets_order_by = datasets_order_by
+
+  @property
+  def kernels_order_by(self) -> 'SearchKernelsOrderBy':
+    """Kernels order to apply to the results"""
+    return self._kernels_order_by or SearchKernelsOrderBy.SEARCH_KERNELS_ORDER_BY_UNSPECIFIED
+
+  @kernels_order_by.setter
+  def kernels_order_by(self, kernels_order_by: 'SearchKernelsOrderBy'):
+    if kernels_order_by is None:
+      del self.kernels_order_by
+      return
+    if not isinstance(kernels_order_by, SearchKernelsOrderBy):
+      raise TypeError('kernels_order_by must be of type SearchKernelsOrderBy')
+    del self.canonical_order_by
+    del self.competitions_order_by
+    del self.datasets_order_by
+    del self.models_order_by
+    del self.discussions_order_by
+    del self.users_order_by
+    self._kernels_order_by = kernels_order_by
+
+  @property
+  def models_order_by(self) -> 'SearchModelsOrderBy':
+    """Models order to apply to the results"""
+    return self._models_order_by or SearchModelsOrderBy.MODELS_SEARCH_ORDER_BY_UNSPECIFIED
+
+  @models_order_by.setter
+  def models_order_by(self, models_order_by: 'SearchModelsOrderBy'):
+    if models_order_by is None:
+      del self.models_order_by
+      return
+    if not isinstance(models_order_by, SearchModelsOrderBy):
+      raise TypeError('models_order_by must be of type SearchModelsOrderBy')
+    del self.canonical_order_by
+    del self.competitions_order_by
+    del self.datasets_order_by
+    del self.kernels_order_by
+    del self.discussions_order_by
+    del self.users_order_by
+    self._models_order_by = models_order_by
+
+  @property
+  def discussions_order_by(self) -> 'SearchDiscussionsOrderBy':
+    """Discussions order to apply to the results"""
+    return self._discussions_order_by or SearchDiscussionsOrderBy.SEARCH_DISCUSSIONS_ORDER_BY_UNSPECIFIED
+
+  @discussions_order_by.setter
+  def discussions_order_by(self, discussions_order_by: 'SearchDiscussionsOrderBy'):
+    if discussions_order_by is None:
+      del self.discussions_order_by
+      return
+    if not isinstance(discussions_order_by, SearchDiscussionsOrderBy):
+      raise TypeError('discussions_order_by must be of type SearchDiscussionsOrderBy')
+    del self.canonical_order_by
+    del self.competitions_order_by
+    del self.datasets_order_by
+    del self.kernels_order_by
+    del self.models_order_by
+    del self.users_order_by
+    self._discussions_order_by = discussions_order_by
+
+  @property
+  def users_order_by(self) -> 'SearchUsersOrderBy':
+    """Users order to apply to the results"""
+    return self._users_order_by or SearchUsersOrderBy.SEARCH_USERS_ORDER_BY_UNSPECIFIED
+
+  @users_order_by.setter
+  def users_order_by(self, users_order_by: 'SearchUsersOrderBy'):
+    if users_order_by is None:
+      del self.users_order_by
+      return
+    if not isinstance(users_order_by, SearchUsersOrderBy):
+      raise TypeError('users_order_by must be of type SearchUsersOrderBy')
+    del self.canonical_order_by
+    del self.competitions_order_by
+    del self.datasets_order_by
+    del self.kernels_order_by
+    del self.models_order_by
+    del self.discussions_order_by
+    self._users_order_by = users_order_by
+
+  @property
+  def page_token(self) -> str:
+    """Page token for paging (see aip.dev/158)"""
+    return self._page_token
+
+  @page_token.setter
+  def page_token(self, page_token: str):
+    if page_token is None:
+      del self.page_token
+      return
+    if not isinstance(page_token, str):
+      raise TypeError('page_token must be of type str')
+    self._page_token = page_token
+
+  @property
+  def page_size(self) -> int:
+    """Number of documents per page to return"""
+    return self._page_size
+
+  @page_size.setter
+  def page_size(self, page_size: int):
+    if page_size is None:
+      del self.page_size
+      return
+    if not isinstance(page_size, int):
+      raise TypeError('page_size must be of type int')
+    self._page_size = page_size
+
+  @property
+  def skip(self) -> int:
+    """How many results to skip"""
+    return self._skip
+
+  @skip.setter
+  def skip(self, skip: int):
+    if skip is None:
+      del self.skip
+      return
+    if not isinstance(skip, int):
+      raise TypeError('skip must be of type int')
+    self._skip = skip
+
+  def endpoint(self):
+    path = '/api/v1/search/list-entities'
+    return path.format_map(self.to_field_map(self))
+
+
+class ListEntitiesResponse(KaggleObject):
+  r"""
+  Attributes:
+    documents (ListEntitiesDocument)
+      The list of documents returned after filtering
+    total_documents (int)
+      The total number of documents matching any filters
+    next_page_token (str)
+      The token to request the next page
+  """
+
+  def __init__(self):
+    self._documents = []
+    self._total_documents = 0
+    self._next_page_token = ""
+    self._freeze()
+
+  @property
+  def documents(self) -> Optional[List[Optional['ListEntitiesDocument']]]:
+    """The list of documents returned after filtering"""
+    return self._documents
+
+  @documents.setter
+  def documents(self, documents: Optional[List[Optional['ListEntitiesDocument']]]):
+    if documents is None:
+      del self.documents
+      return
+    if not isinstance(documents, list):
+      raise TypeError('documents must be of type list')
+    if not all([isinstance(t, ListEntitiesDocument) for t in documents]):
+      raise TypeError('documents must contain only items of type ListEntitiesDocument')
+    self._documents = documents
+
+  @property
+  def total_documents(self) -> int:
+    """The total number of documents matching any filters"""
+    return self._total_documents
+
+  @total_documents.setter
+  def total_documents(self, total_documents: int):
+    if total_documents is None:
+      del self.total_documents
+      return
+    if not isinstance(total_documents, int):
+      raise TypeError('total_documents must be of type int')
+    self._total_documents = total_documents
+
+  @property
+  def next_page_token(self) -> str:
+    """The token to request the next page"""
+    return self._next_page_token
+
+  @next_page_token.setter
+  def next_page_token(self, next_page_token: str):
+    if next_page_token is None:
+      del self.next_page_token
+      return
+    if not isinstance(next_page_token, str):
+      raise TypeError('next_page_token must be of type str')
+    self._next_page_token = next_page_token
+
+  @property
+  def totalDocuments(self):
+    return self.total_documents
+
+  @property
+  def nextPageToken(self):
+    return self.next_page_token
+
+
+ApiOrganizationCard._fields = [
+  FieldMetadata("name", "name", "_name", str, "", PredefinedSerializer()),
+  FieldMetadata("id", "id", "_id", int, 0, PredefinedSerializer()),
+  FieldMetadata("thumbnailImageUrl", "thumbnail_image_url", "_thumbnail_image_url", str, "", PredefinedSerializer()),
+  FieldMetadata("slug", "slug", "_slug", str, "", PredefinedSerializer()),
+]
+
+ApiSearchCompetitionsDocument._fields = [
+  FieldMetadata("hostSegment", "host_segment", "_host_segment", HostSegment, HostSegment.HOST_SEGMENT_UNSPECIFIED, EnumSerializer()),
+  FieldMetadata("deadline", "deadline", "_deadline", datetime, None, DateTimeSerializer()),
+  FieldMetadata("teamCount", "team_count", "_team_count", int, 0, PredefinedSerializer()),
+  FieldMetadata("teamRank", "team_rank", "_team_rank", int, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("isEnvironmentEvaluation", "is_environment_evaluation", "_is_environment_evaluation", bool, False, PredefinedSerializer()),
+  FieldMetadata("prizeType", "prize_type", "_prize_type", RewardTypeId, RewardTypeId.REWARD_TYPE_ID_UNSPECIFIED, EnumSerializer()),
+  FieldMetadata("prizeValue", "prize_value", "_prize_value", float, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("isLaunched", "is_launched", "_is_launched", bool, False, PredefinedSerializer()),
+  FieldMetadata("ownerUserHasJoined", "owner_user_has_joined", "_owner_user_has_joined", bool, False, PredefinedSerializer()),
+  FieldMetadata("isLimitedParticipation", "is_limited_participation", "_is_limited_participation", bool, False, PredefinedSerializer()),
+  FieldMetadata("onlyAllowKernelSubmissions", "only_allow_kernel_submissions", "_only_allow_kernel_submissions", bool, False, PredefinedSerializer()),
+]
+
+ApiSearchCompetitionsFilters._fields = [
+  FieldMetadata("role", "role", "_role", SearchCompetitionsRole, SearchCompetitionsRole.SEARCH_COMPETITIONS_ROLE_ANY, EnumSerializer()),
+  FieldMetadata("status", "status", "_status", SearchCompetitionsStatus, SearchCompetitionsStatus.SEARCH_COMPETITIONS_STATUS_ANY, EnumSerializer()),
+  FieldMetadata("profileVisibility", "profile_visibility", "_profile_visibility", SearchCompetitionsProfileVisibility, SearchCompetitionsProfileVisibility.SEARCH_COMPETITIONS_PROFILE_VISIBILITY_ANY, EnumSerializer()),
+  FieldMetadata("earnedMedal", "earned_medal", "_earned_medal", bool, None, PredefinedSerializer(), optional=True),
+]
+
+ApiSearchDatasetsDocument._fields = [
+  FieldMetadata("usabilityRating", "usability_rating", "_usability_rating", float, 0.0, PredefinedSerializer()),
+  FieldMetadata("fileCount", "file_count", "_file_count", int, 0, PredefinedSerializer()),
+  FieldMetadata("fileTypes", "file_types", "_file_types", DatasetFileType, [], ListSerializer(EnumSerializer())),
+  FieldMetadata("size", "size", "_size", int, 0, PredefinedSerializer()),
+]
+
+ApiSearchDatasetsFilters._fields = [
+  FieldMetadata("fileType", "file_type", "_file_type", DatasetFileTypeGroup, DatasetFileTypeGroup.DATASET_FILE_TYPE_GROUP_ALL, EnumSerializer()),
+  FieldMetadata("licenseGroup", "license_group", "_license_group", DatasetLicenseGroup, None, EnumSerializer(), optional=True),
+  FieldMetadata("size", "size", "_size", DatasetSizeGroup, None, EnumSerializer(), optional=True),
+  FieldMetadata("earnedMedal", "earned_medal", "_earned_medal", bool, None, PredefinedSerializer(), optional=True),
+]
+
+ApiSearchDiscussionsDocument._fields = [
+  FieldMetadata("newCommentUrl", "new_comment_url", "_new_comment_url", str, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("messageStripped", "message_stripped", "_message_stripped", str, "", PredefinedSerializer()),
+  FieldMetadata("messageMarkdown", "message_markdown", "_message_markdown", str, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("forumName", "forum_name", "_forum_name", str, "", PredefinedSerializer()),
+  FieldMetadata("forumUrl", "forum_url", "_forum_url", str, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("sourceType", "source_type", "_source_type", SearchDiscussionsSourceType, SearchDiscussionsSourceType.SEARCH_DISCUSSIONS_SOURCE_TYPE_UNSPECIFIED, EnumSerializer()),
+  FieldMetadata("topicType", "topic_type", "_topic_type", SearchDiscussionsTopicType, SearchDiscussionsTopicType.SEARCH_DISCUSSIONS_TOPIC_TYPE_UNSPECIFIED, EnumSerializer()),
+  FieldMetadata("type", "type", "_type", SearchDiscussionsDocumentType, SearchDiscussionsDocumentType.SEARCH_DISCUSSIONS_DOCUMENT_TYPE_UNSPECIFIED, EnumSerializer()),
+  FieldMetadata("writeUpMetadata", "write_up_metadata", "_write_up_metadata", WriteUpItemInfo, None, KaggleObjectSerializer(), optional=True),
+]
+
+ApiSearchDiscussionsFilters._fields = [
+  FieldMetadata("sourceType", "source_type", "_source_type", SearchDiscussionsSourceType, SearchDiscussionsSourceType.SEARCH_DISCUSSIONS_SOURCE_TYPE_UNSPECIFIED, EnumSerializer()),
+  FieldMetadata("onlyNewComments", "only_new_comments", "_only_new_comments", bool, False, PredefinedSerializer()),
+  FieldMetadata("writeUpInclusionType", "write_up_inclusion_type", "_write_up_inclusion_type", WriteUpInclusionType, WriteUpInclusionType.WRITE_UP_INCLUSION_TYPE_UNSPECIFIED, EnumSerializer()),
+  FieldMetadata("writeUpTypes", "write_up_types", "_write_up_types", WriteUpType, [], ListSerializer(EnumSerializer())),
+]
+
+ApiSearchKernelsDocument._fields = [
+  FieldMetadata("sessionId", "session_id", "_session_id", int, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("hasLinkedSubmission", "has_linked_submission", "_has_linked_submission", bool, False, PredefinedSerializer()),
+  FieldMetadata("datasourceIsPrivate", "datasource_is_private", "_datasource_is_private", bool, False, PredefinedSerializer()),
+  FieldMetadata("bestPublicScore", "best_public_score", "_best_public_score", float, 0.0, PredefinedSerializer()),
+  FieldMetadata("isDraft", "is_draft", "_is_draft", bool, False, PredefinedSerializer()),
+]
+
+ApiSearchKernelsFilters._fields = [
+  FieldMetadata("language", "language", "_language", str, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("earnedMedal", "earned_medal", "_earned_medal", bool, None, PredefinedSerializer(), optional=True),
+]
+
+ApiSearchModelsDocument._fields = [
+  FieldMetadata("instanceCount", "instance_count", "_instance_count", int, 0, PredefinedSerializer()),
+  FieldMetadata("notebookCount", "notebook_count", "_notebook_count", int, 0, PredefinedSerializer()),
+]
+
+ApiSearchModelsFilters._fields = [
+  FieldMetadata("size", "size", "_size", ListSearchContentRangeFilter, None, KaggleObjectSerializer()),
+]
+
+ApiSearchUsersDocument._fields = [
+  FieldMetadata("grandmasterTierLevel", "grandmaster_tier_level", "_grandmaster_tier_level", int, 0, PredefinedSerializer()),
+  FieldMetadata("userLocation", "user_location", "_user_location", str, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("occupationOrganizationName", "occupation_organization_name", "_occupation_organization_name", str, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("competitionRanking", "competition_ranking", "_competition_ranking", int, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("competitionPoints", "competition_points", "_competition_points", int, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("kernelRanking", "kernel_ranking", "_kernel_ranking", int, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("kernelPoints", "kernel_points", "_kernel_points", int, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("datasetRanking", "dataset_ranking", "_dataset_ranking", int, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("datasetPoints", "dataset_points", "_dataset_points", int, None, PredefinedSerializer(), optional=True),
+]
+
+ApiSearchUsersFilters._fields = [
+  FieldMetadata("userLocations", "user_locations", "_user_locations", str, [], ListSerializer(PredefinedSerializer())),
+  FieldMetadata("tier", "tier", "_tier", UserAchievementTier, None, EnumSerializer(), optional=True),
+  FieldMetadata("userIds", "user_ids", "_user_ids", int, [], ListSerializer(PredefinedSerializer())),
+  FieldMetadata("requireRankingForType", "require_ranking_for_type", "_require_ranking_for_type", UserAchievementType, None, EnumSerializer(), optional=True),
+  FieldMetadata("occupationOrganizationNames", "occupation_organization_names", "_occupation_organization_names", str, [], ListSerializer(PredefinedSerializer())),
+  FieldMetadata("grandmasterLevel", "grandmaster_level", "_grandmaster_level", ListSearchContentRangeFilter, None, KaggleObjectSerializer()),
+]
+
+ApiUserAvatar._fields = [
+  FieldMetadata("id", "id", "_id", int, 0, PredefinedSerializer()),
+  FieldMetadata("displayName", "display_name", "_display_name", str, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("thumbnailUrl", "thumbnail_url", "_thumbnail_url", str, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("url", "url", "_url", str, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("userName", "user_name", "_user_name", str, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("progressionOptOut", "progression_opt_out", "_progression_opt_out", bool, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("tier", "tier", "_tier", UserAchievementTier, UserAchievementTier.NOVICE, EnumSerializer()),
+]
+
+ListEntitiesDocument._fields = [
+  FieldMetadata("id", "id", "_id", int, 0, PredefinedSerializer()),
+  FieldMetadata("documentType", "document_type", "_document_type", DocumentType, DocumentType.DOCUMENT_TYPE_UNSPECIFIED, EnumSerializer()),
+  FieldMetadata("title", "title", "_title", str, "", PredefinedSerializer()),
+  FieldMetadata("imageUrl", "image_url", "_image_url", str, "", PredefinedSerializer()),
+  FieldMetadata("createTime", "create_time", "_create_time", datetime, None, DateTimeSerializer()),
+  FieldMetadata("updateTime", "update_time", "_update_time", datetime, None, DateTimeSerializer(), optional=True),
+  FieldMetadata("isPrivate", "is_private", "_is_private", bool, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("votes", "votes", "_votes", int, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("ownerUser", "owner_user", "_owner_user", ApiUserAvatar, None, KaggleObjectSerializer(), optional=True),
+  FieldMetadata("ownerOrganization", "owner_organization", "_owner_organization", ApiOrganizationCard, None, KaggleObjectSerializer(), optional=True),
+  FieldMetadata("competitionDocument", "competition_document", "_competition_document", ApiSearchCompetitionsDocument, None, KaggleObjectSerializer(), optional=True),
+  FieldMetadata("datasetDocument", "dataset_document", "_dataset_document", ApiSearchDatasetsDocument, None, KaggleObjectSerializer(), optional=True),
+  FieldMetadata("kernelDocument", "kernel_document", "_kernel_document", ApiSearchKernelsDocument, None, KaggleObjectSerializer(), optional=True),
+  FieldMetadata("modelDocument", "model_document", "_model_document", ApiSearchModelsDocument, None, KaggleObjectSerializer(), optional=True),
+  FieldMetadata("discussionDocument", "discussion_document", "_discussion_document", ApiSearchDiscussionsDocument, None, KaggleObjectSerializer(), optional=True),
+  FieldMetadata("userDocument", "user_document", "_user_document", ApiSearchUsersDocument, None, KaggleObjectSerializer(), optional=True),
+  FieldMetadata("slug", "slug", "_slug", str, None, PredefinedSerializer(), optional=True),
+]
+
+ListEntitiesFilters._fields = [
+  FieldMetadata("query", "query", "_query", str, "", PredefinedSerializer()),
+  FieldMetadata("listType", "list_type", "_list_type", ApiListType, ApiListType.API_LIST_TYPE_UNSPECIFIED, EnumSerializer()),
+  FieldMetadata("privacy", "privacy", "_privacy", PrivacyFilter, PrivacyFilter.ALL, EnumSerializer()),
+  FieldMetadata("ownerType", "owner_type", "_owner_type", OwnerType, OwnerType.OWNER_TYPE_UNSPECIFIED, EnumSerializer()),
+  FieldMetadata("documentTypes", "document_types", "_document_types", DocumentType, [], ListSerializer(EnumSerializer())),
+  FieldMetadata("competitionFilters", "competition_filters", "_competition_filters", ApiSearchCompetitionsFilters, None, KaggleObjectSerializer()),
+  FieldMetadata("datasetFilters", "dataset_filters", "_dataset_filters", ApiSearchDatasetsFilters, None, KaggleObjectSerializer()),
+  FieldMetadata("discussionFilters", "discussion_filters", "_discussion_filters", ApiSearchDiscussionsFilters, None, KaggleObjectSerializer()),
+  FieldMetadata("kernelFilters", "kernel_filters", "_kernel_filters", ApiSearchKernelsFilters, None, KaggleObjectSerializer()),
+  FieldMetadata("modelFilters", "model_filters", "_model_filters", ApiSearchModelsFilters, None, KaggleObjectSerializer()),
+  FieldMetadata("userFilters", "user_filters", "_user_filters", ApiSearchUsersFilters, None, KaggleObjectSerializer()),
+]
+
+ListEntitiesRequest._fields = [
+  FieldMetadata("filters", "filters", "_filters", ListEntitiesFilters, None, KaggleObjectSerializer()),
+  FieldMetadata("canonicalOrderBy", "canonical_order_by", "_canonical_order_by", ListSearchContentOrderBy, None, EnumSerializer(), optional=True),
+  FieldMetadata("competitionsOrderBy", "competitions_order_by", "_competitions_order_by", SearchCompetitionsOrderBy, None, EnumSerializer(), optional=True),
+  FieldMetadata("datasetsOrderBy", "datasets_order_by", "_datasets_order_by", SearchDatasetsOrderBy, None, EnumSerializer(), optional=True),
+  FieldMetadata("kernelsOrderBy", "kernels_order_by", "_kernels_order_by", SearchKernelsOrderBy, None, EnumSerializer(), optional=True),
+  FieldMetadata("modelsOrderBy", "models_order_by", "_models_order_by", SearchModelsOrderBy, None, EnumSerializer(), optional=True),
+  FieldMetadata("discussionsOrderBy", "discussions_order_by", "_discussions_order_by", SearchDiscussionsOrderBy, None, EnumSerializer(), optional=True),
+  FieldMetadata("usersOrderBy", "users_order_by", "_users_order_by", SearchUsersOrderBy, None, EnumSerializer(), optional=True),
+  FieldMetadata("pageToken", "page_token", "_page_token", str, "", PredefinedSerializer()),
+  FieldMetadata("pageSize", "page_size", "_page_size", int, 0, PredefinedSerializer()),
+  FieldMetadata("skip", "skip", "_skip", int, 0, PredefinedSerializer()),
+]
+
+ListEntitiesResponse._fields = [
+  FieldMetadata("documents", "documents", "_documents", ListEntitiesDocument, [], ListSerializer(KaggleObjectSerializer())),
+  FieldMetadata("totalDocuments", "total_documents", "_total_documents", int, 0, PredefinedSerializer()),
+  FieldMetadata("nextPageToken", "next_page_token", "_next_page_token", str, "", PredefinedSerializer()),
+]
+