google-genai 1.30.0__py3-none-any.whl → 1.32.0__py3-none-any.whl

google/genai/types.py

@@ -19,6 +19,7 @@ from abc import ABC, abstractmethod
 import datetime
 from enum import Enum, EnumMeta
 import inspect
+import io
 import json
 import logging
 import sys
@@ -29,6 +30,11 @@ import pydantic
 from pydantic import ConfigDict, Field, PrivateAttr, model_validator
 from typing_extensions import Self, TypedDict
 from . import _common
+from ._operations_converters import (
+    _GenerateVideosOperation_from_mldev,
+    _GenerateVideosOperation_from_vertex,
+)
+
 
 if sys.version_info >= (3, 10):
   # Supports both Union[t1, t2] and t1 | t2
@@ -429,6 +435,22 @@ class AdapterSize(_common.CaseInSensitiveEnum):
   """Adapter size 32."""
 
 
+class JSONSchemaType(Enum):
+  """The type of the data supported by JSON Schema.
+
+  The values of the enums are lower case strings, while the values of the enums
+  for the Type class are upper case strings.
+  """
+
+  NULL = 'null'
+  BOOLEAN = 'boolean'
+  OBJECT = 'object'
+  ARRAY = 'array'
+  NUMBER = 'number'
+  INTEGER = 'integer'
+  STRING = 'string'
+
+
 class FeatureSelectionPreference(_common.CaseInSensitiveEnum):
   """Options for feature selection preference."""
 
@@ -480,6 +502,8 @@ class FunctionCallingConfigMode(_common.CaseInSensitiveEnum):
   """Model is constrained to always predicting function calls only. If "allowed_function_names" are set, the predicted function calls will be limited to any one of "allowed_function_names", else the predicted function calls will be any one of the provided "function_declarations"."""
   NONE = 'NONE'
   """Model will not predict any function calls. Model behavior is same as when not passing any function declarations."""
+  VALIDATED = 'VALIDATED'
+  """Model decides to predict either a function call or a natural language response, but will validate function calls with constrained decoding. If "allowed_function_names" are set, the predicted function call will be limited to any one of "allowed_function_names", else the predicted function call will be any one of the provided "function_declarations"."""
 
 
 class SafetyFilterLevel(_common.CaseInSensitiveEnum):
@@ -564,6 +588,28 @@ class EditMode(_common.CaseInSensitiveEnum):
   EDIT_MODE_PRODUCT_IMAGE = 'EDIT_MODE_PRODUCT_IMAGE'
 
 
+class SegmentMode(_common.CaseInSensitiveEnum):
+  """Enum that represents the segmentation mode."""
+
+  FOREGROUND = 'FOREGROUND'
+  BACKGROUND = 'BACKGROUND'
+  PROMPT = 'PROMPT'
+  SEMANTIC = 'SEMANTIC'
+  INTERACTIVE = 'INTERACTIVE'
+
+
+class VideoGenerationReferenceType(_common.CaseInSensitiveEnum):
+  """Enum for the reference type of a video generation reference image."""
+
+  ASSET = 'ASSET'
+  """A reference image that provides assets to the generated video,
+      such as the scene, an object, a character, etc."""
+  STYLE = 'STYLE'
+  """A reference image that provides aesthetics including colors,
+      lighting, texture, etc., to be used as the style of the generated video,
+      such as 'anime', 'photography', 'origami', etc."""
+
+
 class VideoCompressionQuality(_common.CaseInSensitiveEnum):
   """Enum that controls the compression quality of the generated videos."""
 
@@ -609,6 +655,19 @@ class MediaModality(_common.CaseInSensitiveEnum):
   """Document, e.g. PDF."""
 
 
+class FunctionResponseScheduling(_common.CaseInSensitiveEnum):
+  """Specifies how the response should be scheduled in the conversation."""
+
+  SCHEDULING_UNSPECIFIED = 'SCHEDULING_UNSPECIFIED'
+  """This value is unused."""
+  SILENT = 'SILENT'
+  """Only add the result to the conversation context, do not interrupt or trigger generation."""
+  WHEN_IDLE = 'WHEN_IDLE'
+  """Add the result to the conversation context, and prompt to generate output without interrupting ongoing generation."""
+  INTERRUPT = 'INTERRUPT'
+  """Add the result to the conversation context, interrupt ongoing generation and prompt to generate output."""
+
+
 class StartSensitivity(_common.CaseInSensitiveEnum):
   """Start of speech sensitivity."""
 
@@ -653,19 +712,6 @@ class TurnCoverage(_common.CaseInSensitiveEnum):
   """The users turn includes all realtime input since the last turn, including inactivity (e.g. silence on the audio stream)."""
 
 
-class FunctionResponseScheduling(_common.CaseInSensitiveEnum):
-  """Specifies how the response should be scheduled in the conversation."""
-
-  SCHEDULING_UNSPECIFIED = 'SCHEDULING_UNSPECIFIED'
-  """This value is unused."""
-  SILENT = 'SILENT'
-  """Only add the result to the conversation context, do not interrupt or trigger generation."""
-  WHEN_IDLE = 'WHEN_IDLE'
-  """Add the result to the conversation context, and prompt to generate output without interrupting ongoing generation."""
-  INTERRUPT = 'INTERRUPT'
-  """Add the result to the conversation context, interrupt ongoing generation and prompt to generate output."""
-
-
 class Scale(_common.CaseInSensitiveEnum):
   """Scale of the generated music."""
 
@@ -778,6 +824,21 @@ class Blob(_common.BaseModel):
       description="""Required. The IANA standard MIME type of the source data.""",
   )
 
+  def as_image(self) -> Optional['PIL_Image']:
+    """Returns the Blob as a PIL Image, or None if the Blob is not an image."""
+    if (
+        not self.data
+        or not self.mime_type
+        or not self.mime_type.startswith('image/')
+    ):
+      return None
+    if not _is_pillow_image_imported:
+      raise ImportError(
+          'The PIL module is not available. Please install the Pillow'
+          ' package. `pip install pillow`'
+      )
+    return PIL.Image.open(io.BytesIO(self.data))
+
 
 class BlobDict(TypedDict, total=False):
   """Content blob."""
@@ -1037,6 +1098,12 @@ class Part(_common.BaseModel):
       default=None, description="""Optional. Text part (can be code)."""
   )
 
+  def as_image(self) -> Optional['PIL_Image']:
+    """Returns the part as a PIL Image, or None if the part is not an image."""
+    if not self.inline_data:
+      return None
+    return self.inline_data.as_image()
+
   @classmethod
   def from_uri(
       cls, *, file_uri: str, mime_type: Optional[str] = None
@@ -1152,67 +1219,6 @@ class Content(_common.BaseModel):
   )
 
 
-class UserContent(Content):
-  """UserContent facilitates the creation of a Content object with a user role.
-
-  Example usages:
-
-
-  - Create a user Content object with a string:
-    user_content = UserContent("Why is the sky blue?")
-  - Create a user Content object with a file data Part object:
-    user_content = UserContent(Part.from_uri(file_uril="gs://bucket/file.txt",
-    mime_type="text/plain"))
-  - Create a user Content object with byte data Part object:
-    user_content = UserContent(Part.from_bytes(data=b"Hello, World!",
-    mime_type="text/plain"))
-
-    You can create a user Content object using other classmethods in the Part
-    class as well.
-    You can also create a user Content using a list of Part objects or strings.
-  """
-
-  role: Literal['user'] = Field(default='user', init=False, frozen=True)
-  parts: list[Part] = Field()
-
-  def __init__(
-      self, parts: Union['PartUnionDict', list['PartUnionDict'], list['Part']]
-  ):
-    from . import _transformers as t
-
-    super().__init__(parts=t.t_parts(parts=parts))
-
-
-class ModelContent(Content):
-  """ModelContent facilitates the creation of a Content object with a model role.
-
-  Example usages:
-
-  - Create a model Content object with a string:
-    model_content = ModelContent("Why is the sky blue?")
-  - Create a model Content object with a file data Part object:
-    model_content = ModelContent(Part.from_uri(file_uril="gs://bucket/file.txt",
-    mime_type="text/plain"))
-  - Create a model Content object with byte data Part object:
-    model_content = ModelContent(Part.from_bytes(data=b"Hello, World!",
-    mime_type="text/plain"))
-
-    You can create a model Content object using other classmethods in the Part
-    class as well.
-    You can also create a model Content using a list of Part objects or strings.
-  """
-
-  role: Literal['model'] = Field(default='model', init=False, frozen=True)
-  parts: list[Part] = Field()
-
-  def __init__(
-      self, parts: Union['PartUnionDict', list['PartUnionDict'], list['Part']]
-  ):
-    from . import _transformers as t
-
-    super().__init__(parts=t.t_parts(parts=parts))
-
-
 class ContentDict(TypedDict, total=False):
   """Contains the multi-part content of a message."""
 
@@ -1355,23 +1361,7 @@ class HttpOptionsDict(TypedDict, total=False):
 HttpOptionsOrDict = Union[HttpOptions, HttpOptionsDict]
 
 
-class JSONSchemaType(Enum):
-  """The type of the data supported by JSON Schema.
-
-  The values of the enums are lower case strings, while the values of the enums
-  for the Type class are upper case strings.
-  """
-
-  NULL = 'null'
-  BOOLEAN = 'boolean'
-  OBJECT = 'object'
-  ARRAY = 'array'
-  NUMBER = 'number'
-  INTEGER = 'integer'
-  STRING = 'string'
-
-
-class JSONSchema(pydantic.BaseModel):
+class JSONSchema(_common.BaseModel):
   """A subset of JSON Schema according to 2020-12 JSON Schema draft.
 
   Represents a subset of a JSON Schema object that is used by the Gemini model.
@@ -5497,6 +5487,23 @@ class GenerateContentResponse(_common.BaseModel):
     # part.text == '' is different from part.text is None
     return text if any_text_part_text else None
 
+  @property
+  def parts(self) -> Optional[list[Part]]:
+    """Returns the content-parts in the response."""
+    if (
+        not self.candidates
+        or self.candidates[0].content is None
+        or self.candidates[0].content.parts is None
+    ):
+      return None
+    if len(self.candidates) > 1:
+      logger.warning(
+          'Warning: there are multiple candidates in the response, returning'
+          ' parts from the first one.'
+      )
+
+    return self.candidates[0].content.parts
+
   @property
   def text(self) -> Optional[str]:
     """Returns the concatenation of all text parts in the response."""
@@ -6905,6 +6912,10 @@ class _UpscaleImageAPIConfig(_common.BaseModel):
   http_options: Optional[HttpOptions] = Field(
       default=None, description="""Used to override HTTP request options."""
   )
+  output_gcs_uri: Optional[str] = Field(
+      default=None,
+      description="""Cloud Storage URI used to store the generated images.""",
+  )
   include_rai_reason: Optional[bool] = Field(
       default=None,
       description="""Whether to include a reason for filtered-out images in the
@@ -6946,6 +6957,9 @@ class _UpscaleImageAPIConfigDict(TypedDict, total=False):
   http_options: Optional[HttpOptionsDict]
   """Used to override HTTP request options."""
 
+  output_gcs_uri: Optional[str]
+  """Cloud Storage URI used to store the generated images."""
+
   include_rai_reason: Optional[bool]
   """Whether to include a reason for filtered-out images in the
       response."""
@@ -7129,6 +7143,10 @@ class RecontextImageConfig(_common.BaseModel):
       description="""Whether allow to generate person images, and restrict to specific
       ages.""",
   )
+  add_watermark: Optional[bool] = Field(
+      default=None,
+      description="""Whether to add a SynthID watermark to the generated images.""",
+  )
   output_mime_type: Optional[str] = Field(
       default=None, description="""MIME type of the generated image."""
   )
@@ -7168,6 +7186,9 @@ class RecontextImageConfigDict(TypedDict, total=False):
   """Whether allow to generate person images, and restrict to specific
       ages."""
 
+  add_watermark: Optional[bool]
+  """Whether to add a SynthID watermark to the generated images."""
+
   output_mime_type: Optional[str]
   """MIME type of the generated image."""
 
@@ -7241,118 +7262,348 @@ RecontextImageResponseOrDict = Union[
 ]
 
 
-class GetModelConfig(_common.BaseModel):
-  """Optional parameters for models.get method."""
+class ScribbleImage(_common.BaseModel):
+  """An image mask representing a brush scribble."""
 
-  http_options: Optional[HttpOptions] = Field(
-      default=None, description="""Used to override HTTP request options."""
+  image: Optional[Image] = Field(
+      default=None,
+      description="""The brush scribble to guide segmentation. Valid for the interactive mode.""",
   )
 
 
-class GetModelConfigDict(TypedDict, total=False):
-  """Optional parameters for models.get method."""
+class ScribbleImageDict(TypedDict, total=False):
+  """An image mask representing a brush scribble."""
 
-  http_options: Optional[HttpOptionsDict]
-  """Used to override HTTP request options."""
+  image: Optional[ImageDict]
+  """The brush scribble to guide segmentation. Valid for the interactive mode."""
 
 
-GetModelConfigOrDict = Union[GetModelConfig, GetModelConfigDict]
+ScribbleImageOrDict = Union[ScribbleImage, ScribbleImageDict]
 
 
-class _GetModelParameters(_common.BaseModel):
+class SegmentImageSource(_common.BaseModel):
+  """A set of source input(s) for image segmentation."""
 
-  model: Optional[str] = Field(default=None, description="""""")
-  config: Optional[GetModelConfig] = Field(
-      default=None, description="""Optional parameters for the request."""
+  prompt: Optional[str] = Field(
+      default=None,
+      description="""A text prompt for guiding the model during image segmentation.
+      Required for prompt mode and semantic mode, disallowed for other modes.""",
+  )
+  image: Optional[Image] = Field(
+      default=None, description="""The image to be segmented."""
+  )
+  scribble_image: Optional[ScribbleImage] = Field(
+      default=None,
+      description="""The brush scribble to guide segmentation.
+      Required for the interactive mode, disallowed for other modes.""",
   )
 
 
-class _GetModelParametersDict(TypedDict, total=False):
+class SegmentImageSourceDict(TypedDict, total=False):
+  """A set of source input(s) for image segmentation."""
 
-  model: Optional[str]
-  """"""
+  prompt: Optional[str]
+  """A text prompt for guiding the model during image segmentation.
+      Required for prompt mode and semantic mode, disallowed for other modes."""
 
-  config: Optional[GetModelConfigDict]
-  """Optional parameters for the request."""
+  image: Optional[ImageDict]
+  """The image to be segmented."""
 
+  scribble_image: Optional[ScribbleImageDict]
+  """The brush scribble to guide segmentation.
+      Required for the interactive mode, disallowed for other modes."""
 
-_GetModelParametersOrDict = Union[_GetModelParameters, _GetModelParametersDict]
 
+SegmentImageSourceOrDict = Union[SegmentImageSource, SegmentImageSourceDict]
 
-class Endpoint(_common.BaseModel):
-  """An endpoint where you deploy models."""
 
-  name: Optional[str] = Field(
-      default=None, description="""Resource name of the endpoint."""
+class SegmentImageConfig(_common.BaseModel):
+  """Configuration for segmenting an image."""
+
+  http_options: Optional[HttpOptions] = Field(
+      default=None, description="""Used to override HTTP request options."""
   )
-  deployed_model_id: Optional[str] = Field(
+  mode: Optional[SegmentMode] = Field(
+      default=None, description="""The segmentation mode to use."""
+  )
+  max_predictions: Optional[int] = Field(
       default=None,
-      description="""ID of the model that's deployed to the endpoint.""",
+      description="""The maximum number of predictions to return up to, by top
+      confidence score.""",
+  )
+  confidence_threshold: Optional[float] = Field(
+      default=None,
+      description="""The confidence score threshold for the detections as a decimal
+      value. Only predictions with a confidence score higher than this
+      threshold will be returned.""",
+  )
+  mask_dilation: Optional[float] = Field(
+      default=None,
+      description="""A decimal value representing how much dilation to apply to the
+      masks. 0 for no dilation. 1.0 means the masked area covers the whole
+      image.""",
+  )
+  binary_color_threshold: Optional[float] = Field(
+      default=None,
+      description="""The binary color threshold to apply to the masks. The threshold
+      can be set to a decimal value between 0 and 255 non-inclusive.
+      Set to -1 for no binary color thresholding.""",
   )
 
 
-class EndpointDict(TypedDict, total=False):
-  """An endpoint where you deploy models."""
+class SegmentImageConfigDict(TypedDict, total=False):
+  """Configuration for segmenting an image."""
 
-  name: Optional[str]
-  """Resource name of the endpoint."""
+  http_options: Optional[HttpOptionsDict]
+  """Used to override HTTP request options."""
 
-  deployed_model_id: Optional[str]
-  """ID of the model that's deployed to the endpoint."""
+  mode: Optional[SegmentMode]
+  """The segmentation mode to use."""
 
+  max_predictions: Optional[int]
+  """The maximum number of predictions to return up to, by top
+      confidence score."""
 
-EndpointOrDict = Union[Endpoint, EndpointDict]
+  confidence_threshold: Optional[float]
+  """The confidence score threshold for the detections as a decimal
+      value. Only predictions with a confidence score higher than this
+      threshold will be returned."""
 
+  mask_dilation: Optional[float]
+  """A decimal value representing how much dilation to apply to the
+      masks. 0 for no dilation. 1.0 means the masked area covers the whole
+      image."""
 
-class TunedModelInfo(_common.BaseModel):
-  """A tuned machine learning model."""
+  binary_color_threshold: Optional[float]
+  """The binary color threshold to apply to the masks. The threshold
+      can be set to a decimal value between 0 and 255 non-inclusive.
+      Set to -1 for no binary color thresholding."""
 
-  base_model: Optional[str] = Field(
+
+SegmentImageConfigOrDict = Union[SegmentImageConfig, SegmentImageConfigDict]
+
+
+class _SegmentImageParameters(_common.BaseModel):
+  """The parameters for segmenting an image."""
+
+  model: Optional[str] = Field(
       default=None,
-      description="""ID of the base model that you want to tune.""",
+      description="""ID of the model to use. For a list of models, see `Google models
+    <https://cloud.google.com/vertex-ai/generative-ai/docs/learn/models>`_.""",
   )
-  create_time: Optional[datetime.datetime] = Field(
+  source: Optional[SegmentImageSource] = Field(
       default=None,
-      description="""Date and time when the base model was created.""",
+      description="""A set of source input(s) for image segmentation.""",
   )
-  update_time: Optional[datetime.datetime] = Field(
-      default=None,
-      description="""Date and time when the base model was last updated.""",
+  config: Optional[SegmentImageConfig] = Field(
+      default=None, description="""Configuration for image segmentation."""
   )
 
 
-class TunedModelInfoDict(TypedDict, total=False):
-  """A tuned machine learning model."""
+class _SegmentImageParametersDict(TypedDict, total=False):
+  """The parameters for segmenting an image."""
 
-  base_model: Optional[str]
-  """ID of the base model that you want to tune."""
+  model: Optional[str]
+  """ID of the model to use. For a list of models, see `Google models
+    <https://cloud.google.com/vertex-ai/generative-ai/docs/learn/models>`_."""
 
-  create_time: Optional[datetime.datetime]
-  """Date and time when the base model was created."""
+  source: Optional[SegmentImageSourceDict]
+  """A set of source input(s) for image segmentation."""
 
-  update_time: Optional[datetime.datetime]
-  """Date and time when the base model was last updated."""
+  config: Optional[SegmentImageConfigDict]
+  """Configuration for image segmentation."""
 
 
-TunedModelInfoOrDict = Union[TunedModelInfo, TunedModelInfoDict]
+_SegmentImageParametersOrDict = Union[
+    _SegmentImageParameters, _SegmentImageParametersDict
+]
 
 
-class Checkpoint(_common.BaseModel):
-  """Describes the machine learning model version checkpoint."""
+class EntityLabel(_common.BaseModel):
+  """An entity representing the segmented area."""
 
-  checkpoint_id: Optional[str] = Field(
-      default=None,
-      description="""The ID of the checkpoint.
-      """,
+  label: Optional[str] = Field(
+      default=None, description="""The label of the segmented entity."""
   )
-  epoch: Optional[int] = Field(
+  score: Optional[float] = Field(
       default=None,
-      description="""The epoch of the checkpoint.
-      """,
+      description="""The confidence score of the detected label.""",
   )
-  step: Optional[int] = Field(
-      default=None,
-      description="""The step of the checkpoint.
+
+
+class EntityLabelDict(TypedDict, total=False):
+  """An entity representing the segmented area."""
+
+  label: Optional[str]
+  """The label of the segmented entity."""
+
+  score: Optional[float]
+  """The confidence score of the detected label."""
+
+
+EntityLabelOrDict = Union[EntityLabel, EntityLabelDict]
+
+
+class GeneratedImageMask(_common.BaseModel):
+  """A generated image mask."""
+
+  mask: Optional[Image] = Field(
+      default=None, description="""The generated image mask."""
+  )
+  labels: Optional[list[EntityLabel]] = Field(
+      default=None,
+      description="""The detected entities on the segmented area.""",
+  )
+
+
+class GeneratedImageMaskDict(TypedDict, total=False):
+  """A generated image mask."""
+
+  mask: Optional[ImageDict]
+  """The generated image mask."""
+
+  labels: Optional[list[EntityLabelDict]]
+  """The detected entities on the segmented area."""
+
+
+GeneratedImageMaskOrDict = Union[GeneratedImageMask, GeneratedImageMaskDict]
+
+
+class SegmentImageResponse(_common.BaseModel):
+  """The output images response."""
+
+  generated_masks: Optional[list[GeneratedImageMask]] = Field(
+      default=None,
+      description="""List of generated image masks.
+      """,
+  )
+
+
+class SegmentImageResponseDict(TypedDict, total=False):
+  """The output images response."""
+
+  generated_masks: Optional[list[GeneratedImageMaskDict]]
+  """List of generated image masks.
+      """
+
+
+SegmentImageResponseOrDict = Union[
+    SegmentImageResponse, SegmentImageResponseDict
+]
+
+
+class GetModelConfig(_common.BaseModel):
+  """Optional parameters for models.get method."""
+
+  http_options: Optional[HttpOptions] = Field(
+      default=None, description="""Used to override HTTP request options."""
+  )
+
+
+class GetModelConfigDict(TypedDict, total=False):
+  """Optional parameters for models.get method."""
+
+  http_options: Optional[HttpOptionsDict]
+  """Used to override HTTP request options."""
+
+
+GetModelConfigOrDict = Union[GetModelConfig, GetModelConfigDict]
+
+
+class _GetModelParameters(_common.BaseModel):
+
+  model: Optional[str] = Field(default=None, description="""""")
+  config: Optional[GetModelConfig] = Field(
+      default=None, description="""Optional parameters for the request."""
+  )
+
+
+class _GetModelParametersDict(TypedDict, total=False):
+
+  model: Optional[str]
+  """"""
+
+  config: Optional[GetModelConfigDict]
+  """Optional parameters for the request."""
+
+
+_GetModelParametersOrDict = Union[_GetModelParameters, _GetModelParametersDict]
+
+
+class Endpoint(_common.BaseModel):
+  """An endpoint where you deploy models."""
+
+  name: Optional[str] = Field(
+      default=None, description="""Resource name of the endpoint."""
+  )
+  deployed_model_id: Optional[str] = Field(
+      default=None,
+      description="""ID of the model that's deployed to the endpoint.""",
+  )
+
+
+class EndpointDict(TypedDict, total=False):
+  """An endpoint where you deploy models."""
+
+  name: Optional[str]
+  """Resource name of the endpoint."""
+
+  deployed_model_id: Optional[str]
+  """ID of the model that's deployed to the endpoint."""
+
+
+EndpointOrDict = Union[Endpoint, EndpointDict]
+
+
+class TunedModelInfo(_common.BaseModel):
+  """A tuned machine learning model."""
+
+  base_model: Optional[str] = Field(
+      default=None,
+      description="""ID of the base model that you want to tune.""",
+  )
+  create_time: Optional[datetime.datetime] = Field(
+      default=None,
+      description="""Date and time when the base model was created.""",
+  )
+  update_time: Optional[datetime.datetime] = Field(
+      default=None,
+      description="""Date and time when the base model was last updated.""",
+  )
+
+
+class TunedModelInfoDict(TypedDict, total=False):
+  """A tuned machine learning model."""
+
+  base_model: Optional[str]
+  """ID of the base model that you want to tune."""
+
+  create_time: Optional[datetime.datetime]
+  """Date and time when the base model was created."""
+
+  update_time: Optional[datetime.datetime]
+  """Date and time when the base model was last updated."""
+
+
+TunedModelInfoOrDict = Union[TunedModelInfo, TunedModelInfoDict]
+
+
+class Checkpoint(_common.BaseModel):
+  """Describes the machine learning model version checkpoint."""
+
+  checkpoint_id: Optional[str] = Field(
+      default=None,
+      description="""The ID of the checkpoint.
+      """,
+  )
+  epoch: Optional[int] = Field(
+      default=None,
+      description="""The epoch of the checkpoint.
+      """,
+  )
+  step: Optional[int] = Field(
+      default=None,
+      description="""The step of the checkpoint.
       """,
   )
 
@@ -7649,12 +7900,15 @@ _DeleteModelParametersOrDict = Union[
 
 class DeleteModelResponse(_common.BaseModel):
 
-  pass
+  sdk_http_response: Optional[HttpResponse] = Field(
+      default=None, description="""Used to retain the full HTTP response."""
+  )
 
 
 class DeleteModelResponseDict(TypedDict, total=False):
 
-  pass
+  sdk_http_response: Optional[HttpResponseDict]
+  """Used to retain the full HTTP response."""
 
 
 DeleteModelResponseOrDict = Union[DeleteModelResponse, DeleteModelResponseDict]
@@ -8019,7 +8273,7 @@ class TokensInfo(_common.BaseModel):
 
   role: Optional[str] = Field(
       default=None,
-      description="""Optional. Optional fields for the role from the corresponding Content.""",
+      description="""Optional fields for the role from the corresponding Content.""",
   )
   token_ids: Optional[list[int]] = Field(
       default=None, description="""A list of token ids from the input."""
@@ -8033,7 +8287,7 @@ class TokensInfoDict(TypedDict, total=False):
   """Tokens info with a list of tokens and the corresponding list of token ids."""
 
   role: Optional[str]
-  """Optional. Optional fields for the role from the corresponding Content."""
+  """Optional fields for the role from the corresponding Content."""
 
   token_ids: Optional[list[int]]
   """A list of token ids from the input."""
@@ -8175,6 +8429,79 @@ class VideoDict(TypedDict, total=False):
 VideoOrDict = Union[Video, VideoDict]
 
 
+class GenerateVideosSource(_common.BaseModel):
+  """A set of source input(s) for video generation."""
+
+  prompt: Optional[str] = Field(
+      default=None,
+      description="""The text prompt for generating the videos.
+      Optional if image or video is provided.""",
+  )
+  image: Optional[Image] = Field(
+      default=None,
+      description="""The input image for generating the videos.
+      Optional if prompt or video is provided.""",
+  )
+  video: Optional[Video] = Field(
+      default=None,
+      description="""The input video for video extension use cases.
+      Optional if prompt or image is provided.""",
+  )
+
+
+class GenerateVideosSourceDict(TypedDict, total=False):
+  """A set of source input(s) for video generation."""
+
+  prompt: Optional[str]
+  """The text prompt for generating the videos.
+      Optional if image or video is provided."""
+
+  image: Optional[ImageDict]
+  """The input image for generating the videos.
+      Optional if prompt or video is provided."""
+
+  video: Optional[VideoDict]
+  """The input video for video extension use cases.
+      Optional if prompt or image is provided."""
+
+
+GenerateVideosSourceOrDict = Union[
+    GenerateVideosSource, GenerateVideosSourceDict
+]
+
+
+class VideoGenerationReferenceImage(_common.BaseModel):
+  """A reference image for video generation."""
+
+  image: Optional[Image] = Field(
+      default=None,
+      description="""The reference image.
+      """,
+  )
+  reference_type: Optional[VideoGenerationReferenceType] = Field(
+      default=None,
+      description="""The type of the reference image, which defines how the reference
+      image will be used to generate the video.""",
+  )
+
+
+class VideoGenerationReferenceImageDict(TypedDict, total=False):
+  """A reference image for video generation."""
+
+  image: Optional[ImageDict]
+  """The reference image.
+      """
+
+  reference_type: Optional[VideoGenerationReferenceType]
+  """The type of the reference image, which defines how the reference
+      image will be used to generate the video."""
+
+
+VideoGenerationReferenceImageOrDict = Union[
+    VideoGenerationReferenceImage, VideoGenerationReferenceImageDict
+]
+
+
 class GenerateVideosConfig(_common.BaseModel):
   """Configuration for generating videos."""
 
@@ -8230,6 +8557,14 @@ class GenerateVideosConfig(_common.BaseModel):
       default=None,
       description="""Image to use as the last frame of generated videos. Only supported for image to video use cases.""",
   )
+  reference_images: Optional[list[VideoGenerationReferenceImage]] = Field(
+      default=None,
+      description="""The images to use as the references to generate the videos.
+      If this field is provided, the text prompt field must also be provided.
+      The image, video, or last_frame field are not supported. Each image must
+      be associated with a type. Veo 2 supports up to 3 asset images *or* 1
+      style image.""",
+  )
   compression_quality: Optional[VideoCompressionQuality] = Field(
       default=None,
       description="""Compression quality of the generated videos.""",
@@ -8281,6 +8616,13 @@ class GenerateVideosConfigDict(TypedDict, total=False):
   last_frame: Optional[ImageDict]
   """Image to use as the last frame of generated videos. Only supported for image to video use cases."""
 
+  reference_images: Optional[list[VideoGenerationReferenceImageDict]]
+  """The images to use as the references to generate the videos.
+      If this field is provided, the text prompt field must also be provided.
+      The image, video, or last_frame field are not supported. Each image must
+      be associated with a type. Veo 2 supports up to 3 asset images *or* 1
+      style image."""
+
   compression_quality: Optional[VideoCompressionQuality]
   """Compression quality of the generated videos."""
 
@@ -8312,6 +8654,10 @@ class _GenerateVideosParameters(_common.BaseModel):
       description="""The input video for video extension use cases.
       Optional if prompt or image is provided.""",
   )
+  source: Optional[GenerateVideosSource] = Field(
+      default=None,
+      description="""A set of source input(s) for video generation.""",
+  )
   config: Optional[GenerateVideosConfig] = Field(
       default=None, description="""Configuration for generating videos."""
   )
@@ -8335,6 +8681,9 @@ class _GenerateVideosParametersDict(TypedDict, total=False):
   """The input video for video extension use cases.
       Optional if prompt or image is provided."""
 
+  source: Optional[GenerateVideosSourceDict]
+  """A set of source input(s) for video generation."""
+
   config: Optional[GenerateVideosConfigDict]
   """Configuration for generating videos."""
 
@@ -8377,6 +8726,24 @@ class GenerateVideosResponse(_common.BaseModel):
   )
 
 
+class GenerateVideosResponseDict(TypedDict, total=False):
+  """Response with generated videos."""
+
+  generated_videos: Optional[list[GeneratedVideoDict]]
+  """List of the generated videos"""
+
+  rai_media_filtered_count: Optional[int]
+  """Returns if any videos were filtered due to RAI policies."""
+
+  rai_media_filtered_reasons: Optional[list[str]]
+  """Returns rai failure reasons if any."""
+
+
+GenerateVideosResponseOrDict = Union[
+    GenerateVideosResponse, GenerateVideosResponseDict
+]
+
+
 class Operation(ABC):
   """A long-running operation."""
 
@@ -8412,7 +8779,6 @@ class GenerateVideosOperation(_common.BaseModel, Operation):
   response: Optional[GenerateVideosResponse] = Field(
       default=None, description="""The generated videos."""
   )
-
   result: Optional[GenerateVideosResponse] = Field(
       default=None, description="""The generated videos."""
   )
@@ -8422,76 +8788,12 @@ class GenerateVideosOperation(_common.BaseModel, Operation):
       cls, api_response: Any, is_vertex_ai: bool = False
   ) -> Self:
     """Instantiates a GenerateVideosOperation from an API response."""
-    new_operation = cls()
-    new_operation.name = api_response.get('name', None)
-    new_operation.metadata = api_response.get('metadata', None)
-    new_operation.done = api_response.get('done', None)
-    new_operation.error = api_response.get('error', None)
-
     if is_vertex_ai:
-      if api_response.get('response', None) is not None:
-        new_operation.response = GenerateVideosResponse(
-            generated_videos=[
-                GeneratedVideo(
-                    video=Video(
-                        uri=video.get('gcsUri', None),
-                        video_bytes=video.get('bytesBase64Encoded', None),
-                        mime_type=video.get('mimeType', None),
-                    )
-                )
-                for video in api_response.get('response', {}).get('videos', [])
-            ],
-            rai_media_filtered_count=api_response.get('response', {}).get(
-                'raiMediaFilteredCount', None
-            ),
-            rai_media_filtered_reasons=api_response.get('response', {}).get(
-                'raiMediaFilteredReasons', None
-            ),
-        )
+      response_dict = _GenerateVideosOperation_from_vertex(api_response)
     else:
-      if api_response.get('response', None) is not None:
-        new_operation.response = GenerateVideosResponse(
-            generated_videos=[
-                GeneratedVideo(
-                    video=Video(
-                        uri=video.get('video', {}).get('uri', None),
-                        video_bytes=video.get('video', {}).get(
-                            'encodedVideo', None
-                        ),
-                        mime_type=video.get('encoding', None),
-                    )
-                )
-                for video in api_response.get('response', {})
-                .get('generateVideoResponse', {})
-                .get('generatedSamples', [])
-            ],
-            rai_media_filtered_count=api_response.get('response', {})
-            .get('generateVideoResponse', {})
-            .get('raiMediaFilteredCount', None),
-            rai_media_filtered_reasons=api_response.get('response', {})
-            .get('generateVideoResponse', {})
-            .get('raiMediaFilteredReasons', None),
-        )
-    new_operation.result = new_operation.response
-    return new_operation
-
-
-class GenerateVideosResponseDict(TypedDict, total=False):
-  """Response with generated videos."""
-
-  generated_videos: Optional[list[GeneratedVideoDict]]
-  """List of the generated videos"""
-
-  rai_media_filtered_count: Optional[int]
-  """Returns if any videos were filtered due to RAI policies."""
-
-  rai_media_filtered_reasons: Optional[list[str]]
-  """Returns rai failure reasons if any."""
-
+      response_dict = _GenerateVideosOperation_from_mldev(api_response)
 
-GenerateVideosResponseOrDict = Union[
-    GenerateVideosResponse, GenerateVideosResponseDict
-]
+    return cls._from_response(response=response_dict, kwargs={})
 
 
 class GetTuningJobConfig(_common.BaseModel):
@@ -9965,13 +10267,59 @@ ListTuningJobsResponseOrDict = Union[
 ]
 
 
-class TuningExample(_common.BaseModel):
+class CancelTuningJobConfig(_common.BaseModel):
+  """Optional parameters for tunings.cancel method."""
 
-  text_input: Optional[str] = Field(
-      default=None, description="""Text model input."""
+  http_options: Optional[HttpOptions] = Field(
+      default=None, description="""Used to override HTTP request options."""
   )
-  output: Optional[str] = Field(
-      default=None, description="""The expected model output."""
+
+
+class CancelTuningJobConfigDict(TypedDict, total=False):
+  """Optional parameters for tunings.cancel method."""
+
+  http_options: Optional[HttpOptionsDict]
+  """Used to override HTTP request options."""
+
+
+CancelTuningJobConfigOrDict = Union[
+    CancelTuningJobConfig, CancelTuningJobConfigDict
+]
+
+
+class _CancelTuningJobParameters(_common.BaseModel):
+  """Parameters for the cancel method."""
+
+  name: Optional[str] = Field(
+      default=None, description="""The resource name of the tuning job."""
+  )
+  config: Optional[CancelTuningJobConfig] = Field(
+      default=None, description="""Optional parameters for the request."""
+  )
+
+
+class _CancelTuningJobParametersDict(TypedDict, total=False):
+  """Parameters for the cancel method."""
+
+  name: Optional[str]
+  """The resource name of the tuning job."""
+
+  config: Optional[CancelTuningJobConfigDict]
+  """Optional parameters for the request."""
+
+
+_CancelTuningJobParametersOrDict = Union[
+    _CancelTuningJobParameters, _CancelTuningJobParametersDict
+]
+
+
+class TuningExample(_common.BaseModel):
+
+  text_input: Optional[str] = Field(
+      default=None, description="""Text model input."""
+  )
+  output: Optional[str] = Field(
+      default=None, description="""The expected model output."""
   )
 
 
@@ -10569,13 +10917,16 @@ _DeleteCachedContentParametersOrDict = Union[
 class DeleteCachedContentResponse(_common.BaseModel):
   """Empty response for caches.delete method."""
 
-  pass
+  sdk_http_response: Optional[HttpResponse] = Field(
+      default=None, description="""Used to retain the full HTTP response."""
+  )
 
 
 class DeleteCachedContentResponseDict(TypedDict, total=False):
   """Empty response for caches.delete method."""
 
-  pass
+  sdk_http_response: Optional[HttpResponseDict]
+  """Used to retain the full HTTP response."""
 
 
 DeleteCachedContentResponseOrDict = Union[
@@ -10980,13 +11331,16 @@ _DeleteFileParametersOrDict = Union[
 class DeleteFileResponse(_common.BaseModel):
   """Response for the delete file method."""
 
-  pass
+  sdk_http_response: Optional[HttpResponse] = Field(
+      default=None, description="""Used to retain the full HTTP response."""
+  )
 
 
 class DeleteFileResponseDict(TypedDict, total=False):
   """Response for the delete file method."""
 
-  pass
+  sdk_http_response: Optional[HttpResponseDict]
+  """Used to retain the full HTTP response."""
 
 
 DeleteFileResponseOrDict = Union[DeleteFileResponse, DeleteFileResponseDict]
@@ -12053,6 +12407,10 @@ class UpscaleImageConfig(_common.BaseModel):
   http_options: Optional[HttpOptions] = Field(
       default=None, description="""Used to override HTTP request options."""
   )
+  output_gcs_uri: Optional[str] = Field(
+      default=None,
+      description="""Cloud Storage URI used to store the generated images.""",
+  )
   include_rai_reason: Optional[bool] = Field(
       default=None,
       description="""Whether to include a reason for filtered-out images in the
@@ -12093,6 +12451,9 @@ class UpscaleImageConfigDict(TypedDict, total=False):
   http_options: Optional[HttpOptionsDict]
   """Used to override HTTP request options."""
 
+  output_gcs_uri: Optional[str]
+  """Cloud Storage URI used to store the generated images."""
+
   include_rai_reason: Optional[bool]
   """Whether to include a reason for filtered-out images in the
       response."""
@@ -12964,95 +13325,6 @@ class LiveServerMessageDict(TypedDict, total=False):
 LiveServerMessageOrDict = Union[LiveServerMessage, LiveServerMessageDict]
 
 
-class AutomaticActivityDetection(_common.BaseModel):
-  """Configures automatic detection of activity."""
-
-  disabled: Optional[bool] = Field(
-      default=None,
-      description="""If enabled, detected voice and text input count as activity. If disabled, the client must send activity signals.""",
-  )
-  start_of_speech_sensitivity: Optional[StartSensitivity] = Field(
-      default=None,
-      description="""Determines how likely speech is to be detected.""",
-  )
-  end_of_speech_sensitivity: Optional[EndSensitivity] = Field(
-      default=None,
-      description="""Determines how likely detected speech is ended.""",
-  )
-  prefix_padding_ms: Optional[int] = Field(
-      default=None,
-      description="""The required duration of detected speech before start-of-speech is committed. The lower this value the more sensitive the start-of-speech detection is and the shorter speech can be recognized. However, this also increases the probability of false positives.""",
-  )
-  silence_duration_ms: Optional[int] = Field(
-      default=None,
-      description="""The required duration of detected non-speech (e.g. silence) before end-of-speech is committed. The larger this value, the longer speech gaps can be without interrupting the user's activity but this will increase the model's latency.""",
-  )
-
-
-class AutomaticActivityDetectionDict(TypedDict, total=False):
-  """Configures automatic detection of activity."""
-
-  disabled: Optional[bool]
-  """If enabled, detected voice and text input count as activity. If disabled, the client must send activity signals."""
-
-  start_of_speech_sensitivity: Optional[StartSensitivity]
-  """Determines how likely speech is to be detected."""
-
-  end_of_speech_sensitivity: Optional[EndSensitivity]
-  """Determines how likely detected speech is ended."""
-
-  prefix_padding_ms: Optional[int]
-  """The required duration of detected speech before start-of-speech is committed. The lower this value the more sensitive the start-of-speech detection is and the shorter speech can be recognized. However, this also increases the probability of false positives."""
-
-  silence_duration_ms: Optional[int]
-  """The required duration of detected non-speech (e.g. silence) before end-of-speech is committed. The larger this value, the longer speech gaps can be without interrupting the user's activity but this will increase the model's latency."""
-
-
-AutomaticActivityDetectionOrDict = Union[
-    AutomaticActivityDetection, AutomaticActivityDetectionDict
-]
-
-
-class RealtimeInputConfig(_common.BaseModel):
-  """Marks the end of user activity.
-
-  This can only be sent if automatic (i.e. server-side) activity detection is
-  disabled.
-  """
-
-  automatic_activity_detection: Optional[AutomaticActivityDetection] = Field(
-      default=None,
-      description="""If not set, automatic activity detection is enabled by default. If automatic voice detection is disabled, the client must send activity signals.""",
-  )
-  activity_handling: Optional[ActivityHandling] = Field(
-      default=None, description="""Defines what effect activity has."""
-  )
-  turn_coverage: Optional[TurnCoverage] = Field(
-      default=None,
-      description="""Defines which input is included in the user's turn.""",
-  )
-
-
-class RealtimeInputConfigDict(TypedDict, total=False):
-  """Marks the end of user activity.
-
-  This can only be sent if automatic (i.e. server-side) activity detection is
-  disabled.
-  """
-
-  automatic_activity_detection: Optional[AutomaticActivityDetectionDict]
-  """If not set, automatic activity detection is enabled by default. If automatic voice detection is disabled, the client must send activity signals."""
-
-  activity_handling: Optional[ActivityHandling]
-  """Defines what effect activity has."""
-
-  turn_coverage: Optional[TurnCoverage]
-  """Defines which input is included in the user's turn."""
-
-
-RealtimeInputConfigOrDict = Union[RealtimeInputConfig, RealtimeInputConfigDict]
-
-
 class SessionResumptionConfig(_common.BaseModel):
   """Configuration of session resumption mechanism.
 
@@ -13191,6 +13463,95 @@ class ProactivityConfigDict(TypedDict, total=False):
 ProactivityConfigOrDict = Union[ProactivityConfig, ProactivityConfigDict]
 
 
+class AutomaticActivityDetection(_common.BaseModel):
+  """Configures automatic detection of activity."""
+
+  disabled: Optional[bool] = Field(
+      default=None,
+      description="""If enabled, detected voice and text input count as activity. If disabled, the client must send activity signals.""",
+  )
+  start_of_speech_sensitivity: Optional[StartSensitivity] = Field(
+      default=None,
+      description="""Determines how likely speech is to be detected.""",
+  )
+  end_of_speech_sensitivity: Optional[EndSensitivity] = Field(
+      default=None,
+      description="""Determines how likely detected speech is ended.""",
+  )
+  prefix_padding_ms: Optional[int] = Field(
+      default=None,
+      description="""The required duration of detected speech before start-of-speech is committed. The lower this value the more sensitive the start-of-speech detection is and the shorter speech can be recognized. However, this also increases the probability of false positives.""",
+  )
+  silence_duration_ms: Optional[int] = Field(
+      default=None,
+      description="""The required duration of detected non-speech (e.g. silence) before end-of-speech is committed. The larger this value, the longer speech gaps can be without interrupting the user's activity but this will increase the model's latency.""",
+  )
+
+
+class AutomaticActivityDetectionDict(TypedDict, total=False):
+  """Configures automatic detection of activity."""
+
+  disabled: Optional[bool]
+  """If enabled, detected voice and text input count as activity. If disabled, the client must send activity signals."""
+
+  start_of_speech_sensitivity: Optional[StartSensitivity]
+  """Determines how likely speech is to be detected."""
+
+  end_of_speech_sensitivity: Optional[EndSensitivity]
+  """Determines how likely detected speech is ended."""
+
+  prefix_padding_ms: Optional[int]
+  """The required duration of detected speech before start-of-speech is committed. The lower this value the more sensitive the start-of-speech detection is and the shorter speech can be recognized. However, this also increases the probability of false positives."""
+
+  silence_duration_ms: Optional[int]
+  """The required duration of detected non-speech (e.g. silence) before end-of-speech is committed. The larger this value, the longer speech gaps can be without interrupting the user's activity but this will increase the model's latency."""
+
+
+AutomaticActivityDetectionOrDict = Union[
+    AutomaticActivityDetection, AutomaticActivityDetectionDict
+]
+
+
+class RealtimeInputConfig(_common.BaseModel):
+  """Marks the end of user activity.
+
+  This can only be sent if automatic (i.e. server-side) activity detection is
+  disabled.
+  """
+
+  automatic_activity_detection: Optional[AutomaticActivityDetection] = Field(
+      default=None,
+      description="""If not set, automatic activity detection is enabled by default. If automatic voice detection is disabled, the client must send activity signals.""",
+  )
+  activity_handling: Optional[ActivityHandling] = Field(
+      default=None, description="""Defines what effect activity has."""
+  )
+  turn_coverage: Optional[TurnCoverage] = Field(
+      default=None,
+      description="""Defines which input is included in the user's turn.""",
+  )
+
+
+class RealtimeInputConfigDict(TypedDict, total=False):
+  """Marks the end of user activity.
+
+  This can only be sent if automatic (i.e. server-side) activity detection is
+  disabled.
+  """
+
+  automatic_activity_detection: Optional[AutomaticActivityDetectionDict]
+  """If not set, automatic activity detection is enabled by default. If automatic voice detection is disabled, the client must send activity signals."""
+
+  activity_handling: Optional[ActivityHandling]
+  """Defines what effect activity has."""
+
+  turn_coverage: Optional[TurnCoverage]
+  """Defines which input is included in the user's turn."""
+
+
+RealtimeInputConfigOrDict = Union[RealtimeInputConfig, RealtimeInputConfigDict]
+
+
 class LiveClientSetup(_common.BaseModel):
   """Message contains configuration that will apply for the duration of the streaming session."""
 
@@ -14509,6 +14870,42 @@ CreateAuthTokenParametersOrDict = Union[
 ]
 
 
+class CountTokensResult(_common.BaseModel):
+  """Local tokenizer count tokens result."""
+
+  total_tokens: Optional[int] = Field(
+      default=None, description="""The total number of tokens."""
+  )
+
+
+class CountTokensResultDict(TypedDict, total=False):
+  """Local tokenizer count tokens result."""
+
+  total_tokens: Optional[int]
+  """The total number of tokens."""
+
+
+CountTokensResultOrDict = Union[CountTokensResult, CountTokensResultDict]
+
+
+class ComputeTokensResult(_common.BaseModel):
+  """Local tokenizer compute tokens result."""
+
+  tokens_info: Optional[list[TokensInfo]] = Field(
+      default=None, description="""Lists of tokens info from the input."""
+  )
+
+
+class ComputeTokensResultDict(TypedDict, total=False):
+  """Local tokenizer compute tokens result."""
+
+  tokens_info: Optional[list[TokensInfoDict]]
+  """Lists of tokens info from the input."""
+
+
+ComputeTokensResultOrDict = Union[ComputeTokensResult, ComputeTokensResultDict]
+
+
 class CreateTuningJobParameters(_common.BaseModel):
   """Supervised fine-tuning job creation parameters - optional fields."""
 
@@ -14543,6 +14940,67 @@ CreateTuningJobParametersOrDict = Union[
 ]
 
 
+class UserContent(Content):
+  """UserContent facilitates the creation of a Content object with a user role.
+
+  Example usages:
+
+
+  - Create a user Content object with a string:
+    user_content = UserContent("Why is the sky blue?")
+  - Create a user Content object with a file data Part object:
+    user_content = UserContent(Part.from_uri(file_uril="gs://bucket/file.txt",
+    mime_type="text/plain"))
+  - Create a user Content object with byte data Part object:
+    user_content = UserContent(Part.from_bytes(data=b"Hello, World!",
+    mime_type="text/plain"))
+
+    You can create a user Content object using other classmethods in the Part
+    class as well.
+    You can also create a user Content using a list of Part objects or strings.
+  """
+
+  role: Literal['user'] = Field(default='user', init=False, frozen=True)
+  parts: list[Part] = Field()
+
+  def __init__(
+      self, parts: Union['PartUnionDict', list['PartUnionDict'], list['Part']]
+  ):
+    from . import _transformers as t
+
+    super().__init__(parts=t.t_parts(parts=parts))
+
+
+class ModelContent(Content):
+  """ModelContent facilitates the creation of a Content object with a model role.
+
+  Example usages:
+
+  - Create a model Content object with a string:
+    model_content = ModelContent("Why is the sky blue?")
+  - Create a model Content object with a file data Part object:
+    model_content = ModelContent(Part.from_uri(file_uril="gs://bucket/file.txt",
+    mime_type="text/plain"))
+  - Create a model Content object with byte data Part object:
+    model_content = ModelContent(Part.from_bytes(data=b"Hello, World!",
+    mime_type="text/plain"))
+
+    You can create a model Content object using other classmethods in the Part
+    class as well.
+    You can also create a model Content using a list of Part objects or strings.
+  """
+
+  role: Literal['model'] = Field(default='model', init=False, frozen=True)
+  parts: list[Part] = Field()
+
+  def __init__(
+      self, parts: Union['PartUnionDict', list['PartUnionDict'], list['Part']]
+  ):
+    from . import _transformers as t
+
+    super().__init__(parts=t.t_parts(parts=parts))
+
+
 class CustomOutputFormatConfig(_common.BaseModel):
   """Config for custom output format."""