-module(glopenai@image).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/glopenai/image.gleam").
-export([new_create_request/1, with_model/2, with_n/2, with_quality/2, with_response_format/2, with_output_format/2, with_output_compression/2, with_size/2, with_moderation/2, with_background/2, with_style/2, with_user/2, image_size_to_json/1, image_model_to_json/1, image_quality_to_json/1, image_style_to_json/1, image_moderation_to_json/1, image_output_format_to_json/1, image_response_format_to_json/1, image_background_to_json/1, create_image_request_to_json/1, image_size_decoder/0, image_model_decoder/0, image_quality_decoder/0, image_style_decoder/0, image_output_format_decoder/0, image_response_format_decoder/0, image_response_background_decoder/0, image_decoder/0, image_gen_input_usage_details_decoder/0, image_gen_output_tokens_details_decoder/0, image_gen_usage_decoder/0, create_request/2, create_response/1]).
-export_type([image_size/0, image_model/0, image_quality/0, image_style/0, image_moderation/0, image_output_format/0, image_response_format/0, image_background/0, create_image_request/0, image/0, image_response_background/0, image_gen_input_usage_details/0, image_gen_output_tokens_details/0, image_gen_usage/0, images_response/0]).

-if(?OTP_RELEASE >= 27).
-define(MODULEDOC(Str), -moduledoc(Str)).
-define(DOC(Str), -doc(Str)).
-else.
-define(MODULEDOC(Str), -compile([])).
-define(DOC(Str), -compile([])).
-endif.

-type image_size() :: size_auto |
    size256x256 |
    size512x512 |
    size1024x1024 |
    size1792x1024 |
    size1024x1792 |
    size1536x1024 |
    size1024x1536.

-type image_model() :: gpt_image1 |
    gpt_image1dot5 |
    gpt_image1_mini |
    dall_e2 |
    dall_e3 |
    {other_image_model, binary()}.

-type image_quality() :: quality_standard |
    quality_hd |
    quality_high |
    quality_medium |
    quality_low |
    quality_auto.

-type image_style() :: vivid | natural.

-type image_moderation() :: moderation_auto | moderation_low.

-type image_output_format() :: png | jpeg | webp.

-type image_response_format() :: url | b64_json.

-type image_background() :: background_auto |
    background_transparent |
    background_opaque.

-type create_image_request() :: {create_image_request,
        binary(),
        gleam@option:option(image_model()),
        gleam@option:option(integer()),
        gleam@option:option(image_quality()),
        gleam@option:option(image_response_format()),
        gleam@option:option(image_output_format()),
        gleam@option:option(integer()),
        gleam@option:option(image_size()),
        gleam@option:option(image_moderation()),
        gleam@option:option(image_background()),
        gleam@option:option(image_style()),
        gleam@option:option(binary())}.

-type image() :: {image_url, binary(), gleam@option:option(binary())} |
    {image_b64_json, binary(), gleam@option:option(binary())}.

-type image_response_background() :: response_transparent | response_opaque.

-type image_gen_input_usage_details() :: {image_gen_input_usage_details,
        integer(),
        integer()}.

-type image_gen_output_tokens_details() :: {image_gen_output_tokens_details,
        integer(),
        integer()}.

-type image_gen_usage() :: {image_gen_usage,
        integer(),
        integer(),
        integer(),
        image_gen_input_usage_details(),
        gleam@option:option(image_gen_output_tokens_details())}.

-type images_response() :: {images_response,
        integer(),
        list(image()),
        gleam@option:option(image_response_background()),
        gleam@option:option(image_output_format()),
        gleam@option:option(image_size()),
        gleam@option:option(image_quality()),
        gleam@option:option(image_gen_usage())}.

-file("src/glopenai/image.gleam", 138).
?DOC(" Create a new image generation request with the required prompt.\n").
-spec new_create_request(binary()) -> create_image_request().
new_create_request(Prompt) ->
    {create_image_request,
        Prompt,
        none,
        none,
        none,
        none,
        none,
        none,
        none,
        none,
        none,
        none,
        none}.

-file("src/glopenai/image.gleam", 155).
-spec with_model(create_image_request(), image_model()) -> create_image_request().
with_model(Request, Model) ->
    {create_image_request,
        erlang:element(2, Request),
        {some, Model},
        erlang:element(4, Request),
        erlang:element(5, Request),
        erlang:element(6, Request),
        erlang:element(7, Request),
        erlang:element(8, Request),
        erlang:element(9, Request),
        erlang:element(10, Request),
        erlang:element(11, Request),
        erlang:element(12, Request),
        erlang:element(13, Request)}.

-file("src/glopenai/image.gleam", 162).
-spec with_n(create_image_request(), integer()) -> create_image_request().
with_n(Request, N) ->
    {create_image_request,
        erlang:element(2, Request),
        erlang:element(3, Request),
        {some, N},
        erlang:element(5, Request),
        erlang:element(6, Request),
        erlang:element(7, Request),
        erlang:element(8, Request),
        erlang:element(9, Request),
        erlang:element(10, Request),
        erlang:element(11, Request),
        erlang:element(12, Request),
        erlang:element(13, Request)}.

-file("src/glopenai/image.gleam", 166).
-spec with_quality(create_image_request(), image_quality()) -> create_image_request().
with_quality(Request, Quality) ->
    {create_image_request,
        erlang:element(2, Request),
        erlang:element(3, Request),
        erlang:element(4, Request),
        {some, Quality},
        erlang:element(6, Request),
        erlang:element(7, Request),
        erlang:element(8, Request),
        erlang:element(9, Request),
        erlang:element(10, Request),
        erlang:element(11, Request),
        erlang:element(12, Request),
        erlang:element(13, Request)}.

-file("src/glopenai/image.gleam", 173).
-spec with_response_format(create_image_request(), image_response_format()) -> create_image_request().
with_response_format(Request, Format) ->
    {create_image_request,
        erlang:element(2, Request),
        erlang:element(3, Request),
        erlang:element(4, Request),
        erlang:element(5, Request),
        {some, Format},
        erlang:element(7, Request),
        erlang:element(8, Request),
        erlang:element(9, Request),
        erlang:element(10, Request),
        erlang:element(11, Request),
        erlang:element(12, Request),
        erlang:element(13, Request)}.

-file("src/glopenai/image.gleam", 180).
-spec with_output_format(create_image_request(), image_output_format()) -> create_image_request().
with_output_format(Request, Format) ->
    {create_image_request,
        erlang:element(2, Request),
        erlang:element(3, Request),
        erlang:element(4, Request),
        erlang:element(5, Request),
        erlang:element(6, Request),
        {some, Format},
        erlang:element(8, Request),
        erlang:element(9, Request),
        erlang:element(10, Request),
        erlang:element(11, Request),
        erlang:element(12, Request),
        erlang:element(13, Request)}.

-file("src/glopenai/image.gleam", 187).
-spec with_output_compression(create_image_request(), integer()) -> create_image_request().
with_output_compression(Request, Compression) ->
    {create_image_request,
        erlang:element(2, Request),
        erlang:element(3, Request),
        erlang:element(4, Request),
        erlang:element(5, Request),
        erlang:element(6, Request),
        erlang:element(7, Request),
        {some, Compression},
        erlang:element(9, Request),
        erlang:element(10, Request),
        erlang:element(11, Request),
        erlang:element(12, Request),
        erlang:element(13, Request)}.

-file("src/glopenai/image.gleam", 194).
-spec with_size(create_image_request(), image_size()) -> create_image_request().
with_size(Request, Size) ->
    {create_image_request,
        erlang:element(2, Request),
        erlang:element(3, Request),
        erlang:element(4, Request),
        erlang:element(5, Request),
        erlang:element(6, Request),
        erlang:element(7, Request),
        erlang:element(8, Request),
        {some, Size},
        erlang:element(10, Request),
        erlang:element(11, Request),
        erlang:element(12, Request),
        erlang:element(13, Request)}.

-file("src/glopenai/image.gleam", 201).
-spec with_moderation(create_image_request(), image_moderation()) -> create_image_request().
with_moderation(Request, Moderation) ->
    {create_image_request,
        erlang:element(2, Request),
        erlang:element(3, Request),
        erlang:element(4, Request),
        erlang:element(5, Request),
        erlang:element(6, Request),
        erlang:element(7, Request),
        erlang:element(8, Request),
        erlang:element(9, Request),
        {some, Moderation},
        erlang:element(11, Request),
        erlang:element(12, Request),
        erlang:element(13, Request)}.

-file("src/glopenai/image.gleam", 208).
-spec with_background(create_image_request(), image_background()) -> create_image_request().
with_background(Request, Background) ->
    {create_image_request,
        erlang:element(2, Request),
        erlang:element(3, Request),
        erlang:element(4, Request),
        erlang:element(5, Request),
        erlang:element(6, Request),
        erlang:element(7, Request),
        erlang:element(8, Request),
        erlang:element(9, Request),
        erlang:element(10, Request),
        {some, Background},
        erlang:element(12, Request),
        erlang:element(13, Request)}.

-file("src/glopenai/image.gleam", 215).
-spec with_style(create_image_request(), image_style()) -> create_image_request().
with_style(Request, Style) ->
    {create_image_request,
        erlang:element(2, Request),
        erlang:element(3, Request),
        erlang:element(4, Request),
        erlang:element(5, Request),
        erlang:element(6, Request),
        erlang:element(7, Request),
        erlang:element(8, Request),
        erlang:element(9, Request),
        erlang:element(10, Request),
        erlang:element(11, Request),
        {some, Style},
        erlang:element(13, Request)}.

-file("src/glopenai/image.gleam", 222).
-spec with_user(create_image_request(), binary()) -> create_image_request().
with_user(Request, User) ->
    {create_image_request,
        erlang:element(2, Request),
        erlang:element(3, Request),
        erlang:element(4, Request),
        erlang:element(5, Request),
        erlang:element(6, Request),
        erlang:element(7, Request),
        erlang:element(8, Request),
        erlang:element(9, Request),
        erlang:element(10, Request),
        erlang:element(11, Request),
        erlang:element(12, Request),
        {some, User}}.

-file("src/glopenai/image.gleam", 231).
-spec image_size_to_json(image_size()) -> gleam@json:json().
image_size_to_json(Size) ->
    gleam@json:string(case Size of
            size_auto ->
                <<"auto"/utf8>>;

            size256x256 ->
                <<"256x256"/utf8>>;

            size512x512 ->
                <<"512x512"/utf8>>;

            size1024x1024 ->
                <<"1024x1024"/utf8>>;

            size1792x1024 ->
                <<"1792x1024"/utf8>>;

            size1024x1792 ->
                <<"1024x1792"/utf8>>;

            size1536x1024 ->
                <<"1536x1024"/utf8>>;

            size1024x1536 ->
                <<"1024x1536"/utf8>>
        end).

-file("src/glopenai/image.gleam", 244).
-spec image_model_to_json(image_model()) -> gleam@json:json().
image_model_to_json(Model) ->
    gleam@json:string(case Model of
            gpt_image1 ->
                <<"gpt-image-1"/utf8>>;

            gpt_image1dot5 ->
                <<"gpt-image-1.5"/utf8>>;

            gpt_image1_mini ->
                <<"gpt-image-1-mini"/utf8>>;

            dall_e2 ->
                <<"dall-e-2"/utf8>>;

            dall_e3 ->
                <<"dall-e-3"/utf8>>;

            {other_image_model, Name} ->
                Name
        end).

-file("src/glopenai/image.gleam", 255).
-spec image_quality_to_json(image_quality()) -> gleam@json:json().
image_quality_to_json(Quality) ->
    gleam@json:string(case Quality of
            quality_standard ->
                <<"standard"/utf8>>;

            quality_hd ->
                <<"hd"/utf8>>;

            quality_high ->
                <<"high"/utf8>>;

            quality_medium ->
                <<"medium"/utf8>>;

            quality_low ->
                <<"low"/utf8>>;

            quality_auto ->
                <<"auto"/utf8>>
        end).

-file("src/glopenai/image.gleam", 266).
-spec image_style_to_json(image_style()) -> gleam@json:json().
image_style_to_json(Style) ->
    gleam@json:string(case Style of
            vivid ->
                <<"vivid"/utf8>>;

            natural ->
                <<"natural"/utf8>>
        end).

-file("src/glopenai/image.gleam", 273).
-spec image_moderation_to_json(image_moderation()) -> gleam@json:json().
image_moderation_to_json(Moderation) ->
    gleam@json:string(case Moderation of
            moderation_auto ->
                <<"auto"/utf8>>;

            moderation_low ->
                <<"low"/utf8>>
        end).

-file("src/glopenai/image.gleam", 280).
-spec image_output_format_to_json(image_output_format()) -> gleam@json:json().
image_output_format_to_json(Format) ->
    gleam@json:string(case Format of
            png ->
                <<"png"/utf8>>;

            jpeg ->
                <<"jpeg"/utf8>>;

            webp ->
                <<"webp"/utf8>>
        end).

-file("src/glopenai/image.gleam", 288).
-spec image_response_format_to_json(image_response_format()) -> gleam@json:json().
image_response_format_to_json(Format) ->
    gleam@json:string(case Format of
            url ->
                <<"url"/utf8>>;

            b64_json ->
                <<"b64_json"/utf8>>
        end).

-file("src/glopenai/image.gleam", 295).
-spec image_background_to_json(image_background()) -> gleam@json:json().
image_background_to_json(Background) ->
    gleam@json:string(case Background of
            background_auto ->
                <<"auto"/utf8>>;

            background_transparent ->
                <<"transparent"/utf8>>;

            background_opaque ->
                <<"opaque"/utf8>>
        end).

-file("src/glopenai/image.gleam", 303).
-spec create_image_request_to_json(create_image_request()) -> gleam@json:json().
create_image_request_to_json(Request) ->
    glopenai@internal@codec:object_with_optional(
        [{<<"prompt"/utf8>>, gleam@json:string(erlang:element(2, Request))}],
        [glopenai@internal@codec:optional_field(
                <<"model"/utf8>>,
                erlang:element(3, Request),
                fun image_model_to_json/1
            ),
            glopenai@internal@codec:optional_field(
                <<"n"/utf8>>,
                erlang:element(4, Request),
                fun gleam@json:int/1
            ),
            glopenai@internal@codec:optional_field(
                <<"quality"/utf8>>,
                erlang:element(5, Request),
                fun image_quality_to_json/1
            ),
            glopenai@internal@codec:optional_field(
                <<"response_format"/utf8>>,
                erlang:element(6, Request),
                fun image_response_format_to_json/1
            ),
            glopenai@internal@codec:optional_field(
                <<"output_format"/utf8>>,
                erlang:element(7, Request),
                fun image_output_format_to_json/1
            ),
            glopenai@internal@codec:optional_field(
                <<"output_compression"/utf8>>,
                erlang:element(8, Request),
                fun gleam@json:int/1
            ),
            glopenai@internal@codec:optional_field(
                <<"size"/utf8>>,
                erlang:element(9, Request),
                fun image_size_to_json/1
            ),
            glopenai@internal@codec:optional_field(
                <<"moderation"/utf8>>,
                erlang:element(10, Request),
                fun image_moderation_to_json/1
            ),
            glopenai@internal@codec:optional_field(
                <<"background"/utf8>>,
                erlang:element(11, Request),
                fun image_background_to_json/1
            ),
            glopenai@internal@codec:optional_field(
                <<"style"/utf8>>,
                erlang:element(12, Request),
                fun image_style_to_json/1
            ),
            glopenai@internal@codec:optional_field(
                <<"user"/utf8>>,
                erlang:element(13, Request),
                fun gleam@json:string/1
            )]
    ).

-file("src/glopenai/image.gleam", 341).
-spec image_size_decoder() -> gleam@dynamic@decode:decoder(image_size()).
image_size_decoder() ->
    gleam@dynamic@decode:then(
        {decoder, fun gleam@dynamic@decode:decode_string/1},
        fun(Value) -> case Value of
                <<"auto"/utf8>> ->
                    gleam@dynamic@decode:success(size_auto);

                <<"256x256"/utf8>> ->
                    gleam@dynamic@decode:success(size256x256);

                <<"512x512"/utf8>> ->
                    gleam@dynamic@decode:success(size512x512);

                <<"1024x1024"/utf8>> ->
                    gleam@dynamic@decode:success(size1024x1024);

                <<"1792x1024"/utf8>> ->
                    gleam@dynamic@decode:success(size1792x1024);

                <<"1024x1792"/utf8>> ->
                    gleam@dynamic@decode:success(size1024x1792);

                <<"1536x1024"/utf8>> ->
                    gleam@dynamic@decode:success(size1536x1024);

                <<"1024x1536"/utf8>> ->
                    gleam@dynamic@decode:success(size1024x1536);

                _ ->
                    gleam@dynamic@decode:failure(
                        size_auto,
                        <<"ImageSize"/utf8>>
                    )
            end end
    ).

-file("src/glopenai/image.gleam", 356).
-spec image_model_decoder() -> gleam@dynamic@decode:decoder(image_model()).
image_model_decoder() ->
    gleam@dynamic@decode:then(
        {decoder, fun gleam@dynamic@decode:decode_string/1},
        fun(Value) -> case Value of
                <<"gpt-image-1"/utf8>> ->
                    gleam@dynamic@decode:success(gpt_image1);

                <<"gpt-image-1.5"/utf8>> ->
                    gleam@dynamic@decode:success(gpt_image1dot5);

                <<"gpt-image-1-mini"/utf8>> ->
                    gleam@dynamic@decode:success(gpt_image1_mini);

                <<"dall-e-2"/utf8>> ->
                    gleam@dynamic@decode:success(dall_e2);

                <<"dall-e-3"/utf8>> ->
                    gleam@dynamic@decode:success(dall_e3);

                Other ->
                    gleam@dynamic@decode:success({other_image_model, Other})
            end end
    ).

-file("src/glopenai/image.gleam", 368).
-spec image_quality_decoder() -> gleam@dynamic@decode:decoder(image_quality()).
image_quality_decoder() ->
    gleam@dynamic@decode:then(
        {decoder, fun gleam@dynamic@decode:decode_string/1},
        fun(Value) -> case Value of
                <<"standard"/utf8>> ->
                    gleam@dynamic@decode:success(quality_standard);

                <<"hd"/utf8>> ->
                    gleam@dynamic@decode:success(quality_hd);

                <<"high"/utf8>> ->
                    gleam@dynamic@decode:success(quality_high);

                <<"medium"/utf8>> ->
                    gleam@dynamic@decode:success(quality_medium);

                <<"low"/utf8>> ->
                    gleam@dynamic@decode:success(quality_low);

                <<"auto"/utf8>> ->
                    gleam@dynamic@decode:success(quality_auto);

                _ ->
                    gleam@dynamic@decode:failure(
                        quality_auto,
                        <<"ImageQuality"/utf8>>
                    )
            end end
    ).

-file("src/glopenai/image.gleam", 381).
-spec image_style_decoder() -> gleam@dynamic@decode:decoder(image_style()).
image_style_decoder() ->
    gleam@dynamic@decode:then(
        {decoder, fun gleam@dynamic@decode:decode_string/1},
        fun(Value) -> case Value of
                <<"vivid"/utf8>> ->
                    gleam@dynamic@decode:success(vivid);

                <<"natural"/utf8>> ->
                    gleam@dynamic@decode:success(natural);

                _ ->
                    gleam@dynamic@decode:failure(vivid, <<"ImageStyle"/utf8>>)
            end end
    ).

-file("src/glopenai/image.gleam", 390).
-spec image_output_format_decoder() -> gleam@dynamic@decode:decoder(image_output_format()).
image_output_format_decoder() ->
    gleam@dynamic@decode:then(
        {decoder, fun gleam@dynamic@decode:decode_string/1},
        fun(Value) -> case Value of
                <<"png"/utf8>> ->
                    gleam@dynamic@decode:success(png);

                <<"jpeg"/utf8>> ->
                    gleam@dynamic@decode:success(jpeg);

                <<"webp"/utf8>> ->
                    gleam@dynamic@decode:success(webp);

                _ ->
                    gleam@dynamic@decode:failure(
                        png,
                        <<"ImageOutputFormat"/utf8>>
                    )
            end end
    ).

-file("src/glopenai/image.gleam", 400).
-spec image_response_format_decoder() -> gleam@dynamic@decode:decoder(image_response_format()).
image_response_format_decoder() ->
    gleam@dynamic@decode:then(
        {decoder, fun gleam@dynamic@decode:decode_string/1},
        fun(Value) -> case Value of
                <<"url"/utf8>> ->
                    gleam@dynamic@decode:success(url);

                <<"b64_json"/utf8>> ->
                    gleam@dynamic@decode:success(b64_json);

                _ ->
                    gleam@dynamic@decode:failure(
                        url,
                        <<"ImageResponseFormat"/utf8>>
                    )
            end end
    ).

-file("src/glopenai/image.gleam", 409).
-spec image_response_background_decoder() -> gleam@dynamic@decode:decoder(image_response_background()).
image_response_background_decoder() ->
    gleam@dynamic@decode:then(
        {decoder, fun gleam@dynamic@decode:decode_string/1},
        fun(Value) -> case Value of
                <<"transparent"/utf8>> ->
                    gleam@dynamic@decode:success(response_transparent);

                <<"opaque"/utf8>> ->
                    gleam@dynamic@decode:success(response_opaque);

                _ ->
                    gleam@dynamic@decode:failure(
                        response_opaque,
                        <<"ImageResponseBackground"/utf8>>
                    )
            end end
    ).

-file("src/glopenai/image.gleam", 422).
?DOC(
    " Decode a generated image. The API returns either a \"url\" or \"b64_json\" field\n"
    " depending on the response_format requested. We try URL first, then b64.\n"
).
-spec image_decoder() -> gleam@dynamic@decode:decoder(image()).
image_decoder() ->
    gleam@dynamic@decode:one_of(
        begin
            gleam@dynamic@decode:field(
                <<"url"/utf8>>,
                {decoder, fun gleam@dynamic@decode:decode_string/1},
                fun(Url) ->
                    gleam@dynamic@decode:optional_field(
                        <<"revised_prompt"/utf8>>,
                        none,
                        gleam@dynamic@decode:optional(
                            {decoder, fun gleam@dynamic@decode:decode_string/1}
                        ),
                        fun(Revised_prompt) ->
                            gleam@dynamic@decode:success(
                                {image_url, Url, Revised_prompt}
                            )
                        end
                    )
                end
            )
        end,
        [begin
                gleam@dynamic@decode:field(
                    <<"b64_json"/utf8>>,
                    {decoder, fun gleam@dynamic@decode:decode_string/1},
                    fun(B64) ->
                        gleam@dynamic@decode:optional_field(
                            <<"revised_prompt"/utf8>>,
                            none,
                            gleam@dynamic@decode:optional(
                                {decoder,
                                    fun gleam@dynamic@decode:decode_string/1}
                            ),
                            fun(Revised_prompt@1) ->
                                gleam@dynamic@decode:success(
                                    {image_b64_json, B64, Revised_prompt@1}
                                )
                            end
                        )
                    end
                )
            end]
    ).

-file("src/glopenai/image.gleam", 450).
-spec image_gen_input_usage_details_decoder() -> gleam@dynamic@decode:decoder(image_gen_input_usage_details()).
image_gen_input_usage_details_decoder() ->
    gleam@dynamic@decode:field(
        <<"text_tokens"/utf8>>,
        {decoder, fun gleam@dynamic@decode:decode_int/1},
        fun(Text_tokens) ->
            gleam@dynamic@decode:field(
                <<"image_tokens"/utf8>>,
                {decoder, fun gleam@dynamic@decode:decode_int/1},
                fun(Image_tokens) ->
                    gleam@dynamic@decode:success(
                        {image_gen_input_usage_details,
                            Text_tokens,
                            Image_tokens}
                    )
                end
            )
        end
    ).

-file("src/glopenai/image.gleam", 461).
-spec image_gen_output_tokens_details_decoder() -> gleam@dynamic@decode:decoder(image_gen_output_tokens_details()).
image_gen_output_tokens_details_decoder() ->
    gleam@dynamic@decode:field(
        <<"text_tokens"/utf8>>,
        {decoder, fun gleam@dynamic@decode:decode_int/1},
        fun(Text_tokens) ->
            gleam@dynamic@decode:field(
                <<"image_tokens"/utf8>>,
                {decoder, fun gleam@dynamic@decode:decode_int/1},
                fun(Image_tokens) ->
                    gleam@dynamic@decode:success(
                        {image_gen_output_tokens_details,
                            Text_tokens,
                            Image_tokens}
                    )
                end
            )
        end
    ).

-file("src/glopenai/image.gleam", 472).
-spec image_gen_usage_decoder() -> gleam@dynamic@decode:decoder(image_gen_usage()).
image_gen_usage_decoder() ->
    gleam@dynamic@decode:field(
        <<"input_tokens"/utf8>>,
        {decoder, fun gleam@dynamic@decode:decode_int/1},
        fun(Input_tokens) ->
            gleam@dynamic@decode:field(
                <<"output_tokens"/utf8>>,
                {decoder, fun gleam@dynamic@decode:decode_int/1},
                fun(Output_tokens) ->
                    gleam@dynamic@decode:field(
                        <<"total_tokens"/utf8>>,
                        {decoder, fun gleam@dynamic@decode:decode_int/1},
                        fun(Total_tokens) ->
                            gleam@dynamic@decode:field(
                                <<"input_tokens_details"/utf8>>,
                                image_gen_input_usage_details_decoder(),
                                fun(Input_tokens_details) ->
                                    gleam@dynamic@decode:optional_field(
                                        <<"output_token_details"/utf8>>,
                                        none,
                                        gleam@dynamic@decode:optional(
                                            image_gen_output_tokens_details_decoder(
                                                
                                            )
                                        ),
                                        fun(Output_token_details) ->
                                            gleam@dynamic@decode:success(
                                                {image_gen_usage,
                                                    Input_tokens,
                                                    Output_tokens,
                                                    Total_tokens,
                                                    Input_tokens_details,
                                                    Output_token_details}
                                            )
                                        end
                                    )
                                end
                            )
                        end
                    )
                end
            )
        end
    ).

-file("src/glopenai/image.gleam", 494).
-spec images_response_decoder() -> gleam@dynamic@decode:decoder(images_response()).
images_response_decoder() ->
    gleam@dynamic@decode:field(
        <<"created"/utf8>>,
        {decoder, fun gleam@dynamic@decode:decode_int/1},
        fun(Created) ->
            gleam@dynamic@decode:field(
                <<"data"/utf8>>,
                gleam@dynamic@decode:list(image_decoder()),
                fun(Data) ->
                    gleam@dynamic@decode:optional_field(
                        <<"background"/utf8>>,
                        none,
                        gleam@dynamic@decode:optional(
                            image_response_background_decoder()
                        ),
                        fun(Background) ->
                            gleam@dynamic@decode:optional_field(
                                <<"output_format"/utf8>>,
                                none,
                                gleam@dynamic@decode:optional(
                                    image_output_format_decoder()
                                ),
                                fun(Output_format) ->
                                    gleam@dynamic@decode:optional_field(
                                        <<"size"/utf8>>,
                                        none,
                                        gleam@dynamic@decode:optional(
                                            image_size_decoder()
                                        ),
                                        fun(Size) ->
                                            gleam@dynamic@decode:optional_field(
                                                <<"quality"/utf8>>,
                                                none,
                                                gleam@dynamic@decode:optional(
                                                    image_quality_decoder()
                                                ),
                                                fun(Quality) ->
                                                    gleam@dynamic@decode:optional_field(
                                                        <<"usage"/utf8>>,
                                                        none,
                                                        gleam@dynamic@decode:optional(
                                                            image_gen_usage_decoder(
                                                                
                                                            )
                                                        ),
                                                        fun(Usage) ->
                                                            gleam@dynamic@decode:success(
                                                                {images_response,
                                                                    Created,
                                                                    Data,
                                                                    Background,
                                                                    Output_format,
                                                                    Size,
                                                                    Quality,
                                                                    Usage}
                                                            )
                                                        end
                                                    )
                                                end
                                            )
                                        end
                                    )
                                end
                            )
                        end
                    )
                end
            )
        end
    ).

-file("src/glopenai/image.gleam", 536).
?DOC(" Build a request to generate images.\n").
-spec create_request(glopenai@config:config(), create_image_request()) -> gleam@http@request:request(binary()).
create_request(Config, Params) ->
    glopenai@internal:post_request(
        Config,
        <<"/images/generations"/utf8>>,
        create_image_request_to_json(Params)
    ).

-file("src/glopenai/image.gleam", 548).
?DOC(" Parse the response from generating images.\n").
-spec create_response(gleam@http@response:response(binary())) -> {ok,
        images_response()} |
    {error, glopenai@error:glopenai_error()}.
create_response(Response) ->
    glopenai@internal:parse_response(Response, images_response_decoder()).