diff --git a/.release-please-manifest.json b/.release-please-manifest.json
index 6b38a1bd5a..7b33636f46 100644
--- a/.release-please-manifest.json
+++ b/.release-please-manifest.json
@@ -1,3 +1,3 @@
 {
-  ".": "1.96.1"
+  ".": "1.97.0"
 }
\ No newline at end of file
diff --git a/.stats.yml b/.stats.yml
index 571b0ee797..2b9160cf6e 100644
--- a/.stats.yml
+++ b/.stats.yml
@@ -1,4 +1,4 @@
 configured_endpoints: 111
-openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/openai%2Fopenai-c7dacca97e28bceff218684bb429481a70aa47aadad983ed9178bfda75ff4cd2.yml
-openapi_spec_hash: 28eb1bb901ca10d2e37db4606d2bcfa7
-config_hash: 167ad0ca036d0f023c78e6496b4311e8
+openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/openai%2Fopenai-670ea0d2cc44f52a87dd3cadea45632953283e0636ba30788fdbdb22a232ccac.yml
+openapi_spec_hash: d8b7d38911fead545adf3e4297956410
+config_hash: 5525bda35e48ea6387c6175c4d1651fa
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 93bfb63f37..2e603f06be 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,13 @@
 # Changelog
 
+## 1.97.0 (2025-07-16)
+
+Full Changelog: [v1.96.1...v1.97.0](https://github.com/openai/openai-python/compare/v1.96.1...v1.97.0)
+
+### Features
+
+* **api:** manual updates ([ed8e899](https://github.com/openai/openai-python/commit/ed8e89953d11bd5f44fa531422bdbb7a577ab426))
+
 ## 1.96.1 (2025-07-15)
 
 Full Changelog: [v1.96.0...v1.96.1](https://github.com/openai/openai-python/compare/v1.96.0...v1.96.1)
diff --git a/api.md b/api.md
index abf0de481d..b3a2245cdd 100644
--- a/api.md
+++ b/api.md
@@ -127,7 +127,17 @@ Methods:
 Types:
 
 ```python
-from openai.types import Image, ImageModel, ImagesResponse
+from openai.types import (
+    Image,
+    ImageEditCompletedEvent,
+    ImageEditPartialImageEvent,
+    ImageEditStreamEvent,
+    ImageGenCompletedEvent,
+    ImageGenPartialImageEvent,
+    ImageGenStreamEvent,
+    ImageModel,
+    ImagesResponse,
+)
 ```
 
 Methods:
diff --git a/examples/image_stream.py b/examples/image_stream.py
new file mode 100644
index 0000000000..c188e68717
--- /dev/null
+++ b/examples/image_stream.py
@@ -0,0 +1,53 @@
+#!/usr/bin/env python
+
+import base64
+from pathlib import Path
+
+from openai import OpenAI
+
+client = OpenAI()
+
+
+def main() -> None:
+    """Example of OpenAI image streaming with partial images."""
+    stream = client.images.generate(
+        model="gpt-image-1",
+        prompt="A cute baby sea otter",
+        n=1,
+        size="1024x1024",
+        stream=True,
+        partial_images=3,
+    )
+
+    for event in stream:
+        if event.type == "image_generation.partial_image":
+            print(f"  Partial image {event.partial_image_index + 1}/3 received")
+            print(f"   Size: {len(event.b64_json)} characters (base64)")
+
+            # Save partial image to file
+            filename = f"partial_{event.partial_image_index + 1}.png"
+            image_data = base64.b64decode(event.b64_json)
+            with open(filename, "wb") as f:
+                f.write(image_data)
+            print(f"   💾 Saved to: {Path(filename).resolve()}")
+
+        elif event.type == "image_generation.completed":
+            print(f"\n✅ Final image completed!")
+            print(f"   Size: {len(event.b64_json)} characters (base64)")
+
+            # Save final image to file
+            filename = "final_image.png"
+            image_data = base64.b64decode(event.b64_json)
+            with open(filename, "wb") as f:
+                f.write(image_data)
+            print(f"   💾 Saved to: {Path(filename).resolve()}")
+
+        else:
+            print(f"❓ Unknown event: {event}")  # type: ignore[unreachable]
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except Exception as error:
+        print(f"Error generating image: {error}")
\ No newline at end of file
diff --git a/pyproject.toml b/pyproject.toml
index 0f655d058d..533379d52a 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,6 +1,6 @@
 [project]
 name = "openai"
-version = "1.96.1"
+version = "1.97.0"
 description = "The official Python library for the openai API"
 dynamic = ["readme"]
 license = "Apache-2.0"
diff --git a/src/openai/_streaming.py b/src/openai/_streaming.py
index f5621f92a7..fa0a30e183 100644
--- a/src/openai/_streaming.py
+++ b/src/openai/_streaming.py
@@ -59,7 +59,12 @@ def __stream__(self) -> Iterator[_T]:
             if sse.data.startswith("[DONE]"):
                 break
 
-            if sse.event is None or sse.event.startswith("response.") or sse.event.startswith("transcript."):
+            if sse.event is None or (
+                sse.event.startswith("response.") or 
+                sse.event.startswith("transcript.") or 
+                sse.event.startswith("image_edit.") or 
+                sse.event.startswith("image_generation.")
+            ):
                 data = sse.json()
                 if is_mapping(data) and data.get("error"):
                     message = None
diff --git a/src/openai/_version.py b/src/openai/_version.py
index 39be0338f6..8e5ed5fa86 100644
--- a/src/openai/_version.py
+++ b/src/openai/_version.py
@@ -1,4 +1,4 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 __title__ = "openai"
-__version__ = "1.96.1"  # x-release-please-version
+__version__ = "1.97.0"  # x-release-please-version
diff --git a/src/openai/resources/images.py b/src/openai/resources/images.py
index 43f6189f91..77b7a1b24e 100644
--- a/src/openai/resources/images.py
+++ b/src/openai/resources/images.py
@@ -3,20 +3,23 @@
 from __future__ import annotations
 
 from typing import List, Union, Mapping, Optional, cast
-from typing_extensions import Literal
+from typing_extensions import Literal, overload
 
 import httpx
 
 from .. import _legacy_response
 from ..types import image_edit_params, image_generate_params, image_create_variation_params
 from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven, FileTypes
-from .._utils import extract_files, maybe_transform, deepcopy_minimal, async_maybe_transform
+from .._utils import extract_files, required_args, maybe_transform, deepcopy_minimal, async_maybe_transform
 from .._compat import cached_property
 from .._resource import SyncAPIResource, AsyncAPIResource
 from .._response import to_streamed_response_wrapper, async_to_streamed_response_wrapper
+from .._streaming import Stream, AsyncStream
 from .._base_client import make_request_options
 from ..types.image_model import ImageModel
 from ..types.images_response import ImagesResponse
+from ..types.image_gen_stream_event import ImageGenStreamEvent
+from ..types.image_edit_stream_event import ImageEditStreamEvent
 
 __all__ = ["Images", "AsyncImages"]
 
@@ -114,21 +117,25 @@ def create_variation(
             cast_to=ImagesResponse,
         )
 
+    @overload
     def edit(
         self,
         *,
         image: Union[FileTypes, List[FileTypes]],
         prompt: str,
         background: Optional[Literal["transparent", "opaque", "auto"]] | NotGiven = NOT_GIVEN,
+        input_fidelity: Optional[Literal["high", "low"]] | NotGiven = NOT_GIVEN,
         mask: FileTypes | NotGiven = NOT_GIVEN,
         model: Union[str, ImageModel, None] | NotGiven = NOT_GIVEN,
         n: Optional[int] | NotGiven = NOT_GIVEN,
         output_compression: Optional[int] | NotGiven = NOT_GIVEN,
         output_format: Optional[Literal["png", "jpeg", "webp"]] | NotGiven = NOT_GIVEN,
+        partial_images: Optional[int] | NotGiven = NOT_GIVEN,
         quality: Optional[Literal["standard", "low", "medium", "high", "auto"]] | NotGiven = NOT_GIVEN,
         response_format: Optional[Literal["url", "b64_json"]] | NotGiven = NOT_GIVEN,
         size: Optional[Literal["256x256", "512x512", "1024x1024", "1536x1024", "1024x1536", "auto"]]
         | NotGiven = NOT_GIVEN,
+        stream: Optional[Literal[False]] | NotGiven = NOT_GIVEN,
         user: str | NotGiven = NOT_GIVEN,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
@@ -162,6 +169,234 @@ def edit(
               If `transparent`, the output format needs to support transparency, so it should
               be set to either `png` (default value) or `webp`.
 
+          input_fidelity: Control how much effort the model will exert to match the style and features,
+              especially facial features, of input images. This parameter is only supported
+              for `gpt-image-1`. Supports `high` and `low`. Defaults to `low`.
+
+          mask: An additional image whose fully transparent areas (e.g. where alpha is zero)
+              indicate where `image` should be edited. If there are multiple images provided,
+              the mask will be applied on the first image. Must be a valid PNG file, less than
+              4MB, and have the same dimensions as `image`.
+
+          model: The model to use for image generation. Only `dall-e-2` and `gpt-image-1` are
+              supported. Defaults to `dall-e-2` unless a parameter specific to `gpt-image-1`
+              is used.
+
+          n: The number of images to generate. Must be between 1 and 10.
+
+          output_compression: The compression level (0-100%) for the generated images. This parameter is only
+              supported for `gpt-image-1` with the `webp` or `jpeg` output formats, and
+              defaults to 100.
+
+          output_format: The format in which the generated images are returned. This parameter is only
+              supported for `gpt-image-1`. Must be one of `png`, `jpeg`, or `webp`. The
+              default value is `png`.
+
+          partial_images: The number of partial images to generate. This parameter is used for streaming
+              responses that return partial images. Value must be between 0 and 3. When set to
+              0, the response will be a single image sent in one streaming event.
+
+          quality: The quality of the image that will be generated. `high`, `medium` and `low` are
+              only supported for `gpt-image-1`. `dall-e-2` only supports `standard` quality.
+              Defaults to `auto`.
+
+          response_format: The format in which the generated images are returned. Must be one of `url` or
+              `b64_json`. URLs are only valid for 60 minutes after the image has been
+              generated. This parameter is only supported for `dall-e-2`, as `gpt-image-1`
+              will always return base64-encoded images.
+
+          size: The size of the generated images. Must be one of `1024x1024`, `1536x1024`
+              (landscape), `1024x1536` (portrait), or `auto` (default value) for
+              `gpt-image-1`, and one of `256x256`, `512x512`, or `1024x1024` for `dall-e-2`.
+
+          stream: Edit the image in streaming mode. Defaults to `false`. See the
+              [Image generation guide](https://platform.openai.com/docs/guides/image-generation)
+              for more information.
+
+          user: A unique identifier representing your end-user, which can help OpenAI to monitor
+              and detect abuse.
+              [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#end-user-ids).
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        ...
+
+    @overload
+    def edit(
+        self,
+        *,
+        image: Union[FileTypes, List[FileTypes]],
+        prompt: str,
+        stream: Literal[True],
+        background: Optional[Literal["transparent", "opaque", "auto"]] | NotGiven = NOT_GIVEN,
+        input_fidelity: Optional[Literal["high", "low"]] | NotGiven = NOT_GIVEN,
+        mask: FileTypes | NotGiven = NOT_GIVEN,
+        model: Union[str, ImageModel, None] | NotGiven = NOT_GIVEN,
+        n: Optional[int] | NotGiven = NOT_GIVEN,
+        output_compression: Optional[int] | NotGiven = NOT_GIVEN,
+        output_format: Optional[Literal["png", "jpeg", "webp"]] | NotGiven = NOT_GIVEN,
+        partial_images: Optional[int] | NotGiven = NOT_GIVEN,
+        quality: Optional[Literal["standard", "low", "medium", "high", "auto"]] | NotGiven = NOT_GIVEN,
+        response_format: Optional[Literal["url", "b64_json"]] | NotGiven = NOT_GIVEN,
+        size: Optional[Literal["256x256", "512x512", "1024x1024", "1536x1024", "1024x1536", "auto"]]
+        | NotGiven = NOT_GIVEN,
+        user: str | NotGiven = NOT_GIVEN,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> Stream[ImageEditStreamEvent]:
+        """Creates an edited or extended image given one or more source images and a
+        prompt.
+
+        This endpoint only supports `gpt-image-1` and `dall-e-2`.
+
+        Args:
+          image: The image(s) to edit. Must be a supported image file or an array of images.
+
+              For `gpt-image-1`, each image should be a `png`, `webp`, or `jpg` file less than
+              50MB. You can provide up to 16 images.
+
+              For `dall-e-2`, you can only provide one image, and it should be a square `png`
+              file less than 4MB.
+
+          prompt: A text description of the desired image(s). The maximum length is 1000
+              characters for `dall-e-2`, and 32000 characters for `gpt-image-1`.
+
+          stream: Edit the image in streaming mode. Defaults to `false`. See the
+              [Image generation guide](https://platform.openai.com/docs/guides/image-generation)
+              for more information.
+
+          background: Allows to set transparency for the background of the generated image(s). This
+              parameter is only supported for `gpt-image-1`. Must be one of `transparent`,
+              `opaque` or `auto` (default value). When `auto` is used, the model will
+              automatically determine the best background for the image.
+
+              If `transparent`, the output format needs to support transparency, so it should
+              be set to either `png` (default value) or `webp`.
+
+          input_fidelity: Control how much effort the model will exert to match the style and features,
+              especially facial features, of input images. This parameter is only supported
+              for `gpt-image-1`. Supports `high` and `low`. Defaults to `low`.
+
+          mask: An additional image whose fully transparent areas (e.g. where alpha is zero)
+              indicate where `image` should be edited. If there are multiple images provided,
+              the mask will be applied on the first image. Must be a valid PNG file, less than
+              4MB, and have the same dimensions as `image`.
+
+          model: The model to use for image generation. Only `dall-e-2` and `gpt-image-1` are
+              supported. Defaults to `dall-e-2` unless a parameter specific to `gpt-image-1`
+              is used.
+
+          n: The number of images to generate. Must be between 1 and 10.
+
+          output_compression: The compression level (0-100%) for the generated images. This parameter is only
+              supported for `gpt-image-1` with the `webp` or `jpeg` output formats, and
+              defaults to 100.
+
+          output_format: The format in which the generated images are returned. This parameter is only
+              supported for `gpt-image-1`. Must be one of `png`, `jpeg`, or `webp`. The
+              default value is `png`.
+
+          partial_images: The number of partial images to generate. This parameter is used for streaming
+              responses that return partial images. Value must be between 0 and 3. When set to
+              0, the response will be a single image sent in one streaming event.
+
+          quality: The quality of the image that will be generated. `high`, `medium` and `low` are
+              only supported for `gpt-image-1`. `dall-e-2` only supports `standard` quality.
+              Defaults to `auto`.
+
+          response_format: The format in which the generated images are returned. Must be one of `url` or
+              `b64_json`. URLs are only valid for 60 minutes after the image has been
+              generated. This parameter is only supported for `dall-e-2`, as `gpt-image-1`
+              will always return base64-encoded images.
+
+          size: The size of the generated images. Must be one of `1024x1024`, `1536x1024`
+              (landscape), `1024x1536` (portrait), or `auto` (default value) for
+              `gpt-image-1`, and one of `256x256`, `512x512`, or `1024x1024` for `dall-e-2`.
+
+          user: A unique identifier representing your end-user, which can help OpenAI to monitor
+              and detect abuse.
+              [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#end-user-ids).
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        ...
+
+    @overload
+    def edit(
+        self,
+        *,
+        image: Union[FileTypes, List[FileTypes]],
+        prompt: str,
+        stream: bool,
+        background: Optional[Literal["transparent", "opaque", "auto"]] | NotGiven = NOT_GIVEN,
+        input_fidelity: Optional[Literal["high", "low"]] | NotGiven = NOT_GIVEN,
+        mask: FileTypes | NotGiven = NOT_GIVEN,
+        model: Union[str, ImageModel, None] | NotGiven = NOT_GIVEN,
+        n: Optional[int] | NotGiven = NOT_GIVEN,
+        output_compression: Optional[int] | NotGiven = NOT_GIVEN,
+        output_format: Optional[Literal["png", "jpeg", "webp"]] | NotGiven = NOT_GIVEN,
+        partial_images: Optional[int] | NotGiven = NOT_GIVEN,
+        quality: Optional[Literal["standard", "low", "medium", "high", "auto"]] | NotGiven = NOT_GIVEN,
+        response_format: Optional[Literal["url", "b64_json"]] | NotGiven = NOT_GIVEN,
+        size: Optional[Literal["256x256", "512x512", "1024x1024", "1536x1024", "1024x1536", "auto"]]
+        | NotGiven = NOT_GIVEN,
+        user: str | NotGiven = NOT_GIVEN,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> ImagesResponse | Stream[ImageEditStreamEvent]:
+        """Creates an edited or extended image given one or more source images and a
+        prompt.
+
+        This endpoint only supports `gpt-image-1` and `dall-e-2`.
+
+        Args:
+          image: The image(s) to edit. Must be a supported image file or an array of images.
+
+              For `gpt-image-1`, each image should be a `png`, `webp`, or `jpg` file less than
+              50MB. You can provide up to 16 images.
+
+              For `dall-e-2`, you can only provide one image, and it should be a square `png`
+              file less than 4MB.
+
+          prompt: A text description of the desired image(s). The maximum length is 1000
+              characters for `dall-e-2`, and 32000 characters for `gpt-image-1`.
+
+          stream: Edit the image in streaming mode. Defaults to `false`. See the
+              [Image generation guide](https://platform.openai.com/docs/guides/image-generation)
+              for more information.
+
+          background: Allows to set transparency for the background of the generated image(s). This
+              parameter is only supported for `gpt-image-1`. Must be one of `transparent`,
+              `opaque` or `auto` (default value). When `auto` is used, the model will
+              automatically determine the best background for the image.
+
+              If `transparent`, the output format needs to support transparency, so it should
+              be set to either `png` (default value) or `webp`.
+
+          input_fidelity: Control how much effort the model will exert to match the style and features,
+              especially facial features, of input images. This parameter is only supported
+              for `gpt-image-1`. Supports `high` and `low`. Defaults to `low`.
+
           mask: An additional image whose fully transparent areas (e.g. where alpha is zero)
               indicate where `image` should be edited. If there are multiple images provided,
               the mask will be applied on the first image. Must be a valid PNG file, less than
@@ -181,6 +416,10 @@ def edit(
               supported for `gpt-image-1`. Must be one of `png`, `jpeg`, or `webp`. The
               default value is `png`.
 
+          partial_images: The number of partial images to generate. This parameter is used for streaming
+              responses that return partial images. Value must be between 0 and 3. When set to
+              0, the response will be a single image sent in one streaming event.
+
           quality: The quality of the image that will be generated. `high`, `medium` and `low` are
               only supported for `gpt-image-1`. `dall-e-2` only supports `standard` quality.
               Defaults to `auto`.
@@ -206,19 +445,51 @@ def edit(
 
           timeout: Override the client-level default timeout for this request, in seconds
         """
+        ...
+
+    @required_args(["image", "prompt"], ["image", "prompt", "stream"])
+    def edit(
+        self,
+        *,
+        image: Union[FileTypes, List[FileTypes]],
+        prompt: str,
+        background: Optional[Literal["transparent", "opaque", "auto"]] | NotGiven = NOT_GIVEN,
+        input_fidelity: Optional[Literal["high", "low"]] | NotGiven = NOT_GIVEN,
+        mask: FileTypes | NotGiven = NOT_GIVEN,
+        model: Union[str, ImageModel, None] | NotGiven = NOT_GIVEN,
+        n: Optional[int] | NotGiven = NOT_GIVEN,
+        output_compression: Optional[int] | NotGiven = NOT_GIVEN,
+        output_format: Optional[Literal["png", "jpeg", "webp"]] | NotGiven = NOT_GIVEN,
+        partial_images: Optional[int] | NotGiven = NOT_GIVEN,
+        quality: Optional[Literal["standard", "low", "medium", "high", "auto"]] | NotGiven = NOT_GIVEN,
+        response_format: Optional[Literal["url", "b64_json"]] | NotGiven = NOT_GIVEN,
+        size: Optional[Literal["256x256", "512x512", "1024x1024", "1536x1024", "1024x1536", "auto"]]
+        | NotGiven = NOT_GIVEN,
+        stream: Optional[Literal[False]] | Literal[True] | NotGiven = NOT_GIVEN,
+        user: str | NotGiven = NOT_GIVEN,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> ImagesResponse | Stream[ImageEditStreamEvent]:
         body = deepcopy_minimal(
             {
                 "image": image,
                 "prompt": prompt,
                 "background": background,
+                "input_fidelity": input_fidelity,
                 "mask": mask,
                 "model": model,
                 "n": n,
                 "output_compression": output_compression,
                 "output_format": output_format,
+                "partial_images": partial_images,
                 "quality": quality,
                 "response_format": response_format,
                 "size": size,
+                "stream": stream,
                 "user": user,
             }
         )
@@ -229,15 +500,891 @@ def edit(
         extra_headers = {"Content-Type": "multipart/form-data", **(extra_headers or {})}
         return self._post(
             "/images/edits",
-            body=maybe_transform(body, image_edit_params.ImageEditParams),
+            body=maybe_transform(
+                body,
+                image_edit_params.ImageEditParamsStreaming if stream else image_edit_params.ImageEditParamsNonStreaming,
+            ),
+            files=files,
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=ImagesResponse,
+            stream=stream or False,
+            stream_cls=Stream[ImageEditStreamEvent],
+        )
+
+    @overload
+    def generate(
+        self,
+        *,
+        prompt: str,
+        background: Optional[Literal["transparent", "opaque", "auto"]] | NotGiven = NOT_GIVEN,
+        model: Union[str, ImageModel, None] | NotGiven = NOT_GIVEN,
+        moderation: Optional[Literal["low", "auto"]] | NotGiven = NOT_GIVEN,
+        n: Optional[int] | NotGiven = NOT_GIVEN,
+        output_compression: Optional[int] | NotGiven = NOT_GIVEN,
+        output_format: Optional[Literal["png", "jpeg", "webp"]] | NotGiven = NOT_GIVEN,
+        partial_images: Optional[int] | NotGiven = NOT_GIVEN,
+        quality: Optional[Literal["standard", "hd", "low", "medium", "high", "auto"]] | NotGiven = NOT_GIVEN,
+        response_format: Optional[Literal["url", "b64_json"]] | NotGiven = NOT_GIVEN,
+        size: Optional[
+            Literal["auto", "1024x1024", "1536x1024", "1024x1536", "256x256", "512x512", "1792x1024", "1024x1792"]
+        ]
+        | NotGiven = NOT_GIVEN,
+        stream: Optional[Literal[False]] | NotGiven = NOT_GIVEN,
+        style: Optional[Literal["vivid", "natural"]] | NotGiven = NOT_GIVEN,
+        user: str | NotGiven = NOT_GIVEN,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> ImagesResponse:
+        """
+        Creates an image given a prompt.
+        [Learn more](https://platform.openai.com/docs/guides/images).
+
+        Args:
+          prompt: A text description of the desired image(s). The maximum length is 32000
+              characters for `gpt-image-1`, 1000 characters for `dall-e-2` and 4000 characters
+              for `dall-e-3`.
+
+          background: Allows to set transparency for the background of the generated image(s). This
+              parameter is only supported for `gpt-image-1`. Must be one of `transparent`,
+              `opaque` or `auto` (default value). When `auto` is used, the model will
+              automatically determine the best background for the image.
+
+              If `transparent`, the output format needs to support transparency, so it should
+              be set to either `png` (default value) or `webp`.
+
+          model: The model to use for image generation. One of `dall-e-2`, `dall-e-3`, or
+              `gpt-image-1`. Defaults to `dall-e-2` unless a parameter specific to
+              `gpt-image-1` is used.
+
+          moderation: Control the content-moderation level for images generated by `gpt-image-1`. Must
+              be either `low` for less restrictive filtering or `auto` (default value).
+
+          n: The number of images to generate. Must be between 1 and 10. For `dall-e-3`, only
+              `n=1` is supported.
+
+          output_compression: The compression level (0-100%) for the generated images. This parameter is only
+              supported for `gpt-image-1` with the `webp` or `jpeg` output formats, and
+              defaults to 100.
+
+          output_format: The format in which the generated images are returned. This parameter is only
+              supported for `gpt-image-1`. Must be one of `png`, `jpeg`, or `webp`.
+
+          partial_images: The number of partial images to generate. This parameter is used for streaming
+              responses that return partial images. Value must be between 0 and 3. When set to
+              0, the response will be a single image sent in one streaming event.
+
+          quality: The quality of the image that will be generated.
+
+              - `auto` (default value) will automatically select the best quality for the
+                given model.
+              - `high`, `medium` and `low` are supported for `gpt-image-1`.
+              - `hd` and `standard` are supported for `dall-e-3`.
+              - `standard` is the only option for `dall-e-2`.
+
+          response_format: The format in which generated images with `dall-e-2` and `dall-e-3` are
+              returned. Must be one of `url` or `b64_json`. URLs are only valid for 60 minutes
+              after the image has been generated. This parameter isn't supported for
+              `gpt-image-1` which will always return base64-encoded images.
+
+          size: The size of the generated images. Must be one of `1024x1024`, `1536x1024`
+              (landscape), `1024x1536` (portrait), or `auto` (default value) for
+              `gpt-image-1`, one of `256x256`, `512x512`, or `1024x1024` for `dall-e-2`, and
+              one of `1024x1024`, `1792x1024`, or `1024x1792` for `dall-e-3`.
+
+          stream: Generate the image in streaming mode. Defaults to `false`. See the
+              [Image generation guide](https://platform.openai.com/docs/guides/image-generation)
+              for more information. This parameter is only supported for `gpt-image-1`.
+
+          style: The style of the generated images. This parameter is only supported for
+              `dall-e-3`. Must be one of `vivid` or `natural`. Vivid causes the model to lean
+              towards generating hyper-real and dramatic images. Natural causes the model to
+              produce more natural, less hyper-real looking images.
+
+          user: A unique identifier representing your end-user, which can help OpenAI to monitor
+              and detect abuse.
+              [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#end-user-ids).
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        ...
+
+    @overload
+    def generate(
+        self,
+        *,
+        prompt: str,
+        stream: Literal[True],
+        background: Optional[Literal["transparent", "opaque", "auto"]] | NotGiven = NOT_GIVEN,
+        model: Union[str, ImageModel, None] | NotGiven = NOT_GIVEN,
+        moderation: Optional[Literal["low", "auto"]] | NotGiven = NOT_GIVEN,
+        n: Optional[int] | NotGiven = NOT_GIVEN,
+        output_compression: Optional[int] | NotGiven = NOT_GIVEN,
+        output_format: Optional[Literal["png", "jpeg", "webp"]] | NotGiven = NOT_GIVEN,
+        partial_images: Optional[int] | NotGiven = NOT_GIVEN,
+        quality: Optional[Literal["standard", "hd", "low", "medium", "high", "auto"]] | NotGiven = NOT_GIVEN,
+        response_format: Optional[Literal["url", "b64_json"]] | NotGiven = NOT_GIVEN,
+        size: Optional[
+            Literal["auto", "1024x1024", "1536x1024", "1024x1536", "256x256", "512x512", "1792x1024", "1024x1792"]
+        ]
+        | NotGiven = NOT_GIVEN,
+        style: Optional[Literal["vivid", "natural"]] | NotGiven = NOT_GIVEN,
+        user: str | NotGiven = NOT_GIVEN,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> Stream[ImageGenStreamEvent]:
+        """
+        Creates an image given a prompt.
+        [Learn more](https://platform.openai.com/docs/guides/images).
+
+        Args:
+          prompt: A text description of the desired image(s). The maximum length is 32000
+              characters for `gpt-image-1`, 1000 characters for `dall-e-2` and 4000 characters
+              for `dall-e-3`.
+
+          stream: Generate the image in streaming mode. Defaults to `false`. See the
+              [Image generation guide](https://platform.openai.com/docs/guides/image-generation)
+              for more information. This parameter is only supported for `gpt-image-1`.
+
+          background: Allows to set transparency for the background of the generated image(s). This
+              parameter is only supported for `gpt-image-1`. Must be one of `transparent`,
+              `opaque` or `auto` (default value). When `auto` is used, the model will
+              automatically determine the best background for the image.
+
+              If `transparent`, the output format needs to support transparency, so it should
+              be set to either `png` (default value) or `webp`.
+
+          model: The model to use for image generation. One of `dall-e-2`, `dall-e-3`, or
+              `gpt-image-1`. Defaults to `dall-e-2` unless a parameter specific to
+              `gpt-image-1` is used.
+
+          moderation: Control the content-moderation level for images generated by `gpt-image-1`. Must
+              be either `low` for less restrictive filtering or `auto` (default value).
+
+          n: The number of images to generate. Must be between 1 and 10. For `dall-e-3`, only
+              `n=1` is supported.
+
+          output_compression: The compression level (0-100%) for the generated images. This parameter is only
+              supported for `gpt-image-1` with the `webp` or `jpeg` output formats, and
+              defaults to 100.
+
+          output_format: The format in which the generated images are returned. This parameter is only
+              supported for `gpt-image-1`. Must be one of `png`, `jpeg`, or `webp`.
+
+          partial_images: The number of partial images to generate. This parameter is used for streaming
+              responses that return partial images. Value must be between 0 and 3. When set to
+              0, the response will be a single image sent in one streaming event.
+
+          quality: The quality of the image that will be generated.
+
+              - `auto` (default value) will automatically select the best quality for the
+                given model.
+              - `high`, `medium` and `low` are supported for `gpt-image-1`.
+              - `hd` and `standard` are supported for `dall-e-3`.
+              - `standard` is the only option for `dall-e-2`.
+
+          response_format: The format in which generated images with `dall-e-2` and `dall-e-3` are
+              returned. Must be one of `url` or `b64_json`. URLs are only valid for 60 minutes
+              after the image has been generated. This parameter isn't supported for
+              `gpt-image-1` which will always return base64-encoded images.
+
+          size: The size of the generated images. Must be one of `1024x1024`, `1536x1024`
+              (landscape), `1024x1536` (portrait), or `auto` (default value) for
+              `gpt-image-1`, one of `256x256`, `512x512`, or `1024x1024` for `dall-e-2`, and
+              one of `1024x1024`, `1792x1024`, or `1024x1792` for `dall-e-3`.
+
+          style: The style of the generated images. This parameter is only supported for
+              `dall-e-3`. Must be one of `vivid` or `natural`. Vivid causes the model to lean
+              towards generating hyper-real and dramatic images. Natural causes the model to
+              produce more natural, less hyper-real looking images.
+
+          user: A unique identifier representing your end-user, which can help OpenAI to monitor
+              and detect abuse.
+              [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#end-user-ids).
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        ...
+
+    @overload
+    def generate(
+        self,
+        *,
+        prompt: str,
+        stream: bool,
+        background: Optional[Literal["transparent", "opaque", "auto"]] | NotGiven = NOT_GIVEN,
+        model: Union[str, ImageModel, None] | NotGiven = NOT_GIVEN,
+        moderation: Optional[Literal["low", "auto"]] | NotGiven = NOT_GIVEN,
+        n: Optional[int] | NotGiven = NOT_GIVEN,
+        output_compression: Optional[int] | NotGiven = NOT_GIVEN,
+        output_format: Optional[Literal["png", "jpeg", "webp"]] | NotGiven = NOT_GIVEN,
+        partial_images: Optional[int] | NotGiven = NOT_GIVEN,
+        quality: Optional[Literal["standard", "hd", "low", "medium", "high", "auto"]] | NotGiven = NOT_GIVEN,
+        response_format: Optional[Literal["url", "b64_json"]] | NotGiven = NOT_GIVEN,
+        size: Optional[
+            Literal["auto", "1024x1024", "1536x1024", "1024x1536", "256x256", "512x512", "1792x1024", "1024x1792"]
+        ]
+        | NotGiven = NOT_GIVEN,
+        style: Optional[Literal["vivid", "natural"]] | NotGiven = NOT_GIVEN,
+        user: str | NotGiven = NOT_GIVEN,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> ImagesResponse | Stream[ImageGenStreamEvent]:
+        """
+        Creates an image given a prompt.
+        [Learn more](https://platform.openai.com/docs/guides/images).
+
+        Args:
+          prompt: A text description of the desired image(s). The maximum length is 32000
+              characters for `gpt-image-1`, 1000 characters for `dall-e-2` and 4000 characters
+              for `dall-e-3`.
+
+          stream: Generate the image in streaming mode. Defaults to `false`. See the
+              [Image generation guide](https://platform.openai.com/docs/guides/image-generation)
+              for more information. This parameter is only supported for `gpt-image-1`.
+
+          background: Allows to set transparency for the background of the generated image(s). This
+              parameter is only supported for `gpt-image-1`. Must be one of `transparent`,
+              `opaque` or `auto` (default value). When `auto` is used, the model will
+              automatically determine the best background for the image.
+
+              If `transparent`, the output format needs to support transparency, so it should
+              be set to either `png` (default value) or `webp`.
+
+          model: The model to use for image generation. One of `dall-e-2`, `dall-e-3`, or
+              `gpt-image-1`. Defaults to `dall-e-2` unless a parameter specific to
+              `gpt-image-1` is used.
+
+          moderation: Control the content-moderation level for images generated by `gpt-image-1`. Must
+              be either `low` for less restrictive filtering or `auto` (default value).
+
+          n: The number of images to generate. Must be between 1 and 10. For `dall-e-3`, only
+              `n=1` is supported.
+
+          output_compression: The compression level (0-100%) for the generated images. This parameter is only
+              supported for `gpt-image-1` with the `webp` or `jpeg` output formats, and
+              defaults to 100.
+
+          output_format: The format in which the generated images are returned. This parameter is only
+              supported for `gpt-image-1`. Must be one of `png`, `jpeg`, or `webp`.
+
+          partial_images: The number of partial images to generate. This parameter is used for streaming
+              responses that return partial images. Value must be between 0 and 3. When set to
+              0, the response will be a single image sent in one streaming event.
+
+          quality: The quality of the image that will be generated.
+
+              - `auto` (default value) will automatically select the best quality for the
+                given model.
+              - `high`, `medium` and `low` are supported for `gpt-image-1`.
+              - `hd` and `standard` are supported for `dall-e-3`.
+              - `standard` is the only option for `dall-e-2`.
+
+          response_format: The format in which generated images with `dall-e-2` and `dall-e-3` are
+              returned. Must be one of `url` or `b64_json`. URLs are only valid for 60 minutes
+              after the image has been generated. This parameter isn't supported for
+              `gpt-image-1` which will always return base64-encoded images.
+
+          size: The size of the generated images. Must be one of `1024x1024`, `1536x1024`
+              (landscape), `1024x1536` (portrait), or `auto` (default value) for
+              `gpt-image-1`, one of `256x256`, `512x512`, or `1024x1024` for `dall-e-2`, and
+              one of `1024x1024`, `1792x1024`, or `1024x1792` for `dall-e-3`.
+
+          style: The style of the generated images. This parameter is only supported for
+              `dall-e-3`. Must be one of `vivid` or `natural`. Vivid causes the model to lean
+              towards generating hyper-real and dramatic images. Natural causes the model to
+              produce more natural, less hyper-real looking images.
+
+          user: A unique identifier representing your end-user, which can help OpenAI to monitor
+              and detect abuse.
+              [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#end-user-ids).
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        ...
+
+    @required_args(["prompt"], ["prompt", "stream"])
+    def generate(
+        self,
+        *,
+        prompt: str,
+        background: Optional[Literal["transparent", "opaque", "auto"]] | NotGiven = NOT_GIVEN,
+        model: Union[str, ImageModel, None] | NotGiven = NOT_GIVEN,
+        moderation: Optional[Literal["low", "auto"]] | NotGiven = NOT_GIVEN,
+        n: Optional[int] | NotGiven = NOT_GIVEN,
+        output_compression: Optional[int] | NotGiven = NOT_GIVEN,
+        output_format: Optional[Literal["png", "jpeg", "webp"]] | NotGiven = NOT_GIVEN,
+        partial_images: Optional[int] | NotGiven = NOT_GIVEN,
+        quality: Optional[Literal["standard", "hd", "low", "medium", "high", "auto"]] | NotGiven = NOT_GIVEN,
+        response_format: Optional[Literal["url", "b64_json"]] | NotGiven = NOT_GIVEN,
+        size: Optional[
+            Literal["auto", "1024x1024", "1536x1024", "1024x1536", "256x256", "512x512", "1792x1024", "1024x1792"]
+        ]
+        | NotGiven = NOT_GIVEN,
+        stream: Optional[Literal[False]] | Literal[True] | NotGiven = NOT_GIVEN,
+        style: Optional[Literal["vivid", "natural"]] | NotGiven = NOT_GIVEN,
+        user: str | NotGiven = NOT_GIVEN,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> ImagesResponse | Stream[ImageGenStreamEvent]:
+        return self._post(
+            "/images/generations",
+            body=maybe_transform(
+                {
+                    "prompt": prompt,
+                    "background": background,
+                    "model": model,
+                    "moderation": moderation,
+                    "n": n,
+                    "output_compression": output_compression,
+                    "output_format": output_format,
+                    "partial_images": partial_images,
+                    "quality": quality,
+                    "response_format": response_format,
+                    "size": size,
+                    "stream": stream,
+                    "style": style,
+                    "user": user,
+                },
+                image_generate_params.ImageGenerateParamsStreaming
+                if stream
+                else image_generate_params.ImageGenerateParamsNonStreaming,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=ImagesResponse,
+            stream=stream or False,
+            stream_cls=Stream[ImageGenStreamEvent],
+        )
+
+
+class AsyncImages(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncImagesWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/openai/openai-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncImagesWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncImagesWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/openai/openai-python#with_streaming_response
+        """
+        return AsyncImagesWithStreamingResponse(self)
+
+    async def create_variation(
+        self,
+        *,
+        image: FileTypes,
+        model: Union[str, ImageModel, None] | NotGiven = NOT_GIVEN,
+        n: Optional[int] | NotGiven = NOT_GIVEN,
+        response_format: Optional[Literal["url", "b64_json"]] | NotGiven = NOT_GIVEN,
+        size: Optional[Literal["256x256", "512x512", "1024x1024"]] | NotGiven = NOT_GIVEN,
+        user: str | NotGiven = NOT_GIVEN,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> ImagesResponse:
+        """Creates a variation of a given image.
+
+        This endpoint only supports `dall-e-2`.
+
+        Args:
+          image: The image to use as the basis for the variation(s). Must be a valid PNG file,
+              less than 4MB, and square.
+
+          model: The model to use for image generation. Only `dall-e-2` is supported at this
+              time.
+
+          n: The number of images to generate. Must be between 1 and 10.
+
+          response_format: The format in which the generated images are returned. Must be one of `url` or
+              `b64_json`. URLs are only valid for 60 minutes after the image has been
+              generated.
+
+          size: The size of the generated images. Must be one of `256x256`, `512x512`, or
+              `1024x1024`.
+
+          user: A unique identifier representing your end-user, which can help OpenAI to monitor
+              and detect abuse.
+              [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#end-user-ids).
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        body = deepcopy_minimal(
+            {
+                "image": image,
+                "model": model,
+                "n": n,
+                "response_format": response_format,
+                "size": size,
+                "user": user,
+            }
+        )
+        files = extract_files(cast(Mapping[str, object], body), paths=[["image"]])
+        # It should be noted that the actual Content-Type header that will be
+        # sent to the server will contain a `boundary` parameter, e.g.
+        # multipart/form-data; boundary=---abc--
+        extra_headers = {"Content-Type": "multipart/form-data", **(extra_headers or {})}
+        return await self._post(
+            "/images/variations",
+            body=await async_maybe_transform(body, image_create_variation_params.ImageCreateVariationParams),
+            files=files,
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=ImagesResponse,
+        )
+
+    @overload
+    async def edit(
+        self,
+        *,
+        image: Union[FileTypes, List[FileTypes]],
+        prompt: str,
+        background: Optional[Literal["transparent", "opaque", "auto"]] | NotGiven = NOT_GIVEN,
+        input_fidelity: Optional[Literal["high", "low"]] | NotGiven = NOT_GIVEN,
+        mask: FileTypes | NotGiven = NOT_GIVEN,
+        model: Union[str, ImageModel, None] | NotGiven = NOT_GIVEN,
+        n: Optional[int] | NotGiven = NOT_GIVEN,
+        output_compression: Optional[int] | NotGiven = NOT_GIVEN,
+        output_format: Optional[Literal["png", "jpeg", "webp"]] | NotGiven = NOT_GIVEN,
+        partial_images: Optional[int] | NotGiven = NOT_GIVEN,
+        quality: Optional[Literal["standard", "low", "medium", "high", "auto"]] | NotGiven = NOT_GIVEN,
+        response_format: Optional[Literal["url", "b64_json"]] | NotGiven = NOT_GIVEN,
+        size: Optional[Literal["256x256", "512x512", "1024x1024", "1536x1024", "1024x1536", "auto"]]
+        | NotGiven = NOT_GIVEN,
+        stream: Optional[Literal[False]] | NotGiven = NOT_GIVEN,
+        user: str | NotGiven = NOT_GIVEN,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> ImagesResponse:
+        """Creates an edited or extended image given one or more source images and a
+        prompt.
+
+        This endpoint only supports `gpt-image-1` and `dall-e-2`.
+
+        Args:
+          image: The image(s) to edit. Must be a supported image file or an array of images.
+
+              For `gpt-image-1`, each image should be a `png`, `webp`, or `jpg` file less than
+              50MB. You can provide up to 16 images.
+
+              For `dall-e-2`, you can only provide one image, and it should be a square `png`
+              file less than 4MB.
+
+          prompt: A text description of the desired image(s). The maximum length is 1000
+              characters for `dall-e-2`, and 32000 characters for `gpt-image-1`.
+
+          background: Allows to set transparency for the background of the generated image(s). This
+              parameter is only supported for `gpt-image-1`. Must be one of `transparent`,
+              `opaque` or `auto` (default value). When `auto` is used, the model will
+              automatically determine the best background for the image.
+
+              If `transparent`, the output format needs to support transparency, so it should
+              be set to either `png` (default value) or `webp`.
+
+          input_fidelity: Control how much effort the model will exert to match the style and features,
+              especially facial features, of input images. This parameter is only supported
+              for `gpt-image-1`. Supports `high` and `low`. Defaults to `low`.
+
+          mask: An additional image whose fully transparent areas (e.g. where alpha is zero)
+              indicate where `image` should be edited. If there are multiple images provided,
+              the mask will be applied on the first image. Must be a valid PNG file, less than
+              4MB, and have the same dimensions as `image`.
+
+          model: The model to use for image generation. Only `dall-e-2` and `gpt-image-1` are
+              supported. Defaults to `dall-e-2` unless a parameter specific to `gpt-image-1`
+              is used.
+
+          n: The number of images to generate. Must be between 1 and 10.
+
+          output_compression: The compression level (0-100%) for the generated images. This parameter is only
+              supported for `gpt-image-1` with the `webp` or `jpeg` output formats, and
+              defaults to 100.
+
+          output_format: The format in which the generated images are returned. This parameter is only
+              supported for `gpt-image-1`. Must be one of `png`, `jpeg`, or `webp`. The
+              default value is `png`.
+
+          partial_images: The number of partial images to generate. This parameter is used for streaming
+              responses that return partial images. Value must be between 0 and 3. When set to
+              0, the response will be a single image sent in one streaming event.
+
+          quality: The quality of the image that will be generated. `high`, `medium` and `low` are
+              only supported for `gpt-image-1`. `dall-e-2` only supports `standard` quality.
+              Defaults to `auto`.
+
+          response_format: The format in which the generated images are returned. Must be one of `url` or
+              `b64_json`. URLs are only valid for 60 minutes after the image has been
+              generated. This parameter is only supported for `dall-e-2`, as `gpt-image-1`
+              will always return base64-encoded images.
+
+          size: The size of the generated images. Must be one of `1024x1024`, `1536x1024`
+              (landscape), `1024x1536` (portrait), or `auto` (default value) for
+              `gpt-image-1`, and one of `256x256`, `512x512`, or `1024x1024` for `dall-e-2`.
+
+          stream: Edit the image in streaming mode. Defaults to `false`. See the
+              [Image generation guide](https://platform.openai.com/docs/guides/image-generation)
+              for more information.
+
+          user: A unique identifier representing your end-user, which can help OpenAI to monitor
+              and detect abuse.
+              [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#end-user-ids).
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        ...
+
+    @overload
+    async def edit(
+        self,
+        *,
+        image: Union[FileTypes, List[FileTypes]],
+        prompt: str,
+        stream: Literal[True],
+        background: Optional[Literal["transparent", "opaque", "auto"]] | NotGiven = NOT_GIVEN,
+        input_fidelity: Optional[Literal["high", "low"]] | NotGiven = NOT_GIVEN,
+        mask: FileTypes | NotGiven = NOT_GIVEN,
+        model: Union[str, ImageModel, None] | NotGiven = NOT_GIVEN,
+        n: Optional[int] | NotGiven = NOT_GIVEN,
+        output_compression: Optional[int] | NotGiven = NOT_GIVEN,
+        output_format: Optional[Literal["png", "jpeg", "webp"]] | NotGiven = NOT_GIVEN,
+        partial_images: Optional[int] | NotGiven = NOT_GIVEN,
+        quality: Optional[Literal["standard", "low", "medium", "high", "auto"]] | NotGiven = NOT_GIVEN,
+        response_format: Optional[Literal["url", "b64_json"]] | NotGiven = NOT_GIVEN,
+        size: Optional[Literal["256x256", "512x512", "1024x1024", "1536x1024", "1024x1536", "auto"]]
+        | NotGiven = NOT_GIVEN,
+        user: str | NotGiven = NOT_GIVEN,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> AsyncStream[ImageEditStreamEvent]:
+        """Creates an edited or extended image given one or more source images and a
+        prompt.
+
+        This endpoint only supports `gpt-image-1` and `dall-e-2`.
+
+        Args:
+          image: The image(s) to edit. Must be a supported image file or an array of images.
+
+              For `gpt-image-1`, each image should be a `png`, `webp`, or `jpg` file less than
+              50MB. You can provide up to 16 images.
+
+              For `dall-e-2`, you can only provide one image, and it should be a square `png`
+              file less than 4MB.
+
+          prompt: A text description of the desired image(s). The maximum length is 1000
+              characters for `dall-e-2`, and 32000 characters for `gpt-image-1`.
+
+          stream: Edit the image in streaming mode. Defaults to `false`. See the
+              [Image generation guide](https://platform.openai.com/docs/guides/image-generation)
+              for more information.
+
+          background: Allows to set transparency for the background of the generated image(s). This
+              parameter is only supported for `gpt-image-1`. Must be one of `transparent`,
+              `opaque` or `auto` (default value). When `auto` is used, the model will
+              automatically determine the best background for the image.
+
+              If `transparent`, the output format needs to support transparency, so it should
+              be set to either `png` (default value) or `webp`.
+
+          input_fidelity: Control how much effort the model will exert to match the style and features,
+              especially facial features, of input images. This parameter is only supported
+              for `gpt-image-1`. Supports `high` and `low`. Defaults to `low`.
+
+          mask: An additional image whose fully transparent areas (e.g. where alpha is zero)
+              indicate where `image` should be edited. If there are multiple images provided,
+              the mask will be applied on the first image. Must be a valid PNG file, less than
+              4MB, and have the same dimensions as `image`.
+
+          model: The model to use for image generation. Only `dall-e-2` and `gpt-image-1` are
+              supported. Defaults to `dall-e-2` unless a parameter specific to `gpt-image-1`
+              is used.
+
+          n: The number of images to generate. Must be between 1 and 10.
+
+          output_compression: The compression level (0-100%) for the generated images. This parameter is only
+              supported for `gpt-image-1` with the `webp` or `jpeg` output formats, and
+              defaults to 100.
+
+          output_format: The format in which the generated images are returned. This parameter is only
+              supported for `gpt-image-1`. Must be one of `png`, `jpeg`, or `webp`. The
+              default value is `png`.
+
+          partial_images: The number of partial images to generate. This parameter is used for streaming
+              responses that return partial images. Value must be between 0 and 3. When set to
+              0, the response will be a single image sent in one streaming event.
+
+          quality: The quality of the image that will be generated. `high`, `medium` and `low` are
+              only supported for `gpt-image-1`. `dall-e-2` only supports `standard` quality.
+              Defaults to `auto`.
+
+          response_format: The format in which the generated images are returned. Must be one of `url` or
+              `b64_json`. URLs are only valid for 60 minutes after the image has been
+              generated. This parameter is only supported for `dall-e-2`, as `gpt-image-1`
+              will always return base64-encoded images.
+
+          size: The size of the generated images. Must be one of `1024x1024`, `1536x1024`
+              (landscape), `1024x1536` (portrait), or `auto` (default value) for
+              `gpt-image-1`, and one of `256x256`, `512x512`, or `1024x1024` for `dall-e-2`.
+
+          user: A unique identifier representing your end-user, which can help OpenAI to monitor
+              and detect abuse.
+              [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#end-user-ids).
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        ...
+
+    @overload
+    async def edit(
+        self,
+        *,
+        image: Union[FileTypes, List[FileTypes]],
+        prompt: str,
+        stream: bool,
+        background: Optional[Literal["transparent", "opaque", "auto"]] | NotGiven = NOT_GIVEN,
+        input_fidelity: Optional[Literal["high", "low"]] | NotGiven = NOT_GIVEN,
+        mask: FileTypes | NotGiven = NOT_GIVEN,
+        model: Union[str, ImageModel, None] | NotGiven = NOT_GIVEN,
+        n: Optional[int] | NotGiven = NOT_GIVEN,
+        output_compression: Optional[int] | NotGiven = NOT_GIVEN,
+        output_format: Optional[Literal["png", "jpeg", "webp"]] | NotGiven = NOT_GIVEN,
+        partial_images: Optional[int] | NotGiven = NOT_GIVEN,
+        quality: Optional[Literal["standard", "low", "medium", "high", "auto"]] | NotGiven = NOT_GIVEN,
+        response_format: Optional[Literal["url", "b64_json"]] | NotGiven = NOT_GIVEN,
+        size: Optional[Literal["256x256", "512x512", "1024x1024", "1536x1024", "1024x1536", "auto"]]
+        | NotGiven = NOT_GIVEN,
+        user: str | NotGiven = NOT_GIVEN,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> ImagesResponse | AsyncStream[ImageEditStreamEvent]:
+        """Creates an edited or extended image given one or more source images and a
+        prompt.
+
+        This endpoint only supports `gpt-image-1` and `dall-e-2`.
+
+        Args:
+          image: The image(s) to edit. Must be a supported image file or an array of images.
+
+              For `gpt-image-1`, each image should be a `png`, `webp`, or `jpg` file less than
+              50MB. You can provide up to 16 images.
+
+              For `dall-e-2`, you can only provide one image, and it should be a square `png`
+              file less than 4MB.
+
+          prompt: A text description of the desired image(s). The maximum length is 1000
+              characters for `dall-e-2`, and 32000 characters for `gpt-image-1`.
+
+          stream: Edit the image in streaming mode. Defaults to `false`. See the
+              [Image generation guide](https://platform.openai.com/docs/guides/image-generation)
+              for more information.
+
+          background: Allows to set transparency for the background of the generated image(s). This
+              parameter is only supported for `gpt-image-1`. Must be one of `transparent`,
+              `opaque` or `auto` (default value). When `auto` is used, the model will
+              automatically determine the best background for the image.
+
+              If `transparent`, the output format needs to support transparency, so it should
+              be set to either `png` (default value) or `webp`.
+
+          input_fidelity: Control how much effort the model will exert to match the style and features,
+              especially facial features, of input images. This parameter is only supported
+              for `gpt-image-1`. Supports `high` and `low`. Defaults to `low`.
+
+          mask: An additional image whose fully transparent areas (e.g. where alpha is zero)
+              indicate where `image` should be edited. If there are multiple images provided,
+              the mask will be applied on the first image. Must be a valid PNG file, less than
+              4MB, and have the same dimensions as `image`.
+
+          model: The model to use for image generation. Only `dall-e-2` and `gpt-image-1` are
+              supported. Defaults to `dall-e-2` unless a parameter specific to `gpt-image-1`
+              is used.
+
+          n: The number of images to generate. Must be between 1 and 10.
+
+          output_compression: The compression level (0-100%) for the generated images. This parameter is only
+              supported for `gpt-image-1` with the `webp` or `jpeg` output formats, and
+              defaults to 100.
+
+          output_format: The format in which the generated images are returned. This parameter is only
+              supported for `gpt-image-1`. Must be one of `png`, `jpeg`, or `webp`. The
+              default value is `png`.
+
+          partial_images: The number of partial images to generate. This parameter is used for streaming
+              responses that return partial images. Value must be between 0 and 3. When set to
+              0, the response will be a single image sent in one streaming event.
+
+          quality: The quality of the image that will be generated. `high`, `medium` and `low` are
+              only supported for `gpt-image-1`. `dall-e-2` only supports `standard` quality.
+              Defaults to `auto`.
+
+          response_format: The format in which the generated images are returned. Must be one of `url` or
+              `b64_json`. URLs are only valid for 60 minutes after the image has been
+              generated. This parameter is only supported for `dall-e-2`, as `gpt-image-1`
+              will always return base64-encoded images.
+
+          size: The size of the generated images. Must be one of `1024x1024`, `1536x1024`
+              (landscape), `1024x1536` (portrait), or `auto` (default value) for
+              `gpt-image-1`, and one of `256x256`, `512x512`, or `1024x1024` for `dall-e-2`.
+
+          user: A unique identifier representing your end-user, which can help OpenAI to monitor
+              and detect abuse.
+              [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#end-user-ids).
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        ...
+
+    @required_args(["image", "prompt"], ["image", "prompt", "stream"])
+    async def edit(
+        self,
+        *,
+        image: Union[FileTypes, List[FileTypes]],
+        prompt: str,
+        background: Optional[Literal["transparent", "opaque", "auto"]] | NotGiven = NOT_GIVEN,
+        input_fidelity: Optional[Literal["high", "low"]] | NotGiven = NOT_GIVEN,
+        mask: FileTypes | NotGiven = NOT_GIVEN,
+        model: Union[str, ImageModel, None] | NotGiven = NOT_GIVEN,
+        n: Optional[int] | NotGiven = NOT_GIVEN,
+        output_compression: Optional[int] | NotGiven = NOT_GIVEN,
+        output_format: Optional[Literal["png", "jpeg", "webp"]] | NotGiven = NOT_GIVEN,
+        partial_images: Optional[int] | NotGiven = NOT_GIVEN,
+        quality: Optional[Literal["standard", "low", "medium", "high", "auto"]] | NotGiven = NOT_GIVEN,
+        response_format: Optional[Literal["url", "b64_json"]] | NotGiven = NOT_GIVEN,
+        size: Optional[Literal["256x256", "512x512", "1024x1024", "1536x1024", "1024x1536", "auto"]]
+        | NotGiven = NOT_GIVEN,
+        stream: Optional[Literal[False]] | Literal[True] | NotGiven = NOT_GIVEN,
+        user: str | NotGiven = NOT_GIVEN,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> ImagesResponse | AsyncStream[ImageEditStreamEvent]:
+        body = deepcopy_minimal(
+            {
+                "image": image,
+                "prompt": prompt,
+                "background": background,
+                "input_fidelity": input_fidelity,
+                "mask": mask,
+                "model": model,
+                "n": n,
+                "output_compression": output_compression,
+                "output_format": output_format,
+                "partial_images": partial_images,
+                "quality": quality,
+                "response_format": response_format,
+                "size": size,
+                "stream": stream,
+                "user": user,
+            }
+        )
+        files = extract_files(cast(Mapping[str, object], body), paths=[["image"], ["image", "<array>"], ["mask"]])
+        # It should be noted that the actual Content-Type header that will be
+        # sent to the server will contain a `boundary` parameter, e.g.
+        # multipart/form-data; boundary=---abc--
+        extra_headers = {"Content-Type": "multipart/form-data", **(extra_headers or {})}
+        return await self._post(
+            "/images/edits",
+            body=await async_maybe_transform(
+                body,
+                image_edit_params.ImageEditParamsStreaming if stream else image_edit_params.ImageEditParamsNonStreaming,
+            ),
             files=files,
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
             cast_to=ImagesResponse,
+            stream=stream or False,
+            stream_cls=AsyncStream[ImageEditStreamEvent],
         )
 
-    def generate(
+    @overload
+    async def generate(
         self,
         *,
         prompt: str,
@@ -247,12 +1394,14 @@ def generate(
         n: Optional[int] | NotGiven = NOT_GIVEN,
         output_compression: Optional[int] | NotGiven = NOT_GIVEN,
         output_format: Optional[Literal["png", "jpeg", "webp"]] | NotGiven = NOT_GIVEN,
+        partial_images: Optional[int] | NotGiven = NOT_GIVEN,
         quality: Optional[Literal["standard", "hd", "low", "medium", "high", "auto"]] | NotGiven = NOT_GIVEN,
         response_format: Optional[Literal["url", "b64_json"]] | NotGiven = NOT_GIVEN,
         size: Optional[
             Literal["auto", "1024x1024", "1536x1024", "1024x1536", "256x256", "512x512", "1792x1024", "1024x1792"]
         ]
         | NotGiven = NOT_GIVEN,
+        stream: Optional[Literal[False]] | NotGiven = NOT_GIVEN,
         style: Optional[Literal["vivid", "natural"]] | NotGiven = NOT_GIVEN,
         user: str | NotGiven = NOT_GIVEN,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
@@ -296,6 +1445,10 @@ def generate(
           output_format: The format in which the generated images are returned. This parameter is only
               supported for `gpt-image-1`. Must be one of `png`, `jpeg`, or `webp`.
 
+          partial_images: The number of partial images to generate. This parameter is used for streaming
+              responses that return partial images. Value must be between 0 and 3. When set to
+              0, the response will be a single image sent in one streaming event.
+
           quality: The quality of the image that will be generated.
 
               - `auto` (default value) will automatically select the best quality for the
@@ -314,6 +1467,10 @@ def generate(
               `gpt-image-1`, one of `256x256`, `512x512`, or `1024x1024` for `dall-e-2`, and
               one of `1024x1024`, `1792x1024`, or `1024x1792` for `dall-e-3`.
 
+          stream: Generate the image in streaming mode. Defaults to `false`. See the
+              [Image generation guide](https://platform.openai.com/docs/guides/image-generation)
+              for more information. This parameter is only supported for `gpt-image-1`.
+
           style: The style of the generated images. This parameter is only supported for
               `dall-e-3`. Must be one of `vivid` or `natural`. Vivid causes the model to lean
               towards generating hyper-real and dramatic images. Natural causes the model to
@@ -331,140 +1488,28 @@ def generate(
 
           timeout: Override the client-level default timeout for this request, in seconds
         """
-        return self._post(
-            "/images/generations",
-            body=maybe_transform(
-                {
-                    "prompt": prompt,
-                    "background": background,
-                    "model": model,
-                    "moderation": moderation,
-                    "n": n,
-                    "output_compression": output_compression,
-                    "output_format": output_format,
-                    "quality": quality,
-                    "response_format": response_format,
-                    "size": size,
-                    "style": style,
-                    "user": user,
-                },
-                image_generate_params.ImageGenerateParams,
-            ),
-            options=make_request_options(
-                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
-            ),
-            cast_to=ImagesResponse,
-        )
-
-
-class AsyncImages(AsyncAPIResource):
-    @cached_property
-    def with_raw_response(self) -> AsyncImagesWithRawResponse:
-        """
-        This property can be used as a prefix for any HTTP method call to return
-        the raw response object instead of the parsed content.
-
-        For more information, see https://www.github.com/openai/openai-python#accessing-raw-response-data-eg-headers
-        """
-        return AsyncImagesWithRawResponse(self)
-
-    @cached_property
-    def with_streaming_response(self) -> AsyncImagesWithStreamingResponse:
-        """
-        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
-
-        For more information, see https://www.github.com/openai/openai-python#with_streaming_response
-        """
-        return AsyncImagesWithStreamingResponse(self)
-
-    async def create_variation(
-        self,
-        *,
-        image: FileTypes,
-        model: Union[str, ImageModel, None] | NotGiven = NOT_GIVEN,
-        n: Optional[int] | NotGiven = NOT_GIVEN,
-        response_format: Optional[Literal["url", "b64_json"]] | NotGiven = NOT_GIVEN,
-        size: Optional[Literal["256x256", "512x512", "1024x1024"]] | NotGiven = NOT_GIVEN,
-        user: str | NotGiven = NOT_GIVEN,
-        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
-        # The extra values given here take precedence over values defined on the client or passed to this method.
-        extra_headers: Headers | None = None,
-        extra_query: Query | None = None,
-        extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> ImagesResponse:
-        """Creates a variation of a given image.
-
-        This endpoint only supports `dall-e-2`.
-
-        Args:
-          image: The image to use as the basis for the variation(s). Must be a valid PNG file,
-              less than 4MB, and square.
-
-          model: The model to use for image generation. Only `dall-e-2` is supported at this
-              time.
-
-          n: The number of images to generate. Must be between 1 and 10.
-
-          response_format: The format in which the generated images are returned. Must be one of `url` or
-              `b64_json`. URLs are only valid for 60 minutes after the image has been
-              generated.
-
-          size: The size of the generated images. Must be one of `256x256`, `512x512`, or
-              `1024x1024`.
-
-          user: A unique identifier representing your end-user, which can help OpenAI to monitor
-              and detect abuse.
-              [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#end-user-ids).
-
-          extra_headers: Send extra headers
-
-          extra_query: Add additional query parameters to the request
-
-          extra_body: Add additional JSON properties to the request
-
-          timeout: Override the client-level default timeout for this request, in seconds
-        """
-        body = deepcopy_minimal(
-            {
-                "image": image,
-                "model": model,
-                "n": n,
-                "response_format": response_format,
-                "size": size,
-                "user": user,
-            }
-        )
-        files = extract_files(cast(Mapping[str, object], body), paths=[["image"]])
-        # It should be noted that the actual Content-Type header that will be
-        # sent to the server will contain a `boundary` parameter, e.g.
-        # multipart/form-data; boundary=---abc--
-        extra_headers = {"Content-Type": "multipart/form-data", **(extra_headers or {})}
-        return await self._post(
-            "/images/variations",
-            body=await async_maybe_transform(body, image_create_variation_params.ImageCreateVariationParams),
-            files=files,
-            options=make_request_options(
-                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
-            ),
-            cast_to=ImagesResponse,
-        )
+        ...
 
-    async def edit(
+    @overload
+    async def generate(
         self,
         *,
-        image: Union[FileTypes, List[FileTypes]],
         prompt: str,
+        stream: Literal[True],
         background: Optional[Literal["transparent", "opaque", "auto"]] | NotGiven = NOT_GIVEN,
-        mask: FileTypes | NotGiven = NOT_GIVEN,
         model: Union[str, ImageModel, None] | NotGiven = NOT_GIVEN,
+        moderation: Optional[Literal["low", "auto"]] | NotGiven = NOT_GIVEN,
         n: Optional[int] | NotGiven = NOT_GIVEN,
         output_compression: Optional[int] | NotGiven = NOT_GIVEN,
         output_format: Optional[Literal["png", "jpeg", "webp"]] | NotGiven = NOT_GIVEN,
-        quality: Optional[Literal["standard", "low", "medium", "high", "auto"]] | NotGiven = NOT_GIVEN,
+        partial_images: Optional[int] | NotGiven = NOT_GIVEN,
+        quality: Optional[Literal["standard", "hd", "low", "medium", "high", "auto"]] | NotGiven = NOT_GIVEN,
         response_format: Optional[Literal["url", "b64_json"]] | NotGiven = NOT_GIVEN,
-        size: Optional[Literal["256x256", "512x512", "1024x1024", "1536x1024", "1024x1536", "auto"]]
+        size: Optional[
+            Literal["auto", "1024x1024", "1536x1024", "1024x1536", "256x256", "512x512", "1792x1024", "1024x1792"]
+        ]
         | NotGiven = NOT_GIVEN,
+        style: Optional[Literal["vivid", "natural"]] | NotGiven = NOT_GIVEN,
         user: str | NotGiven = NOT_GIVEN,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
@@ -472,23 +1517,19 @@ async def edit(
         extra_query: Query | None = None,
         extra_body: Body | None = None,
         timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> ImagesResponse:
-        """Creates an edited or extended image given one or more source images and a
-        prompt.
-
-        This endpoint only supports `gpt-image-1` and `dall-e-2`.
+    ) -> AsyncStream[ImageGenStreamEvent]:
+        """
+        Creates an image given a prompt.
+        [Learn more](https://platform.openai.com/docs/guides/images).
 
         Args:
-          image: The image(s) to edit. Must be a supported image file or an array of images.
-
-              For `gpt-image-1`, each image should be a `png`, `webp`, or `jpg` file less than
-              50MB. You can provide up to 16 images.
-
-              For `dall-e-2`, you can only provide one image, and it should be a square `png`
-              file less than 4MB.
+          prompt: A text description of the desired image(s). The maximum length is 32000
+              characters for `gpt-image-1`, 1000 characters for `dall-e-2` and 4000 characters
+              for `dall-e-3`.
 
-          prompt: A text description of the desired image(s). The maximum length is 1000
-              characters for `dall-e-2`, and 32000 characters for `gpt-image-1`.
+          stream: Generate the image in streaming mode. Defaults to `false`. See the
+              [Image generation guide](https://platform.openai.com/docs/guides/image-generation)
+              for more information. This parameter is only supported for `gpt-image-1`.
 
           background: Allows to set transparency for the background of the generated image(s). This
               parameter is only supported for `gpt-image-1`. Must be one of `transparent`,
@@ -498,37 +1539,49 @@ async def edit(
               If `transparent`, the output format needs to support transparency, so it should
               be set to either `png` (default value) or `webp`.
 
-          mask: An additional image whose fully transparent areas (e.g. where alpha is zero)
-              indicate where `image` should be edited. If there are multiple images provided,
-              the mask will be applied on the first image. Must be a valid PNG file, less than
-              4MB, and have the same dimensions as `image`.
+          model: The model to use for image generation. One of `dall-e-2`, `dall-e-3`, or
+              `gpt-image-1`. Defaults to `dall-e-2` unless a parameter specific to
+              `gpt-image-1` is used.
 
-          model: The model to use for image generation. Only `dall-e-2` and `gpt-image-1` are
-              supported. Defaults to `dall-e-2` unless a parameter specific to `gpt-image-1`
-              is used.
+          moderation: Control the content-moderation level for images generated by `gpt-image-1`. Must
+              be either `low` for less restrictive filtering or `auto` (default value).
 
-          n: The number of images to generate. Must be between 1 and 10.
+          n: The number of images to generate. Must be between 1 and 10. For `dall-e-3`, only
+              `n=1` is supported.
 
           output_compression: The compression level (0-100%) for the generated images. This parameter is only
               supported for `gpt-image-1` with the `webp` or `jpeg` output formats, and
               defaults to 100.
 
           output_format: The format in which the generated images are returned. This parameter is only
-              supported for `gpt-image-1`. Must be one of `png`, `jpeg`, or `webp`. The
-              default value is `png`.
+              supported for `gpt-image-1`. Must be one of `png`, `jpeg`, or `webp`.
 
-          quality: The quality of the image that will be generated. `high`, `medium` and `low` are
-              only supported for `gpt-image-1`. `dall-e-2` only supports `standard` quality.
-              Defaults to `auto`.
+          partial_images: The number of partial images to generate. This parameter is used for streaming
+              responses that return partial images. Value must be between 0 and 3. When set to
+              0, the response will be a single image sent in one streaming event.
 
-          response_format: The format in which the generated images are returned. Must be one of `url` or
-              `b64_json`. URLs are only valid for 60 minutes after the image has been
-              generated. This parameter is only supported for `dall-e-2`, as `gpt-image-1`
-              will always return base64-encoded images.
+          quality: The quality of the image that will be generated.
+
+              - `auto` (default value) will automatically select the best quality for the
+                given model.
+              - `high`, `medium` and `low` are supported for `gpt-image-1`.
+              - `hd` and `standard` are supported for `dall-e-3`.
+              - `standard` is the only option for `dall-e-2`.
+
+          response_format: The format in which generated images with `dall-e-2` and `dall-e-3` are
+              returned. Must be one of `url` or `b64_json`. URLs are only valid for 60 minutes
+              after the image has been generated. This parameter isn't supported for
+              `gpt-image-1` which will always return base64-encoded images.
 
           size: The size of the generated images. Must be one of `1024x1024`, `1536x1024`
               (landscape), `1024x1536` (portrait), or `auto` (default value) for
-              `gpt-image-1`, and one of `256x256`, `512x512`, or `1024x1024` for `dall-e-2`.
+              `gpt-image-1`, one of `256x256`, `512x512`, or `1024x1024` for `dall-e-2`, and
+              one of `1024x1024`, `1792x1024`, or `1024x1792` for `dall-e-3`.
+
+          style: The style of the generated images. This parameter is only supported for
+              `dall-e-3`. Must be one of `vivid` or `natural`. Vivid causes the model to lean
+              towards generating hyper-real and dramatic images. Natural causes the model to
+              produce more natural, less hyper-real looking images.
 
           user: A unique identifier representing your end-user, which can help OpenAI to monitor
               and detect abuse.
@@ -542,47 +1595,21 @@ async def edit(
 
           timeout: Override the client-level default timeout for this request, in seconds
         """
-        body = deepcopy_minimal(
-            {
-                "image": image,
-                "prompt": prompt,
-                "background": background,
-                "mask": mask,
-                "model": model,
-                "n": n,
-                "output_compression": output_compression,
-                "output_format": output_format,
-                "quality": quality,
-                "response_format": response_format,
-                "size": size,
-                "user": user,
-            }
-        )
-        files = extract_files(cast(Mapping[str, object], body), paths=[["image"], ["image", "<array>"], ["mask"]])
-        # It should be noted that the actual Content-Type header that will be
-        # sent to the server will contain a `boundary` parameter, e.g.
-        # multipart/form-data; boundary=---abc--
-        extra_headers = {"Content-Type": "multipart/form-data", **(extra_headers or {})}
-        return await self._post(
-            "/images/edits",
-            body=await async_maybe_transform(body, image_edit_params.ImageEditParams),
-            files=files,
-            options=make_request_options(
-                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
-            ),
-            cast_to=ImagesResponse,
-        )
+        ...
 
+    @overload
     async def generate(
         self,
         *,
         prompt: str,
+        stream: bool,
         background: Optional[Literal["transparent", "opaque", "auto"]] | NotGiven = NOT_GIVEN,
         model: Union[str, ImageModel, None] | NotGiven = NOT_GIVEN,
         moderation: Optional[Literal["low", "auto"]] | NotGiven = NOT_GIVEN,
         n: Optional[int] | NotGiven = NOT_GIVEN,
         output_compression: Optional[int] | NotGiven = NOT_GIVEN,
         output_format: Optional[Literal["png", "jpeg", "webp"]] | NotGiven = NOT_GIVEN,
+        partial_images: Optional[int] | NotGiven = NOT_GIVEN,
         quality: Optional[Literal["standard", "hd", "low", "medium", "high", "auto"]] | NotGiven = NOT_GIVEN,
         response_format: Optional[Literal["url", "b64_json"]] | NotGiven = NOT_GIVEN,
         size: Optional[
@@ -597,7 +1624,7 @@ async def generate(
         extra_query: Query | None = None,
         extra_body: Body | None = None,
         timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> ImagesResponse:
+    ) -> ImagesResponse | AsyncStream[ImageGenStreamEvent]:
         """
         Creates an image given a prompt.
         [Learn more](https://platform.openai.com/docs/guides/images).
@@ -607,6 +1634,10 @@ async def generate(
               characters for `gpt-image-1`, 1000 characters for `dall-e-2` and 4000 characters
               for `dall-e-3`.
 
+          stream: Generate the image in streaming mode. Defaults to `false`. See the
+              [Image generation guide](https://platform.openai.com/docs/guides/image-generation)
+              for more information. This parameter is only supported for `gpt-image-1`.
+
           background: Allows to set transparency for the background of the generated image(s). This
               parameter is only supported for `gpt-image-1`. Must be one of `transparent`,
               `opaque` or `auto` (default value). When `auto` is used, the model will
@@ -632,6 +1663,10 @@ async def generate(
           output_format: The format in which the generated images are returned. This parameter is only
               supported for `gpt-image-1`. Must be one of `png`, `jpeg`, or `webp`.
 
+          partial_images: The number of partial images to generate. This parameter is used for streaming
+              responses that return partial images. Value must be between 0 and 3. When set to
+              0, the response will be a single image sent in one streaming event.
+
           quality: The quality of the image that will be generated.
 
               - `auto` (default value) will automatically select the best quality for the
@@ -667,6 +1702,36 @@ async def generate(
 
           timeout: Override the client-level default timeout for this request, in seconds
         """
+        ...
+
+    @required_args(["prompt"], ["prompt", "stream"])
+    async def generate(
+        self,
+        *,
+        prompt: str,
+        background: Optional[Literal["transparent", "opaque", "auto"]] | NotGiven = NOT_GIVEN,
+        model: Union[str, ImageModel, None] | NotGiven = NOT_GIVEN,
+        moderation: Optional[Literal["low", "auto"]] | NotGiven = NOT_GIVEN,
+        n: Optional[int] | NotGiven = NOT_GIVEN,
+        output_compression: Optional[int] | NotGiven = NOT_GIVEN,
+        output_format: Optional[Literal["png", "jpeg", "webp"]] | NotGiven = NOT_GIVEN,
+        partial_images: Optional[int] | NotGiven = NOT_GIVEN,
+        quality: Optional[Literal["standard", "hd", "low", "medium", "high", "auto"]] | NotGiven = NOT_GIVEN,
+        response_format: Optional[Literal["url", "b64_json"]] | NotGiven = NOT_GIVEN,
+        size: Optional[
+            Literal["auto", "1024x1024", "1536x1024", "1024x1536", "256x256", "512x512", "1792x1024", "1024x1792"]
+        ]
+        | NotGiven = NOT_GIVEN,
+        stream: Optional[Literal[False]] | Literal[True] | NotGiven = NOT_GIVEN,
+        style: Optional[Literal["vivid", "natural"]] | NotGiven = NOT_GIVEN,
+        user: str | NotGiven = NOT_GIVEN,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> ImagesResponse | AsyncStream[ImageGenStreamEvent]:
         return await self._post(
             "/images/generations",
             body=await async_maybe_transform(
@@ -678,18 +1743,24 @@ async def generate(
                     "n": n,
                     "output_compression": output_compression,
                     "output_format": output_format,
+                    "partial_images": partial_images,
                     "quality": quality,
                     "response_format": response_format,
                     "size": size,
+                    "stream": stream,
                     "style": style,
                     "user": user,
                 },
-                image_generate_params.ImageGenerateParams,
+                image_generate_params.ImageGenerateParamsStreaming
+                if stream
+                else image_generate_params.ImageGenerateParamsNonStreaming,
             ),
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
             cast_to=ImagesResponse,
+            stream=stream or False,
+            stream_cls=AsyncStream[ImageGenStreamEvent],
         )
 
 
diff --git a/src/openai/types/__init__.py b/src/openai/types/__init__.py
index 453b26f555..51f3ee5c9b 100644
--- a/src/openai/types/__init__.py
+++ b/src/openai/types/__init__.py
@@ -60,15 +60,19 @@
 from .image_generate_params import ImageGenerateParams as ImageGenerateParams
 from .eval_retrieve_response import EvalRetrieveResponse as EvalRetrieveResponse
 from .file_chunking_strategy import FileChunkingStrategy as FileChunkingStrategy
+from .image_gen_stream_event import ImageGenStreamEvent as ImageGenStreamEvent
 from .upload_complete_params import UploadCompleteParams as UploadCompleteParams
 from .container_create_params import ContainerCreateParams as ContainerCreateParams
 from .container_list_response import ContainerListResponse as ContainerListResponse
 from .embedding_create_params import EmbeddingCreateParams as EmbeddingCreateParams
+from .image_edit_stream_event import ImageEditStreamEvent as ImageEditStreamEvent
 from .completion_create_params import CompletionCreateParams as CompletionCreateParams
 from .moderation_create_params import ModerationCreateParams as ModerationCreateParams
 from .vector_store_list_params import VectorStoreListParams as VectorStoreListParams
 from .container_create_response import ContainerCreateResponse as ContainerCreateResponse
 from .create_embedding_response import CreateEmbeddingResponse as CreateEmbeddingResponse
+from .image_gen_completed_event import ImageGenCompletedEvent as ImageGenCompletedEvent
+from .image_edit_completed_event import ImageEditCompletedEvent as ImageEditCompletedEvent
 from .moderation_create_response import ModerationCreateResponse as ModerationCreateResponse
 from .vector_store_create_params import VectorStoreCreateParams as VectorStoreCreateParams
 from .vector_store_search_params import VectorStoreSearchParams as VectorStoreSearchParams
@@ -79,8 +83,10 @@
 from .vector_store_search_response import VectorStoreSearchResponse as VectorStoreSearchResponse
 from .websocket_connection_options import WebsocketConnectionOptions as WebsocketConnectionOptions
 from .image_create_variation_params import ImageCreateVariationParams as ImageCreateVariationParams
+from .image_gen_partial_image_event import ImageGenPartialImageEvent as ImageGenPartialImageEvent
 from .static_file_chunking_strategy import StaticFileChunkingStrategy as StaticFileChunkingStrategy
 from .eval_custom_data_source_config import EvalCustomDataSourceConfig as EvalCustomDataSourceConfig
+from .image_edit_partial_image_event import ImageEditPartialImageEvent as ImageEditPartialImageEvent
 from .moderation_image_url_input_param import ModerationImageURLInputParam as ModerationImageURLInputParam
 from .auto_file_chunking_strategy_param import AutoFileChunkingStrategyParam as AutoFileChunkingStrategyParam
 from .moderation_multi_modal_input_param import ModerationMultiModalInputParam as ModerationMultiModalInputParam
diff --git a/src/openai/types/image_edit_completed_event.py b/src/openai/types/image_edit_completed_event.py
new file mode 100644
index 0000000000..a40682da6a
--- /dev/null
+++ b/src/openai/types/image_edit_completed_event.py
@@ -0,0 +1,55 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from .._models import BaseModel
+
+__all__ = ["ImageEditCompletedEvent", "Usage", "UsageInputTokensDetails"]
+
+
+class UsageInputTokensDetails(BaseModel):
+    image_tokens: int
+    """The number of image tokens in the input prompt."""
+
+    text_tokens: int
+    """The number of text tokens in the input prompt."""
+
+
+class Usage(BaseModel):
+    input_tokens: int
+    """The number of tokens (images and text) in the input prompt."""
+
+    input_tokens_details: UsageInputTokensDetails
+    """The input tokens detailed information for the image generation."""
+
+    output_tokens: int
+    """The number of image tokens in the output image."""
+
+    total_tokens: int
+    """The total number of tokens (images and text) used for the image generation."""
+
+
+class ImageEditCompletedEvent(BaseModel):
+    b64_json: str
+    """Base64-encoded final edited image data, suitable for rendering as an image."""
+
+    background: Literal["transparent", "opaque", "auto"]
+    """The background setting for the edited image."""
+
+    created_at: int
+    """The Unix timestamp when the event was created."""
+
+    output_format: Literal["png", "webp", "jpeg"]
+    """The output format for the edited image."""
+
+    quality: Literal["low", "medium", "high", "auto"]
+    """The quality setting for the edited image."""
+
+    size: Literal["1024x1024", "1024x1536", "1536x1024", "auto"]
+    """The size of the edited image."""
+
+    type: Literal["image_edit.completed"]
+    """The type of the event. Always `image_edit.completed`."""
+
+    usage: Usage
+    """For `gpt-image-1` only, the token usage information for the image generation."""
diff --git a/src/openai/types/image_edit_params.py b/src/openai/types/image_edit_params.py
index aecb98fa6f..d839e2fcbe 100644
--- a/src/openai/types/image_edit_params.py
+++ b/src/openai/types/image_edit_params.py
@@ -8,10 +8,10 @@
 from .._types import FileTypes
 from .image_model import ImageModel
 
-__all__ = ["ImageEditParams"]
+__all__ = ["ImageEditParamsBase", "ImageEditParamsNonStreaming", "ImageEditParamsStreaming"]
 
 
-class ImageEditParams(TypedDict, total=False):
+class ImageEditParamsBase(TypedDict, total=False):
     image: Required[Union[FileTypes, List[FileTypes]]]
     """The image(s) to edit. Must be a supported image file or an array of images.
 
@@ -40,6 +40,13 @@ class ImageEditParams(TypedDict, total=False):
     be set to either `png` (default value) or `webp`.
     """
 
+    input_fidelity: Optional[Literal["high", "low"]]
+    """
+    Control how much effort the model will exert to match the style and features,
+    especially facial features, of input images. This parameter is only supported
+    for `gpt-image-1`. Supports `high` and `low`. Defaults to `low`.
+    """
+
     mask: FileTypes
     """An additional image whose fully transparent areas (e.g.
 
@@ -72,6 +79,14 @@ class ImageEditParams(TypedDict, total=False):
     `jpeg`, or `webp`. The default value is `png`.
     """
 
+    partial_images: Optional[int]
+    """The number of partial images to generate.
+
+    This parameter is used for streaming responses that return partial images. Value
+    must be between 0 and 3. When set to 0, the response will be a single image sent
+    in one streaming event.
+    """
+
     quality: Optional[Literal["standard", "low", "medium", "high", "auto"]]
     """The quality of the image that will be generated.
 
@@ -101,3 +116,26 @@ class ImageEditParams(TypedDict, total=False):
     and detect abuse.
     [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#end-user-ids).
     """
+
+
+class ImageEditParamsNonStreaming(ImageEditParamsBase, total=False):
+    stream: Optional[Literal[False]]
+    """Edit the image in streaming mode.
+
+    Defaults to `false`. See the
+    [Image generation guide](https://platform.openai.com/docs/guides/image-generation)
+    for more information.
+    """
+
+
+class ImageEditParamsStreaming(ImageEditParamsBase):
+    stream: Required[Literal[True]]
+    """Edit the image in streaming mode.
+
+    Defaults to `false`. See the
+    [Image generation guide](https://platform.openai.com/docs/guides/image-generation)
+    for more information.
+    """
+
+
+ImageEditParams = Union[ImageEditParamsNonStreaming, ImageEditParamsStreaming]
diff --git a/src/openai/types/image_edit_partial_image_event.py b/src/openai/types/image_edit_partial_image_event.py
new file mode 100644
index 0000000000..20da45efc3
--- /dev/null
+++ b/src/openai/types/image_edit_partial_image_event.py
@@ -0,0 +1,33 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from .._models import BaseModel
+
+__all__ = ["ImageEditPartialImageEvent"]
+
+
+class ImageEditPartialImageEvent(BaseModel):
+    b64_json: str
+    """Base64-encoded partial image data, suitable for rendering as an image."""
+
+    background: Literal["transparent", "opaque", "auto"]
+    """The background setting for the requested edited image."""
+
+    created_at: int
+    """The Unix timestamp when the event was created."""
+
+    output_format: Literal["png", "webp", "jpeg"]
+    """The output format for the requested edited image."""
+
+    partial_image_index: int
+    """0-based index for the partial image (streaming)."""
+
+    quality: Literal["low", "medium", "high", "auto"]
+    """The quality setting for the requested edited image."""
+
+    size: Literal["1024x1024", "1024x1536", "1536x1024", "auto"]
+    """The size of the requested edited image."""
+
+    type: Literal["image_edit.partial_image"]
+    """The type of the event. Always `image_edit.partial_image`."""
diff --git a/src/openai/types/image_edit_stream_event.py b/src/openai/types/image_edit_stream_event.py
new file mode 100644
index 0000000000..759f6c6db5
--- /dev/null
+++ b/src/openai/types/image_edit_stream_event.py
@@ -0,0 +1,14 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Union
+from typing_extensions import Annotated, TypeAlias
+
+from .._utils import PropertyInfo
+from .image_edit_completed_event import ImageEditCompletedEvent
+from .image_edit_partial_image_event import ImageEditPartialImageEvent
+
+__all__ = ["ImageEditStreamEvent"]
+
+ImageEditStreamEvent: TypeAlias = Annotated[
+    Union[ImageEditPartialImageEvent, ImageEditCompletedEvent], PropertyInfo(discriminator="type")
+]
diff --git a/src/openai/types/image_gen_completed_event.py b/src/openai/types/image_gen_completed_event.py
new file mode 100644
index 0000000000..e78da842d4
--- /dev/null
+++ b/src/openai/types/image_gen_completed_event.py
@@ -0,0 +1,55 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from .._models import BaseModel
+
+__all__ = ["ImageGenCompletedEvent", "Usage", "UsageInputTokensDetails"]
+
+
+class UsageInputTokensDetails(BaseModel):
+    image_tokens: int
+    """The number of image tokens in the input prompt."""
+
+    text_tokens: int
+    """The number of text tokens in the input prompt."""
+
+
+class Usage(BaseModel):
+    input_tokens: int
+    """The number of tokens (images and text) in the input prompt."""
+
+    input_tokens_details: UsageInputTokensDetails
+    """The input tokens detailed information for the image generation."""
+
+    output_tokens: int
+    """The number of image tokens in the output image."""
+
+    total_tokens: int
+    """The total number of tokens (images and text) used for the image generation."""
+
+
+class ImageGenCompletedEvent(BaseModel):
+    b64_json: str
+    """Base64-encoded image data, suitable for rendering as an image."""
+
+    background: Literal["transparent", "opaque", "auto"]
+    """The background setting for the generated image."""
+
+    created_at: int
+    """The Unix timestamp when the event was created."""
+
+    output_format: Literal["png", "webp", "jpeg"]
+    """The output format for the generated image."""
+
+    quality: Literal["low", "medium", "high", "auto"]
+    """The quality setting for the generated image."""
+
+    size: Literal["1024x1024", "1024x1536", "1536x1024", "auto"]
+    """The size of the generated image."""
+
+    type: Literal["image_generation.completed"]
+    """The type of the event. Always `image_generation.completed`."""
+
+    usage: Usage
+    """For `gpt-image-1` only, the token usage information for the image generation."""
diff --git a/src/openai/types/image_gen_partial_image_event.py b/src/openai/types/image_gen_partial_image_event.py
new file mode 100644
index 0000000000..965d450604
--- /dev/null
+++ b/src/openai/types/image_gen_partial_image_event.py
@@ -0,0 +1,33 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from .._models import BaseModel
+
+__all__ = ["ImageGenPartialImageEvent"]
+
+
+class ImageGenPartialImageEvent(BaseModel):
+    b64_json: str
+    """Base64-encoded partial image data, suitable for rendering as an image."""
+
+    background: Literal["transparent", "opaque", "auto"]
+    """The background setting for the requested image."""
+
+    created_at: int
+    """The Unix timestamp when the event was created."""
+
+    output_format: Literal["png", "webp", "jpeg"]
+    """The output format for the requested image."""
+
+    partial_image_index: int
+    """0-based index for the partial image (streaming)."""
+
+    quality: Literal["low", "medium", "high", "auto"]
+    """The quality setting for the requested image."""
+
+    size: Literal["1024x1024", "1024x1536", "1536x1024", "auto"]
+    """The size of the requested image."""
+
+    type: Literal["image_generation.partial_image"]
+    """The type of the event. Always `image_generation.partial_image`."""
diff --git a/src/openai/types/image_gen_stream_event.py b/src/openai/types/image_gen_stream_event.py
new file mode 100644
index 0000000000..7dde5d5245
--- /dev/null
+++ b/src/openai/types/image_gen_stream_event.py
@@ -0,0 +1,14 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Union
+from typing_extensions import Annotated, TypeAlias
+
+from .._utils import PropertyInfo
+from .image_gen_completed_event import ImageGenCompletedEvent
+from .image_gen_partial_image_event import ImageGenPartialImageEvent
+
+__all__ = ["ImageGenStreamEvent"]
+
+ImageGenStreamEvent: TypeAlias = Annotated[
+    Union[ImageGenPartialImageEvent, ImageGenCompletedEvent], PropertyInfo(discriminator="type")
+]
diff --git a/src/openai/types/image_generate_params.py b/src/openai/types/image_generate_params.py
index 8fc10220dc..bd9f34b28e 100644
--- a/src/openai/types/image_generate_params.py
+++ b/src/openai/types/image_generate_params.py
@@ -7,10 +7,10 @@
 
 from .image_model import ImageModel
 
-__all__ = ["ImageGenerateParams"]
+__all__ = ["ImageGenerateParamsBase", "ImageGenerateParamsNonStreaming", "ImageGenerateParamsStreaming"]
 
 
-class ImageGenerateParams(TypedDict, total=False):
+class ImageGenerateParamsBase(TypedDict, total=False):
     prompt: Required[str]
     """A text description of the desired image(s).
 
@@ -62,6 +62,14 @@ class ImageGenerateParams(TypedDict, total=False):
     `jpeg`, or `webp`.
     """
 
+    partial_images: Optional[int]
+    """The number of partial images to generate.
+
+    This parameter is used for streaming responses that return partial images. Value
+    must be between 0 and 3. When set to 0, the response will be a single image sent
+    in one streaming event.
+    """
+
     quality: Optional[Literal["standard", "hd", "low", "medium", "high", "auto"]]
     """The quality of the image that will be generated.
 
@@ -107,3 +115,26 @@ class ImageGenerateParams(TypedDict, total=False):
     and detect abuse.
     [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#end-user-ids).
     """
+
+
+class ImageGenerateParamsNonStreaming(ImageGenerateParamsBase, total=False):
+    stream: Optional[Literal[False]]
+    """Generate the image in streaming mode.
+
+    Defaults to `false`. See the
+    [Image generation guide](https://platform.openai.com/docs/guides/image-generation)
+    for more information. This parameter is only supported for `gpt-image-1`.
+    """
+
+
+class ImageGenerateParamsStreaming(ImageGenerateParamsBase):
+    stream: Required[Literal[True]]
+    """Generate the image in streaming mode.
+
+    Defaults to `false`. See the
+    [Image generation guide](https://platform.openai.com/docs/guides/image-generation)
+    for more information. This parameter is only supported for `gpt-image-1`.
+    """
+
+
+ImageGenerateParams = Union[ImageGenerateParamsNonStreaming, ImageGenerateParamsStreaming]
diff --git a/src/openai/types/responses/response_output_refusal.py b/src/openai/types/responses/response_output_refusal.py
index eba581070d..685c8722a6 100644
--- a/src/openai/types/responses/response_output_refusal.py
+++ b/src/openai/types/responses/response_output_refusal.py
@@ -9,7 +9,7 @@
 
 class ResponseOutputRefusal(BaseModel):
     refusal: str
-    """The refusal explanationfrom the model."""
+    """The refusal explanation from the model."""
 
     type: Literal["refusal"]
     """The type of the refusal. Always `refusal`."""
diff --git a/src/openai/types/responses/response_output_refusal_param.py b/src/openai/types/responses/response_output_refusal_param.py
index 53140a6080..54cfaf0791 100644
--- a/src/openai/types/responses/response_output_refusal_param.py
+++ b/src/openai/types/responses/response_output_refusal_param.py
@@ -9,7 +9,7 @@
 
 class ResponseOutputRefusalParam(TypedDict, total=False):
     refusal: Required[str]
-    """The refusal explanationfrom the model."""
+    """The refusal explanation from the model."""
 
     type: Required[Literal["refusal"]]
     """The type of the refusal. Always `refusal`."""
diff --git a/src/openai/types/responses/tool.py b/src/openai/types/responses/tool.py
index 9c1573bda9..4399871e29 100644
--- a/src/openai/types/responses/tool.py
+++ b/src/openai/types/responses/tool.py
@@ -124,6 +124,13 @@ class ImageGeneration(BaseModel):
     One of `transparent`, `opaque`, or `auto`. Default: `auto`.
     """
 
+    input_fidelity: Optional[Literal["high", "low"]] = None
+    """
+    Control how much effort the model will exert to match the style and features,
+    especially facial features, of input images. This parameter is only supported
+    for `gpt-image-1`. Supports `high` and `low`. Defaults to `low`.
+    """
+
     input_image_mask: Optional[ImageGenerationInputImageMask] = None
     """Optional mask for inpainting.
 
diff --git a/src/openai/types/responses/tool_param.py b/src/openai/types/responses/tool_param.py
index 493a1dad9c..a977f06e3f 100644
--- a/src/openai/types/responses/tool_param.py
+++ b/src/openai/types/responses/tool_param.py
@@ -125,6 +125,13 @@ class ImageGeneration(TypedDict, total=False):
     One of `transparent`, `opaque`, or `auto`. Default: `auto`.
     """
 
+    input_fidelity: Optional[Literal["high", "low"]]
+    """
+    Control how much effort the model will exert to match the style and features,
+    especially facial features, of input images. This parameter is only supported
+    for `gpt-image-1`. Supports `high` and `low`. Defaults to `low`.
+    """
+
     input_image_mask: ImageGenerationInputImageMask
     """Optional mask for inpainting.
 
diff --git a/tests/api_resources/test_images.py b/tests/api_resources/test_images.py
index 10fc56d685..99fe77d8e0 100644
--- a/tests/api_resources/test_images.py
+++ b/tests/api_resources/test_images.py
@@ -61,7 +61,7 @@ def test_streaming_response_create_variation(self, client: OpenAI) -> None:
         assert cast(Any, response.is_closed) is True
 
     @parametrize
-    def test_method_edit(self, client: OpenAI) -> None:
+    def test_method_edit_overload_1(self, client: OpenAI) -> None:
         image = client.images.edit(
             image=b"raw file contents",
             prompt="A cute baby sea otter wearing a beret",
@@ -69,25 +69,28 @@ def test_method_edit(self, client: OpenAI) -> None:
         assert_matches_type(ImagesResponse, image, path=["response"])
 
     @parametrize
-    def test_method_edit_with_all_params(self, client: OpenAI) -> None:
+    def test_method_edit_with_all_params_overload_1(self, client: OpenAI) -> None:
         image = client.images.edit(
             image=b"raw file contents",
             prompt="A cute baby sea otter wearing a beret",
             background="transparent",
+            input_fidelity="high",
             mask=b"raw file contents",
             model="string",
             n=1,
             output_compression=100,
             output_format="png",
+            partial_images=1,
             quality="high",
             response_format="url",
             size="1024x1024",
+            stream=False,
             user="user-1234",
         )
         assert_matches_type(ImagesResponse, image, path=["response"])
 
     @parametrize
-    def test_raw_response_edit(self, client: OpenAI) -> None:
+    def test_raw_response_edit_overload_1(self, client: OpenAI) -> None:
         response = client.images.with_raw_response.edit(
             image=b"raw file contents",
             prompt="A cute baby sea otter wearing a beret",
@@ -99,7 +102,7 @@ def test_raw_response_edit(self, client: OpenAI) -> None:
         assert_matches_type(ImagesResponse, image, path=["response"])
 
     @parametrize
-    def test_streaming_response_edit(self, client: OpenAI) -> None:
+    def test_streaming_response_edit_overload_1(self, client: OpenAI) -> None:
         with client.images.with_streaming_response.edit(
             image=b"raw file contents",
             prompt="A cute baby sea otter wearing a beret",
@@ -113,14 +116,71 @@ def test_streaming_response_edit(self, client: OpenAI) -> None:
         assert cast(Any, response.is_closed) is True
 
     @parametrize
-    def test_method_generate(self, client: OpenAI) -> None:
+    def test_method_edit_overload_2(self, client: OpenAI) -> None:
+        image_stream = client.images.edit(
+            image=b"raw file contents",
+            prompt="A cute baby sea otter wearing a beret",
+            stream=True,
+        )
+        image_stream.response.close()
+
+    @parametrize
+    def test_method_edit_with_all_params_overload_2(self, client: OpenAI) -> None:
+        image_stream = client.images.edit(
+            image=b"raw file contents",
+            prompt="A cute baby sea otter wearing a beret",
+            stream=True,
+            background="transparent",
+            input_fidelity="high",
+            mask=b"raw file contents",
+            model="string",
+            n=1,
+            output_compression=100,
+            output_format="png",
+            partial_images=1,
+            quality="high",
+            response_format="url",
+            size="1024x1024",
+            user="user-1234",
+        )
+        image_stream.response.close()
+
+    @parametrize
+    def test_raw_response_edit_overload_2(self, client: OpenAI) -> None:
+        response = client.images.with_raw_response.edit(
+            image=b"raw file contents",
+            prompt="A cute baby sea otter wearing a beret",
+            stream=True,
+        )
+
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        stream = response.parse()
+        stream.close()
+
+    @parametrize
+    def test_streaming_response_edit_overload_2(self, client: OpenAI) -> None:
+        with client.images.with_streaming_response.edit(
+            image=b"raw file contents",
+            prompt="A cute baby sea otter wearing a beret",
+            stream=True,
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            stream = response.parse()
+            stream.close()
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    def test_method_generate_overload_1(self, client: OpenAI) -> None:
         image = client.images.generate(
             prompt="A cute baby sea otter",
         )
         assert_matches_type(ImagesResponse, image, path=["response"])
 
     @parametrize
-    def test_method_generate_with_all_params(self, client: OpenAI) -> None:
+    def test_method_generate_with_all_params_overload_1(self, client: OpenAI) -> None:
         image = client.images.generate(
             prompt="A cute baby sea otter",
             background="transparent",
@@ -129,16 +189,18 @@ def test_method_generate_with_all_params(self, client: OpenAI) -> None:
             n=1,
             output_compression=100,
             output_format="png",
+            partial_images=1,
             quality="medium",
             response_format="url",
             size="1024x1024",
+            stream=False,
             style="vivid",
             user="user-1234",
         )
         assert_matches_type(ImagesResponse, image, path=["response"])
 
     @parametrize
-    def test_raw_response_generate(self, client: OpenAI) -> None:
+    def test_raw_response_generate_overload_1(self, client: OpenAI) -> None:
         response = client.images.with_raw_response.generate(
             prompt="A cute baby sea otter",
         )
@@ -149,7 +211,7 @@ def test_raw_response_generate(self, client: OpenAI) -> None:
         assert_matches_type(ImagesResponse, image, path=["response"])
 
     @parametrize
-    def test_streaming_response_generate(self, client: OpenAI) -> None:
+    def test_streaming_response_generate_overload_1(self, client: OpenAI) -> None:
         with client.images.with_streaming_response.generate(
             prompt="A cute baby sea otter",
         ) as response:
@@ -161,6 +223,59 @@ def test_streaming_response_generate(self, client: OpenAI) -> None:
 
         assert cast(Any, response.is_closed) is True
 
+    @parametrize
+    def test_method_generate_overload_2(self, client: OpenAI) -> None:
+        image_stream = client.images.generate(
+            prompt="A cute baby sea otter",
+            stream=True,
+        )
+        image_stream.response.close()
+
+    @parametrize
+    def test_method_generate_with_all_params_overload_2(self, client: OpenAI) -> None:
+        image_stream = client.images.generate(
+            prompt="A cute baby sea otter",
+            stream=True,
+            background="transparent",
+            model="string",
+            moderation="low",
+            n=1,
+            output_compression=100,
+            output_format="png",
+            partial_images=1,
+            quality="medium",
+            response_format="url",
+            size="1024x1024",
+            style="vivid",
+            user="user-1234",
+        )
+        image_stream.response.close()
+
+    @parametrize
+    def test_raw_response_generate_overload_2(self, client: OpenAI) -> None:
+        response = client.images.with_raw_response.generate(
+            prompt="A cute baby sea otter",
+            stream=True,
+        )
+
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        stream = response.parse()
+        stream.close()
+
+    @parametrize
+    def test_streaming_response_generate_overload_2(self, client: OpenAI) -> None:
+        with client.images.with_streaming_response.generate(
+            prompt="A cute baby sea otter",
+            stream=True,
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            stream = response.parse()
+            stream.close()
+
+        assert cast(Any, response.is_closed) is True
+
 
 class TestAsyncImages:
     parametrize = pytest.mark.parametrize(
@@ -211,7 +326,7 @@ async def test_streaming_response_create_variation(self, async_client: AsyncOpen
         assert cast(Any, response.is_closed) is True
 
     @parametrize
-    async def test_method_edit(self, async_client: AsyncOpenAI) -> None:
+    async def test_method_edit_overload_1(self, async_client: AsyncOpenAI) -> None:
         image = await async_client.images.edit(
             image=b"raw file contents",
             prompt="A cute baby sea otter wearing a beret",
@@ -219,25 +334,28 @@ async def test_method_edit(self, async_client: AsyncOpenAI) -> None:
         assert_matches_type(ImagesResponse, image, path=["response"])
 
     @parametrize
-    async def test_method_edit_with_all_params(self, async_client: AsyncOpenAI) -> None:
+    async def test_method_edit_with_all_params_overload_1(self, async_client: AsyncOpenAI) -> None:
         image = await async_client.images.edit(
             image=b"raw file contents",
             prompt="A cute baby sea otter wearing a beret",
             background="transparent",
+            input_fidelity="high",
             mask=b"raw file contents",
             model="string",
             n=1,
             output_compression=100,
             output_format="png",
+            partial_images=1,
             quality="high",
             response_format="url",
             size="1024x1024",
+            stream=False,
             user="user-1234",
         )
         assert_matches_type(ImagesResponse, image, path=["response"])
 
     @parametrize
-    async def test_raw_response_edit(self, async_client: AsyncOpenAI) -> None:
+    async def test_raw_response_edit_overload_1(self, async_client: AsyncOpenAI) -> None:
         response = await async_client.images.with_raw_response.edit(
             image=b"raw file contents",
             prompt="A cute baby sea otter wearing a beret",
@@ -249,7 +367,7 @@ async def test_raw_response_edit(self, async_client: AsyncOpenAI) -> None:
         assert_matches_type(ImagesResponse, image, path=["response"])
 
     @parametrize
-    async def test_streaming_response_edit(self, async_client: AsyncOpenAI) -> None:
+    async def test_streaming_response_edit_overload_1(self, async_client: AsyncOpenAI) -> None:
         async with async_client.images.with_streaming_response.edit(
             image=b"raw file contents",
             prompt="A cute baby sea otter wearing a beret",
@@ -263,14 +381,71 @@ async def test_streaming_response_edit(self, async_client: AsyncOpenAI) -> None:
         assert cast(Any, response.is_closed) is True
 
     @parametrize
-    async def test_method_generate(self, async_client: AsyncOpenAI) -> None:
+    async def test_method_edit_overload_2(self, async_client: AsyncOpenAI) -> None:
+        image_stream = await async_client.images.edit(
+            image=b"raw file contents",
+            prompt="A cute baby sea otter wearing a beret",
+            stream=True,
+        )
+        await image_stream.response.aclose()
+
+    @parametrize
+    async def test_method_edit_with_all_params_overload_2(self, async_client: AsyncOpenAI) -> None:
+        image_stream = await async_client.images.edit(
+            image=b"raw file contents",
+            prompt="A cute baby sea otter wearing a beret",
+            stream=True,
+            background="transparent",
+            input_fidelity="high",
+            mask=b"raw file contents",
+            model="string",
+            n=1,
+            output_compression=100,
+            output_format="png",
+            partial_images=1,
+            quality="high",
+            response_format="url",
+            size="1024x1024",
+            user="user-1234",
+        )
+        await image_stream.response.aclose()
+
+    @parametrize
+    async def test_raw_response_edit_overload_2(self, async_client: AsyncOpenAI) -> None:
+        response = await async_client.images.with_raw_response.edit(
+            image=b"raw file contents",
+            prompt="A cute baby sea otter wearing a beret",
+            stream=True,
+        )
+
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        stream = response.parse()
+        await stream.close()
+
+    @parametrize
+    async def test_streaming_response_edit_overload_2(self, async_client: AsyncOpenAI) -> None:
+        async with async_client.images.with_streaming_response.edit(
+            image=b"raw file contents",
+            prompt="A cute baby sea otter wearing a beret",
+            stream=True,
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            stream = await response.parse()
+            await stream.close()
+
+        assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    async def test_method_generate_overload_1(self, async_client: AsyncOpenAI) -> None:
         image = await async_client.images.generate(
             prompt="A cute baby sea otter",
         )
         assert_matches_type(ImagesResponse, image, path=["response"])
 
     @parametrize
-    async def test_method_generate_with_all_params(self, async_client: AsyncOpenAI) -> None:
+    async def test_method_generate_with_all_params_overload_1(self, async_client: AsyncOpenAI) -> None:
         image = await async_client.images.generate(
             prompt="A cute baby sea otter",
             background="transparent",
@@ -279,16 +454,18 @@ async def test_method_generate_with_all_params(self, async_client: AsyncOpenAI)
             n=1,
             output_compression=100,
             output_format="png",
+            partial_images=1,
             quality="medium",
             response_format="url",
             size="1024x1024",
+            stream=False,
             style="vivid",
             user="user-1234",
         )
         assert_matches_type(ImagesResponse, image, path=["response"])
 
     @parametrize
-    async def test_raw_response_generate(self, async_client: AsyncOpenAI) -> None:
+    async def test_raw_response_generate_overload_1(self, async_client: AsyncOpenAI) -> None:
         response = await async_client.images.with_raw_response.generate(
             prompt="A cute baby sea otter",
         )
@@ -299,7 +476,7 @@ async def test_raw_response_generate(self, async_client: AsyncOpenAI) -> None:
         assert_matches_type(ImagesResponse, image, path=["response"])
 
     @parametrize
-    async def test_streaming_response_generate(self, async_client: AsyncOpenAI) -> None:
+    async def test_streaming_response_generate_overload_1(self, async_client: AsyncOpenAI) -> None:
         async with async_client.images.with_streaming_response.generate(
             prompt="A cute baby sea otter",
         ) as response:
@@ -310,3 +487,56 @@ async def test_streaming_response_generate(self, async_client: AsyncOpenAI) -> N
             assert_matches_type(ImagesResponse, image, path=["response"])
 
         assert cast(Any, response.is_closed) is True
+
+    @parametrize
+    async def test_method_generate_overload_2(self, async_client: AsyncOpenAI) -> None:
+        image_stream = await async_client.images.generate(
+            prompt="A cute baby sea otter",
+            stream=True,
+        )
+        await image_stream.response.aclose()
+
+    @parametrize
+    async def test_method_generate_with_all_params_overload_2(self, async_client: AsyncOpenAI) -> None:
+        image_stream = await async_client.images.generate(
+            prompt="A cute baby sea otter",
+            stream=True,
+            background="transparent",
+            model="string",
+            moderation="low",
+            n=1,
+            output_compression=100,
+            output_format="png",
+            partial_images=1,
+            quality="medium",
+            response_format="url",
+            size="1024x1024",
+            style="vivid",
+            user="user-1234",
+        )
+        await image_stream.response.aclose()
+
+    @parametrize
+    async def test_raw_response_generate_overload_2(self, async_client: AsyncOpenAI) -> None:
+        response = await async_client.images.with_raw_response.generate(
+            prompt="A cute baby sea otter",
+            stream=True,
+        )
+
+        assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+        stream = response.parse()
+        await stream.close()
+
+    @parametrize
+    async def test_streaming_response_generate_overload_2(self, async_client: AsyncOpenAI) -> None:
+        async with async_client.images.with_streaming_response.generate(
+            prompt="A cute baby sea otter",
+            stream=True,
+        ) as response:
+            assert not response.is_closed
+            assert response.http_request.headers.get("X-Stainless-Lang") == "python"
+
+            stream = await response.parse()
+            await stream.close()
+
+        assert cast(Any, response.is_closed) is True