google-genai 1.2.0__py3-none-any.whl → 1.4.0__py3-none-any.whl

google/genai/types.py

@@ -21,8 +21,9 @@ import inspect
 import json
 import logging
 import sys
+import types as builtin_types
 import typing
-from typing import Any, Callable, GenericAlias, Literal, Optional, Union
+from typing import Any, Callable, Literal, Optional, Union, _UnionGenericAlias
 import pydantic
 from pydantic import Field
 from typing_extensions import TypedDict
@@ -30,11 +31,11 @@ from . import _common
 
 if sys.version_info >= (3, 10):
   # Supports both Union[t1, t2] and t1 | t2
-  VersionedUnionType = Union[typing.types.UnionType, typing._UnionGenericAlias]
-  _UNION_TYPES = (typing.Union, typing.types.UnionType)
+  VersionedUnionType = Union[builtin_types.UnionType, _UnionGenericAlias]
+  _UNION_TYPES = (typing.Union, builtin_types.UnionType)
 else:
   # Supports only Union[t1, t2]
-  VersionedUnionType = typing._UnionGenericAlias
+  VersionedUnionType = _UnionGenericAlias
   _UNION_TYPES = (typing.Union,)
 
 _is_pillow_image_imported = False
@@ -53,6 +54,8 @@ else:
   except ImportError:
     PIL_Image = None
 
+logger = logging.getLogger('google_genai.types')
+
 
 class Outcome(_common.CaseInSensitiveEnum):
   """Required. Outcome of the code execution."""
@@ -71,7 +74,7 @@ class Language(_common.CaseInSensitiveEnum):
 
 
 class Type(_common.CaseInSensitiveEnum):
-  """A basic data type."""
+  """Optional. The type of the data."""
 
   TYPE_UNSPECIFIED = 'TYPE_UNSPECIFIED'
   STRING = 'STRING'
@@ -691,6 +694,63 @@ 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']]):
+    from . import _transformers as t
+
+    super().__init__(parts=t.t_parts(None, 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']]):
+    from . import _transformers as t
+
+    super().__init__(parts=t.t_parts(None, parts=parts))
+
+
 class ContentDict(TypedDict, total=False):
   """Contains the multi-part content of a message."""
 
@@ -751,18 +811,10 @@ class Schema(_common.BaseModel):
   Represents a select subset of an OpenAPI 3.0 schema object.
   """
 
-  min_items: Optional[int] = Field(
-      default=None,
-      description="""Optional. Minimum number of the elements for Type.ARRAY.""",
-  )
   example: Optional[Any] = Field(
       default=None,
       description="""Optional. Example of the object. Will only populated when the object is the root.""",
   )
-  property_ordering: Optional[list[str]] = Field(
-      default=None,
-      description="""Optional. The order of the properties. Not a standard field in open api spec. Only used to support the order of the properties.""",
-  )
   pattern: Optional[str] = Field(
       default=None,
       description="""Optional. Pattern of the Type.STRING to restrict a string to a regular expression.""",
@@ -774,7 +826,7 @@ class Schema(_common.BaseModel):
   default: Optional[Any] = Field(
       default=None, description="""Optional. Default value of the data."""
   )
-  any_of: list['Schema'] = Field(
+  any_of: Optional[list['Schema']] = Field(
       default=None,
       description="""Optional. The value should be validated against any (one or more) of the subschemas in the list.""",
   )
@@ -793,25 +845,14 @@ class Schema(_common.BaseModel):
       default=None,
       description="""Optional. Minimum number of the properties for Type.OBJECT.""",
   )
-  max_items: Optional[int] = Field(
-      default=None,
-      description="""Optional. Maximum number of the elements for Type.ARRAY.""",
-  )
   maximum: Optional[float] = Field(
       default=None,
       description="""Optional. Maximum value of the Type.INTEGER and Type.NUMBER""",
   )
-  nullable: Optional[bool] = Field(
-      default=None,
-      description="""Optional. Indicates if the value may be null.""",
-  )
   max_properties: Optional[int] = Field(
       default=None,
       description="""Optional. Maximum number of the properties for Type.OBJECT.""",
   )
-  type: Optional[Type] = Field(
-      default=None, description="""Optional. The type of the data."""
-  )
   description: Optional[str] = Field(
       default=None, description="""Optional. The description of the data."""
   )
@@ -823,18 +864,37 @@ class Schema(_common.BaseModel):
       default=None,
       description="""Optional. The format of the data. Supported formats: for NUMBER type: "float", "double" for INTEGER type: "int32", "int64" for STRING type: "email", "byte", etc""",
   )
-  items: 'Schema' = Field(
+  items: Optional['Schema'] = Field(
       default=None,
       description="""Optional. SCHEMA FIELDS FOR TYPE ARRAY Schema of the elements of Type.ARRAY.""",
   )
-  properties: dict[str, 'Schema'] = Field(
+  max_items: Optional[int] = Field(
+      default=None,
+      description="""Optional. Maximum number of the elements for Type.ARRAY.""",
+  )
+  min_items: Optional[int] = Field(
+      default=None,
+      description="""Optional. Minimum number of the elements for Type.ARRAY.""",
+  )
+  nullable: Optional[bool] = Field(
+      default=None,
+      description="""Optional. Indicates if the value may be null.""",
+  )
+  properties: Optional[dict[str, 'Schema']] = Field(
       default=None,
       description="""Optional. SCHEMA FIELDS FOR TYPE OBJECT Properties of Type.OBJECT.""",
   )
+  property_ordering: Optional[list[str]] = Field(
+      default=None,
+      description="""Optional. The order of the properties. Not a standard field in open api spec. Only used to support the order of the properties.""",
+  )
   required: Optional[list[str]] = Field(
       default=None,
       description="""Optional. Required properties of Type.OBJECT.""",
   )
+  type: Optional[Type] = Field(
+      default=None, description="""Optional. The type of the data."""
+  )
 
 
 class SchemaDict(TypedDict, total=False):
@@ -843,15 +903,9 @@ class SchemaDict(TypedDict, total=False):
   Represents a select subset of an OpenAPI 3.0 schema object.
   """
 
-  min_items: Optional[int]
-  """Optional. Minimum number of the elements for Type.ARRAY."""
-
   example: Optional[Any]
   """Optional. Example of the object. Will only populated when the object is the root."""
 
-  property_ordering: Optional[list[str]]
-  """Optional. The order of the properties. Not a standard field in open api spec. Only used to support the order of the properties."""
-
   pattern: Optional[str]
   """Optional. Pattern of the Type.STRING to restrict a string to a regular expression."""
 
@@ -861,7 +915,7 @@ class SchemaDict(TypedDict, total=False):
   default: Optional[Any]
   """Optional. Default value of the data."""
 
-  any_of: list['SchemaDict']
+  any_of: Optional[list['SchemaDict']]
   """Optional. The value should be validated against any (one or more) of the subschemas in the list."""
 
   max_length: Optional[int]
@@ -876,21 +930,12 @@ class SchemaDict(TypedDict, total=False):
   min_properties: Optional[int]
   """Optional. Minimum number of the properties for Type.OBJECT."""
 
-  max_items: Optional[int]
-  """Optional. Maximum number of the elements for Type.ARRAY."""
-
   maximum: Optional[float]
   """Optional. Maximum value of the Type.INTEGER and Type.NUMBER"""
 
-  nullable: Optional[bool]
-  """Optional. Indicates if the value may be null."""
-
   max_properties: Optional[int]
   """Optional. Maximum number of the properties for Type.OBJECT."""
 
-  type: Optional[Type]
-  """Optional. The type of the data."""
-
   description: Optional[str]
   """Optional. The description of the data."""
 
@@ -900,15 +945,30 @@ class SchemaDict(TypedDict, total=False):
   format: Optional[str]
   """Optional. The format of the data. Supported formats: for NUMBER type: "float", "double" for INTEGER type: "int32", "int64" for STRING type: "email", "byte", etc"""
 
-  items: 'SchemaDict'
+  items: Optional['SchemaDict']
   """Optional. SCHEMA FIELDS FOR TYPE ARRAY Schema of the elements of Type.ARRAY."""
 
-  properties: dict[str, 'SchemaDict']
+  max_items: Optional[int]
+  """Optional. Maximum number of the elements for Type.ARRAY."""
+
+  min_items: Optional[int]
+  """Optional. Minimum number of the elements for Type.ARRAY."""
+
+  nullable: Optional[bool]
+  """Optional. Indicates if the value may be null."""
+
+  properties: Optional[dict[str, 'SchemaDict']]
   """Optional. SCHEMA FIELDS FOR TYPE OBJECT Properties of Type.OBJECT."""
 
+  property_ordering: Optional[list[str]]
+  """Optional. The order of the properties. Not a standard field in open api spec. Only used to support the order of the properties."""
+
   required: Optional[list[str]]
   """Optional. Required properties of Type.OBJECT."""
 
+  type: Optional[Type]
+  """Optional. The type of the data."""
+
 
 SchemaOrDict = Union[Schema, SchemaDict]
 
@@ -1688,7 +1748,9 @@ ContentUnion = Union[Content, list[PartUnion], PartUnion]
 ContentUnionDict = Union[ContentUnion, ContentDict]
 
 
-SchemaUnion = Union[dict, type, Schema, GenericAlias, VersionedUnionType]
+SchemaUnion = Union[
+    dict, type, Schema, builtin_types.GenericAlias, VersionedUnionType
+]
 
 
 SchemaUnionDict = Union[SchemaUnion, SchemaDict]
@@ -2823,6 +2885,16 @@ class GenerateContentResponse(_common.BaseModel):
       description="""Response variations returned by the model.
       """,
   )
+  create_time: Optional[datetime.datetime] = Field(
+      default=None,
+      description="""Timestamp when the request is made to the server.
+      """,
+  )
+  response_id: Optional[str] = Field(
+      default=None,
+      description="""Identifier for each response.
+      """,
+  )
   model_version: Optional[str] = Field(
       default=None,
       description="""Output only. The model version used to generate the response.""",
@@ -2835,7 +2907,7 @@ class GenerateContentResponse(_common.BaseModel):
       default=None, description="""Usage metadata about the response(s)."""
   )
   automatic_function_calling_history: Optional[list[Content]] = None
-  parsed: Union[pydantic.BaseModel, dict, Enum] = Field(
+  parsed: Optional[Union[pydantic.BaseModel, dict, Enum]] = Field(
       default=None,
       description="""Parsed response if response_schema is provided. Not available for streaming.""",
   )
@@ -2850,27 +2922,31 @@ class GenerateContentResponse(_common.BaseModel):
     ):
       return None
     if len(self.candidates) > 1:
-      logging.warning(
+      logger.warning(
           f'there are {len(self.candidates)} candidates, returning text from'
           ' the first candidate.Access response.candidates directly to get'
           ' text from other candidates.'
       )
     text = ''
     any_text_part_text = False
+    non_text_parts = []
     for part in self.candidates[0].content.parts:
       for field_name, field_value in part.model_dump(
           exclude={'text', 'thought'}
       ).items():
         if field_value is not None:
-          raise ValueError(
-              'GenerateContentResponse.text only supports text parts, but got'
-              f' {field_name} part{part}'
-          )
+          non_text_parts.append(field_name)
       if isinstance(part.text, str):
         if isinstance(part.thought, bool) and part.thought:
           continue
         any_text_part_text = True
         text += part.text
+    if non_text_parts:
+      logger.warning(
+          'Warning: there are non-text parts in the response:'
+          f' {non_text_parts},returning concatenated text from text parts,check'
+          ' out the non text parts for full response from model.'
+      )
     # part.text == '' is different from part.text is None
     return text if any_text_part_text else None
 
@@ -2884,7 +2960,7 @@ class GenerateContentResponse(_common.BaseModel):
     ):
       return None
     if len(self.candidates) > 1:
-      logging.warning(
+      logger.warning(
           'Warning: there are multiple candidates in the response, returning'
           ' function calls from the first one.'
       )
@@ -2896,11 +2972,49 @@ class GenerateContentResponse(_common.BaseModel):
 
     return function_calls if function_calls else None
 
+  @property
+  def executable_code(self) -> Optional[str]:
+    """Returns the executable code in the response."""
+    if (
+        not self.candidates
+        or not self.candidates[0].content
+        or not self.candidates[0].content.parts
+    ):
+      return None
+    if len(self.candidates) > 1:
+      logging.warning(
+          'Warning: there are multiple candidates in the response, returning'
+          ' executable code from the first one.'
+      )
+    for part in self.candidates[0].content.parts:
+      if part.executable_code is not None:
+        return part.executable_code.code
+    return None
+
+  @property
+  def code_execution_result(self) -> Optional[str]:
+    """Returns the code execution result in the response."""
+    if (
+        not self.candidates
+        or not self.candidates[0].content
+        or not self.candidates[0].content.parts
+    ):
+      return None
+    if len(self.candidates) > 1:
+      logging.warning(
+          'Warning: there are multiple candidates in the response, returning'
+          ' code execution result from the first one.'
+      )
+    for part in self.candidates[0].content.parts:
+      if part.code_execution_result is not None:
+        return part.code_execution_result.output
+    return None
+
   @classmethod
   def _from_response(
       cls, *, response: dict[str, object], kwargs: dict[str, object]
-  ):
-    result = super()._from_response(response, kwargs)
+  ) -> _common.BaseModel:
+    result = super()._from_response(response=response, kwargs=kwargs)
 
     # Handles response schema.
     response_schema = _common.get_value_by_path(
@@ -2909,7 +3023,7 @@ class GenerateContentResponse(_common.BaseModel):
     if (
         inspect.isclass(response_schema)
         and not (
-            isinstance(response_schema, GenericAlias)
+            isinstance(response_schema, builtin_types.GenericAlias)
         )  # Needed for Python 3.9 and 3.10
         and issubclass(response_schema, pydantic.BaseModel)
     ):
@@ -2933,7 +3047,7 @@ class GenerateContentResponse(_common.BaseModel):
           result.parsed = str(response_schema(enum_value).name)
       except ValueError:
         pass
-    elif isinstance(response_schema, GenericAlias) or isinstance(
+    elif isinstance(response_schema, builtin_types.GenericAlias) or isinstance(
         response_schema, type
     ):
 
@@ -2967,7 +3081,7 @@ class GenerateContentResponse(_common.BaseModel):
         if issubclass(union_type, pydantic.BaseModel):
           try:
 
-            class Placeholder(pydantic.BaseModel):
+            class Placeholder(pydantic.BaseModel):  # type: ignore[no-redef]
               placeholder: response_schema
 
             parsed = {'placeholder': json.loads(result.text)}
@@ -2994,6 +3108,14 @@ class GenerateContentResponseDict(TypedDict, total=False):
   """Response variations returned by the model.
       """
 
+  create_time: Optional[datetime.datetime]
+  """Timestamp when the request is made to the server.
+      """
+
+  response_id: Optional[str]
+  """Identifier for each response.
+      """
+
   model_version: Optional[str]
   """Output only. The model version used to generate the response."""
 
@@ -3271,6 +3393,11 @@ class GenerateImagesConfig(_common.BaseModel):
       description="""Number of images to generate.
       """,
   )
+  aspect_ratio: Optional[str] = Field(
+      default=None,
+      description="""Aspect ratio of the generated images.
+      """,
+  )
   guidance_scale: Optional[float] = Field(
       default=None,
       description="""Controls how much the model adheres to the text prompt. Large
@@ -3326,11 +3453,6 @@ class GenerateImagesConfig(_common.BaseModel):
       description="""Whether to add a watermark to the generated images.
       """,
   )
-  aspect_ratio: Optional[str] = Field(
-      default=None,
-      description="""Aspect ratio of the generated images.
-      """,
-  )
   enhance_prompt: Optional[bool] = Field(
       default=None,
       description="""Whether to use the prompt rewriting logic.
@@ -3356,6 +3478,10 @@ class GenerateImagesConfigDict(TypedDict, total=False):
   """Number of images to generate.
       """
 
+  aspect_ratio: Optional[str]
+  """Aspect ratio of the generated images.
+      """
+
   guidance_scale: Optional[float]
   """Controls how much the model adheres to the text prompt. Large
       values increase output and prompt alignment, but may compromise image
@@ -3401,10 +3527,6 @@ class GenerateImagesConfigDict(TypedDict, total=False):
   """Whether to add a watermark to the generated images.
       """
 
-  aspect_ratio: Optional[str]
-  """Aspect ratio of the generated images.
-      """
-
   enhance_prompt: Optional[bool]
   """Whether to use the prompt rewriting logic.
       """
@@ -3527,7 +3649,8 @@ class Image(_common.BaseModel):
       IPython_display.display(self._pil_image)
 
   @property
-  def _pil_image(self) -> 'PIL_Image.Image':
+  def _pil_image(self) -> 'PIL_Image':
+    PIL_Image: Optional[builtin_types.ModuleType]
     try:
       from PIL import Image as PIL_Image
     except ImportError:
@@ -3796,7 +3919,8 @@ class _ReferenceImageAPI(_common.BaseModel):
       default=None, description="""The id of the reference image."""
   )
   reference_type: Optional[str] = Field(
-      default=None, description="""The type of the reference image."""
+      default=None,
+      description="""The type of the reference image. Only set by the SDK.""",
   )
   mask_image_config: Optional[MaskReferenceConfig] = Field(
       default=None,
@@ -3826,7 +3950,7 @@ class _ReferenceImageAPIDict(TypedDict, total=False):
   """The id of the reference image."""
 
   reference_type: Optional[str]
-  """The type of the reference image."""
+  """The type of the reference image. Only set by the SDK."""
 
   mask_image_config: Optional[MaskReferenceConfigDict]
   """Configuration for the mask reference image."""
@@ -3865,6 +3989,11 @@ class EditImageConfig(_common.BaseModel):
       description="""Number of images to generate.
       """,
   )
+  aspect_ratio: Optional[str] = Field(
+      default=None,
+      description="""Aspect ratio of the generated images.
+      """,
+  )
   guidance_scale: Optional[float] = Field(
       default=None,
       description="""Controls how much the model adheres to the text prompt. Large
@@ -3939,6 +4068,10 @@ class EditImageConfigDict(TypedDict, total=False):
   """Number of images to generate.
       """
 
+  aspect_ratio: Optional[str]
+  """Aspect ratio of the generated images.
+      """
+
   guidance_scale: Optional[float]
   """Controls how much the model adheres to the text prompt. Large
       values increase output and prompt alignment, but may compromise image
@@ -4835,6 +4968,331 @@ ComputeTokensResponseOrDict = Union[
 ]
 
 
+class GenerateVideosConfig(_common.BaseModel):
+  """Configuration for generating videos."""
+
+  http_options: Optional[HttpOptions] = Field(
+      default=None, description="""Used to override HTTP request options."""
+  )
+  number_of_videos: Optional[int] = Field(
+      default=None, description="""Number of output videos."""
+  )
+  output_gcs_uri: Optional[str] = Field(
+      default=None,
+      description="""The gcs bucket where to save the generated videos.""",
+  )
+  fps: Optional[int] = Field(
+      default=None, description="""Frames per second for video generation."""
+  )
+  duration_seconds: Optional[int] = Field(
+      default=None,
+      description="""Duration of the clip for video generation in seconds.""",
+  )
+  seed: Optional[int] = Field(
+      default=None,
+      description="""The RNG seed. If RNG seed is exactly same for each request with unchanged inputs, the prediction results will be consistent. Otherwise, a random RNG seed will be used each time to produce a different result.""",
+  )
+  aspect_ratio: Optional[str] = Field(
+      default=None,
+      description="""The aspect ratio for the generated video. 16:9 (landscape) and 9:16 (portrait) are supported.""",
+  )
+  resolution: Optional[str] = Field(
+      default=None,
+      description="""The resolution for the generated video. 1280x720, 1920x1080 are supported.""",
+  )
+  person_generation: Optional[str] = Field(
+      default=None,
+      description="""Whether allow to generate person videos, and restrict to specific ages. Supported values are: dont_allow, allow_adult.""",
+  )
+  pubsub_topic: Optional[str] = Field(
+      default=None,
+      description="""The pubsub topic where to publish the video generation progress.""",
+  )
+  negative_prompt: Optional[str] = Field(
+      default=None,
+      description="""Optional field in addition to the text content. Negative prompts can be explicitly stated here to help generate the video.""",
+  )
+  enhance_prompt: Optional[bool] = Field(
+      default=None, description="""Whether to use the prompt rewriting logic."""
+  )
+
+
+class GenerateVideosConfigDict(TypedDict, total=False):
+  """Configuration for generating videos."""
+
+  http_options: Optional[HttpOptionsDict]
+  """Used to override HTTP request options."""
+
+  number_of_videos: Optional[int]
+  """Number of output videos."""
+
+  output_gcs_uri: Optional[str]
+  """The gcs bucket where to save the generated videos."""
+
+  fps: Optional[int]
+  """Frames per second for video generation."""
+
+  duration_seconds: Optional[int]
+  """Duration of the clip for video generation in seconds."""
+
+  seed: Optional[int]
+  """The RNG seed. If RNG seed is exactly same for each request with unchanged inputs, the prediction results will be consistent. Otherwise, a random RNG seed will be used each time to produce a different result."""
+
+  aspect_ratio: Optional[str]
+  """The aspect ratio for the generated video. 16:9 (landscape) and 9:16 (portrait) are supported."""
+
+  resolution: Optional[str]
+  """The resolution for the generated video. 1280x720, 1920x1080 are supported."""
+
+  person_generation: Optional[str]
+  """Whether allow to generate person videos, and restrict to specific ages. Supported values are: dont_allow, allow_adult."""
+
+  pubsub_topic: Optional[str]
+  """The pubsub topic where to publish the video generation progress."""
+
+  negative_prompt: Optional[str]
+  """Optional field in addition to the text content. Negative prompts can be explicitly stated here to help generate the video."""
+
+  enhance_prompt: Optional[bool]
+  """Whether to use the prompt rewriting logic."""
+
+
+GenerateVideosConfigOrDict = Union[
+    GenerateVideosConfig, GenerateVideosConfigDict
+]
+
+
+class _GenerateVideosParameters(_common.BaseModel):
+  """Class that represents the parameters for generating an image."""
+
+  model: Optional[str] = Field(
+      default=None,
+      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>`_.""",
+  )
+  prompt: Optional[str] = Field(
+      default=None,
+      description="""The text prompt for generating the videos. Optional for image to video use cases.""",
+  )
+  config: Optional[GenerateVideosConfig] = Field(
+      default=None, description="""Configuration for generating videos."""
+  )
+
+
+class _GenerateVideosParametersDict(TypedDict, total=False):
+  """Class that represents the parameters for generating an image."""
+
+  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>`_."""
+
+  prompt: Optional[str]
+  """The text prompt for generating the videos. Optional for image to video use cases."""
+
+  config: Optional[GenerateVideosConfigDict]
+  """Configuration for generating videos."""
+
+
+_GenerateVideosParametersOrDict = Union[
+    _GenerateVideosParameters, _GenerateVideosParametersDict
+]
+
+
+class Video(_common.BaseModel):
+  """A generated video."""
+
+  uri: Optional[str] = Field(
+      default=None, description="""Path to another storage."""
+  )
+  video_bytes: Optional[bytes] = Field(
+      default=None, description="""Video bytes."""
+  )
+  mime_type: Optional[str] = Field(
+      default=None, description="""Video encoding, for example "video/mp4"."""
+  )
+
+  def save(
+      self,
+      path: str,
+  ) -> None:
+    """Saves the video to a file.
+
+    Args:
+        path: Local path where to save the video.
+    """
+    import pathlib  # pylint: disable=g-import-not-at-top
+
+    if not self.video_bytes:
+      raise NotImplementedError('Saving remote videos is not supported.')
+
+    pathlib.Path(path).write_bytes(self.video_bytes)
+
+  def show(self):
+    """Shows the video.
+
+    This method only works in a notebook environment.
+    """
+    if self.uri:
+      return ValueError('Showing remote videos is not supported.')
+    if not self.video_bytes:
+      return ValueError('Video has no bytes.')
+    if not self.mime_type:
+      return ValueError('Mime type must be provided to display video.')
+
+    try:
+      from IPython import display as IPython_display
+    except ImportError:
+      IPython_display = None
+
+    if IPython_display:
+      return IPython_display.Video(
+          data=self.video_bytes, mimetype=self.mime_type, embed=True
+      )
+
+  def __repr__(self):
+    video_bytes = '<video_bytes>' if self.video_bytes else 'None'
+    return (
+        f'Video(uri={self.uri}, video_bytes={video_bytes},'
+        f' mime_type={self.mime_type})'
+    )
+
+
+class VideoDict(TypedDict, total=False):
+  """A generated video."""
+
+  uri: Optional[str]
+  """Path to another storage."""
+
+  video_bytes: Optional[bytes]
+  """Video bytes."""
+
+  mime_type: Optional[str]
+  """Video encoding, for example "video/mp4"."""
+
+
+VideoOrDict = Union[Video, VideoDict]
+
+
+class GeneratedVideo(_common.BaseModel):
+  """A generated video."""
+
+  video: Optional[Video] = Field(
+      default=None, description="""The output video"""
+  )
+
+
+class GeneratedVideoDict(TypedDict, total=False):
+  """A generated video."""
+
+  video: Optional[VideoDict]
+  """The output video"""
+
+
+GeneratedVideoOrDict = Union[GeneratedVideo, GeneratedVideoDict]
+
+
+class GenerateVideosResponse(_common.BaseModel):
+  """Response with generated videos."""
+
+  generated_videos: Optional[list[GeneratedVideo]] = Field(
+      default=None, description="""List of the generated videos"""
+  )
+  rai_media_filtered_count: Optional[int] = Field(
+      default=None,
+      description="""Returns if any videos were filtered due to RAI policies.""",
+  )
+  rai_media_filtered_reasons: Optional[list[str]] = Field(
+      default=None, description="""Returns rai failure reasons if any."""
+  )
+
+
+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 GenerateVideosOperation(_common.BaseModel):
+  """A video generation operation.
+
+  Use the following code to refresh the operation:
+
+  ```
+  operation = client.operations.get(operation)
+  ```
+  """
+
+  name: Optional[str] = Field(
+      default=None,
+      description="""The server-assigned name, which is only unique within the same service that originally returns it. If you use the default HTTP mapping, the `name` should be a resource name ending with `operations/{unique_id}`.""",
+  )
+  metadata: Optional[dict[str, Any]] = Field(
+      default=None,
+      description="""Service-specific metadata associated with the operation. It typically contains progress information and common metadata such as create time. Some services might not provide such metadata.  Any method that returns a long-running operation should document the metadata type, if any.""",
+  )
+  done: Optional[bool] = Field(
+      default=None,
+      description="""If the value is `false`, it means the operation is still in progress. If `true`, the operation is completed, and either `error` or `response` is available.""",
+  )
+  error: Optional[dict[str, Any]] = Field(
+      default=None,
+      description="""The error result of the operation in case of failure or cancellation.""",
+  )
+  response: Optional[dict[str, Any]] = Field(
+      default=None,
+      description="""The normal response of the operation in case of success.""",
+  )
+  result: Optional[GenerateVideosResponse] = Field(
+      default=None, description="""The generated videos."""
+  )
+
+
+class GenerateVideosOperationDict(TypedDict, total=False):
+  """A video generation operation.
+
+  Use the following code to refresh the operation:
+
+  ```
+  operation = client.operations.get(operation)
+  ```
+  """
+
+  name: Optional[str]
+  """The server-assigned name, which is only unique within the same service that originally returns it. If you use the default HTTP mapping, the `name` should be a resource name ending with `operations/{unique_id}`."""
+
+  metadata: Optional[dict[str, Any]]
+  """Service-specific metadata associated with the operation. It typically contains progress information and common metadata such as create time. Some services might not provide such metadata.  Any method that returns a long-running operation should document the metadata type, if any."""
+
+  done: Optional[bool]
+  """If the value is `false`, it means the operation is still in progress. If `true`, the operation is completed, and either `error` or `response` is available."""
+
+  error: Optional[dict[str, Any]]
+  """The error result of the operation in case of failure or cancellation."""
+
+  response: Optional[dict[str, Any]]
+  """The normal response of the operation in case of success."""
+
+  result: Optional[GenerateVideosResponseDict]
+  """The generated videos."""
+
+
+GenerateVideosOperationOrDict = Union[
+    GenerateVideosOperation, GenerateVideosOperationDict
+]
+
+
 class GetTuningJobConfig(_common.BaseModel):
   """Optional parameters for tunings.get method."""
 
@@ -7764,19 +8222,17 @@ class RawReferenceImage(_common.BaseModel):
       default=None, description="""The id of the reference image."""
   )
   reference_type: Optional[str] = Field(
-      default=None, description="""The type of the reference image."""
+      default=None,
+      description="""The type of the reference image. Only set by the SDK.""",
   )
 
-  def __init__(
-      self,
-      reference_image: Optional[Image] = None,
-      reference_id: Optional[int] = None,
-  ):
-    super().__init__(
-        reference_image=reference_image,
-        reference_id=reference_id,
-        reference_type='REFERENCE_TYPE_RAW',
-    )
+  @pydantic.model_validator(mode='before')
+  @classmethod
+  def _validate_mask_image_config(self, values):
+    if 'reference_type' in values:
+      raise ValueError('Cannot set internal reference_type field directly.')
+    values['reference_type'] = 'REFERENCE_TYPE_RAW'
+    return values
 
 
 class RawReferenceImageDict(TypedDict, total=False):
@@ -7794,7 +8250,7 @@ class RawReferenceImageDict(TypedDict, total=False):
   """The id of the reference image."""
 
   reference_type: Optional[str]
-  """The type of the reference image."""
+  """The type of the reference image. Only set by the SDK."""
 
 
 RawReferenceImageOrDict = Union[RawReferenceImage, RawReferenceImageDict]
@@ -7820,7 +8276,8 @@ class MaskReferenceImage(_common.BaseModel):
       default=None, description="""The id of the reference image."""
   )
   reference_type: Optional[str] = Field(
-      default=None, description="""The type of the reference image."""
+      default=None,
+      description="""The type of the reference image. Only set by the SDK.""",
   )
   config: Optional[MaskReferenceConfig] = Field(
       default=None,
@@ -7831,18 +8288,15 @@ class MaskReferenceImage(_common.BaseModel):
       default=None, description=""""""
   )
 
-  def __init__(
-      self,
-      reference_image: Optional[Image] = None,
-      reference_id: Optional[int] = None,
-      config: Optional['MaskReferenceConfig'] = None,
-  ):
-    super().__init__(
-        reference_image=reference_image,
-        reference_id=reference_id,
-        reference_type='REFERENCE_TYPE_MASK',
-    )
-    self.mask_image_config = config
+  @pydantic.model_validator(mode='before')
+  @classmethod
+  def _validate_mask_image_config(self, values):
+    config = values.get('config', None)
+    values['mask_image_config'] = config
+    if 'reference_type' in values:
+      raise ValueError('Cannot set internal reference_type field directly.')
+    values['reference_type'] = 'REFERENCE_TYPE_MASK'
+    return values
 
 
 class MaskReferenceImageDict(TypedDict, total=False):
@@ -7864,7 +8318,7 @@ class MaskReferenceImageDict(TypedDict, total=False):
   """The id of the reference image."""
 
   reference_type: Optional[str]
-  """The type of the reference image."""
+  """The type of the reference image. Only set by the SDK."""
 
   config: Optional[MaskReferenceConfigDict]
   """Configuration for the mask reference image."""
@@ -7893,7 +8347,8 @@ class ControlReferenceImage(_common.BaseModel):
       default=None, description="""The id of the reference image."""
   )
   reference_type: Optional[str] = Field(
-      default=None, description="""The type of the reference image."""
+      default=None,
+      description="""The type of the reference image. Only set by the SDK.""",
   )
   config: Optional[ControlReferenceConfig] = Field(
       default=None,
@@ -7904,18 +8359,15 @@ class ControlReferenceImage(_common.BaseModel):
       default=None, description=""""""
   )
 
-  def __init__(
-      self,
-      reference_image: Optional[Image] = None,
-      reference_id: Optional[int] = None,
-      config: Optional['ControlReferenceConfig'] = None,
-  ):
-    super().__init__(
-        reference_image=reference_image,
-        reference_id=reference_id,
-        reference_type='REFERENCE_TYPE_CONTROL',
-    )
-    self.control_image_config = config
+  @pydantic.model_validator(mode='before')
+  @classmethod
+  def _validate_mask_image_config(self, values):
+    config = values.get('config', None)
+    values['control_image_config'] = config
+    if 'reference_type' in values:
+      raise ValueError('Cannot set internal reference_type field directly.')
+    values['reference_type'] = 'REFERENCE_TYPE_CONTROL'
+    return values
 
 
 class ControlReferenceImageDict(TypedDict, total=False):
@@ -7937,7 +8389,7 @@ class ControlReferenceImageDict(TypedDict, total=False):
   """The id of the reference image."""
 
   reference_type: Optional[str]
-  """The type of the reference image."""
+  """The type of the reference image. Only set by the SDK."""
 
   config: Optional[ControlReferenceConfigDict]
   """Configuration for the control reference image."""
@@ -7966,7 +8418,8 @@ class StyleReferenceImage(_common.BaseModel):
       default=None, description="""The id of the reference image."""
   )
   reference_type: Optional[str] = Field(
-      default=None, description="""The type of the reference image."""
+      default=None,
+      description="""The type of the reference image. Only set by the SDK.""",
   )
   config: Optional[StyleReferenceConfig] = Field(
       default=None,
@@ -7977,18 +8430,15 @@ class StyleReferenceImage(_common.BaseModel):
       default=None, description=""""""
   )
 
-  def __init__(
-      self,
-      reference_image: Optional[Image] = None,
-      reference_id: Optional[int] = None,
-      config: Optional['StyleReferenceConfig'] = None,
-  ):
-    super().__init__(
-        reference_image=reference_image,
-        reference_id=reference_id,
-        reference_type='REFERENCE_TYPE_STYLE',
-    )
-    self.style_image_config = config
+  @pydantic.model_validator(mode='before')
+  @classmethod
+  def _validate_mask_image_config(self, values):
+    config = values.get('config', None)
+    values['style_image_config'] = config
+    if 'reference_type' in values:
+      raise ValueError('Cannot set internal reference_type field directly.')
+    values['reference_type'] = 'REFERENCE_TYPE_STYLE'
+    return values
 
 
 class StyleReferenceImageDict(TypedDict, total=False):
@@ -8008,7 +8458,7 @@ class StyleReferenceImageDict(TypedDict, total=False):
   """The id of the reference image."""
 
   reference_type: Optional[str]
-  """The type of the reference image."""
+  """The type of the reference image. Only set by the SDK."""
 
   config: Optional[StyleReferenceConfigDict]
   """Configuration for the style reference image."""
@@ -8035,7 +8485,8 @@ class SubjectReferenceImage(_common.BaseModel):
       default=None, description="""The id of the reference image."""
   )
   reference_type: Optional[str] = Field(
-      default=None, description="""The type of the reference image."""
+      default=None,
+      description="""The type of the reference image. Only set by the SDK.""",
   )
   config: Optional[SubjectReferenceConfig] = Field(
       default=None,
@@ -8046,18 +8497,15 @@ class SubjectReferenceImage(_common.BaseModel):
       default=None, description=""""""
   )
 
-  def __init__(
-      self,
-      reference_image: Optional[Image] = None,
-      reference_id: Optional[int] = None,
-      config: Optional['SubjectReferenceConfig'] = None,
-  ):
-    super().__init__(
-        reference_image=reference_image,
-        reference_id=reference_id,
-        reference_type='REFERENCE_TYPE_SUBJECT',
-    )
-    self.subject_image_config = config
+  @pydantic.model_validator(mode='before')
+  @classmethod
+  def _validate_mask_image_config(self, values):
+    config = values.get('config', None)
+    values['subject_image_config'] = config
+    if 'reference_type' in values:
+      raise ValueError('Cannot set internal reference_type field directly.')
+    values['reference_type'] = 'REFERENCE_TYPE_SUBJECT'
+    return values
 
 
 class SubjectReferenceImageDict(TypedDict, total=False):
@@ -8077,7 +8525,7 @@ class SubjectReferenceImageDict(TypedDict, total=False):
   """The id of the reference image."""
 
   reference_type: Optional[str]
-  """The type of the reference image."""
+  """The type of the reference image. Only set by the SDK."""
 
   config: Optional[SubjectReferenceConfigDict]
   """Configuration for the subject reference image."""
@@ -8298,7 +8746,7 @@ The following fields are supported:
       Note: only text should be used in parts and content in each part will be
       in a separate paragraph.""",
   )
-  tools: Optional[list[Tool]] = Field(
+  tools: Optional[ToolListUnion] = Field(
       default=None,
       description=""" A list of `Tools` the model may use to generate the next response.
 
@@ -8335,7 +8783,7 @@ The following fields are supported:
       Note: only text should be used in parts and content in each part will be
       in a separate paragraph."""
 
-  tools: Optional[list[ToolDict]]
+  tools: Optional[ToolListUnionDict]
   """ A list of `Tools` the model may use to generate the next response.
 
       A `Tool` is a piece of code that enables the system to interact with
@@ -8547,7 +8995,7 @@ class LiveConnectConfig(_common.BaseModel):
       Note: only text should be used in parts and content in each part will be
       in a separate paragraph.""",
   )
-  tools: Optional[list[Tool]] = Field(
+  tools: Optional[ToolListUnion] = Field(
       default=None,
       description="""A list of `Tools` the model may use to generate the next response.
 
@@ -8577,7 +9025,7 @@ class LiveConnectConfigDict(TypedDict, total=False):
       Note: only text should be used in parts and content in each part will be
       in a separate paragraph."""
 
-  tools: Optional[list[ToolDict]]
+  tools: Optional[ToolListUnionDict]
   """A list of `Tools` the model may use to generate the next response.
 
       A `Tool` is a piece of code that enables the system to interact with