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

kagglesdk/competitions/types/competition_api_service.py

@@ -4,278 +4,560 @@ from kagglesdk.competitions.types.submission_status import SubmissionStatus
 from kagglesdk.kaggle_object import *
 from typing import Optional, List
 
-class ApiCreateCodeSubmissionRequest(KaggleObject):
+class ApiCategory(KaggleObject):
   r"""
+  TODO(erdalsivri): Consider reusing with Kaggle.Sdk.Datasets.ApiCategory.
+
   Attributes:
-    competition_name (str)
-    kernel_owner (str)
-    kernel_slug (str)
-    kernel_version (int)
-    file_name (str)
-    submission_description (str)
+    ref (str)
+    name (str)
+    description (str)
+    full_path (str)
+    competition_count (int)
+    dataset_count (int)
+    script_count (int)
+    total_count (int)
   """
 
   def __init__(self):
-    self._competition_name = ""
-    self._kernel_owner = ""
-    self._kernel_slug = ""
-    self._kernel_version = None
-    self._file_name = None
-    self._submission_description = None
+    self._ref = ""
+    self._name = None
+    self._description = None
+    self._full_path = None
+    self._competition_count = 0
+    self._dataset_count = 0
+    self._script_count = 0
+    self._total_count = 0
     self._freeze()
 
   @property
-  def competition_name(self) -> str:
-    return self._competition_name
+  def ref(self) -> str:
+    return self._ref
 
-  @competition_name.setter
-  def competition_name(self, competition_name: str):
-    if competition_name is None:
-      del self.competition_name
+  @ref.setter
+  def ref(self, ref: str):
+    if ref is None:
+      del self.ref
       return
-    if not isinstance(competition_name, str):
-      raise TypeError('competition_name must be of type str')
-    self._competition_name = competition_name
+    if not isinstance(ref, str):
+      raise TypeError('ref must be of type str')
+    self._ref = ref
 
   @property
-  def kernel_owner(self) -> str:
-    return self._kernel_owner
+  def name(self) -> str:
+    return self._name or ""
 
-  @kernel_owner.setter
-  def kernel_owner(self, kernel_owner: str):
-    if kernel_owner is None:
-      del self.kernel_owner
+  @name.setter
+  def name(self, name: Optional[str]):
+    if name is None:
+      del self.name
       return
-    if not isinstance(kernel_owner, str):
-      raise TypeError('kernel_owner must be of type str')
-    self._kernel_owner = kernel_owner
+    if not isinstance(name, str):
+      raise TypeError('name must be of type str')
+    self._name = name
 
   @property
-  def kernel_slug(self) -> str:
-    return self._kernel_slug
+  def description(self) -> str:
+    return self._description or ""
 
-  @kernel_slug.setter
-  def kernel_slug(self, kernel_slug: str):
-    if kernel_slug is None:
-      del self.kernel_slug
+  @description.setter
+  def description(self, description: Optional[str]):
+    if description is None:
+      del self.description
       return
-    if not isinstance(kernel_slug, str):
-      raise TypeError('kernel_slug must be of type str')
-    self._kernel_slug = kernel_slug
+    if not isinstance(description, str):
+      raise TypeError('description must be of type str')
+    self._description = description
 
   @property
-  def kernel_version(self) -> int:
-    return self._kernel_version or 0
+  def full_path(self) -> str:
+    return self._full_path or ""
 
-  @kernel_version.setter
-  def kernel_version(self, kernel_version: int):
-    if kernel_version is None:
-      del self.kernel_version
+  @full_path.setter
+  def full_path(self, full_path: Optional[str]):
+    if full_path is None:
+      del self.full_path
       return
-    if not isinstance(kernel_version, int):
-      raise TypeError('kernel_version must be of type int')
-    self._kernel_version = kernel_version
+    if not isinstance(full_path, str):
+      raise TypeError('full_path must be of type str')
+    self._full_path = full_path
 
   @property
-  def file_name(self) -> str:
-    return self._file_name or ""
+  def competition_count(self) -> int:
+    return self._competition_count
 
-  @file_name.setter
-  def file_name(self, file_name: str):
-    if file_name is None:
-      del self.file_name
+  @competition_count.setter
+  def competition_count(self, competition_count: int):
+    if competition_count is None:
+      del self.competition_count
       return
-    if not isinstance(file_name, str):
-      raise TypeError('file_name must be of type str')
-    self._file_name = file_name
+    if not isinstance(competition_count, int):
+      raise TypeError('competition_count must be of type int')
+    self._competition_count = competition_count
 
   @property
-  def submission_description(self) -> str:
-    return self._submission_description or ""
+  def dataset_count(self) -> int:
+    return self._dataset_count
 
-  @submission_description.setter
-  def submission_description(self, submission_description: str):
-    if submission_description is None:
-      del self.submission_description
+  @dataset_count.setter
+  def dataset_count(self, dataset_count: int):
+    if dataset_count is None:
+      del self.dataset_count
       return
-    if not isinstance(submission_description, str):
-      raise TypeError('submission_description must be of type str')
-    self._submission_description = submission_description
+    if not isinstance(dataset_count, int):
+      raise TypeError('dataset_count must be of type int')
+    self._dataset_count = dataset_count
 
-  def endpoint(self):
-    path = '/api/v1/competitions/submissions/submit-notebook/{competition_name}'
-    return path.format_map(self.to_field_map(self))
+  @property
+  def script_count(self) -> int:
+    return self._script_count
+
+  @script_count.setter
+  def script_count(self, script_count: int):
+    if script_count is None:
+      del self.script_count
+      return
+    if not isinstance(script_count, int):
+      raise TypeError('script_count must be of type int')
+    self._script_count = script_count
 
+  @property
+  def total_count(self) -> int:
+    return self._total_count
 
-  @staticmethod
-  def method():
-    return 'POST'
+  @total_count.setter
+  def total_count(self, total_count: int):
+    if total_count is None:
+      del self.total_count
+      return
+    if not isinstance(total_count, int):
+      raise TypeError('total_count must be of type int')
+    self._total_count = total_count
 
 
-class ApiCreateCodeSubmissionResponse(KaggleObject):
+class ApiCompetition(KaggleObject):
   r"""
   Attributes:
-    message (str)
-    ref (int)
+    id (int)
+    ref (str)
+    title (str)
+    url (str)
+    description (str)
+    organization_name (str)
+    organization_ref (str)
+    category (str)
+    reward (str)
+    tags (ApiCategory)
+    deadline (datetime)
+    kernel_count (int)
+    team_count (int)
+    user_has_entered (bool)
+    user_rank (int)
+    merger_deadline (datetime)
+    new_entrant_deadline (datetime)
+    enabled_date (datetime)
+    max_daily_submissions (int)
+    max_team_size (int)
+    evaluation_metric (str)
+    awards_points (bool)
+    is_kernels_submissions_only (bool)
+    submissions_disabled (bool)
+    thumbnail_image_url (str)
+    host_name (str)
   """
 
   def __init__(self):
-    self._message = ""
-    self._ref = 0
+    self._id = 0
+    self._ref = ""
+    self._title = None
+    self._url = None
+    self._description = None
+    self._organization_name = None
+    self._organization_ref = None
+    self._category = None
+    self._reward = None
+    self._tags = []
+    self._deadline = None
+    self._kernel_count = 0
+    self._team_count = 0
+    self._user_has_entered = False
+    self._user_rank = None
+    self._merger_deadline = None
+    self._new_entrant_deadline = None
+    self._enabled_date = None
+    self._max_daily_submissions = 0
+    self._max_team_size = None
+    self._evaluation_metric = None
+    self._awards_points = False
+    self._is_kernels_submissions_only = False
+    self._submissions_disabled = False
+    self._thumbnail_image_url = None
+    self._host_name = ""
     self._freeze()
 
   @property
-  def message(self) -> str:
-    return self._message
+  def id(self) -> int:
+    return self._id
 
-  @message.setter
-  def message(self, message: str):
-    if message is None:
-      del self.message
+  @id.setter
+  def id(self, id: int):
+    if id is None:
+      del self.id
       return
-    if not isinstance(message, str):
-      raise TypeError('message must be of type str')
-    self._message = message
+    if not isinstance(id, int):
+      raise TypeError('id must be of type int')
+    self._id = id
 
   @property
-  def ref(self) -> int:
+  def ref(self) -> str:
     return self._ref
 
   @ref.setter
-  def ref(self, ref: int):
+  def ref(self, ref: str):
     if ref is None:
       del self.ref
       return
-    if not isinstance(ref, int):
-      raise TypeError('ref must be of type int')
+    if not isinstance(ref, str):
+      raise TypeError('ref must be of type str')
     self._ref = ref
 
+  @property
+  def title(self) -> str:
+    return self._title or ""
 
-class ApiCreateSubmissionRequest(KaggleObject):
-  r"""
-  Attributes:
-    competition_name (str)
-      Competition name. Example: 'titanic'.
-    blob_file_tokens (str)
-      Token identifying location of uploaded submission file.
-    submission_description (str)
-      Description of competition submission.
-  """
+  @title.setter
+  def title(self, title: Optional[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
 
-  def __init__(self):
-    self._competition_name = ""
-    self._blob_file_tokens = ""
-    self._submission_description = None
-    self._freeze()
+  @property
+  def url(self) -> str:
+    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 competition_name(self) -> str:
-    """Competition name. Example: 'titanic'."""
-    return self._competition_name
+  def description(self) -> str:
+    return self._description or ""
 
-  @competition_name.setter
-  def competition_name(self, competition_name: str):
-    if competition_name is None:
-      del self.competition_name
+  @description.setter
+  def description(self, description: Optional[str]):
+    if description is None:
+      del self.description
       return
-    if not isinstance(competition_name, str):
-      raise TypeError('competition_name must be of type str')
-    self._competition_name = competition_name
+    if not isinstance(description, str):
+      raise TypeError('description must be of type str')
+    self._description = description
 
   @property
-  def blob_file_tokens(self) -> str:
-    """Token identifying location of uploaded submission file."""
-    return self._blob_file_tokens
+  def organization_name(self) -> str:
+    return self._organization_name or ""
 
-  @blob_file_tokens.setter
-  def blob_file_tokens(self, blob_file_tokens: str):
-    if blob_file_tokens is None:
-      del self.blob_file_tokens
+  @organization_name.setter
+  def organization_name(self, organization_name: Optional[str]):
+    if organization_name is None:
+      del self.organization_name
       return
-    if not isinstance(blob_file_tokens, str):
-      raise TypeError('blob_file_tokens must be of type str')
-    self._blob_file_tokens = blob_file_tokens
+    if not isinstance(organization_name, str):
+      raise TypeError('organization_name must be of type str')
+    self._organization_name = organization_name
 
   @property
-  def submission_description(self) -> str:
-    """Description of competition submission."""
-    return self._submission_description or ""
+  def organization_ref(self) -> str:
+    return self._organization_ref or ""
 
-  @submission_description.setter
-  def submission_description(self, submission_description: str):
-    if submission_description is None:
-      del self.submission_description
+  @organization_ref.setter
+  def organization_ref(self, organization_ref: Optional[str]):
+    if organization_ref is None:
+      del self.organization_ref
       return
-    if not isinstance(submission_description, str):
-      raise TypeError('submission_description must be of type str')
-    self._submission_description = submission_description
+    if not isinstance(organization_ref, str):
+      raise TypeError('organization_ref must be of type str')
+    self._organization_ref = organization_ref
 
-  def endpoint(self):
-    path = '/api/v1/competitions/submissions/submit/{competition_name}'
-    return path.format_map(self.to_field_map(self))
+  @property
+  def category(self) -> str:
+    return self._category or ""
 
+  @category.setter
+  def category(self, category: Optional[str]):
+    if category is None:
+      del self.category
+      return
+    if not isinstance(category, str):
+      raise TypeError('category must be of type str')
+    self._category = category
 
-  @staticmethod
-  def method():
-    return 'POST'
+  @property
+  def reward(self) -> str:
+    return self._reward or ""
 
+  @reward.setter
+  def reward(self, reward: Optional[str]):
+    if reward is None:
+      del self.reward
+      return
+    if not isinstance(reward, str):
+      raise TypeError('reward must be of type str')
+    self._reward = reward
 
-class ApiCreateSubmissionResponse(KaggleObject):
-  r"""
-  Attributes:
-    message (str)
-    ref (int)
-  """
+  @property
+  def tags(self) -> Optional[List[Optional['ApiCategory']]]:
+    return self._tags
 
-  def __init__(self):
-    self._message = ""
-    self._ref = 0
-    self._freeze()
+  @tags.setter
+  def tags(self, tags: Optional[List[Optional['ApiCategory']]]):
+    if tags is None:
+      del self.tags
+      return
+    if not isinstance(tags, list):
+      raise TypeError('tags must be of type list')
+    if not all([isinstance(t, ApiCategory) for t in tags]):
+      raise TypeError('tags must contain only items of type ApiCategory')
+    self._tags = tags
 
   @property
-  def message(self) -> str:
-    return self._message
+  def deadline(self) -> datetime:
+    return self._deadline
 
-  @message.setter
-  def message(self, message: str):
-    if message is None:
-      del self.message
+  @deadline.setter
+  def deadline(self, deadline: datetime):
+    if deadline is None:
+      del self.deadline
       return
-    if not isinstance(message, str):
-      raise TypeError('message must be of type str')
-    self._message = message
+    if not isinstance(deadline, datetime):
+      raise TypeError('deadline must be of type datetime')
+    self._deadline = deadline
 
   @property
-  def ref(self) -> int:
-    return self._ref
+  def kernel_count(self) -> int:
+    return self._kernel_count
 
-  @ref.setter
-  def ref(self, ref: int):
-    if ref is None:
-      del self.ref
+  @kernel_count.setter
+  def kernel_count(self, kernel_count: int):
+    if kernel_count is None:
+      del self.kernel_count
       return
-    if not isinstance(ref, int):
-      raise TypeError('ref must be of type int')
-    self._ref = ref
+    if not isinstance(kernel_count, int):
+      raise TypeError('kernel_count must be of type int')
+    self._kernel_count = kernel_count
 
+  @property
+  def team_count(self) -> int:
+    return self._team_count
 
-class ApiDownloadDataFileRequest(KaggleObject):
+  @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 user_has_entered(self) -> bool:
+    return self._user_has_entered
+
+  @user_has_entered.setter
+  def user_has_entered(self, user_has_entered: bool):
+    if user_has_entered is None:
+      del self.user_has_entered
+      return
+    if not isinstance(user_has_entered, bool):
+      raise TypeError('user_has_entered must be of type bool')
+    self._user_has_entered = user_has_entered
+
+  @property
+  def user_rank(self) -> int:
+    return self._user_rank or 0
+
+  @user_rank.setter
+  def user_rank(self, user_rank: Optional[int]):
+    if user_rank is None:
+      del self.user_rank
+      return
+    if not isinstance(user_rank, int):
+      raise TypeError('user_rank must be of type int')
+    self._user_rank = user_rank
+
+  @property
+  def merger_deadline(self) -> datetime:
+    return self._merger_deadline
+
+  @merger_deadline.setter
+  def merger_deadline(self, merger_deadline: datetime):
+    if merger_deadline is None:
+      del self.merger_deadline
+      return
+    if not isinstance(merger_deadline, datetime):
+      raise TypeError('merger_deadline must be of type datetime')
+    self._merger_deadline = merger_deadline
+
+  @property
+  def new_entrant_deadline(self) -> datetime:
+    return self._new_entrant_deadline
+
+  @new_entrant_deadline.setter
+  def new_entrant_deadline(self, new_entrant_deadline: datetime):
+    if new_entrant_deadline is None:
+      del self.new_entrant_deadline
+      return
+    if not isinstance(new_entrant_deadline, datetime):
+      raise TypeError('new_entrant_deadline must be of type datetime')
+    self._new_entrant_deadline = new_entrant_deadline
+
+  @property
+  def enabled_date(self) -> datetime:
+    return self._enabled_date
+
+  @enabled_date.setter
+  def enabled_date(self, enabled_date: datetime):
+    if enabled_date is None:
+      del self.enabled_date
+      return
+    if not isinstance(enabled_date, datetime):
+      raise TypeError('enabled_date must be of type datetime')
+    self._enabled_date = enabled_date
+
+  @property
+  def max_daily_submissions(self) -> int:
+    return self._max_daily_submissions
+
+  @max_daily_submissions.setter
+  def max_daily_submissions(self, max_daily_submissions: int):
+    if max_daily_submissions is None:
+      del self.max_daily_submissions
+      return
+    if not isinstance(max_daily_submissions, int):
+      raise TypeError('max_daily_submissions must be of type int')
+    self._max_daily_submissions = max_daily_submissions
+
+  @property
+  def max_team_size(self) -> int:
+    return self._max_team_size or 0
+
+  @max_team_size.setter
+  def max_team_size(self, max_team_size: Optional[int]):
+    if max_team_size is None:
+      del self.max_team_size
+      return
+    if not isinstance(max_team_size, int):
+      raise TypeError('max_team_size must be of type int')
+    self._max_team_size = max_team_size
+
+  @property
+  def evaluation_metric(self) -> str:
+    return self._evaluation_metric or ""
+
+  @evaluation_metric.setter
+  def evaluation_metric(self, evaluation_metric: Optional[str]):
+    if evaluation_metric is None:
+      del self.evaluation_metric
+      return
+    if not isinstance(evaluation_metric, str):
+      raise TypeError('evaluation_metric must be of type str')
+    self._evaluation_metric = evaluation_metric
+
+  @property
+  def awards_points(self) -> bool:
+    return self._awards_points
+
+  @awards_points.setter
+  def awards_points(self, awards_points: bool):
+    if awards_points is None:
+      del self.awards_points
+      return
+    if not isinstance(awards_points, bool):
+      raise TypeError('awards_points must be of type bool')
+    self._awards_points = awards_points
+
+  @property
+  def is_kernels_submissions_only(self) -> bool:
+    return self._is_kernels_submissions_only
+
+  @is_kernels_submissions_only.setter
+  def is_kernels_submissions_only(self, is_kernels_submissions_only: bool):
+    if is_kernels_submissions_only is None:
+      del self.is_kernels_submissions_only
+      return
+    if not isinstance(is_kernels_submissions_only, bool):
+      raise TypeError('is_kernels_submissions_only must be of type bool')
+    self._is_kernels_submissions_only = is_kernels_submissions_only
+
+  @property
+  def submissions_disabled(self) -> bool:
+    return self._submissions_disabled
+
+  @submissions_disabled.setter
+  def submissions_disabled(self, submissions_disabled: bool):
+    if submissions_disabled is None:
+      del self.submissions_disabled
+      return
+    if not isinstance(submissions_disabled, bool):
+      raise TypeError('submissions_disabled must be of type bool')
+    self._submissions_disabled = submissions_disabled
+
+  @property
+  def thumbnail_image_url(self) -> str:
+    return self._thumbnail_image_url or ""
+
+  @thumbnail_image_url.setter
+  def thumbnail_image_url(self, thumbnail_image_url: Optional[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 host_name(self) -> str:
+    return self._host_name
+
+  @host_name.setter
+  def host_name(self, host_name: str):
+    if host_name is None:
+      del self.host_name
+      return
+    if not isinstance(host_name, str):
+      raise TypeError('host_name must be of type str')
+    self._host_name = host_name
+
+
+class ApiCreateCodeSubmissionRequest(KaggleObject):
   r"""
   Attributes:
     competition_name (str)
-      Competition name. Example: 'titanic'.
+    kernel_owner (str)
+    kernel_slug (str)
+    kernel_version (int)
     file_name (str)
-      Name of the file to download. Example: 'train/foo/bar.png'.
+    submission_description (str)
   """
 
   def __init__(self):
     self._competition_name = ""
-    self._file_name = ""
+    self._kernel_owner = ""
+    self._kernel_slug = ""
+    self._kernel_version = None
+    self._file_name = None
+    self._submission_description = None
     self._freeze()
 
   @property
   def competition_name(self) -> str:
-    """Competition name. Example: 'titanic'."""
     return self._competition_name
 
   @competition_name.setter
@@ -287,13 +569,51 @@ class ApiDownloadDataFileRequest(KaggleObject):
       raise TypeError('competition_name must be of type str')
     self._competition_name = competition_name
 
+  @property
+  def kernel_owner(self) -> str:
+    return self._kernel_owner
+
+  @kernel_owner.setter
+  def kernel_owner(self, kernel_owner: str):
+    if kernel_owner is None:
+      del self.kernel_owner
+      return
+    if not isinstance(kernel_owner, str):
+      raise TypeError('kernel_owner must be of type str')
+    self._kernel_owner = kernel_owner
+
+  @property
+  def kernel_slug(self) -> str:
+    return self._kernel_slug
+
+  @kernel_slug.setter
+  def kernel_slug(self, kernel_slug: str):
+    if kernel_slug is None:
+      del self.kernel_slug
+      return
+    if not isinstance(kernel_slug, str):
+      raise TypeError('kernel_slug must be of type str')
+    self._kernel_slug = kernel_slug
+
+  @property
+  def kernel_version(self) -> int:
+    return self._kernel_version or 0
+
+  @kernel_version.setter
+  def kernel_version(self, kernel_version: Optional[int]):
+    if kernel_version is None:
+      del self.kernel_version
+      return
+    if not isinstance(kernel_version, int):
+      raise TypeError('kernel_version must be of type int')
+    self._kernel_version = kernel_version
+
   @property
   def file_name(self) -> str:
-    """Name of the file to download. Example: 'train/foo/bar.png'."""
-    return self._file_name
+    return self._file_name or ""
 
   @file_name.setter
-  def file_name(self, file_name: str):
+  def file_name(self, file_name: Optional[str]):
     if file_name is None:
       del self.file_name
       return
@@ -301,95 +621,83 @@ class ApiDownloadDataFileRequest(KaggleObject):
       raise TypeError('file_name must be of type str')
     self._file_name = file_name
 
-  def endpoint(self):
-    path = '/api/v1/competitions/data/download/{competition_name}/{file_name}'
-    return path.format_map(self.to_field_map(self))
-
-  @staticmethod
-  def endpoint_path():
-    return '/api/v1/competitions/data/download/{competition_name}/{file_name}'
-
-
-class ApiDownloadDataFilesRequest(KaggleObject):
-  r"""
-  Attributes:
-    competition_name (str)
-      Competition name. Example: 'titanic'.
-  """
-
-  def __init__(self):
-    self._competition_name = ""
-    self._freeze()
-
   @property
-  def competition_name(self) -> str:
-    """Competition name. Example: 'titanic'."""
-    return self._competition_name
+  def submission_description(self) -> str:
+    return self._submission_description or ""
 
-  @competition_name.setter
-  def competition_name(self, competition_name: str):
-    if competition_name is None:
-      del self.competition_name
+  @submission_description.setter
+  def submission_description(self, submission_description: Optional[str]):
+    if submission_description is None:
+      del self.submission_description
       return
-    if not isinstance(competition_name, str):
-      raise TypeError('competition_name must be of type str')
-    self._competition_name = competition_name
+    if not isinstance(submission_description, str):
+      raise TypeError('submission_description must be of type str')
+    self._submission_description = submission_description
 
   def endpoint(self):
-    path = '/api/v1/competitions/data/download-all/{competition_name}'
+    path = '/api/v1/competitions/submissions/submit-notebook/{competition_name}'
     return path.format_map(self.to_field_map(self))
 
+
   @staticmethod
-  def endpoint_path():
-    return '/api/v1/competitions/data/download-all/{competition_name}'
+  def method():
+    return 'POST'
 
 
-class ApiDownloadLeaderboardRequest(KaggleObject):
+class ApiCreateCodeSubmissionResponse(KaggleObject):
   r"""
   Attributes:
-    competition_name (str)
+    message (str)
+    ref (int)
   """
 
   def __init__(self):
-    self._competition_name = ""
+    self._message = ""
+    self._ref = 0
     self._freeze()
 
   @property
-  def competition_name(self) -> str:
-    return self._competition_name
+  def message(self) -> str:
+    return self._message
 
-  @competition_name.setter
-  def competition_name(self, competition_name: str):
-    if competition_name is None:
-      del self.competition_name
+  @message.setter
+  def message(self, message: str):
+    if message is None:
+      del self.message
       return
-    if not isinstance(competition_name, str):
-      raise TypeError('competition_name must be of type str')
-    self._competition_name = competition_name
+    if not isinstance(message, str):
+      raise TypeError('message must be of type str')
+    self._message = message
 
-  def endpoint(self):
-    path = '/api/v1/competitions/{competition_name}/leaderboard/download'
-    return path.format_map(self.to_field_map(self))
+  @property
+  def ref(self) -> int:
+    return self._ref
 
-  @staticmethod
-  def endpoint_path():
-    return '/api/v1/competitions/{competition_name}/leaderboard/download'
+  @ref.setter
+  def ref(self, ref: int):
+    if ref is None:
+      del self.ref
+      return
+    if not isinstance(ref, int):
+      raise TypeError('ref must be of type int')
+    self._ref = ref
 
 
-class ApiGetLeaderboardRequest(KaggleObject):
+class ApiCreateSubmissionRequest(KaggleObject):
   r"""
   Attributes:
     competition_name (str)
       Competition name. Example: 'titanic'.
-    override_public (bool)
-      By default we return the private leaderboard if it's available, otherwise
-      the public LB. This flag lets you override to get public even if private
-      is available.
+    blob_file_tokens (str)
+      Token identifying location of uploaded submission file.
+    submission_description (str)
+      Description of competition submission.
   """
 
   def __init__(self):
     self._competition_name = ""
-    self._override_public = None
+    self._blob_file_tokens = ""
+    self._submission_description = None
     self._freeze()
 
   @property
@@ -407,72 +715,70 @@ class ApiGetLeaderboardRequest(KaggleObject):
     self._competition_name = competition_name
 
   @property
-  def override_public(self) -> bool:
-    r"""
-    By default we return the private leaderboard if it's available, otherwise
-    the public LB. This flag lets you override to get public even if private
-    is available.
-    """
-    return self._override_public or False
+  def blob_file_tokens(self) -> str:
+    """Token identifying location of uploaded submission file."""
+    return self._blob_file_tokens
 
-  @override_public.setter
-  def override_public(self, override_public: bool):
-    if override_public is None:
-      del self.override_public
+  @blob_file_tokens.setter
+  def blob_file_tokens(self, blob_file_tokens: str):
+    if blob_file_tokens is None:
+      del self.blob_file_tokens
       return
-    if not isinstance(override_public, bool):
-      raise TypeError('override_public must be of type bool')
-    self._override_public = override_public
+    if not isinstance(blob_file_tokens, str):
+      raise TypeError('blob_file_tokens must be of type str')
+    self._blob_file_tokens = blob_file_tokens
+
+  @property
+  def submission_description(self) -> str:
+    """Description of competition submission."""
+    return self._submission_description or ""
+
+  @submission_description.setter
+  def submission_description(self, submission_description: Optional[str]):
+    if submission_description is None:
+      del self.submission_description
+      return
+    if not isinstance(submission_description, str):
+      raise TypeError('submission_description must be of type str')
+    self._submission_description = submission_description
 
   def endpoint(self):
-    path = '/api/v1/competitions/{competition_name}/leaderboard/view'
+    path = '/api/v1/competitions/submissions/submit/{competition_name}'
     return path.format_map(self.to_field_map(self))
 
+
   @staticmethod
-  def endpoint_path():
-    return '/api/v1/competitions/{competition_name}/leaderboard/view'
+  def method():
+    return 'POST'
 
 
-class ApiGetLeaderboardResponse(KaggleObject):
+class ApiCreateSubmissionResponse(KaggleObject):
   r"""
   Attributes:
-    submissions (ApiLeaderboardSubmission)
+    message (str)
+    ref (int)
   """
 
   def __init__(self):
-    self._submissions = []
+    self._message = ""
+    self._ref = 0
     self._freeze()
 
   @property
-  def submissions(self) -> Optional[List[Optional['ApiLeaderboardSubmission']]]:
-    return self._submissions
+  def message(self) -> str:
+    return self._message
 
-  @submissions.setter
-  def submissions(self, submissions: Optional[List[Optional['ApiLeaderboardSubmission']]]):
-    if submissions is None:
-      del self.submissions
+  @message.setter
+  def message(self, message: str):
+    if message is None:
+      del self.message
       return
-    if not isinstance(submissions, list):
-      raise TypeError('submissions must be of type list')
-    if not all([isinstance(t, ApiLeaderboardSubmission) for t in submissions]):
-      raise TypeError('submissions must contain only items of type ApiLeaderboardSubmission')
-    self._submissions = submissions
-
-
-class ApiGetSubmissionRequest(KaggleObject):
-  r"""
-  Attributes:
-    ref (int)
-      SubmissionId.
-  """
-
-  def __init__(self):
-    self._ref = 0
-    self._freeze()
+    if not isinstance(message, str):
+      raise TypeError('message must be of type str')
+    self._message = message
 
   @property
   def ref(self) -> int:
-    """SubmissionId."""
     return self._ref
 
   @ref.setter
@@ -484,242 +790,118 @@ class ApiGetSubmissionRequest(KaggleObject):
       raise TypeError('ref must be of type int')
     self._ref = ref
 
-  def endpoint(self):
-    path = '/api/v1/competitions/submissions/get/{ref}'
-    return path.format_map(self.to_field_map(self))
-
-
-  @staticmethod
-  def method():
-    return 'POST'
-
-
-class ApiLeaderboardSubmission(KaggleObject):
-  r"""
-  Attributes:
-    team_id (int)
-    team_name (str)
-    submission_date (datetime)
-    score (str)
-  """
-
-  def __init__(self):
-    self._team_id = 0
-    self._team_name = None
-    self._submission_date = None
-    self._score = None
-    self._freeze()
-
-  @property
-  def team_id(self) -> int:
-    return self._team_id
-
-  @team_id.setter
-  def team_id(self, team_id: int):
-    if team_id is None:
-      del self.team_id
-      return
-    if not isinstance(team_id, int):
-      raise TypeError('team_id must be of type int')
-    self._team_id = team_id
-
-  @property
-  def team_name(self) -> str:
-    return self._team_name or ""
-
-  @team_name.setter
-  def team_name(self, team_name: str):
-    if team_name is None:
-      del self.team_name
-      return
-    if not isinstance(team_name, str):
-      raise TypeError('team_name must be of type str')
-    self._team_name = team_name
-
-  @property
-  def submission_date(self) -> datetime:
-    return self._submission_date
-
-  @submission_date.setter
-  def submission_date(self, submission_date: datetime):
-    if submission_date is None:
-      del self.submission_date
-      return
-    if not isinstance(submission_date, datetime):
-      raise TypeError('submission_date must be of type datetime')
-    self._submission_date = submission_date
-
-  @property
-  def score(self) -> str:
-    return self._score or ""
-
-  @score.setter
-  def score(self, score: str):
-    if score is None:
-      del self.score
-      return
-    if not isinstance(score, str):
-      raise TypeError('score must be of type str')
-    self._score = score
-
 
-class ApiListCompetitionsRequest(KaggleObject):
+class ApiDataFile(KaggleObject):
   r"""
   Attributes:
-    group (CompetitionListTab)
-      Filter competitions by a particular group (default is 'general').
-      One of 'general', 'entered' and 'inClass'.
-    category (HostSegment)
-      Filter competitions by a particular category (default is 'all').
-      One of 'all', 'featured', 'research', 'recruitment', 'gettingStarted',
-      'masters', 'playground'.
-    sort_by (CompetitionSortBy)
-      Sort the results (default is 'latestDeadline').
-      One of 'grouped', 'prize', 'earliestDeadline', 'latestDeadline',
-      'numberOfTeams', 'recentlyCreated'.
-    search (str)
-      Filter competitions by search terms.
-    page (int)
-      Page number (default is 1).
+    ref (str)
+    name (str)
+    description (str)
+    total_bytes (int)
+    url (str)
+    creation_date (datetime)
   """
 
   def __init__(self):
-    self._group = None
-    self._category = None
-    self._sort_by = None
-    self._search = None
-    self._page = None
+    self._ref = ""
+    self._name = None
+    self._description = None
+    self._total_bytes = 0
+    self._url = None
+    self._creation_date = None
     self._freeze()
 
   @property
-  def group(self) -> 'CompetitionListTab':
-    r"""
-    Filter competitions by a particular group (default is 'general').
-    One of 'general', 'entered' and 'inClass'.
-    """
-    return self._group or CompetitionListTab.COMPETITION_LIST_TAB_GENERAL
-
-  @group.setter
-  def group(self, group: 'CompetitionListTab'):
-    if group is None:
-      del self.group
-      return
-    if not isinstance(group, CompetitionListTab):
-      raise TypeError('group must be of type CompetitionListTab')
-    self._group = group
-
-  @property
-  def category(self) -> 'HostSegment':
-    r"""
-    Filter competitions by a particular category (default is 'all').
-    One of 'all', 'featured', 'research', 'recruitment', 'gettingStarted',
-    'masters', 'playground'.
-    """
-    return self._category or HostSegment.HOST_SEGMENT_UNSPECIFIED
+  def ref(self) -> str:
+    return self._ref
 
-  @category.setter
-  def category(self, category: 'HostSegment'):
-    if category is None:
-      del self.category
+  @ref.setter
+  def ref(self, ref: str):
+    if ref is None:
+      del self.ref
       return
-    if not isinstance(category, HostSegment):
-      raise TypeError('category must be of type HostSegment')
-    self._category = category
+    if not isinstance(ref, str):
+      raise TypeError('ref must be of type str')
+    self._ref = ref
 
   @property
-  def sort_by(self) -> 'CompetitionSortBy':
-    r"""
-    Sort the results (default is 'latestDeadline').
-    One of 'grouped', 'prize', 'earliestDeadline', 'latestDeadline',
-    'numberOfTeams', 'recentlyCreated'.
-    """
-    return self._sort_by or CompetitionSortBy.COMPETITION_SORT_BY_GROUPED
+  def name(self) -> str:
+    return self._name or ""
 
-  @sort_by.setter
-  def sort_by(self, sort_by: 'CompetitionSortBy'):
-    if sort_by is None:
-      del self.sort_by
+  @name.setter
+  def name(self, name: Optional[str]):
+    if name is None:
+      del self.name
       return
-    if not isinstance(sort_by, CompetitionSortBy):
-      raise TypeError('sort_by must be of type CompetitionSortBy')
-    self._sort_by = sort_by
+    if not isinstance(name, str):
+      raise TypeError('name must be of type str')
+    self._name = name
 
   @property
-  def search(self) -> str:
-    """Filter competitions by search terms."""
-    return self._search or ""
+  def description(self) -> str:
+    return self._description or ""
 
-  @search.setter
-  def search(self, search: str):
-    if search is None:
-      del self.search
+  @description.setter
+  def description(self, description: Optional[str]):
+    if description is None:
+      del self.description
       return
-    if not isinstance(search, str):
-      raise TypeError('search must be of type str')
-    self._search = search
+    if not isinstance(description, str):
+      raise TypeError('description must be of type str')
+    self._description = description
 
   @property
-  def page(self) -> int:
-    """Page number (default is 1)."""
-    return self._page or 0
+  def total_bytes(self) -> int:
+    return self._total_bytes
 
-  @page.setter
-  def page(self, page: int):
-    if page is None:
-      del self.page
+  @total_bytes.setter
+  def total_bytes(self, total_bytes: int):
+    if total_bytes is None:
+      del self.total_bytes
       return
-    if not isinstance(page, int):
-      raise TypeError('page must be of type int')
-    self._page = page
-
-  def endpoint(self):
-    path = '/api/v1/competitions/list'
-    return path.format_map(self.to_field_map(self))
-
+    if not isinstance(total_bytes, int):
+      raise TypeError('total_bytes must be of type int')
+    self._total_bytes = total_bytes
 
-class ApiListCompetitionsResponse(KaggleObject):
-  r"""
-  Attributes:
-    competitions (ApiCompetition)
-  """
+  @property
+  def url(self) -> str:
+    return self._url or ""
 
-  def __init__(self):
-    self._competitions = []
-    self._freeze()
+  @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 competitions(self) -> Optional[List[Optional['ApiCompetition']]]:
-    return self._competitions
+  def creation_date(self) -> datetime:
+    return self._creation_date
 
-  @competitions.setter
-  def competitions(self, competitions: Optional[List[Optional['ApiCompetition']]]):
-    if competitions is None:
-      del self.competitions
+  @creation_date.setter
+  def creation_date(self, creation_date: datetime):
+    if creation_date is None:
+      del self.creation_date
       return
-    if not isinstance(competitions, list):
-      raise TypeError('competitions must be of type list')
-    if not all([isinstance(t, ApiCompetition) for t in competitions]):
-      raise TypeError('competitions must contain only items of type ApiCompetition')
-    self._competitions = competitions
-
-  @classmethod
-  def prepare_from(cls, http_response):
-    return cls.from_dict({'competitions': json.loads(http_response.text)})
+    if not isinstance(creation_date, datetime):
+      raise TypeError('creation_date must be of type datetime')
+    self._creation_date = creation_date
 
 
-class ApiListDataFilesRequest(KaggleObject):
+class ApiDownloadDataFileRequest(KaggleObject):
   r"""
   Attributes:
     competition_name (str)
       Competition name. Example: 'titanic'.
-    page_size (int)
-    page_token (str)
+    file_name (str)
+      Name of the file to download. Example: 'train/foo/bar.png'.
   """
 
   def __init__(self):
     self._competition_name = ""
-    self._page_size = None
-    self._page_token = None
+    self._file_name = ""
     self._freeze()
 
   @property
@@ -737,99 +919,70 @@ class ApiListDataFilesRequest(KaggleObject):
     self._competition_name = competition_name
 
   @property
-  def page_size(self) -> int:
-    return self._page_size or 0
-
-  @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 page_token(self) -> str:
-    return self._page_token or ""
+  def file_name(self) -> str:
+    """Name of the file to download. Example: 'train/foo/bar.png'."""
+    return self._file_name
 
-  @page_token.setter
-  def page_token(self, page_token: str):
-    if page_token is None:
-      del self.page_token
+  @file_name.setter
+  def file_name(self, file_name: str):
+    if file_name is None:
+      del self.file_name
       return
-    if not isinstance(page_token, str):
-      raise TypeError('page_token must be of type str')
-    self._page_token = page_token
+    if not isinstance(file_name, str):
+      raise TypeError('file_name must be of type str')
+    self._file_name = file_name
 
   def endpoint(self):
-    path = '/api/v1/competitions/data/list/{competition_name}'
+    path = '/api/v1/competitions/data/download/{competition_name}/{file_name}'
     return path.format_map(self.to_field_map(self))
 
   @staticmethod
   def endpoint_path():
-    return '/api/v1/competitions/data/list/{competition_name}'
+    return '/api/v1/competitions/data/download/{competition_name}/{file_name}'
 
 
-class ApiListDataFilesResponse(KaggleObject):
+class ApiDownloadDataFilesRequest(KaggleObject):
   r"""
   Attributes:
-    files (ApiDataFile)
-    next_page_token (str)
+    competition_name (str)
+      Competition name. Example: 'titanic'.
   """
 
   def __init__(self):
-    self._files = []
-    self._next_page_token = ""
+    self._competition_name = ""
     self._freeze()
 
   @property
-  def files(self) -> Optional[List[Optional['ApiDataFile']]]:
-    return self._files
+  def competition_name(self) -> str:
+    """Competition name. Example: 'titanic'."""
+    return self._competition_name
 
-  @files.setter
-  def files(self, files: Optional[List[Optional['ApiDataFile']]]):
-    if files is None:
-      del self.files
+  @competition_name.setter
+  def competition_name(self, competition_name: str):
+    if competition_name is None:
+      del self.competition_name
       return
-    if not isinstance(files, list):
-      raise TypeError('files must be of type list')
-    if not all([isinstance(t, ApiDataFile) for t in files]):
-      raise TypeError('files must contain only items of type ApiDataFile')
-    self._files = files
-
-  @property
-  def next_page_token(self) -> str:
-    return self._next_page_token
+    if not isinstance(competition_name, str):
+      raise TypeError('competition_name must be of type str')
+    self._competition_name = competition_name
 
-  @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
+  def endpoint(self):
+    path = '/api/v1/competitions/data/download-all/{competition_name}'
+    return path.format_map(self.to_field_map(self))
 
-  @property
-  def nextPageToken(self):
-    return self.next_page_token
+  @staticmethod
+  def endpoint_path():
+    return '/api/v1/competitions/data/download-all/{competition_name}'
 
 
-class ApiListSubmissionsRequest(KaggleObject):
+class ApiDownloadLeaderboardRequest(KaggleObject):
   r"""
   Attributes:
     competition_name (str)
-    sort_by (SubmissionSortBy)
-    group (SubmissionGroup)
-    page (int)
   """
 
   def __init__(self):
     self._competition_name = ""
-    self._sort_by = SubmissionSortBy.SUBMISSION_SORT_BY_DATE
-    self._group = SubmissionGroup.SUBMISSION_GROUP_ALL
-    self._page = None
     self._freeze()
 
   @property
@@ -845,104 +998,103 @@ class ApiListSubmissionsRequest(KaggleObject):
       raise TypeError('competition_name must be of type str')
     self._competition_name = competition_name
 
-  @property
-  def sort_by(self) -> 'SubmissionSortBy':
-    return self._sort_by
+  def endpoint(self):
+    path = '/api/v1/competitions/{competition_name}/leaderboard/download'
+    return path.format_map(self.to_field_map(self))
 
-  @sort_by.setter
-  def sort_by(self, sort_by: 'SubmissionSortBy'):
-    if sort_by is None:
-      del self.sort_by
-      return
-    if not isinstance(sort_by, SubmissionSortBy):
-      raise TypeError('sort_by must be of type SubmissionSortBy')
-    self._sort_by = sort_by
+  @staticmethod
+  def endpoint_path():
+    return '/api/v1/competitions/{competition_name}/leaderboard/download'
 
-  @property
-  def group(self) -> 'SubmissionGroup':
-    return self._group
 
-  @group.setter
-  def group(self, group: 'SubmissionGroup'):
-    if group is None:
-      del self.group
-      return
-    if not isinstance(group, SubmissionGroup):
-      raise TypeError('group must be of type SubmissionGroup')
-    self._group = group
+class ApiGetCompetitionDataFilesSummaryRequest(KaggleObject):
+  r"""
+  Attributes:
+    competition_name (str)
+  """
+
+  def __init__(self):
+    self._competition_name = ""
+    self._freeze()
 
   @property
-  def page(self) -> int:
-    return self._page or 0
+  def competition_name(self) -> str:
+    return self._competition_name
 
-  @page.setter
-  def page(self, page: int):
-    if page is None:
-      del self.page
+  @competition_name.setter
+  def competition_name(self, competition_name: str):
+    if competition_name is None:
+      del self.competition_name
       return
-    if not isinstance(page, int):
-      raise TypeError('page must be of type int')
-    self._page = page
+    if not isinstance(competition_name, str):
+      raise TypeError('competition_name must be of type str')
+    self._competition_name = competition_name
 
   def endpoint(self):
-    path = '/api/v1/competitions/submissions/list/{competition_name}'
+    path = '/api/v1/competitions/data/summary/{competition_name}'
     return path.format_map(self.to_field_map(self))
 
   @staticmethod
   def endpoint_path():
-    return '/api/v1/competitions/submissions/list/{competition_name}'
+    return '/api/v1/competitions/data/summary/{competition_name}'
 
 
-class ApiListSubmissionsResponse(KaggleObject):
+class ApiGetCompetitionRequest(KaggleObject):
   r"""
   Attributes:
-    submissions (ApiSubmission)
+    competition_name (str)
   """
 
   def __init__(self):
-    self._submissions = []
+    self._competition_name = ""
     self._freeze()
 
   @property
-  def submissions(self) -> Optional[List[Optional['ApiSubmission']]]:
-    return self._submissions
+  def competition_name(self) -> str:
+    return self._competition_name
 
-  @submissions.setter
-  def submissions(self, submissions: Optional[List[Optional['ApiSubmission']]]):
-    if submissions is None:
-      del self.submissions
+  @competition_name.setter
+  def competition_name(self, competition_name: str):
+    if competition_name is None:
+      del self.competition_name
       return
-    if not isinstance(submissions, list):
-      raise TypeError('submissions must be of type list')
-    if not all([isinstance(t, ApiSubmission) for t in submissions]):
-      raise TypeError('submissions must contain only items of type ApiSubmission')
-    self._submissions = submissions
+    if not isinstance(competition_name, str):
+      raise TypeError('competition_name must be of type str')
+    self._competition_name = competition_name
+
+  def endpoint(self):
+    path = '/api/v1/competitions/get/{competition_name}'
+    return path.format_map(self.to_field_map(self))
 
-  @classmethod
-  def prepare_from(cls, http_response):
-    return cls.from_dict({'submissions': json.loads(http_response.text)})
+  @staticmethod
+  def endpoint_path():
+    return '/api/v1/competitions/get/{competition_name}'
 
 
-class ApiStartSubmissionUploadRequest(KaggleObject):
+class ApiGetLeaderboardRequest(KaggleObject):
   r"""
   Attributes:
     competition_name (str)
-    content_length (int)
-    last_modified_epoch_seconds (int)
-    file_name (str)
-      Comes from form upload
+      Competition name. Example: 'titanic'.
+    override_public (bool)
+      By default we return the private leaderboard if it's available, otherwise
+      the public LB. This flag lets you override to get public even if private
+      is available.
+    page_size (int)
+    page_token (str)
   """
 
   def __init__(self):
-    self._competition_name = None
-    self._content_length = 0
-    self._last_modified_epoch_seconds = 0
-    self._file_name = ""
+    self._competition_name = ""
+    self._override_public = None
+    self._page_size = None
+    self._page_token = None
     self._freeze()
 
   @property
   def competition_name(self) -> str:
-    return self._competition_name or ""
+    """Competition name. Example: 'titanic'."""
+    return self._competition_name
 
   @competition_name.setter
   def competition_name(self, competition_name: str):
@@ -954,839 +1106,968 @@ class ApiStartSubmissionUploadRequest(KaggleObject):
     self._competition_name = competition_name
 
   @property
-  def content_length(self) -> int:
-    return self._content_length
+  def override_public(self) -> bool:
+    r"""
+    By default we return the private leaderboard if it's available, otherwise
+    the public LB. This flag lets you override to get public even if private
+    is available.
+    """
+    return self._override_public or False
 
-  @content_length.setter
-  def content_length(self, content_length: int):
-    if content_length is None:
-      del self.content_length
+  @override_public.setter
+  def override_public(self, override_public: Optional[bool]):
+    if override_public is None:
+      del self.override_public
       return
-    if not isinstance(content_length, int):
-      raise TypeError('content_length must be of type int')
-    self._content_length = content_length
+    if not isinstance(override_public, bool):
+      raise TypeError('override_public must be of type bool')
+    self._override_public = override_public
 
   @property
-  def last_modified_epoch_seconds(self) -> int:
-    return self._last_modified_epoch_seconds
+  def page_size(self) -> int:
+    return self._page_size or 0
 
-  @last_modified_epoch_seconds.setter
-  def last_modified_epoch_seconds(self, last_modified_epoch_seconds: int):
-    if last_modified_epoch_seconds is None:
-      del self.last_modified_epoch_seconds
+  @page_size.setter
+  def page_size(self, page_size: Optional[int]):
+    if page_size is None:
+      del self.page_size
       return
-    if not isinstance(last_modified_epoch_seconds, int):
-      raise TypeError('last_modified_epoch_seconds must be of type int')
-    self._last_modified_epoch_seconds = last_modified_epoch_seconds
+    if not isinstance(page_size, int):
+      raise TypeError('page_size must be of type int')
+    self._page_size = page_size
 
   @property
-  def file_name(self) -> str:
-    """Comes from form upload"""
-    return self._file_name
+  def page_token(self) -> str:
+    return self._page_token or ""
 
-  @file_name.setter
-  def file_name(self, file_name: str):
-    if file_name is None:
-      del self.file_name
+  @page_token.setter
+  def page_token(self, page_token: Optional[str]):
+    if page_token is None:
+      del self.page_token
       return
-    if not isinstance(file_name, str):
-      raise TypeError('file_name must be of type str')
-    self._file_name = file_name
+    if not isinstance(page_token, str):
+      raise TypeError('page_token must be of type str')
+    self._page_token = page_token
 
   def endpoint(self):
-    path = '/api/v1/competitions/submission-url'
+    path = '/api/v1/competitions/{competition_name}/leaderboard/view'
     return path.format_map(self.to_field_map(self))
 
-
   @staticmethod
-  def method():
-    return 'POST'
+  def endpoint_path():
+    return '/api/v1/competitions/{competition_name}/leaderboard/view'
 
 
-class ApiStartSubmissionUploadResponse(KaggleObject):
+class ApiGetLeaderboardResponse(KaggleObject):
   r"""
-  Currently identical to StartBlobUploadResponse, but keeping separate since
-  they could change independently and this is a legacy V1 type.
-
   Attributes:
-    token (str)
-    create_url (str)
+    submissions (ApiLeaderboardSubmission)
+    next_page_token (str)
   """
 
   def __init__(self):
-    self._token = ""
-    self._create_url = ""
+    self._submissions = []
+    self._next_page_token = ""
     self._freeze()
 
   @property
-  def token(self) -> str:
-    return self._token
+  def submissions(self) -> Optional[List[Optional['ApiLeaderboardSubmission']]]:
+    return self._submissions
 
-  @token.setter
-  def token(self, token: str):
-    if token is None:
-      del self.token
+  @submissions.setter
+  def submissions(self, submissions: Optional[List[Optional['ApiLeaderboardSubmission']]]):
+    if submissions is None:
+      del self.submissions
       return
-    if not isinstance(token, str):
-      raise TypeError('token must be of type str')
-    self._token = token
+    if not isinstance(submissions, list):
+      raise TypeError('submissions must be of type list')
+    if not all([isinstance(t, ApiLeaderboardSubmission) for t in submissions]):
+      raise TypeError('submissions must contain only items of type ApiLeaderboardSubmission')
+    self._submissions = submissions
 
   @property
-  def create_url(self) -> str:
-    return self._create_url
+  def next_page_token(self) -> str:
+    return self._next_page_token
 
-  @create_url.setter
-  def create_url(self, create_url: str):
-    if create_url is None:
-      del self.create_url
+  @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(create_url, str):
-      raise TypeError('create_url must be of type str')
-    self._create_url = create_url
+    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 createUrl(self):
-    return self.create_url
+  def nextPageToken(self):
+    return self.next_page_token
 
 
-class ApiSubmission(KaggleObject):
+class ApiGetSubmissionRequest(KaggleObject):
   r"""
   Attributes:
     ref (int)
-    total_bytes (int)
-    date (datetime)
-    description (str)
-    error_description (str)
-    file_name (str)
-    public_score (str)
-    private_score (str)
-    status (SubmissionStatus)
-    submitted_by (str)
-    submitted_by_ref (str)
-    team_name (str)
-    url (str)
-      Minor note: ListSubmissions and GetSubmission may differ in setting this
-      field.
+      SubmissionId.
   """
 
   def __init__(self):
     self._ref = 0
-    self._total_bytes = None
-    self._date = None
-    self._description = None
-    self._error_description = None
-    self._file_name = None
-    self._public_score = None
-    self._private_score = None
-    self._status = SubmissionStatus.PENDING
-    self._submitted_by = None
-    self._submitted_by_ref = None
+    self._freeze()
+
+  @property
+  def ref(self) -> int:
+    """SubmissionId."""
+    return self._ref
+
+  @ref.setter
+  def ref(self, ref: int):
+    if ref is None:
+      del self.ref
+      return
+    if not isinstance(ref, int):
+      raise TypeError('ref must be of type int')
+    self._ref = ref
+
+  def endpoint(self):
+    path = '/api/v1/competitions/submissions/get/{ref}'
+    return path.format_map(self.to_field_map(self))
+
+
+  @staticmethod
+  def method():
+    return 'POST'
+
+
+class ApiLeaderboardSubmission(KaggleObject):
+  r"""
+  Attributes:
+    team_id (int)
+    team_name (str)
+    submission_date (datetime)
+    score (str)
+  """
+
+  def __init__(self):
+    self._team_id = 0
     self._team_name = None
-    self._url = None
+    self._submission_date = None
+    self._score = None
     self._freeze()
 
   @property
-  def ref(self) -> int:
-    return self._ref
+  def team_id(self) -> int:
+    return self._team_id
+
+  @team_id.setter
+  def team_id(self, team_id: int):
+    if team_id is None:
+      del self.team_id
+      return
+    if not isinstance(team_id, int):
+      raise TypeError('team_id must be of type int')
+    self._team_id = team_id
+
+  @property
+  def team_name(self) -> str:
+    return self._team_name or ""
 
-  @ref.setter
-  def ref(self, ref: int):
-    if ref is None:
-      del self.ref
+  @team_name.setter
+  def team_name(self, team_name: Optional[str]):
+    if team_name is None:
+      del self.team_name
       return
-    if not isinstance(ref, int):
-      raise TypeError('ref must be of type int')
-    self._ref = ref
+    if not isinstance(team_name, str):
+      raise TypeError('team_name must be of type str')
+    self._team_name = team_name
 
   @property
-  def total_bytes(self) -> int:
-    return self._total_bytes or 0
+  def submission_date(self) -> datetime:
+    return self._submission_date
 
-  @total_bytes.setter
-  def total_bytes(self, total_bytes: int):
-    if total_bytes is None:
-      del self.total_bytes
+  @submission_date.setter
+  def submission_date(self, submission_date: datetime):
+    if submission_date is None:
+      del self.submission_date
       return
-    if not isinstance(total_bytes, int):
-      raise TypeError('total_bytes must be of type int')
-    self._total_bytes = total_bytes
+    if not isinstance(submission_date, datetime):
+      raise TypeError('submission_date must be of type datetime')
+    self._submission_date = submission_date
 
   @property
-  def date(self) -> datetime:
-    return self._date
+  def score(self) -> str:
+    return self._score or ""
 
-  @date.setter
-  def date(self, date: datetime):
-    if date is None:
-      del self.date
+  @score.setter
+  def score(self, score: Optional[str]):
+    if score is None:
+      del self.score
       return
-    if not isinstance(date, datetime):
-      raise TypeError('date must be of type datetime')
-    self._date = date
+    if not isinstance(score, str):
+      raise TypeError('score must be of type str')
+    self._score = score
+
+
+class ApiListCompetitionsRequest(KaggleObject):
+  r"""
+  Attributes:
+    group (CompetitionListTab)
+      Filter competitions by a particular group (default is 'general').
+      One of 'general', 'entered' and 'inClass'.
+    category (HostSegment)
+      Filter competitions by a particular category (default is 'all').
+      One of 'all', 'featured', 'research', 'recruitment', 'gettingStarted',
+      'masters', 'playground'.
+    sort_by (CompetitionSortBy)
+      Sort the results (default is 'latestDeadline').
+      One of 'grouped', 'prize', 'earliestDeadline', 'latestDeadline',
+      'numberOfTeams', 'recentlyCreated'.
+    search (str)
+      Filter competitions by search terms.
+    page (int)
+      Page number (default is 1).
+    page_token (str)
+    page_size (int)
+  """
+
+  def __init__(self):
+    self._group = None
+    self._category = None
+    self._sort_by = None
+    self._search = None
+    self._page = None
+    self._page_token = None
+    self._page_size = None
+    self._freeze()
 
   @property
-  def description(self) -> str:
-    return self._description or ""
+  def group(self) -> 'CompetitionListTab':
+    r"""
+    Filter competitions by a particular group (default is 'general').
+    One of 'general', 'entered' and 'inClass'.
+    """
+    return self._group or CompetitionListTab.COMPETITION_LIST_TAB_GENERAL
 
-  @description.setter
-  def description(self, description: str):
-    if description is None:
-      del self.description
+  @group.setter
+  def group(self, group: Optional['CompetitionListTab']):
+    if group is None:
+      del self.group
       return
-    if not isinstance(description, str):
-      raise TypeError('description must be of type str')
-    self._description = description
+    if not isinstance(group, CompetitionListTab):
+      raise TypeError('group must be of type CompetitionListTab')
+    self._group = group
 
   @property
-  def error_description(self) -> str:
-    return self._error_description or ""
+  def category(self) -> 'HostSegment':
+    r"""
+    Filter competitions by a particular category (default is 'all').
+    One of 'all', 'featured', 'research', 'recruitment', 'gettingStarted',
+    'masters', 'playground'.
+    """
+    return self._category or HostSegment.HOST_SEGMENT_UNSPECIFIED
 
-  @error_description.setter
-  def error_description(self, error_description: str):
-    if error_description is None:
-      del self.error_description
+  @category.setter
+  def category(self, category: Optional['HostSegment']):
+    if category is None:
+      del self.category
       return
-    if not isinstance(error_description, str):
-      raise TypeError('error_description must be of type str')
-    self._error_description = error_description
+    if not isinstance(category, HostSegment):
+      raise TypeError('category must be of type HostSegment')
+    self._category = category
 
   @property
-  def file_name(self) -> str:
-    return self._file_name or ""
+  def sort_by(self) -> 'CompetitionSortBy':
+    r"""
+    Sort the results (default is 'latestDeadline').
+    One of 'grouped', 'prize', 'earliestDeadline', 'latestDeadline',
+    'numberOfTeams', 'recentlyCreated'.
+    """
+    return self._sort_by or CompetitionSortBy.COMPETITION_SORT_BY_GROUPED
 
-  @file_name.setter
-  def file_name(self, file_name: str):
-    if file_name is None:
-      del self.file_name
+  @sort_by.setter
+  def sort_by(self, sort_by: Optional['CompetitionSortBy']):
+    if sort_by is None:
+      del self.sort_by
       return
-    if not isinstance(file_name, str):
-      raise TypeError('file_name must be of type str')
-    self._file_name = file_name
+    if not isinstance(sort_by, CompetitionSortBy):
+      raise TypeError('sort_by must be of type CompetitionSortBy')
+    self._sort_by = sort_by
 
   @property
-  def public_score(self) -> str:
-    return self._public_score or ""
+  def search(self) -> str:
+    """Filter competitions by search terms."""
+    return self._search or ""
 
-  @public_score.setter
-  def public_score(self, public_score: str):
-    if public_score is None:
-      del self.public_score
+  @search.setter
+  def search(self, search: Optional[str]):
+    if search is None:
+      del self.search
       return
-    if not isinstance(public_score, str):
-      raise TypeError('public_score must be of type str')
-    self._public_score = public_score
+    if not isinstance(search, str):
+      raise TypeError('search must be of type str')
+    self._search = search
 
   @property
-  def private_score(self) -> str:
-    return self._private_score or ""
+  def page(self) -> int:
+    """Page number (default is 1)."""
+    return self._page or 0
 
-  @private_score.setter
-  def private_score(self, private_score: str):
-    if private_score is None:
-      del self.private_score
+  @page.setter
+  def page(self, page: Optional[int]):
+    if page is None:
+      del self.page
       return
-    if not isinstance(private_score, str):
-      raise TypeError('private_score must be of type str')
-    self._private_score = private_score
+    if not isinstance(page, int):
+      raise TypeError('page must be of type int')
+    self._page = page
 
   @property
-  def status(self) -> 'SubmissionStatus':
-    return self._status
+  def page_token(self) -> str:
+    return self._page_token or ""
 
-  @status.setter
-  def status(self, status: 'SubmissionStatus'):
-    if status is None:
-      del self.status
+  @page_token.setter
+  def page_token(self, page_token: Optional[str]):
+    if page_token is None:
+      del self.page_token
       return
-    if not isinstance(status, SubmissionStatus):
-      raise TypeError('status must be of type SubmissionStatus')
-    self._status = status
+    if not isinstance(page_token, str):
+      raise TypeError('page_token must be of type str')
+    self._page_token = page_token
 
   @property
-  def submitted_by(self) -> str:
-    return self._submitted_by or ""
+  def page_size(self) -> int:
+    return self._page_size or 0
 
-  @submitted_by.setter
-  def submitted_by(self, submitted_by: str):
-    if submitted_by is None:
-      del self.submitted_by
+  @page_size.setter
+  def page_size(self, page_size: Optional[int]):
+    if page_size is None:
+      del self.page_size
       return
-    if not isinstance(submitted_by, str):
-      raise TypeError('submitted_by must be of type str')
-    self._submitted_by = submitted_by
+    if not isinstance(page_size, int):
+      raise TypeError('page_size must be of type int')
+    self._page_size = page_size
+
+  def endpoint(self):
+    path = '/api/v1/competitions/list'
+    return path.format_map(self.to_field_map(self))
+
+
+class ApiListCompetitionsResponse(KaggleObject):
+  r"""
+  Attributes:
+    competitions (ApiCompetition)
+    next_page_token (str)
+  """
+
+  def __init__(self):
+    self._competitions = []
+    self._next_page_token = ""
+    self._freeze()
 
   @property
-  def submitted_by_ref(self) -> str:
-    return self._submitted_by_ref or ""
+  def competitions(self) -> Optional[List[Optional['ApiCompetition']]]:
+    return self._competitions
 
-  @submitted_by_ref.setter
-  def submitted_by_ref(self, submitted_by_ref: str):
-    if submitted_by_ref is None:
-      del self.submitted_by_ref
+  @competitions.setter
+  def competitions(self, competitions: Optional[List[Optional['ApiCompetition']]]):
+    if competitions is None:
+      del self.competitions
       return
-    if not isinstance(submitted_by_ref, str):
-      raise TypeError('submitted_by_ref must be of type str')
-    self._submitted_by_ref = submitted_by_ref
+    if not isinstance(competitions, list):
+      raise TypeError('competitions must be of type list')
+    if not all([isinstance(t, ApiCompetition) for t in competitions]):
+      raise TypeError('competitions must contain only items of type ApiCompetition')
+    self._competitions = competitions
 
   @property
-  def team_name(self) -> str:
-    return self._team_name or ""
+  def next_page_token(self) -> str:
+    return self._next_page_token
 
-  @team_name.setter
-  def team_name(self, team_name: str):
-    if team_name is None:
-      del self.team_name
+  @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(team_name, str):
-      raise TypeError('team_name must be of type str')
-    self._team_name = team_name
+    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 url(self) -> str:
-    r"""
-    Minor note: ListSubmissions and GetSubmission may differ in setting this
-    field.
-    """
-    return self._url or ""
-
-  @url.setter
-  def url(self, url: 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
+  def nextPageToken(self):
+    return self.next_page_token
 
 
-class ApiCompetition(KaggleObject):
+class ApiListDataFilesRequest(KaggleObject):
   r"""
   Attributes:
-    id (int)
-    ref (str)
-    title (str)
-    url (str)
-    description (str)
-    organization_name (str)
-    organization_ref (str)
-    category (str)
-    reward (str)
-    tags (ApiCategory)
-    deadline (datetime)
-    kernel_count (int)
-    team_count (int)
-    user_has_entered (bool)
-    user_rank (int)
-    merger_deadline (datetime)
-    new_entrant_deadline (datetime)
-    enabled_date (datetime)
-    max_daily_submissions (int)
-    max_team_size (int)
-    evaluation_metric (str)
-    awards_points (bool)
-    is_kernels_submissions_only (bool)
-    submissions_disabled (bool)
+    competition_name (str)
+      Competition name. Example: 'titanic'.
+    page_size (int)
+    page_token (str)
   """
 
   def __init__(self):
-    self._id = 0
-    self._ref = ""
-    self._title = None
-    self._url = None
-    self._description = None
-    self._organization_name = None
-    self._organization_ref = None
-    self._category = None
-    self._reward = None
-    self._tags = []
-    self._deadline = None
-    self._kernel_count = 0
-    self._team_count = 0
-    self._user_has_entered = False
-    self._user_rank = None
-    self._merger_deadline = None
-    self._new_entrant_deadline = None
-    self._enabled_date = None
-    self._max_daily_submissions = 0
-    self._max_team_size = None
-    self._evaluation_metric = None
-    self._awards_points = False
-    self._is_kernels_submissions_only = False
-    self._submissions_disabled = False
+    self._competition_name = ""
+    self._page_size = None
+    self._page_token = None
     self._freeze()
 
   @property
-  def id(self) -> int:
-    return self._id
+  def competition_name(self) -> str:
+    """Competition name. Example: 'titanic'."""
+    return self._competition_name
 
-  @id.setter
-  def id(self, id: int):
-    if id is None:
-      del self.id
+  @competition_name.setter
+  def competition_name(self, competition_name: str):
+    if competition_name is None:
+      del self.competition_name
       return
-    if not isinstance(id, int):
-      raise TypeError('id must be of type int')
-    self._id = id
+    if not isinstance(competition_name, str):
+      raise TypeError('competition_name must be of type str')
+    self._competition_name = competition_name
 
   @property
-  def ref(self) -> str:
-    return self._ref
+  def page_size(self) -> int:
+    return self._page_size or 0
 
-  @ref.setter
-  def ref(self, ref: str):
-    if ref is None:
-      del self.ref
+  @page_size.setter
+  def page_size(self, page_size: Optional[int]):
+    if page_size is None:
+      del self.page_size
       return
-    if not isinstance(ref, str):
-      raise TypeError('ref must be of type str')
-    self._ref = ref
+    if not isinstance(page_size, int):
+      raise TypeError('page_size must be of type int')
+    self._page_size = page_size
 
   @property
-  def title(self) -> str:
-    return self._title or ""
+  def page_token(self) -> str:
+    return self._page_token or ""
 
-  @title.setter
-  def title(self, title: str):
-    if title is None:
-      del self.title
+  @page_token.setter
+  def page_token(self, page_token: Optional[str]):
+    if page_token is None:
+      del self.page_token
       return
-    if not isinstance(title, str):
-      raise TypeError('title must be of type str')
-    self._title = title
+    if not isinstance(page_token, str):
+      raise TypeError('page_token must be of type str')
+    self._page_token = page_token
 
-  @property
-  def url(self) -> str:
-    return self._url or ""
+  def endpoint(self):
+    path = '/api/v1/competitions/data/list/{competition_name}'
+    return path.format_map(self.to_field_map(self))
 
-  @url.setter
-  def url(self, url: 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
+  @staticmethod
+  def endpoint_path():
+    return '/api/v1/competitions/data/list/{competition_name}'
 
-  @property
-  def description(self) -> str:
-    return self._description or ""
 
-  @description.setter
-  def description(self, description: str):
-    if description is None:
-      del self.description
-      return
-    if not isinstance(description, str):
-      raise TypeError('description must be of type str')
-    self._description = description
+class ApiListDataFilesResponse(KaggleObject):
+  r"""
+  Attributes:
+    files (ApiDataFile)
+    next_page_token (str)
+    children_fetch_time_ms (int)
+  """
+
+  def __init__(self):
+    self._files = []
+    self._next_page_token = ""
+    self._children_fetch_time_ms = 0
+    self._freeze()
 
   @property
-  def organization_name(self) -> str:
-    return self._organization_name or ""
+  def files(self) -> Optional[List[Optional['ApiDataFile']]]:
+    return self._files
 
-  @organization_name.setter
-  def organization_name(self, organization_name: str):
-    if organization_name is None:
-      del self.organization_name
+  @files.setter
+  def files(self, files: Optional[List[Optional['ApiDataFile']]]):
+    if files is None:
+      del self.files
       return
-    if not isinstance(organization_name, str):
-      raise TypeError('organization_name must be of type str')
-    self._organization_name = organization_name
+    if not isinstance(files, list):
+      raise TypeError('files must be of type list')
+    if not all([isinstance(t, ApiDataFile) for t in files]):
+      raise TypeError('files must contain only items of type ApiDataFile')
+    self._files = files
 
   @property
-  def organization_ref(self) -> str:
-    return self._organization_ref or ""
+  def next_page_token(self) -> str:
+    return self._next_page_token
 
-  @organization_ref.setter
-  def organization_ref(self, organization_ref: str):
-    if organization_ref is None:
-      del self.organization_ref
+  @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(organization_ref, str):
-      raise TypeError('organization_ref must be of type str')
-    self._organization_ref = organization_ref
+    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 category(self) -> str:
-    return self._category or ""
+  def children_fetch_time_ms(self) -> int:
+    return self._children_fetch_time_ms
 
-  @category.setter
-  def category(self, category: str):
-    if category is None:
-      del self.category
+  @children_fetch_time_ms.setter
+  def children_fetch_time_ms(self, children_fetch_time_ms: int):
+    if children_fetch_time_ms is None:
+      del self.children_fetch_time_ms
       return
-    if not isinstance(category, str):
-      raise TypeError('category must be of type str')
-    self._category = category
+    if not isinstance(children_fetch_time_ms, int):
+      raise TypeError('children_fetch_time_ms must be of type int')
+    self._children_fetch_time_ms = children_fetch_time_ms
 
   @property
-  def reward(self) -> str:
-    return self._reward or ""
-
-  @reward.setter
-  def reward(self, reward: str):
-    if reward is None:
-      del self.reward
-      return
-    if not isinstance(reward, str):
-      raise TypeError('reward must be of type str')
-    self._reward = reward
+  def nextPageToken(self):
+    return self.next_page_token
 
   @property
-  def tags(self) -> Optional[List[Optional['ApiCategory']]]:
-    return self._tags
+  def childrenFetchTimeMs(self):
+    return self.children_fetch_time_ms
 
-  @tags.setter
-  def tags(self, tags: Optional[List[Optional['ApiCategory']]]):
-    if tags is None:
-      del self.tags
-      return
-    if not isinstance(tags, list):
-      raise TypeError('tags must be of type list')
-    if not all([isinstance(t, ApiCategory) for t in tags]):
-      raise TypeError('tags must contain only items of type ApiCategory')
-    self._tags = tags
+
+class ApiListDataTreeFilesRequest(KaggleObject):
+  r"""
+  Attributes:
+    competition_name (str)
+      Competition name. Example: 'titanic'.
+    path (str)
+      The path of the directory to list files from. If not provided, the root
+      directory will be listed.
+    page_size (int)
+    page_token (str)
+  """
+
+  def __init__(self):
+    self._competition_name = ""
+    self._path = None
+    self._page_size = None
+    self._page_token = None
+    self._freeze()
 
   @property
-  def deadline(self) -> datetime:
-    return self._deadline
+  def competition_name(self) -> str:
+    """Competition name. Example: 'titanic'."""
+    return self._competition_name
 
-  @deadline.setter
-  def deadline(self, deadline: datetime):
-    if deadline is None:
-      del self.deadline
+  @competition_name.setter
+  def competition_name(self, competition_name: str):
+    if competition_name is None:
+      del self.competition_name
       return
-    if not isinstance(deadline, datetime):
-      raise TypeError('deadline must be of type datetime')
-    self._deadline = deadline
+    if not isinstance(competition_name, str):
+      raise TypeError('competition_name must be of type str')
+    self._competition_name = competition_name
 
   @property
-  def kernel_count(self) -> int:
-    return self._kernel_count
+  def path(self) -> str:
+    r"""
+    The path of the directory to list files from. If not provided, the root
+    directory will be listed.
+    """
+    return self._path or ""
 
-  @kernel_count.setter
-  def kernel_count(self, kernel_count: int):
-    if kernel_count is None:
-      del self.kernel_count
+  @path.setter
+  def path(self, path: Optional[str]):
+    if path is None:
+      del self.path
       return
-    if not isinstance(kernel_count, int):
-      raise TypeError('kernel_count must be of type int')
-    self._kernel_count = kernel_count
+    if not isinstance(path, str):
+      raise TypeError('path must be of type str')
+    self._path = path
 
   @property
-  def team_count(self) -> int:
-    return self._team_count
+  def page_size(self) -> int:
+    return self._page_size or 0
 
-  @team_count.setter
-  def team_count(self, team_count: int):
-    if team_count is None:
-      del self.team_count
+  @page_size.setter
+  def page_size(self, page_size: Optional[int]):
+    if page_size is None:
+      del self.page_size
       return
-    if not isinstance(team_count, int):
-      raise TypeError('team_count must be of type int')
-    self._team_count = team_count
+    if not isinstance(page_size, int):
+      raise TypeError('page_size must be of type int')
+    self._page_size = page_size
 
   @property
-  def user_has_entered(self) -> bool:
-    return self._user_has_entered
+  def page_token(self) -> str:
+    return self._page_token or ""
 
-  @user_has_entered.setter
-  def user_has_entered(self, user_has_entered: bool):
-    if user_has_entered is None:
-      del self.user_has_entered
+  @page_token.setter
+  def page_token(self, page_token: Optional[str]):
+    if page_token is None:
+      del self.page_token
       return
-    if not isinstance(user_has_entered, bool):
-      raise TypeError('user_has_entered must be of type bool')
-    self._user_has_entered = user_has_entered
+    if not isinstance(page_token, str):
+      raise TypeError('page_token must be of type str')
+    self._page_token = page_token
 
-  @property
-  def user_rank(self) -> int:
-    return self._user_rank or 0
+  def endpoint(self):
+    path = '/api/v1/competitions/{competition_name}/data-tree/list/'
+    return path.format_map(self.to_field_map(self))
 
-  @user_rank.setter
-  def user_rank(self, user_rank: int):
-    if user_rank is None:
-      del self.user_rank
-      return
-    if not isinstance(user_rank, int):
-      raise TypeError('user_rank must be of type int')
-    self._user_rank = user_rank
+  @staticmethod
+  def endpoint_path():
+    return '/api/v1/competitions/{competition_name}/data-tree/list/'
 
-  @property
-  def merger_deadline(self) -> datetime:
-    return self._merger_deadline
 
-  @merger_deadline.setter
-  def merger_deadline(self, merger_deadline: datetime):
-    if merger_deadline is None:
-      del self.merger_deadline
-      return
-    if not isinstance(merger_deadline, datetime):
-      raise TypeError('merger_deadline must be of type datetime')
-    self._merger_deadline = merger_deadline
+class ApiListSubmissionsRequest(KaggleObject):
+  r"""
+  Attributes:
+    competition_name (str)
+    sort_by (SubmissionSortBy)
+    group (SubmissionGroup)
+    page (int)
+    page_token (str)
+    page_size (int)
+  """
+
+  def __init__(self):
+    self._competition_name = ""
+    self._sort_by = SubmissionSortBy.SUBMISSION_SORT_BY_DATE
+    self._group = SubmissionGroup.SUBMISSION_GROUP_ALL
+    self._page = None
+    self._page_token = None
+    self._page_size = None
+    self._freeze()
 
   @property
-  def new_entrant_deadline(self) -> datetime:
-    return self._new_entrant_deadline
+  def competition_name(self) -> str:
+    return self._competition_name
 
-  @new_entrant_deadline.setter
-  def new_entrant_deadline(self, new_entrant_deadline: datetime):
-    if new_entrant_deadline is None:
-      del self.new_entrant_deadline
+  @competition_name.setter
+  def competition_name(self, competition_name: str):
+    if competition_name is None:
+      del self.competition_name
       return
-    if not isinstance(new_entrant_deadline, datetime):
-      raise TypeError('new_entrant_deadline must be of type datetime')
-    self._new_entrant_deadline = new_entrant_deadline
+    if not isinstance(competition_name, str):
+      raise TypeError('competition_name must be of type str')
+    self._competition_name = competition_name
 
   @property
-  def enabled_date(self) -> datetime:
-    return self._enabled_date
+  def sort_by(self) -> 'SubmissionSortBy':
+    return self._sort_by
 
-  @enabled_date.setter
-  def enabled_date(self, enabled_date: datetime):
-    if enabled_date is None:
-      del self.enabled_date
+  @sort_by.setter
+  def sort_by(self, sort_by: 'SubmissionSortBy'):
+    if sort_by is None:
+      del self.sort_by
       return
-    if not isinstance(enabled_date, datetime):
-      raise TypeError('enabled_date must be of type datetime')
-    self._enabled_date = enabled_date
+    if not isinstance(sort_by, SubmissionSortBy):
+      raise TypeError('sort_by must be of type SubmissionSortBy')
+    self._sort_by = sort_by
 
   @property
-  def max_daily_submissions(self) -> int:
-    return self._max_daily_submissions
+  def group(self) -> 'SubmissionGroup':
+    return self._group
 
-  @max_daily_submissions.setter
-  def max_daily_submissions(self, max_daily_submissions: int):
-    if max_daily_submissions is None:
-      del self.max_daily_submissions
+  @group.setter
+  def group(self, group: 'SubmissionGroup'):
+    if group is None:
+      del self.group
       return
-    if not isinstance(max_daily_submissions, int):
-      raise TypeError('max_daily_submissions must be of type int')
-    self._max_daily_submissions = max_daily_submissions
+    if not isinstance(group, SubmissionGroup):
+      raise TypeError('group must be of type SubmissionGroup')
+    self._group = group
 
   @property
-  def max_team_size(self) -> int:
-    return self._max_team_size or 0
+  def page(self) -> int:
+    return self._page or 0
 
-  @max_team_size.setter
-  def max_team_size(self, max_team_size: int):
-    if max_team_size is None:
-      del self.max_team_size
+  @page.setter
+  def page(self, page: Optional[int]):
+    if page is None:
+      del self.page
       return
-    if not isinstance(max_team_size, int):
-      raise TypeError('max_team_size must be of type int')
-    self._max_team_size = max_team_size
+    if not isinstance(page, int):
+      raise TypeError('page must be of type int')
+    self._page = page
 
   @property
-  def evaluation_metric(self) -> str:
-    return self._evaluation_metric or ""
+  def page_token(self) -> str:
+    return self._page_token or ""
 
-  @evaluation_metric.setter
-  def evaluation_metric(self, evaluation_metric: str):
-    if evaluation_metric is None:
-      del self.evaluation_metric
+  @page_token.setter
+  def page_token(self, page_token: Optional[str]):
+    if page_token is None:
+      del self.page_token
       return
-    if not isinstance(evaluation_metric, str):
-      raise TypeError('evaluation_metric must be of type str')
-    self._evaluation_metric = evaluation_metric
+    if not isinstance(page_token, str):
+      raise TypeError('page_token must be of type str')
+    self._page_token = page_token
 
   @property
-  def awards_points(self) -> bool:
-    return self._awards_points
+  def page_size(self) -> int:
+    return self._page_size or 0
 
-  @awards_points.setter
-  def awards_points(self, awards_points: bool):
-    if awards_points is None:
-      del self.awards_points
+  @page_size.setter
+  def page_size(self, page_size: Optional[int]):
+    if page_size is None:
+      del self.page_size
       return
-    if not isinstance(awards_points, bool):
-      raise TypeError('awards_points must be of type bool')
-    self._awards_points = awards_points
+    if not isinstance(page_size, int):
+      raise TypeError('page_size must be of type int')
+    self._page_size = page_size
+
+  def endpoint(self):
+    path = '/api/v1/competitions/submissions/list/{competition_name}'
+    return path.format_map(self.to_field_map(self))
+
+  @staticmethod
+  def endpoint_path():
+    return '/api/v1/competitions/submissions/list/{competition_name}'
+
+
+class ApiListSubmissionsResponse(KaggleObject):
+  r"""
+  Attributes:
+    submissions (ApiSubmission)
+    next_page_token (str)
+  """
+
+  def __init__(self):
+    self._submissions = []
+    self._next_page_token = ""
+    self._freeze()
 
   @property
-  def is_kernels_submissions_only(self) -> bool:
-    return self._is_kernels_submissions_only
+  def submissions(self) -> Optional[List[Optional['ApiSubmission']]]:
+    return self._submissions
 
-  @is_kernels_submissions_only.setter
-  def is_kernels_submissions_only(self, is_kernels_submissions_only: bool):
-    if is_kernels_submissions_only is None:
-      del self.is_kernels_submissions_only
+  @submissions.setter
+  def submissions(self, submissions: Optional[List[Optional['ApiSubmission']]]):
+    if submissions is None:
+      del self.submissions
       return
-    if not isinstance(is_kernels_submissions_only, bool):
-      raise TypeError('is_kernels_submissions_only must be of type bool')
-    self._is_kernels_submissions_only = is_kernels_submissions_only
+    if not isinstance(submissions, list):
+      raise TypeError('submissions must be of type list')
+    if not all([isinstance(t, ApiSubmission) for t in submissions]):
+      raise TypeError('submissions must contain only items of type ApiSubmission')
+    self._submissions = submissions
 
   @property
-  def submissions_disabled(self) -> bool:
-    return self._submissions_disabled
+  def next_page_token(self) -> str:
+    return self._next_page_token
 
-  @submissions_disabled.setter
-  def submissions_disabled(self, submissions_disabled: bool):
-    if submissions_disabled is None:
-      del self.submissions_disabled
+  @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(submissions_disabled, bool):
-      raise TypeError('submissions_disabled must be of type bool')
-    self._submissions_disabled = submissions_disabled
+    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 nextPageToken(self):
+    return self.next_page_token
 
 
-class ApiDataFile(KaggleObject):
+class ApiStartSubmissionUploadRequest(KaggleObject):
   r"""
   Attributes:
-    ref (str)
-    name (str)
-    description (str)
-    total_bytes (int)
-    url (str)
-    creation_date (datetime)
+    competition_name (str)
+    content_length (int)
+    last_modified_epoch_seconds (int)
+    file_name (str)
+      Comes from form upload
   """
 
   def __init__(self):
-    self._ref = ""
-    self._name = None
-    self._description = None
-    self._total_bytes = 0
-    self._url = None
-    self._creation_date = None
+    self._competition_name = None
+    self._content_length = 0
+    self._last_modified_epoch_seconds = 0
+    self._file_name = ""
     self._freeze()
 
   @property
-  def ref(self) -> str:
-    return self._ref
+  def competition_name(self) -> str:
+    return self._competition_name or ""
 
-  @ref.setter
-  def ref(self, ref: str):
-    if ref is None:
-      del self.ref
+  @competition_name.setter
+  def competition_name(self, competition_name: Optional[str]):
+    if competition_name is None:
+      del self.competition_name
       return
-    if not isinstance(ref, str):
-      raise TypeError('ref must be of type str')
-    self._ref = ref
+    if not isinstance(competition_name, str):
+      raise TypeError('competition_name must be of type str')
+    self._competition_name = competition_name
 
   @property
-  def name(self) -> str:
-    return self._name or ""
+  def content_length(self) -> int:
+    return self._content_length
 
-  @name.setter
-  def name(self, name: str):
-    if name is None:
-      del self.name
+  @content_length.setter
+  def content_length(self, content_length: int):
+    if content_length is None:
+      del self.content_length
       return
-    if not isinstance(name, str):
-      raise TypeError('name must be of type str')
-    self._name = name
+    if not isinstance(content_length, int):
+      raise TypeError('content_length must be of type int')
+    self._content_length = content_length
 
   @property
-  def description(self) -> str:
-    return self._description or ""
+  def last_modified_epoch_seconds(self) -> int:
+    return self._last_modified_epoch_seconds
 
-  @description.setter
-  def description(self, description: str):
-    if description is None:
-      del self.description
+  @last_modified_epoch_seconds.setter
+  def last_modified_epoch_seconds(self, last_modified_epoch_seconds: int):
+    if last_modified_epoch_seconds is None:
+      del self.last_modified_epoch_seconds
       return
-    if not isinstance(description, str):
-      raise TypeError('description must be of type str')
-    self._description = description
+    if not isinstance(last_modified_epoch_seconds, int):
+      raise TypeError('last_modified_epoch_seconds must be of type int')
+    self._last_modified_epoch_seconds = last_modified_epoch_seconds
 
   @property
-  def total_bytes(self) -> int:
-    return self._total_bytes
+  def file_name(self) -> str:
+    """Comes from form upload"""
+    return self._file_name
 
-  @total_bytes.setter
-  def total_bytes(self, total_bytes: int):
-    if total_bytes is None:
-      del self.total_bytes
+  @file_name.setter
+  def file_name(self, file_name: str):
+    if file_name is None:
+      del self.file_name
       return
-    if not isinstance(total_bytes, int):
-      raise TypeError('total_bytes must be of type int')
-    self._total_bytes = total_bytes
+    if not isinstance(file_name, str):
+      raise TypeError('file_name must be of type str')
+    self._file_name = file_name
+
+  def endpoint(self):
+    path = '/api/v1/competitions/submission-url'
+    return path.format_map(self.to_field_map(self))
+
+
+  @staticmethod
+  def method():
+    return 'POST'
+
+
+class ApiStartSubmissionUploadResponse(KaggleObject):
+  r"""
+  Currently identical to StartBlobUploadResponse, but keeping separate since
+  they could change independently and this is a legacy V1 type.
+
+  Attributes:
+    token (str)
+    create_url (str)
+  """
+
+  def __init__(self):
+    self._token = ""
+    self._create_url = ""
+    self._freeze()
 
   @property
-  def url(self) -> str:
-    return self._url or ""
+  def token(self) -> str:
+    return self._token
 
-  @url.setter
-  def url(self, url: str):
-    if url is None:
-      del self.url
+  @token.setter
+  def token(self, token: str):
+    if token is None:
+      del self.token
       return
-    if not isinstance(url, str):
-      raise TypeError('url must be of type str')
-    self._url = url
+    if not isinstance(token, str):
+      raise TypeError('token must be of type str')
+    self._token = token
 
   @property
-  def creation_date(self) -> datetime:
-    return self._creation_date
+  def create_url(self) -> str:
+    return self._create_url
 
-  @creation_date.setter
-  def creation_date(self, creation_date: datetime):
-    if creation_date is None:
-      del self.creation_date
+  @create_url.setter
+  def create_url(self, create_url: str):
+    if create_url is None:
+      del self.create_url
       return
-    if not isinstance(creation_date, datetime):
-      raise TypeError('creation_date must be of type datetime')
-    self._creation_date = creation_date
+    if not isinstance(create_url, str):
+      raise TypeError('create_url must be of type str')
+    self._create_url = create_url
 
+  @property
+  def createUrl(self):
+    return self.create_url
 
-class ApiCategory(KaggleObject):
-  r"""
-  TODO(erdalsivri): Consider reusing with Kaggle.Sdk.Datasets.ApiCategory.
 
+class ApiSubmission(KaggleObject):
+  r"""
   Attributes:
-    ref (str)
-    name (str)
+    ref (int)
+    total_bytes (int)
+    date (datetime)
     description (str)
-    full_path (str)
-    competition_count (int)
-    dataset_count (int)
-    script_count (int)
-    total_count (int)
+    error_description (str)
+    file_name (str)
+    public_score (str)
+    private_score (str)
+    status (SubmissionStatus)
+    submitted_by (str)
+    submitted_by_ref (str)
+    team_name (str)
+    url (str)
+      Minor note: ListSubmissions and GetSubmission may differ in setting this
+      field.
   """
 
   def __init__(self):
-    self._ref = ""
-    self._name = None
+    self._ref = 0
+    self._total_bytes = None
+    self._date = None
     self._description = None
-    self._full_path = None
-    self._competition_count = 0
-    self._dataset_count = 0
-    self._script_count = 0
-    self._total_count = 0
+    self._error_description = None
+    self._file_name = None
+    self._public_score = None
+    self._private_score = None
+    self._status = SubmissionStatus.PENDING
+    self._submitted_by = None
+    self._submitted_by_ref = None
+    self._team_name = None
+    self._url = None
     self._freeze()
 
   @property
-  def ref(self) -> str:
+  def ref(self) -> int:
     return self._ref
 
   @ref.setter
-  def ref(self, ref: str):
+  def ref(self, ref: int):
     if ref is None:
       del self.ref
       return
-    if not isinstance(ref, str):
-      raise TypeError('ref must be of type str')
+    if not isinstance(ref, int):
+      raise TypeError('ref must be of type int')
     self._ref = ref
 
   @property
-  def name(self) -> str:
-    return self._name or ""
+  def total_bytes(self) -> int:
+    return self._total_bytes or 0
 
-  @name.setter
-  def name(self, name: str):
-    if name is None:
-      del self.name
+  @total_bytes.setter
+  def total_bytes(self, total_bytes: Optional[int]):
+    if total_bytes is None:
+      del self.total_bytes
       return
-    if not isinstance(name, str):
-      raise TypeError('name must be of type str')
-    self._name = name
+    if not isinstance(total_bytes, int):
+      raise TypeError('total_bytes must be of type int')
+    self._total_bytes = total_bytes
+
+  @property
+  def date(self) -> datetime:
+    return self._date
+
+  @date.setter
+  def date(self, date: datetime):
+    if date is None:
+      del self.date
+      return
+    if not isinstance(date, datetime):
+      raise TypeError('date must be of type datetime')
+    self._date = date
 
   @property
   def description(self) -> str:
     return self._description or ""
 
   @description.setter
-  def description(self, description: str):
+  def description(self, description: Optional[str]):
     if description is None:
       del self.description
       return
@@ -1795,70 +2076,166 @@ class ApiCategory(KaggleObject):
     self._description = description
 
   @property
-  def full_path(self) -> str:
-    return self._full_path or ""
+  def error_description(self) -> str:
+    return self._error_description or ""
 
-  @full_path.setter
-  def full_path(self, full_path: str):
-    if full_path is None:
-      del self.full_path
+  @error_description.setter
+  def error_description(self, error_description: Optional[str]):
+    if error_description is None:
+      del self.error_description
       return
-    if not isinstance(full_path, str):
-      raise TypeError('full_path must be of type str')
-    self._full_path = full_path
+    if not isinstance(error_description, str):
+      raise TypeError('error_description must be of type str')
+    self._error_description = error_description
 
   @property
-  def competition_count(self) -> int:
-    return self._competition_count
+  def file_name(self) -> str:
+    return self._file_name or ""
 
-  @competition_count.setter
-  def competition_count(self, competition_count: int):
-    if competition_count is None:
-      del self.competition_count
+  @file_name.setter
+  def file_name(self, file_name: Optional[str]):
+    if file_name is None:
+      del self.file_name
       return
-    if not isinstance(competition_count, int):
-      raise TypeError('competition_count must be of type int')
-    self._competition_count = competition_count
+    if not isinstance(file_name, str):
+      raise TypeError('file_name must be of type str')
+    self._file_name = file_name
 
   @property
-  def dataset_count(self) -> int:
-    return self._dataset_count
+  def public_score(self) -> str:
+    return self._public_score or ""
 
-  @dataset_count.setter
-  def dataset_count(self, dataset_count: int):
-    if dataset_count is None:
-      del self.dataset_count
+  @public_score.setter
+  def public_score(self, public_score: Optional[str]):
+    if public_score is None:
+      del self.public_score
       return
-    if not isinstance(dataset_count, int):
-      raise TypeError('dataset_count must be of type int')
-    self._dataset_count = dataset_count
+    if not isinstance(public_score, str):
+      raise TypeError('public_score must be of type str')
+    self._public_score = public_score
 
   @property
-  def script_count(self) -> int:
-    return self._script_count
+  def private_score(self) -> str:
+    return self._private_score or ""
 
-  @script_count.setter
-  def script_count(self, script_count: int):
-    if script_count is None:
-      del self.script_count
+  @private_score.setter
+  def private_score(self, private_score: Optional[str]):
+    if private_score is None:
+      del self.private_score
       return
-    if not isinstance(script_count, int):
-      raise TypeError('script_count must be of type int')
-    self._script_count = script_count
+    if not isinstance(private_score, str):
+      raise TypeError('private_score must be of type str')
+    self._private_score = private_score
 
   @property
-  def total_count(self) -> int:
-    return self._total_count
+  def status(self) -> 'SubmissionStatus':
+    return self._status
 
-  @total_count.setter
-  def total_count(self, total_count: int):
-    if total_count is None:
-      del self.total_count
+  @status.setter
+  def status(self, status: 'SubmissionStatus'):
+    if status is None:
+      del self.status
       return
-    if not isinstance(total_count, int):
-      raise TypeError('total_count must be of type int')
-    self._total_count = total_count
+    if not isinstance(status, SubmissionStatus):
+      raise TypeError('status must be of type SubmissionStatus')
+    self._status = status
+
+  @property
+  def submitted_by(self) -> str:
+    return self._submitted_by or ""
+
+  @submitted_by.setter
+  def submitted_by(self, submitted_by: Optional[str]):
+    if submitted_by is None:
+      del self.submitted_by
+      return
+    if not isinstance(submitted_by, str):
+      raise TypeError('submitted_by must be of type str')
+    self._submitted_by = submitted_by
+
+  @property
+  def submitted_by_ref(self) -> str:
+    return self._submitted_by_ref or ""
+
+  @submitted_by_ref.setter
+  def submitted_by_ref(self, submitted_by_ref: Optional[str]):
+    if submitted_by_ref is None:
+      del self.submitted_by_ref
+      return
+    if not isinstance(submitted_by_ref, str):
+      raise TypeError('submitted_by_ref must be of type str')
+    self._submitted_by_ref = submitted_by_ref
+
+  @property
+  def team_name(self) -> str:
+    return self._team_name or ""
+
+  @team_name.setter
+  def team_name(self, team_name: Optional[str]):
+    if team_name is None:
+      del self.team_name
+      return
+    if not isinstance(team_name, str):
+      raise TypeError('team_name must be of type str')
+    self._team_name = team_name
+
+  @property
+  def url(self) -> str:
+    r"""
+    Minor note: ListSubmissions and GetSubmission may differ in setting this
+    field.
+    """
+    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
+
+
+ApiCategory._fields = [
+  FieldMetadata("ref", "ref", "_ref", str, "", PredefinedSerializer()),
+  FieldMetadata("name", "name", "_name", str, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("description", "description", "_description", str, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("fullPath", "full_path", "_full_path", str, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("competitionCount", "competition_count", "_competition_count", int, 0, PredefinedSerializer()),
+  FieldMetadata("datasetCount", "dataset_count", "_dataset_count", int, 0, PredefinedSerializer()),
+  FieldMetadata("scriptCount", "script_count", "_script_count", int, 0, PredefinedSerializer()),
+  FieldMetadata("totalCount", "total_count", "_total_count", int, 0, PredefinedSerializer()),
+]
 
+ApiCompetition._fields = [
+  FieldMetadata("id", "id", "_id", int, 0, PredefinedSerializer()),
+  FieldMetadata("ref", "ref", "_ref", str, "", PredefinedSerializer()),
+  FieldMetadata("title", "title", "_title", str, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("url", "url", "_url", str, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("description", "description", "_description", str, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("organizationName", "organization_name", "_organization_name", str, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("organizationRef", "organization_ref", "_organization_ref", str, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("category", "category", "_category", str, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("reward", "reward", "_reward", str, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("tags", "tags", "_tags", ApiCategory, [], ListSerializer(KaggleObjectSerializer())),
+  FieldMetadata("deadline", "deadline", "_deadline", datetime, None, DateTimeSerializer()),
+  FieldMetadata("kernelCount", "kernel_count", "_kernel_count", int, 0, PredefinedSerializer()),
+  FieldMetadata("teamCount", "team_count", "_team_count", int, 0, PredefinedSerializer()),
+  FieldMetadata("userHasEntered", "user_has_entered", "_user_has_entered", bool, False, PredefinedSerializer()),
+  FieldMetadata("userRank", "user_rank", "_user_rank", int, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("mergerDeadline", "merger_deadline", "_merger_deadline", datetime, None, DateTimeSerializer()),
+  FieldMetadata("newEntrantDeadline", "new_entrant_deadline", "_new_entrant_deadline", datetime, None, DateTimeSerializer()),
+  FieldMetadata("enabledDate", "enabled_date", "_enabled_date", datetime, None, DateTimeSerializer()),
+  FieldMetadata("maxDailySubmissions", "max_daily_submissions", "_max_daily_submissions", int, 0, PredefinedSerializer()),
+  FieldMetadata("maxTeamSize", "max_team_size", "_max_team_size", int, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("evaluationMetric", "evaluation_metric", "_evaluation_metric", str, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("awardsPoints", "awards_points", "_awards_points", bool, False, PredefinedSerializer()),
+  FieldMetadata("isKernelsSubmissionsOnly", "is_kernels_submissions_only", "_is_kernels_submissions_only", bool, False, PredefinedSerializer()),
+  FieldMetadata("submissionsDisabled", "submissions_disabled", "_submissions_disabled", bool, False, PredefinedSerializer()),
+  FieldMetadata("thumbnailImageUrl", "thumbnail_image_url", "_thumbnail_image_url", str, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("hostName", "host_name", "_host_name", str, "", PredefinedSerializer()),
+]
 
 ApiCreateCodeSubmissionRequest._fields = [
   FieldMetadata("competitionName", "competition_name", "_competition_name", str, "", PredefinedSerializer()),
@@ -1885,6 +2262,15 @@ ApiCreateSubmissionResponse._fields = [
   FieldMetadata("ref", "ref", "_ref", int, 0, PredefinedSerializer()),
 ]
 
+ApiDataFile._fields = [
+  FieldMetadata("ref", "ref", "_ref", str, "", PredefinedSerializer()),
+  FieldMetadata("name", "name", "_name", str, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("description", "description", "_description", str, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("totalBytes", "total_bytes", "_total_bytes", int, 0, PredefinedSerializer()),
+  FieldMetadata("url", "url", "_url", str, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("creationDate", "creation_date", "_creation_date", datetime, None, DateTimeSerializer()),
+]
+
 ApiDownloadDataFileRequest._fields = [
   FieldMetadata("competitionName", "competition_name", "_competition_name", str, "", PredefinedSerializer()),
   FieldMetadata("fileName", "file_name", "_file_name", str, "", PredefinedSerializer()),
@@ -1898,13 +2284,24 @@ ApiDownloadLeaderboardRequest._fields = [
   FieldMetadata("competitionName", "competition_name", "_competition_name", str, "", PredefinedSerializer()),
 ]
 
+ApiGetCompetitionDataFilesSummaryRequest._fields = [
+  FieldMetadata("competitionName", "competition_name", "_competition_name", str, "", PredefinedSerializer()),
+]
+
+ApiGetCompetitionRequest._fields = [
+  FieldMetadata("competitionName", "competition_name", "_competition_name", str, "", PredefinedSerializer()),
+]
+
 ApiGetLeaderboardRequest._fields = [
   FieldMetadata("competitionName", "competition_name", "_competition_name", str, "", PredefinedSerializer()),
   FieldMetadata("overridePublic", "override_public", "_override_public", bool, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("pageSize", "page_size", "_page_size", int, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("pageToken", "page_token", "_page_token", str, None, PredefinedSerializer(), optional=True),
 ]
 
 ApiGetLeaderboardResponse._fields = [
   FieldMetadata("submissions", "submissions", "_submissions", ApiLeaderboardSubmission, [], ListSerializer(KaggleObjectSerializer())),
+  FieldMetadata("nextPageToken", "next_page_token", "_next_page_token", str, "", PredefinedSerializer()),
 ]
 
 ApiGetSubmissionRequest._fields = [
@@ -1924,10 +2321,13 @@ ApiListCompetitionsRequest._fields = [
   FieldMetadata("sortBy", "sort_by", "_sort_by", CompetitionSortBy, None, EnumSerializer(), optional=True),
   FieldMetadata("search", "search", "_search", str, None, PredefinedSerializer(), optional=True),
   FieldMetadata("page", "page", "_page", int, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("pageToken", "page_token", "_page_token", str, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("pageSize", "page_size", "_page_size", int, None, PredefinedSerializer(), optional=True),
 ]
 
 ApiListCompetitionsResponse._fields = [
   FieldMetadata("competitions", "competitions", "_competitions", ApiCompetition, [], ListSerializer(KaggleObjectSerializer())),
+  FieldMetadata("nextPageToken", "next_page_token", "_next_page_token", str, "", PredefinedSerializer()),
 ]
 
 ApiListDataFilesRequest._fields = [
@@ -1939,6 +2339,14 @@ ApiListDataFilesRequest._fields = [
 ApiListDataFilesResponse._fields = [
   FieldMetadata("files", "files", "_files", ApiDataFile, [], ListSerializer(KaggleObjectSerializer())),
   FieldMetadata("nextPageToken", "next_page_token", "_next_page_token", str, "", PredefinedSerializer()),
+  FieldMetadata("childrenFetchTimeMs", "children_fetch_time_ms", "_children_fetch_time_ms", int, 0, PredefinedSerializer()),
+]
+
+ApiListDataTreeFilesRequest._fields = [
+  FieldMetadata("competitionName", "competition_name", "_competition_name", str, "", PredefinedSerializer()),
+  FieldMetadata("path", "path", "_path", str, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("pageSize", "page_size", "_page_size", int, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("pageToken", "page_token", "_page_token", str, None, PredefinedSerializer(), optional=True),
 ]
 
 ApiListSubmissionsRequest._fields = [
@@ -1946,10 +2354,13 @@ ApiListSubmissionsRequest._fields = [
   FieldMetadata("sortBy", "sort_by", "_sort_by", SubmissionSortBy, SubmissionSortBy.SUBMISSION_SORT_BY_DATE, EnumSerializer()),
   FieldMetadata("group", "group", "_group", SubmissionGroup, SubmissionGroup.SUBMISSION_GROUP_ALL, EnumSerializer()),
   FieldMetadata("page", "page", "_page", int, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("pageToken", "page_token", "_page_token", str, None, PredefinedSerializer(), optional=True),
+  FieldMetadata("pageSize", "page_size", "_page_size", int, None, PredefinedSerializer(), optional=True),
 ]
 
 ApiListSubmissionsResponse._fields = [
   FieldMetadata("submissions", "submissions", "_submissions", ApiSubmission, [], ListSerializer(KaggleObjectSerializer())),
+  FieldMetadata("nextPageToken", "next_page_token", "_next_page_token", str, "", PredefinedSerializer()),
 ]
 
 ApiStartSubmissionUploadRequest._fields = [
@@ -1980,50 +2391,3 @@ ApiSubmission._fields = [
   FieldMetadata("url", "url", "_url", str, None, PredefinedSerializer(), optional=True),
 ]
 
-ApiCompetition._fields = [
-  FieldMetadata("id", "id", "_id", int, 0, PredefinedSerializer()),
-  FieldMetadata("ref", "ref", "_ref", str, "", PredefinedSerializer()),
-  FieldMetadata("title", "title", "_title", str, None, PredefinedSerializer(), optional=True),
-  FieldMetadata("url", "url", "_url", str, None, PredefinedSerializer(), optional=True),
-  FieldMetadata("description", "description", "_description", str, None, PredefinedSerializer(), optional=True),
-  FieldMetadata("organizationName", "organization_name", "_organization_name", str, None, PredefinedSerializer(), optional=True),
-  FieldMetadata("organizationRef", "organization_ref", "_organization_ref", str, None, PredefinedSerializer(), optional=True),
-  FieldMetadata("category", "category", "_category", str, None, PredefinedSerializer(), optional=True),
-  FieldMetadata("reward", "reward", "_reward", str, None, PredefinedSerializer(), optional=True),
-  FieldMetadata("tags", "tags", "_tags", ApiCategory, [], ListSerializer(KaggleObjectSerializer())),
-  FieldMetadata("deadline", "deadline", "_deadline", datetime, None, DateTimeSerializer()),
-  FieldMetadata("kernelCount", "kernel_count", "_kernel_count", int, 0, PredefinedSerializer()),
-  FieldMetadata("teamCount", "team_count", "_team_count", int, 0, PredefinedSerializer()),
-  FieldMetadata("userHasEntered", "user_has_entered", "_user_has_entered", bool, False, PredefinedSerializer()),
-  FieldMetadata("userRank", "user_rank", "_user_rank", int, None, PredefinedSerializer(), optional=True),
-  FieldMetadata("mergerDeadline", "merger_deadline", "_merger_deadline", datetime, None, DateTimeSerializer()),
-  FieldMetadata("newEntrantDeadline", "new_entrant_deadline", "_new_entrant_deadline", datetime, None, DateTimeSerializer()),
-  FieldMetadata("enabledDate", "enabled_date", "_enabled_date", datetime, None, DateTimeSerializer()),
-  FieldMetadata("maxDailySubmissions", "max_daily_submissions", "_max_daily_submissions", int, 0, PredefinedSerializer()),
-  FieldMetadata("maxTeamSize", "max_team_size", "_max_team_size", int, None, PredefinedSerializer(), optional=True),
-  FieldMetadata("evaluationMetric", "evaluation_metric", "_evaluation_metric", str, None, PredefinedSerializer(), optional=True),
-  FieldMetadata("awardsPoints", "awards_points", "_awards_points", bool, False, PredefinedSerializer()),
-  FieldMetadata("isKernelsSubmissionsOnly", "is_kernels_submissions_only", "_is_kernels_submissions_only", bool, False, PredefinedSerializer()),
-  FieldMetadata("submissionsDisabled", "submissions_disabled", "_submissions_disabled", bool, False, PredefinedSerializer()),
-]
-
-ApiDataFile._fields = [
-  FieldMetadata("ref", "ref", "_ref", str, "", PredefinedSerializer()),
-  FieldMetadata("name", "name", "_name", str, None, PredefinedSerializer(), optional=True),
-  FieldMetadata("description", "description", "_description", str, None, PredefinedSerializer(), optional=True),
-  FieldMetadata("totalBytes", "total_bytes", "_total_bytes", int, 0, PredefinedSerializer()),
-  FieldMetadata("url", "url", "_url", str, None, PredefinedSerializer(), optional=True),
-  FieldMetadata("creationDate", "creation_date", "_creation_date", datetime, None, DateTimeSerializer()),
-]
-
-ApiCategory._fields = [
-  FieldMetadata("ref", "ref", "_ref", str, "", PredefinedSerializer()),
-  FieldMetadata("name", "name", "_name", str, None, PredefinedSerializer(), optional=True),
-  FieldMetadata("description", "description", "_description", str, None, PredefinedSerializer(), optional=True),
-  FieldMetadata("fullPath", "full_path", "_full_path", str, None, PredefinedSerializer(), optional=True),
-  FieldMetadata("competitionCount", "competition_count", "_competition_count", int, 0, PredefinedSerializer()),
-  FieldMetadata("datasetCount", "dataset_count", "_dataset_count", int, 0, PredefinedSerializer()),
-  FieldMetadata("scriptCount", "script_count", "_script_count", int, 0, PredefinedSerializer()),
-  FieldMetadata("totalCount", "total_count", "_total_count", int, 0, PredefinedSerializer()),
-]
-