generate initial commit

Generate haskell-http-client from running g4f v-7.1.4.

Server started like this:

    python -m g4f --port 8080 --debug

Code generated like this:

    openapi-generator-cli generate \
        -i http://localhost:8080/openapi.json \
        -g haskell-http-client \
        --skip-validate-spec \
        -o g4f-client \
        --additional-properties=cabalPackage=g4f-client,cabalVersion=7.1.4,baseModule=G4fApi

10 files changed, 4383 insertions, 0 deletions

diff --git a/lib/G4fClient/API.hs b/lib/G4fClient/API.hs
new file mode 100644
index 0000000..0ec10da
--- /dev/null
+++ b/lib/G4fClient/API.hs
@@ -0,0 +1,19 @@
+{-
+   FastAPI
+
+   No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+   OpenAPI Version: 3.1.0
+   FastAPI API version: 0.1.0
+   Generated by OpenAPI Generator (https://openapi-generator.tech)
+-}
+
+{-|
+Module : G4fClient.API
+-}
+
+module G4fClient.API
+  ( module G4fClient.API.ApiDefault
+  ) where
+
+import G4fClient.API.ApiDefault
\ No newline at end of file
diff --git a/lib/G4fClient/API/ApiDefault.hs b/lib/G4fClient/API/ApiDefault.hs
new file mode 100644
index 0000000..3991f71
--- /dev/null
+++ b/lib/G4fClient/API/ApiDefault.hs
@@ -0,0 +1,680 @@
+{-
+   FastAPI
+
+   No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+   OpenAPI Version: 3.1.0
+   FastAPI API version: 0.1.0
+   Generated by OpenAPI Generator (https://openapi-generator.tech)
+-}
+
+{-|
+Module : G4fClient.API.ApiDefault
+-}
+
+{-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE MonoLocalBinds #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# OPTIONS_GHC -fno-warn-name-shadowing -fno-warn-unused-binds -fno-warn-unused-imports #-}
+
+module G4fClient.API.ApiDefault where
+
+import G4fClient.Core
+import G4fClient.MimeTypes
+import G4fClient.Model as M
+
+import qualified Data.Aeson as A
+import qualified Data.ByteString as B
+import qualified Data.ByteString.Lazy as BL
+import qualified Data.Data as P (Typeable, TypeRep, typeOf, typeRep)
+import qualified Data.Foldable as P
+import qualified Data.Map as Map
+import qualified Data.Maybe as P
+import qualified Data.Proxy as P (Proxy(..))
+import qualified Data.Set as Set
+import qualified Data.String as P
+import qualified Data.Text as T
+import qualified Data.Text.Encoding as T
+import qualified Data.Text.Lazy as TL
+import qualified Data.Text.Lazy.Encoding as TL
+import qualified Data.Time as TI
+import qualified Network.HTTP.Client.MultipartFormData as NH
+import qualified Network.HTTP.Media as ME
+import qualified Network.HTTP.Types as NH
+import qualified Web.FormUrlEncoded as WH
+import qualified Web.HttpApiData as WH
+
+import Data.Text (Text)
+import GHC.Base ((<|>))
+
+import Prelude ((==),(/=),($), (.),(<$>),(<*>),(>>=),Maybe(..),Bool(..),Char,Double,FilePath,Float,Int,Integer,String,fmap,undefined,mempty,maybe,pure,Monad,Applicative,Functor)
+import qualified Prelude as P
+
+-- * Operations
+
+
+-- ** Default
+
+-- *** chatCompletionsApiProviderChatCompletionsPost
+
+-- | @POST \/api\/{provider}\/chat\/completions@
+-- 
+-- Chat Completions
+-- 
+-- AuthMethod: 'AuthBasicHTTPBearer'
+-- 
+chatCompletionsApiProviderChatCompletionsPost
+  :: (Consumes ChatCompletionsApiProviderChatCompletionsPost MimeJSON, MimeRender MimeJSON ChatCompletionsConfig)
+  => ChatCompletionsConfig -- ^ "chatCompletionsConfig"
+  -> Provider -- ^ "provider"
+  -> G4fClientRequest ChatCompletionsApiProviderChatCompletionsPost MimeJSON ChatCompletion MimeJSON
+chatCompletionsApiProviderChatCompletionsPost chatCompletionsConfig (Provider provider) =
+  _mkRequest "POST" ["/api/",toPath provider,"/chat/completions"]
+    `_hasAuthType` (P.Proxy :: P.Proxy AuthBasicHTTPBearer)
+    `setBodyParam` chatCompletionsConfig
+
+data ChatCompletionsApiProviderChatCompletionsPost 
+instance HasBodyParam ChatCompletionsApiProviderChatCompletionsPost ChatCompletionsConfig 
+instance HasOptionalParam ChatCompletionsApiProviderChatCompletionsPost ConversationId where
+  applyOptionalParam req (ConversationId xs) =
+    req `addQuery` toQuery ("conversation_id", Just xs)
+instance HasOptionalParam ChatCompletionsApiProviderChatCompletionsPost XUser where
+  applyOptionalParam req (XUser xs) =
+    req `addHeader` toHeader ("x-user", xs)
+
+-- | @application/json@
+instance Consumes ChatCompletionsApiProviderChatCompletionsPost MimeJSON
+
+-- | @application/json@
+instance Produces ChatCompletionsApiProviderChatCompletionsPost MimeJSON
+
+
+-- *** chatCompletionsApiProviderConversationIdChatCompletionsPost
+
+-- | @POST \/api\/{provider}\/{conversation_id}\/chat\/completions@
+-- 
+-- Chat Completions
+-- 
+-- AuthMethod: 'AuthBasicHTTPBearer'
+-- 
+chatCompletionsApiProviderConversationIdChatCompletionsPost
+  :: (Consumes ChatCompletionsApiProviderConversationIdChatCompletionsPost MimeJSON, MimeRender MimeJSON ChatCompletionsConfig)
+  => ChatCompletionsConfig -- ^ "chatCompletionsConfig"
+  -> Provider -- ^ "provider"
+  -> ConversationId -- ^ "conversationId"
+  -> G4fClientRequest ChatCompletionsApiProviderConversationIdChatCompletionsPost MimeJSON ChatCompletion MimeJSON
+chatCompletionsApiProviderConversationIdChatCompletionsPost chatCompletionsConfig (Provider provider) (ConversationId conversationId) =
+  _mkRequest "POST" ["/api/",toPath provider,"/",toPath conversationId,"/chat/completions"]
+    `_hasAuthType` (P.Proxy :: P.Proxy AuthBasicHTTPBearer)
+    `setBodyParam` chatCompletionsConfig
+
+data ChatCompletionsApiProviderConversationIdChatCompletionsPost 
+instance HasBodyParam ChatCompletionsApiProviderConversationIdChatCompletionsPost ChatCompletionsConfig 
+instance HasOptionalParam ChatCompletionsApiProviderConversationIdChatCompletionsPost XUser where
+  applyOptionalParam req (XUser xs) =
+    req `addHeader` toHeader ("x-user", xs)
+
+-- | @application/json@
+instance Consumes ChatCompletionsApiProviderConversationIdChatCompletionsPost MimeJSON
+
+-- | @application/json@
+instance Produces ChatCompletionsApiProviderConversationIdChatCompletionsPost MimeJSON
+
+
+-- *** chatCompletionsV1ChatCompletionsPost
+
+-- | @POST \/v1\/chat\/completions@
+-- 
+-- Chat Completions
+-- 
+-- AuthMethod: 'AuthBasicHTTPBearer'
+-- 
+chatCompletionsV1ChatCompletionsPost
+  :: (Consumes ChatCompletionsV1ChatCompletionsPost MimeJSON, MimeRender MimeJSON ChatCompletionsConfig)
+  => ChatCompletionsConfig -- ^ "chatCompletionsConfig"
+  -> G4fClientRequest ChatCompletionsV1ChatCompletionsPost MimeJSON ChatCompletion MimeJSON
+chatCompletionsV1ChatCompletionsPost chatCompletionsConfig =
+  _mkRequest "POST" ["/v1/chat/completions"]
+    `_hasAuthType` (P.Proxy :: P.Proxy AuthBasicHTTPBearer)
+    `setBodyParam` chatCompletionsConfig
+
+data ChatCompletionsV1ChatCompletionsPost 
+instance HasBodyParam ChatCompletionsV1ChatCompletionsPost ChatCompletionsConfig 
+instance HasOptionalParam ChatCompletionsV1ChatCompletionsPost Provider where
+  applyOptionalParam req (Provider xs) =
+    req `addQuery` toQuery ("provider", Just xs)
+instance HasOptionalParam ChatCompletionsV1ChatCompletionsPost ConversationId where
+  applyOptionalParam req (ConversationId xs) =
+    req `addQuery` toQuery ("conversation_id", Just xs)
+instance HasOptionalParam ChatCompletionsV1ChatCompletionsPost XUser where
+  applyOptionalParam req (XUser xs) =
+    req `addHeader` toHeader ("x-user", xs)
+
+-- | @application/json@
+instance Consumes ChatCompletionsV1ChatCompletionsPost MimeJSON
+
+-- | @application/json@
+instance Produces ChatCompletionsV1ChatCompletionsPost MimeJSON
+
+
+-- *** convertApiMarkitdownPost
+
+-- | @POST \/api\/markitdown@
+-- 
+-- Convert
+-- 
+convertApiMarkitdownPost
+  :: (Consumes ConvertApiMarkitdownPost MimeMultipartFormData)
+  => File -- ^ "file"
+  -> G4fClientRequest ConvertApiMarkitdownPost MimeMultipartFormData TranscriptionResponseModel MimeJSON
+convertApiMarkitdownPost (File file) =
+  _mkRequest "POST" ["/api/markitdown"]
+    `_addMultiFormPart` NH.partFileSource "file" file
+
+data ConvertApiMarkitdownPost  
+instance HasOptionalParam ConvertApiMarkitdownPost Model where
+  applyOptionalParam req (Model xs) =
+    req `_addMultiFormPart` NH.partLBS "model" (mimeRender' MimeMultipartFormData xs)
+instance HasOptionalParam ConvertApiMarkitdownPost Provider where
+  applyOptionalParam req (Provider xs) =
+    req `_addMultiFormPart` NH.partLBS "provider" (mimeRender' MimeMultipartFormData xs)
+instance HasOptionalParam ConvertApiMarkitdownPost Prompt where
+  applyOptionalParam req (Prompt xs) =
+    req `_addMultiFormPart` NH.partLBS "prompt" (mimeRender' MimeMultipartFormData xs)
+instance HasOptionalParam ConvertApiMarkitdownPost PathProvider where
+  applyOptionalParam req (PathProvider xs) =
+    req `addQuery` toQuery ("path_provider", Just xs)
+
+-- | @multipart/form-data@
+instance Consumes ConvertApiMarkitdownPost MimeMultipartFormData
+
+-- | @application/json@
+instance Produces ConvertApiMarkitdownPost MimeJSON
+
+
+-- *** convertApiPathProviderAudioTranscriptionsPost
+
+-- | @POST \/api\/{path_provider}\/audio\/transcriptions@
+-- 
+-- Convert
+-- 
+convertApiPathProviderAudioTranscriptionsPost
+  :: (Consumes ConvertApiPathProviderAudioTranscriptionsPost MimeMultipartFormData)
+  => File -- ^ "file"
+  -> PathProvider -- ^ "pathProvider"
+  -> G4fClientRequest ConvertApiPathProviderAudioTranscriptionsPost MimeMultipartFormData TranscriptionResponseModel MimeJSON
+convertApiPathProviderAudioTranscriptionsPost (File file) (PathProvider pathProvider) =
+  _mkRequest "POST" ["/api/",toPath pathProvider,"/audio/transcriptions"]
+    `_addMultiFormPart` NH.partFileSource "file" file
+
+data ConvertApiPathProviderAudioTranscriptionsPost  
+instance HasOptionalParam ConvertApiPathProviderAudioTranscriptionsPost Model where
+  applyOptionalParam req (Model xs) =
+    req `_addMultiFormPart` NH.partLBS "model" (mimeRender' MimeMultipartFormData xs)
+instance HasOptionalParam ConvertApiPathProviderAudioTranscriptionsPost Provider where
+  applyOptionalParam req (Provider xs) =
+    req `_addMultiFormPart` NH.partLBS "provider" (mimeRender' MimeMultipartFormData xs)
+instance HasOptionalParam ConvertApiPathProviderAudioTranscriptionsPost Prompt where
+  applyOptionalParam req (Prompt xs) =
+    req `_addMultiFormPart` NH.partLBS "prompt" (mimeRender' MimeMultipartFormData xs)
+
+-- | @multipart/form-data@
+instance Consumes ConvertApiPathProviderAudioTranscriptionsPost MimeMultipartFormData
+
+-- | @application/json@
+instance Produces ConvertApiPathProviderAudioTranscriptionsPost MimeJSON
+
+
+-- *** convertV1AudioTranscriptionsPost
+
+-- | @POST \/v1\/audio\/transcriptions@
+-- 
+-- Convert
+-- 
+convertV1AudioTranscriptionsPost
+  :: (Consumes ConvertV1AudioTranscriptionsPost MimeMultipartFormData)
+  => File -- ^ "file"
+  -> G4fClientRequest ConvertV1AudioTranscriptionsPost MimeMultipartFormData TranscriptionResponseModel MimeJSON
+convertV1AudioTranscriptionsPost (File file) =
+  _mkRequest "POST" ["/v1/audio/transcriptions"]
+    `_addMultiFormPart` NH.partFileSource "file" file
+
+data ConvertV1AudioTranscriptionsPost  
+instance HasOptionalParam ConvertV1AudioTranscriptionsPost Model where
+  applyOptionalParam req (Model xs) =
+    req `_addMultiFormPart` NH.partLBS "model" (mimeRender' MimeMultipartFormData xs)
+instance HasOptionalParam ConvertV1AudioTranscriptionsPost Provider where
+  applyOptionalParam req (Provider xs) =
+    req `_addMultiFormPart` NH.partLBS "provider" (mimeRender' MimeMultipartFormData xs)
+instance HasOptionalParam ConvertV1AudioTranscriptionsPost Prompt where
+  applyOptionalParam req (Prompt xs) =
+    req `_addMultiFormPart` NH.partLBS "prompt" (mimeRender' MimeMultipartFormData xs)
+instance HasOptionalParam ConvertV1AudioTranscriptionsPost PathProvider where
+  applyOptionalParam req (PathProvider xs) =
+    req `addQuery` toQuery ("path_provider", Just xs)
+
+-- | @multipart/form-data@
+instance Consumes ConvertV1AudioTranscriptionsPost MimeMultipartFormData
+
+-- | @application/json@
+instance Produces ConvertV1AudioTranscriptionsPost MimeJSON
+
+
+-- *** generateImageApiProviderImagesGenerationsPost
+
+-- | @POST \/api\/{provider}\/images\/generations@
+-- 
+-- Generate Image
+-- 
+-- AuthMethod: 'AuthBasicHTTPBearer'
+-- 
+generateImageApiProviderImagesGenerationsPost
+  :: (Consumes GenerateImageApiProviderImagesGenerationsPost MimeJSON, MimeRender MimeJSON ImageGenerationConfig)
+  => ImageGenerationConfig -- ^ "imageGenerationConfig"
+  -> Provider -- ^ "provider"
+  -> G4fClientRequest GenerateImageApiProviderImagesGenerationsPost MimeJSON ImagesResponse MimeJSON
+generateImageApiProviderImagesGenerationsPost imageGenerationConfig (Provider provider) =
+  _mkRequest "POST" ["/api/",toPath provider,"/images/generations"]
+    `_hasAuthType` (P.Proxy :: P.Proxy AuthBasicHTTPBearer)
+    `setBodyParam` imageGenerationConfig
+
+data GenerateImageApiProviderImagesGenerationsPost 
+instance HasBodyParam GenerateImageApiProviderImagesGenerationsPost ImageGenerationConfig 
+
+-- | @application/json@
+instance Consumes GenerateImageApiProviderImagesGenerationsPost MimeJSON
+
+-- | @application/json@
+instance Produces GenerateImageApiProviderImagesGenerationsPost MimeJSON
+
+
+-- *** generateImageV1ImagesGeneratePost
+
+-- | @POST \/v1\/images\/generate@
+-- 
+-- Generate Image
+-- 
+-- AuthMethod: 'AuthBasicHTTPBearer'
+-- 
+generateImageV1ImagesGeneratePost
+  :: (Consumes GenerateImageV1ImagesGeneratePost MimeJSON, MimeRender MimeJSON ImageGenerationConfig)
+  => ImageGenerationConfig -- ^ "imageGenerationConfig"
+  -> G4fClientRequest GenerateImageV1ImagesGeneratePost MimeJSON ImagesResponse MimeJSON
+generateImageV1ImagesGeneratePost imageGenerationConfig =
+  _mkRequest "POST" ["/v1/images/generate"]
+    `_hasAuthType` (P.Proxy :: P.Proxy AuthBasicHTTPBearer)
+    `setBodyParam` imageGenerationConfig
+
+data GenerateImageV1ImagesGeneratePost 
+instance HasBodyParam GenerateImageV1ImagesGeneratePost ImageGenerationConfig 
+instance HasOptionalParam GenerateImageV1ImagesGeneratePost Provider where
+  applyOptionalParam req (Provider xs) =
+    req `addQuery` toQuery ("provider", Just xs)
+
+-- | @application/json@
+instance Consumes GenerateImageV1ImagesGeneratePost MimeJSON
+
+-- | @application/json@
+instance Produces GenerateImageV1ImagesGeneratePost MimeJSON
+
+
+-- *** generateImageV1ImagesGenerationsPost
+
+-- | @POST \/v1\/images\/generations@
+-- 
+-- Generate Image
+-- 
+-- AuthMethod: 'AuthBasicHTTPBearer'
+-- 
+generateImageV1ImagesGenerationsPost
+  :: (Consumes GenerateImageV1ImagesGenerationsPost MimeJSON, MimeRender MimeJSON ImageGenerationConfig)
+  => ImageGenerationConfig -- ^ "imageGenerationConfig"
+  -> G4fClientRequest GenerateImageV1ImagesGenerationsPost MimeJSON ImagesResponse MimeJSON
+generateImageV1ImagesGenerationsPost imageGenerationConfig =
+  _mkRequest "POST" ["/v1/images/generations"]
+    `_hasAuthType` (P.Proxy :: P.Proxy AuthBasicHTTPBearer)
+    `setBodyParam` imageGenerationConfig
+
+data GenerateImageV1ImagesGenerationsPost 
+instance HasBodyParam GenerateImageV1ImagesGenerationsPost ImageGenerationConfig 
+instance HasOptionalParam GenerateImageV1ImagesGenerationsPost Provider where
+  applyOptionalParam req (Provider xs) =
+    req `addQuery` toQuery ("provider", Just xs)
+
+-- | @application/json@
+instance Consumes GenerateImageV1ImagesGenerationsPost MimeJSON
+
+-- | @application/json@
+instance Produces GenerateImageV1ImagesGenerationsPost MimeJSON
+
+
+-- *** generateImageV1MediaGeneratePost
+
+-- | @POST \/v1\/media\/generate@
+-- 
+-- Generate Image
+-- 
+-- AuthMethod: 'AuthBasicHTTPBearer'
+-- 
+generateImageV1MediaGeneratePost
+  :: (Consumes GenerateImageV1MediaGeneratePost MimeJSON, MimeRender MimeJSON ImageGenerationConfig)
+  => ImageGenerationConfig -- ^ "imageGenerationConfig"
+  -> G4fClientRequest GenerateImageV1MediaGeneratePost MimeJSON ImagesResponse MimeJSON
+generateImageV1MediaGeneratePost imageGenerationConfig =
+  _mkRequest "POST" ["/v1/media/generate"]
+    `_hasAuthType` (P.Proxy :: P.Proxy AuthBasicHTTPBearer)
+    `setBodyParam` imageGenerationConfig
+
+data GenerateImageV1MediaGeneratePost 
+instance HasBodyParam GenerateImageV1MediaGeneratePost ImageGenerationConfig 
+instance HasOptionalParam GenerateImageV1MediaGeneratePost Provider where
+  applyOptionalParam req (Provider xs) =
+    req `addQuery` toQuery ("provider", Just xs)
+
+-- | @application/json@
+instance Consumes GenerateImageV1MediaGeneratePost MimeJSON
+
+-- | @application/json@
+instance Produces GenerateImageV1MediaGeneratePost MimeJSON
+
+
+-- *** generateSpeechApiProviderAudioSpeechPost
+
+-- | @POST \/api\/{provider}\/audio\/speech@
+-- 
+-- Generate Speech
+-- 
+-- AuthMethod: 'AuthBasicHTTPBearer'
+-- 
+generateSpeechApiProviderAudioSpeechPost
+  :: (Consumes GenerateSpeechApiProviderAudioSpeechPost MimeJSON, MimeRender MimeJSON AudioSpeechConfig)
+  => Accept accept -- ^ request accept ('MimeType')
+  -> AudioSpeechConfig -- ^ "audioSpeechConfig"
+  -> Provider -- ^ "provider"
+  -> G4fClientRequest GenerateSpeechApiProviderAudioSpeechPost MimeJSON AnyType accept
+generateSpeechApiProviderAudioSpeechPost  _ audioSpeechConfig (Provider provider) =
+  _mkRequest "POST" ["/api/",toPath provider,"/audio/speech"]
+    `_hasAuthType` (P.Proxy :: P.Proxy AuthBasicHTTPBearer)
+    `setBodyParam` audioSpeechConfig
+
+data GenerateSpeechApiProviderAudioSpeechPost 
+instance HasBodyParam GenerateSpeechApiProviderAudioSpeechPost AudioSpeechConfig 
+
+-- | @application/json@
+instance Consumes GenerateSpeechApiProviderAudioSpeechPost MimeJSON
+
+-- | @application/json@
+instance Produces GenerateSpeechApiProviderAudioSpeechPost MimeJSON
+-- | @audio/*@
+instance Produces GenerateSpeechApiProviderAudioSpeechPost MimeAudio
+
+
+-- *** generateSpeechV1AudioSpeechPost
+
+-- | @POST \/v1\/audio\/speech@
+-- 
+-- Generate Speech
+-- 
+-- AuthMethod: 'AuthBasicHTTPBearer'
+-- 
+generateSpeechV1AudioSpeechPost
+  :: (Consumes GenerateSpeechV1AudioSpeechPost MimeJSON, MimeRender MimeJSON AudioSpeechConfig)
+  => Accept accept -- ^ request accept ('MimeType')
+  -> AudioSpeechConfig -- ^ "audioSpeechConfig"
+  -> G4fClientRequest GenerateSpeechV1AudioSpeechPost MimeJSON AnyType accept
+generateSpeechV1AudioSpeechPost  _ audioSpeechConfig =
+  _mkRequest "POST" ["/v1/audio/speech"]
+    `_hasAuthType` (P.Proxy :: P.Proxy AuthBasicHTTPBearer)
+    `setBodyParam` audioSpeechConfig
+
+data GenerateSpeechV1AudioSpeechPost 
+instance HasBodyParam GenerateSpeechV1AudioSpeechPost AudioSpeechConfig 
+instance HasOptionalParam GenerateSpeechV1AudioSpeechPost Provider where
+  applyOptionalParam req (Provider xs) =
+    req `addQuery` toQuery ("provider", Just xs)
+
+-- | @application/json@
+instance Consumes GenerateSpeechV1AudioSpeechPost MimeJSON
+
+-- | @application/json@
+instance Produces GenerateSpeechV1AudioSpeechPost MimeJSON
+-- | @audio/*@
+instance Produces GenerateSpeechV1AudioSpeechPost MimeAudio
+
+
+-- *** getMediaImagesFilenameGet
+
+-- | @GET \/images\/{filename}@
+-- 
+-- Get Media
+-- 
+getMediaImagesFilenameGet
+  :: Accept accept -- ^ request accept ('MimeType')
+  -> Filename -- ^ "filename"
+  -> G4fClientRequest GetMediaImagesFilenameGet MimeNoContent AnyType accept
+getMediaImagesFilenameGet  _ (Filename filename) =
+  _mkRequest "GET" ["/images/",toPath filename]
+
+data GetMediaImagesFilenameGet  
+instance HasOptionalParam GetMediaImagesFilenameGet Thumbnail where
+  applyOptionalParam req (Thumbnail xs) =
+    req `addQuery` toQuery ("thumbnail", Just xs)
+-- | @image/*@
+instance Produces GetMediaImagesFilenameGet MimeImage
+-- | @application/json@
+instance Produces GetMediaImagesFilenameGet MimeJSON
+
+
+-- *** getMediaMediaFilenameGet
+
+-- | @GET \/media\/{filename}@
+-- 
+-- Get Media
+-- 
+getMediaMediaFilenameGet
+  :: Accept accept -- ^ request accept ('MimeType')
+  -> Filename -- ^ "filename"
+  -> G4fClientRequest GetMediaMediaFilenameGet MimeNoContent AnyType accept
+getMediaMediaFilenameGet  _ (Filename filename) =
+  _mkRequest "GET" ["/media/",toPath filename]
+
+data GetMediaMediaFilenameGet  
+instance HasOptionalParam GetMediaMediaFilenameGet Thumbnail where
+  applyOptionalParam req (Thumbnail xs) =
+    req `addQuery` toQuery ("thumbnail", Just xs)
+-- | @image/*@
+instance Produces GetMediaMediaFilenameGet MimeImage
+-- | @application/json@
+instance Produces GetMediaMediaFilenameGet MimeJSON
+-- | @audio/*@
+instance Produces GetMediaMediaFilenameGet MimeAudio
+
+
+-- *** getMediaThumbnailThumbnailFilenameGet
+
+-- | @GET \/thumbnail\/{filename}@
+-- 
+-- Get Media Thumbnail
+-- 
+getMediaThumbnailThumbnailFilenameGet
+  :: Accept accept -- ^ request accept ('MimeType')
+  -> FilenameText -- ^ "filename"
+  -> G4fClientRequest GetMediaThumbnailThumbnailFilenameGet MimeNoContent AnyType accept
+getMediaThumbnailThumbnailFilenameGet  _ (FilenameText filename) =
+  _mkRequest "GET" ["/thumbnail/",toPath filename]
+
+data GetMediaThumbnailThumbnailFilenameGet  
+-- | @image/*@
+instance Produces GetMediaThumbnailThumbnailFilenameGet MimeImage
+-- | @application/json@
+instance Produces GetMediaThumbnailThumbnailFilenameGet MimeJSON
+-- | @audio/*@
+instance Produces GetMediaThumbnailThumbnailFilenameGet MimeAudio
+
+
+-- *** modelInfoV1ModelsModelNameGet
+
+-- | @GET \/v1\/models\/{model_name}@
+-- 
+-- Model Info
+-- 
+modelInfoV1ModelsModelNameGet
+  :: ModelName -- ^ "modelName"
+  -> G4fClientRequest ModelInfoV1ModelsModelNameGet MimeNoContent ModelResponseModel MimeJSON
+modelInfoV1ModelsModelNameGet (ModelName modelName) =
+  _mkRequest "GET" ["/v1/models/",toPath modelName]
+
+data ModelInfoV1ModelsModelNameGet  
+-- | @application/json@
+instance Produces ModelInfoV1ModelsModelNameGet MimeJSON
+
+
+-- *** modelInfoV1ModelsModelNamePost
+
+-- | @POST \/v1\/models\/{model_name}@
+-- 
+-- Model Info
+-- 
+modelInfoV1ModelsModelNamePost
+  :: ModelName -- ^ "modelName"
+  -> G4fClientRequest ModelInfoV1ModelsModelNamePost MimeNoContent ModelResponseModel MimeJSON
+modelInfoV1ModelsModelNamePost (ModelName modelName) =
+  _mkRequest "POST" ["/v1/models/",toPath modelName]
+
+data ModelInfoV1ModelsModelNamePost  
+-- | @application/json@
+instance Produces ModelInfoV1ModelsModelNamePost MimeJSON
+
+
+-- *** modelsApiProviderModelsGet
+
+-- | @GET \/api\/{provider}\/models@
+-- 
+-- Models
+-- 
+-- AuthMethod: 'AuthBasicHTTPBearer'
+-- 
+modelsApiProviderModelsGet
+  :: Provider -- ^ "provider"
+  -> G4fClientRequest ModelsApiProviderModelsGet MimeNoContent [ModelResponseModel] MimeJSON
+modelsApiProviderModelsGet (Provider provider) =
+  _mkRequest "GET" ["/api/",toPath provider,"/models"]
+    `_hasAuthType` (P.Proxy :: P.Proxy AuthBasicHTTPBearer)
+
+data ModelsApiProviderModelsGet  
+-- | @application/json@
+instance Produces ModelsApiProviderModelsGet MimeJSON
+
+
+-- *** modelsV1ModelsGet
+
+-- | @GET \/v1\/models@
+-- 
+-- Models
+-- 
+modelsV1ModelsGet
+  :: G4fClientRequest ModelsV1ModelsGet MimeNoContent [ModelResponseModel] MimeJSON
+modelsV1ModelsGet =
+  _mkRequest "GET" ["/v1/models"]
+
+data ModelsV1ModelsGet  
+-- | @application/json@
+instance Produces ModelsV1ModelsGet MimeJSON
+
+
+-- *** providerQuotaApiProviderQuotaGet
+
+-- | @GET \/api\/{provider}\/quota@
+-- 
+-- Provider Quota
+-- 
+-- AuthMethod: 'AuthBasicHTTPBearer'
+-- 
+providerQuotaApiProviderQuotaGet
+  :: Provider -- ^ "provider"
+  -> G4fClientRequest ProviderQuotaApiProviderQuotaGet MimeNoContent AnyType MimeJSON
+providerQuotaApiProviderQuotaGet (Provider provider) =
+  _mkRequest "GET" ["/api/",toPath provider,"/quota"]
+    `_hasAuthType` (P.Proxy :: P.Proxy AuthBasicHTTPBearer)
+
+data ProviderQuotaApiProviderQuotaGet  
+-- | @application/json@
+instance Produces ProviderQuotaApiProviderQuotaGet MimeJSON
+
+
+-- *** providersInfoV1ProvidersProviderGet
+
+-- | @GET \/v1\/providers\/{provider}@
+-- 
+-- Providers Info
+-- 
+providersInfoV1ProvidersProviderGet
+  :: Provider -- ^ "provider"
+  -> G4fClientRequest ProvidersInfoV1ProvidersProviderGet MimeNoContent ProviderResponseDetailModel MimeJSON
+providersInfoV1ProvidersProviderGet (Provider provider) =
+  _mkRequest "GET" ["/v1/providers/",toPath provider]
+
+data ProvidersInfoV1ProvidersProviderGet  
+-- | @application/json@
+instance Produces ProvidersInfoV1ProvidersProviderGet MimeJSON
+
+
+-- *** providersV1ProvidersGet
+
+-- | @GET \/v1\/providers@
+-- 
+-- Providers
+-- 
+providersV1ProvidersGet
+  :: G4fClientRequest ProvidersV1ProvidersGet MimeNoContent [ProviderResponseModel] MimeJSON
+providersV1ProvidersGet =
+  _mkRequest "GET" ["/v1/providers"]
+
+data ProvidersV1ProvidersGet  
+-- | @application/json@
+instance Produces ProvidersV1ProvidersGet MimeJSON
+
+
+-- *** readRootV1V1Get
+
+-- | @GET \/v1@
+-- 
+-- Read Root V1
+-- 
+readRootV1V1Get
+  :: G4fClientRequest ReadRootV1V1Get MimeNoContent AnyType MimeJSON
+readRootV1V1Get =
+  _mkRequest "GET" ["/v1"]
+
+data ReadRootV1V1Get  
+-- | @application/json@
+instance Produces ReadRootV1V1Get MimeJSON
+
+
+-- *** uploadCookiesV1UploadCookiesPost
+
+-- | @POST \/v1\/upload_cookies@
+-- 
+-- Upload Cookies
+-- 
+-- AuthMethod: 'AuthBasicHTTPBearer'
+-- 
+uploadCookiesV1UploadCookiesPost
+  :: (Consumes UploadCookiesV1UploadCookiesPost MimeMultipartFormData)
+  => Files -- ^ "files"
+  -> G4fClientRequest UploadCookiesV1UploadCookiesPost MimeMultipartFormData [FileResponseModel] MimeJSON
+uploadCookiesV1UploadCookiesPost (Files files) =
+  _mkRequest "POST" ["/v1/upload_cookies"]
+    `_hasAuthType` (P.Proxy :: P.Proxy AuthBasicHTTPBearer)
+    `_addMultiFormPart` NH.partFileSource "files" files
+
+data UploadCookiesV1UploadCookiesPost  
+
+-- | @multipart/form-data@
+instance Consumes UploadCookiesV1UploadCookiesPost MimeMultipartFormData
+
+-- | @application/json@
+instance Produces UploadCookiesV1UploadCookiesPost MimeJSON
+
diff --git a/lib/G4fClient/Client.hs b/lib/G4fClient/Client.hs
new file mode 100644
index 0000000..0fed516
--- /dev/null
+++ b/lib/G4fClient/Client.hs
@@ -0,0 +1,223 @@
+{-
+   FastAPI
+
+   No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+   OpenAPI Version: 3.1.0
+   FastAPI API version: 0.1.0
+   Generated by OpenAPI Generator (https://openapi-generator.tech)
+-}
+
+{-|
+Module : G4fClient.Client
+-}
+
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE RankNTypes #-}
+{-# LANGUAGE RecordWildCards #-}
+{-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE DeriveFunctor #-}
+{-# LANGUAGE DeriveFoldable #-}
+{-# LANGUAGE DeriveTraversable #-}
+{-# OPTIONS_GHC -fno-warn-unused-binds -fno-warn-unused-imports #-}
+
+module G4fClient.Client where
+
+import G4fClient.Core
+import G4fClient.Logging
+import G4fClient.MimeTypes
+
+import qualified Control.Exception.Safe as E
+import qualified Control.Monad.IO.Class as P
+import qualified Control.Monad as P
+import qualified Data.Aeson.Types as A
+import qualified Data.ByteString as B
+import qualified Data.ByteString.Char8 as BC
+import qualified Data.ByteString.Lazy as BL
+import qualified Data.ByteString.Lazy.Char8 as BCL
+import qualified Data.Proxy as P (Proxy(..))
+import qualified Data.Text as T
+import qualified Data.Text.Encoding as T
+import qualified Network.HTTP.Client as NH
+import qualified Network.HTTP.Client.MultipartFormData as NH
+import qualified Network.HTTP.Types as NH
+import qualified Web.FormUrlEncoded as WH
+import qualified Web.HttpApiData as WH
+
+import Data.Function ((&))
+import Data.Monoid ((<>))
+import Data.Text (Text)
+import GHC.Exts (IsString(..))
+
+-- * Dispatch
+
+-- ** Lbs
+
+-- | send a request returning the raw http response
+dispatchLbs
+  :: (Produces req accept, MimeType contentType)
+  => NH.Manager -- ^ http-client Connection manager
+  -> G4fClientConfig -- ^ config
+  -> G4fClientRequest req contentType res accept -- ^ request
+  -> IO (NH.Response BCL.ByteString) -- ^ response
+dispatchLbs manager config request  = do
+  initReq <- _toInitRequest config request
+  dispatchInitUnsafe manager config initReq
+
+-- ** Mime
+
+-- | pair of decoded http body and http response
+data MimeResult res =
+  MimeResult { mimeResult :: Either MimeError res -- ^ decoded http body
+             , mimeResultResponse :: NH.Response BCL.ByteString -- ^ http response
+             }
+  deriving (Show, Functor, Foldable, Traversable)
+
+-- | pair of unrender/parser error and http response
+data MimeError =
+  MimeError {
+    mimeError :: String -- ^ unrender/parser error
+  , mimeErrorResponse :: NH.Response BCL.ByteString -- ^ http response
+  } deriving (Show)
+
+-- | send a request returning the 'MimeResult'
+dispatchMime
+  :: forall req contentType res accept. (Produces req accept, MimeUnrender accept res, MimeType contentType)
+  => NH.Manager -- ^ http-client Connection manager
+  -> G4fClientConfig -- ^ config
+  -> G4fClientRequest req contentType res accept -- ^ request
+  -> IO (MimeResult res) -- ^ response
+dispatchMime manager config request = do
+  httpResponse <- dispatchLbs manager config request
+  let statusCode = NH.statusCode . NH.responseStatus $ httpResponse
+  parsedResult <-
+    runConfigLogWithExceptions "Client" config $
+    do if (statusCode >= 400 && statusCode < 600)
+         then do
+           let s = "error statusCode: " ++ show statusCode
+           _log "Client" levelError (T.pack s)
+           pure (Left (MimeError s httpResponse))
+         else case mimeUnrender (P.Proxy :: P.Proxy accept) (NH.responseBody httpResponse) of
+           Left s -> do
+             _log "Client" levelError (T.pack s)
+             pure (Left (MimeError s httpResponse))
+           Right r -> pure (Right r)
+  return (MimeResult parsedResult httpResponse)
+
+-- | like 'dispatchMime', but only returns the decoded http body
+dispatchMime'
+  :: (Produces req accept, MimeUnrender accept res, MimeType contentType)
+  => NH.Manager -- ^ http-client Connection manager
+  -> G4fClientConfig -- ^ config
+  -> G4fClientRequest req contentType res accept -- ^ request
+  -> IO (Either MimeError res) -- ^ response
+dispatchMime' manager config request  = do
+    MimeResult parsedResult _ <- dispatchMime manager config request
+    return parsedResult
+
+-- ** Unsafe
+
+-- | like 'dispatchReqLbs', but does not validate the operation is a 'Producer' of the "accept" 'MimeType'.  (Useful if the server's response is undocumented)
+dispatchLbsUnsafe
+  :: (MimeType accept, MimeType contentType)
+  => NH.Manager -- ^ http-client Connection manager
+  -> G4fClientConfig -- ^ config
+  -> G4fClientRequest req contentType res accept -- ^ request
+  -> IO (NH.Response BCL.ByteString) -- ^ response
+dispatchLbsUnsafe manager config request  = do
+  initReq <- _toInitRequest config request
+  dispatchInitUnsafe manager config initReq
+
+-- | dispatch an InitRequest
+dispatchInitUnsafe
+  :: NH.Manager -- ^ http-client Connection manager
+  -> G4fClientConfig -- ^ config
+  -> InitRequest req contentType res accept -- ^ init request
+  -> IO (NH.Response BCL.ByteString) -- ^ response
+dispatchInitUnsafe manager config (InitRequest req) = do
+  runConfigLogWithExceptions src config $
+    do _log src levelInfo requestLogMsg
+       _log src levelDebug requestDbgLogMsg
+       res <- P.liftIO $ NH.httpLbs req manager
+       _log src levelInfo (responseLogMsg res)
+       _log src levelDebug ((T.pack . show) res)
+       return res
+  where
+    src = "Client"
+    endpoint =
+      T.pack $
+      BC.unpack $
+      NH.method req <> " " <> NH.host req <> NH.path req <> NH.queryString req
+    requestLogMsg = "REQ:" <> endpoint
+    requestDbgLogMsg =
+      "Headers=" <> (T.pack . show) (NH.requestHeaders req) <> " Body=" <>
+      (case NH.requestBody req of
+         NH.RequestBodyLBS xs -> T.decodeUtf8 (BL.toStrict xs)
+         _ -> "<RequestBody>")
+    responseStatusCode = (T.pack . show) . NH.statusCode . NH.responseStatus
+    responseLogMsg res =
+      "RES:statusCode=" <> responseStatusCode res <> " (" <> endpoint <> ")"
+
+-- * InitRequest
+
+-- | wraps an http-client 'Request' with request/response type parameters
+newtype InitRequest req contentType res accept = InitRequest
+  { unInitRequest :: NH.Request
+  } deriving (Show)
+
+-- |  Build an http-client 'Request' record from the supplied config and request
+_toInitRequest
+  :: (MimeType accept, MimeType contentType)
+  => G4fClientConfig -- ^ config
+  -> G4fClientRequest req contentType res accept -- ^ request
+  -> IO (InitRequest req contentType res accept) -- ^ initialized request
+_toInitRequest config req0  =
+  runConfigLogWithExceptions "Client" config $ do
+    parsedReq <- P.liftIO $ NH.parseRequest $ BCL.unpack $ BCL.append (configHost config) (BCL.concat (rUrlPath req0))
+    req1 <- P.liftIO $ _applyAuthMethods req0 config
+    P.when
+        (configValidateAuthMethods config && (not . null . rAuthTypes) req1)
+        (E.throw $ AuthMethodException $ "AuthMethod not configured: " <> (show . head . rAuthTypes) req1)
+    let req2 = req1 & _setContentTypeHeader & _setAcceptHeader
+        params = rParams req2
+        reqHeaders = ("User-Agent", WH.toHeader (configUserAgent config)) : paramsHeaders params
+        reqQuery = let query = paramsQuery params
+                       queryExtraUnreserved = configQueryExtraUnreserved config
+                   in if B.null queryExtraUnreserved
+                        then NH.renderQuery True query
+                        else NH.renderQueryPartialEscape True (toPartialEscapeQuery queryExtraUnreserved query)
+        pReq = parsedReq { NH.method = rMethod req2
+                        , NH.requestHeaders = reqHeaders
+                        , NH.queryString = reqQuery
+                        }
+    outReq <- case paramsBody params of
+        ParamBodyNone -> pure (pReq { NH.requestBody = mempty })
+        ParamBodyB bs -> pure (pReq { NH.requestBody = NH.RequestBodyBS bs })
+        ParamBodyBL bl -> pure (pReq { NH.requestBody = NH.RequestBodyLBS bl })
+        ParamBodyFormUrlEncoded form -> pure (pReq { NH.requestBody = NH.RequestBodyLBS (WH.urlEncodeForm form) })
+        ParamBodyMultipartFormData parts -> NH.formDataBody parts pReq
+
+    pure (InitRequest outReq)
+
+-- | modify the underlying Request
+modifyInitRequest :: InitRequest req contentType res accept -> (NH.Request -> NH.Request) -> InitRequest req contentType res accept
+modifyInitRequest (InitRequest req) f = InitRequest (f req)
+
+-- | modify the underlying Request (monadic)
+modifyInitRequestM :: Monad m => InitRequest req contentType res accept -> (NH.Request -> m NH.Request) -> m (InitRequest req contentType res accept)
+modifyInitRequestM (InitRequest req) f = fmap InitRequest (f req)
+
+-- ** Logging
+
+-- | Run a block using the configured logger instance
+runConfigLog
+  :: P.MonadIO m
+  => G4fClientConfig -> LogExec m a
+runConfigLog config = configLogExecWithContext config (configLogContext config)
+
+-- | Run a block using the configured logger instance (logs exceptions)
+runConfigLogWithExceptions
+  :: (E.MonadCatch m, P.MonadIO m)
+  => T.Text -> G4fClientConfig -> LogExec m a
+runConfigLogWithExceptions src config = runConfigLog config . logExceptions src
diff --git a/lib/G4fClient/Core.hs b/lib/G4fClient/Core.hs
new file mode 100644
index 0000000..72756be
--- /dev/null
+++ b/lib/G4fClient/Core.hs
@@ -0,0 +1,589 @@
+{-
+   FastAPI
+
+   No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+   OpenAPI Version: 3.1.0
+   FastAPI API version: 0.1.0
+   Generated by OpenAPI Generator (https://openapi-generator.tech)
+-}
+
+{-|
+Module : G4fClient.Core
+-}
+
+{-# LANGUAGE DeriveDataTypeable #-}
+{-# LANGUAGE ExistentialQuantification #-}
+{-# LANGUAGE GeneralizedNewtypeDeriving #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE NamedFieldPuns #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE RankNTypes #-}
+{-# LANGUAGE RecordWildCards #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE TupleSections #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE TypeOperators #-}
+{-# LANGUAGE CPP #-}
+{-# OPTIONS_GHC -fno-warn-name-shadowing -fno-warn-unused-binds -fno-warn-unused-imports #-}
+
+module G4fClient.Core where
+
+import G4fClient.MimeTypes
+import G4fClient.Logging
+
+import qualified Control.Arrow as P (left)
+import qualified Control.DeepSeq as NF
+import qualified Control.Exception.Safe as E
+import qualified Data.Aeson as A
+import qualified Data.ByteString as B
+import qualified Data.ByteString.Base64.Lazy as BL64
+import qualified Data.ByteString.Builder as BB
+import qualified Data.ByteString.Char8 as BC
+import qualified Data.ByteString.Lazy as BL
+import qualified Data.ByteString.Lazy.Char8 as BCL
+import qualified Data.CaseInsensitive as CI
+import qualified Data.Data as P (Data, Typeable, TypeRep, typeRep)
+import qualified Data.Foldable as P
+import qualified Data.Ix as P
+import qualified Data.Kind as K (Type)
+import qualified Data.Maybe as P
+import qualified Data.Proxy as P (Proxy(..))
+import qualified Data.Text as T
+import qualified Data.Text.Encoding as T
+import qualified Data.Text.Lazy.Encoding as TL
+import qualified Data.Time as TI
+import qualified Data.Time.ISO8601 as TI
+import qualified GHC.Base as P (Alternative)
+import qualified Lens.Micro as L
+import qualified Network.HTTP.Client.MultipartFormData as NH
+import qualified Network.HTTP.Types as NH
+import qualified Prelude as P
+import qualified Text.Printf as T
+import qualified Web.FormUrlEncoded as WH
+import qualified Web.HttpApiData as WH
+
+import Control.Applicative ((<|>))
+import Control.Applicative (Alternative)
+import Control.Monad.Fail (MonadFail)
+import Data.Function ((&))
+import Data.Foldable(foldlM)
+import Data.Monoid ((<>))
+import Data.Text (Text)
+import Prelude (($), (.), (&&), (<$>), (<*>), Maybe(..), Bool(..), Char, String, fmap, mempty, pure, return, show, IO, Monad, Functor, maybe)
+
+-- * G4fClientConfig
+
+-- |
+data G4fClientConfig = G4fClientConfig
+  { configHost  :: BCL.ByteString -- ^ host supplied in the Request
+  , configUserAgent :: Text -- ^ user-agent supplied in the Request
+  , configLogExecWithContext :: LogExecWithContext -- ^ Run a block using a Logger instance
+  , configLogContext :: LogContext -- ^ Configures the logger
+  , configAuthMethods :: [AnyAuthMethod] -- ^ List of configured auth methods
+  , configValidateAuthMethods :: Bool -- ^ throw exceptions if auth methods are not configured
+  , configQueryExtraUnreserved :: B.ByteString -- ^ Configures additional querystring characters which must not be URI encoded, e.g. '+' or ':'
+  }
+
+-- | display the config
+instance P.Show G4fClientConfig where
+  show c =
+    T.printf
+      "{ configHost = %v, configUserAgent = %v, ..}"
+      (show (configHost c))
+      (show (configUserAgent c))
+
+-- | constructs a default G4fClientConfig
+--
+-- configHost:
+--
+-- @http://localhost@
+--
+-- configUserAgent:
+--
+-- @"g4f-client/7.1.4"@
+--
+newConfig :: IO G4fClientConfig
+newConfig = do
+    logCxt <- initLogContext
+    return $ G4fClientConfig
+        { configHost = "http://localhost"
+        , configUserAgent = "g4f-client/7.1.4"
+        , configLogExecWithContext = runDefaultLogExecWithContext
+        , configLogContext = logCxt
+        , configAuthMethods = []
+        , configValidateAuthMethods = True
+        , configQueryExtraUnreserved = ""
+        }
+
+-- | updates config use AuthMethod on matching requests
+addAuthMethod :: AuthMethod auth => G4fClientConfig -> auth -> G4fClientConfig
+addAuthMethod config@G4fClientConfig {configAuthMethods = as} a =
+  config { configAuthMethods = AnyAuthMethod a : as}
+
+-- | updates the config to use stdout logging
+withStdoutLogging :: G4fClientConfig -> IO G4fClientConfig
+withStdoutLogging p = do
+    logCxt <- stdoutLoggingContext (configLogContext p)
+    return $ p { configLogExecWithContext = stdoutLoggingExec, configLogContext = logCxt }
+
+-- | updates the config to use stderr logging
+withStderrLogging :: G4fClientConfig -> IO G4fClientConfig
+withStderrLogging p = do
+    logCxt <- stderrLoggingContext (configLogContext p)
+    return $ p { configLogExecWithContext = stderrLoggingExec, configLogContext = logCxt }
+
+-- | updates the config to disable logging
+withNoLogging :: G4fClientConfig -> G4fClientConfig
+withNoLogging p = p { configLogExecWithContext =  runNullLogExec}
+
+-- * G4fClientRequest
+
+-- | Represents a request.
+--
+--   Type Variables:
+--
+--   * req - request operation
+--   * contentType - 'MimeType' associated with request body
+--   * res - response model
+--   * accept - 'MimeType' associated with response body
+data G4fClientRequest req contentType res accept = G4fClientRequest
+  { rMethod  :: NH.Method   -- ^ Method of G4fClientRequest
+  , rUrlPath :: [BCL.ByteString] -- ^ Endpoint of G4fClientRequest
+  , rParams   :: Params -- ^ params of G4fClientRequest
+  , rAuthTypes :: [P.TypeRep] -- ^ types of auth methods
+  }
+  deriving (P.Show)
+
+-- | 'rMethod' Lens
+rMethodL :: Lens_' (G4fClientRequest req contentType res accept) NH.Method
+rMethodL f G4fClientRequest{..} = (\rMethod -> G4fClientRequest { rMethod, ..} ) <$> f rMethod
+{-# INLINE rMethodL #-}
+
+-- | 'rUrlPath' Lens
+rUrlPathL :: Lens_' (G4fClientRequest req contentType res accept) [BCL.ByteString]
+rUrlPathL f G4fClientRequest{..} = (\rUrlPath -> G4fClientRequest { rUrlPath, ..} ) <$> f rUrlPath
+{-# INLINE rUrlPathL #-}
+
+-- | 'rParams' Lens
+rParamsL :: Lens_' (G4fClientRequest req contentType res accept) Params
+rParamsL f G4fClientRequest{..} = (\rParams -> G4fClientRequest { rParams, ..} ) <$> f rParams
+{-# INLINE rParamsL #-}
+
+-- | 'rParams' Lens
+rAuthTypesL :: Lens_' (G4fClientRequest req contentType res accept) [P.TypeRep]
+rAuthTypesL f G4fClientRequest{..} = (\rAuthTypes -> G4fClientRequest { rAuthTypes, ..} ) <$> f rAuthTypes
+{-# INLINE rAuthTypesL #-}
+
+-- * HasBodyParam
+
+-- | Designates the body parameter of a request
+class HasBodyParam req param where
+  setBodyParam :: forall contentType res accept. (Consumes req contentType, MimeRender contentType param) => G4fClientRequest req contentType res accept -> param -> G4fClientRequest req contentType res accept
+  setBodyParam req xs =
+    req `_setBodyLBS` mimeRender (P.Proxy :: P.Proxy contentType) xs & _setContentTypeHeader
+
+-- * HasOptionalParam
+
+-- | Designates the optional parameters of a request
+class HasOptionalParam req param where
+  {-# MINIMAL applyOptionalParam | (-&-) #-}
+
+  -- | Apply an optional parameter to a request
+  applyOptionalParam :: G4fClientRequest req contentType res accept -> param -> G4fClientRequest req contentType res accept
+  applyOptionalParam = (-&-)
+  {-# INLINE applyOptionalParam #-}
+
+  -- | infix operator \/ alias for 'addOptionalParam'
+  (-&-) :: G4fClientRequest req contentType res accept -> param -> G4fClientRequest req contentType res accept
+  (-&-) = applyOptionalParam
+  {-# INLINE (-&-) #-}
+
+infixl 2 -&-
+
+-- | Request Params
+data Params = Params
+  { paramsQuery :: NH.Query
+  , paramsHeaders :: NH.RequestHeaders
+  , paramsBody :: ParamBody
+  }
+  deriving (P.Show)
+
+-- | 'paramsQuery' Lens
+paramsQueryL :: Lens_' Params NH.Query
+paramsQueryL f Params{..} = (\paramsQuery -> Params { paramsQuery, ..} ) <$> f paramsQuery
+{-# INLINE paramsQueryL #-}
+
+-- | 'paramsHeaders' Lens
+paramsHeadersL :: Lens_' Params NH.RequestHeaders
+paramsHeadersL f Params{..} = (\paramsHeaders -> Params { paramsHeaders, ..} ) <$> f paramsHeaders
+{-# INLINE paramsHeadersL #-}
+
+-- | 'paramsBody' Lens
+paramsBodyL :: Lens_' Params ParamBody
+paramsBodyL f Params{..} = (\paramsBody -> Params { paramsBody, ..} ) <$> f paramsBody
+{-# INLINE paramsBodyL #-}
+
+-- | Request Body
+data ParamBody
+  = ParamBodyNone
+  | ParamBodyB B.ByteString
+  | ParamBodyBL BL.ByteString
+  | ParamBodyFormUrlEncoded WH.Form
+  | ParamBodyMultipartFormData [NH.Part]
+  deriving (P.Show)
+
+-- ** G4fClientRequest Utils
+
+_mkRequest :: NH.Method -- ^ Method
+          -> [BCL.ByteString] -- ^ Endpoint
+          -> G4fClientRequest req contentType res accept -- ^ req: Request Type, res: Response Type
+_mkRequest m u = G4fClientRequest m u _mkParams []
+
+_mkParams :: Params
+_mkParams = Params [] [] ParamBodyNone
+
+setHeader ::
+     G4fClientRequest req contentType res accept
+  -> [NH.Header]
+  -> G4fClientRequest req contentType res accept
+setHeader req header =
+  req `removeHeader` P.fmap P.fst header
+  & (`addHeader` header)
+
+addHeader ::
+     G4fClientRequest req contentType res accept
+  -> [NH.Header]
+  -> G4fClientRequest req contentType res accept
+addHeader req header = L.over (rParamsL . paramsHeadersL) (header P.++) req
+
+removeHeader :: G4fClientRequest req contentType res accept -> [NH.HeaderName] -> G4fClientRequest req contentType res accept
+removeHeader req header =
+  req &
+  L.over
+    (rParamsL . paramsHeadersL)
+    (P.filter (\h -> cifst h `P.notElem` P.fmap CI.mk header))
+  where
+    cifst = CI.mk . P.fst
+
+
+_setContentTypeHeader :: forall req contentType res accept. MimeType contentType => G4fClientRequest req contentType res accept -> G4fClientRequest req contentType res accept
+_setContentTypeHeader req =
+    case mimeType (P.Proxy :: P.Proxy contentType) of
+        Just m -> req `setHeader` [("content-type", BC.pack $ P.show m)]
+        Nothing -> req `removeHeader` ["content-type"]
+
+_setAcceptHeader :: forall req contentType res accept. MimeType accept => G4fClientRequest req contentType res accept -> G4fClientRequest req contentType res accept
+_setAcceptHeader req =
+    case mimeType (P.Proxy :: P.Proxy accept) of
+        Just m -> req `setHeader` [("accept", BC.pack $ P.show m)]
+        Nothing -> req `removeHeader` ["accept"]
+
+setQuery ::
+     G4fClientRequest req contentType res accept
+  -> [NH.QueryItem]
+  -> G4fClientRequest req contentType res accept
+setQuery req query =
+  req &
+  L.over
+    (rParamsL . paramsQueryL)
+    (P.filter (\q -> cifst q `P.notElem` P.fmap cifst query)) &
+  (`addQuery` query)
+  where
+    cifst = CI.mk . P.fst
+
+addQuery ::
+     G4fClientRequest req contentType res accept
+  -> [NH.QueryItem]
+  -> G4fClientRequest req contentType res accept
+addQuery req query = req & L.over (rParamsL . paramsQueryL) (query P.++)
+
+addForm :: G4fClientRequest req contentType res accept -> WH.Form -> G4fClientRequest req contentType res accept
+addForm req newform =
+    let form = case paramsBody (rParams req) of
+            ParamBodyFormUrlEncoded _form -> _form
+            _ -> mempty
+    in req & L.set (rParamsL . paramsBodyL) (ParamBodyFormUrlEncoded (newform <> form))
+
+_addMultiFormPart :: G4fClientRequest req contentType res accept -> NH.Part -> G4fClientRequest req contentType res accept
+_addMultiFormPart req newpart =
+    let parts = case paramsBody (rParams req) of
+            ParamBodyMultipartFormData _parts -> _parts
+            _ -> []
+    in req & L.set (rParamsL . paramsBodyL) (ParamBodyMultipartFormData (newpart : parts))
+
+_setBodyBS :: G4fClientRequest req contentType res accept -> B.ByteString -> G4fClientRequest req contentType res accept
+_setBodyBS req body =
+    req & L.set (rParamsL . paramsBodyL) (ParamBodyB body)
+
+_setBodyLBS :: G4fClientRequest req contentType res accept -> BL.ByteString -> G4fClientRequest req contentType res accept
+_setBodyLBS req body =
+    req & L.set (rParamsL . paramsBodyL) (ParamBodyBL body)
+
+_hasAuthType :: AuthMethod authMethod => G4fClientRequest req contentType res accept -> P.Proxy authMethod -> G4fClientRequest req contentType res accept
+_hasAuthType req proxy =
+  req & L.over rAuthTypesL (P.typeRep proxy :)
+
+-- ** Params Utils
+
+toPath
+  :: WH.ToHttpApiData a
+  => a -> BCL.ByteString
+toPath = BB.toLazyByteString . WH.toEncodedUrlPiece
+
+toHeader :: WH.ToHttpApiData a => (NH.HeaderName, a) -> [NH.Header]
+toHeader x = [fmap WH.toHeader x]
+
+toForm :: WH.ToHttpApiData v => (BC.ByteString, v) -> WH.Form
+toForm (k,v) = WH.toForm [(BC.unpack k,v)]
+
+toQuery :: WH.ToHttpApiData a => (BC.ByteString, Maybe a) -> [NH.QueryItem]
+toQuery x = [(fmap . fmap) toQueryParam x]
+  where toQueryParam = T.encodeUtf8 . WH.toQueryParam
+
+toJsonQuery :: A.ToJSON a => (BC.ByteString, Maybe a) -> [NH.QueryItem]
+toJsonQuery = toQuery . (fmap . fmap) (TL.decodeUtf8 . A.encode)
+
+toPartialEscapeQuery :: B.ByteString -> NH.Query -> NH.PartialEscapeQuery
+toPartialEscapeQuery extraUnreserved query = fmap (\(k, v) -> (k, maybe [] go v)) query
+  where go :: B.ByteString -> [NH.EscapeItem]
+        go v = v & B.groupBy (\a b -> a `B.notElem` extraUnreserved && b `B.notElem` extraUnreserved)
+                 & fmap (\xs -> if B.null xs then NH.QN xs
+                                  else if B.head xs `B.elem` extraUnreserved
+                                          then NH.QN xs -- Not Encoded
+                                          else NH.QE xs -- Encoded
+                        )
+
+-- *** OpenAPI `CollectionFormat` Utils
+
+-- | Determines the format of the array if type array is used.
+data CollectionFormat
+  = CommaSeparated -- ^ CSV format for multiple parameters.
+  | SpaceSeparated -- ^ Also called "SSV"
+  | TabSeparated -- ^ Also called "TSV"
+  | PipeSeparated -- ^ `value1|value2|value2`
+  | MultiParamArray -- ^ Using multiple GET parameters, e.g. `foo=bar&foo=baz`. This is valid only for parameters in "query" ('NH.Query') or "formData" ('WH.Form')
+
+toHeaderColl :: WH.ToHttpApiData a => CollectionFormat -> (NH.HeaderName, [a]) -> [NH.Header]
+toHeaderColl c xs = _toColl c toHeader xs
+
+toFormColl :: WH.ToHttpApiData v => CollectionFormat -> (BC.ByteString, [v]) -> WH.Form
+toFormColl c xs = WH.toForm $ fmap unpack $ _toColl c toHeader $ pack xs
+  where
+    pack (k,v) = (CI.mk k, v)
+    unpack (k,v) = (BC.unpack (CI.original k), BC.unpack v)
+
+toQueryColl :: WH.ToHttpApiData a => CollectionFormat -> (BC.ByteString, Maybe [a]) -> NH.Query
+toQueryColl c xs = _toCollA c toQuery xs
+
+toJsonQueryColl :: A.ToJSON a => CollectionFormat -> (BC.ByteString, Maybe [a]) -> NH.Query
+toJsonQueryColl c xs = _toCollA c toJsonQuery xs
+
+_toColl :: P.Traversable f => CollectionFormat -> (f a -> [(b, BC.ByteString)]) -> f [a] -> [(b, BC.ByteString)]
+_toColl c encode xs = fmap (fmap P.fromJust) (_toCollA' c fencode BC.singleton (fmap Just xs))
+  where fencode = fmap (fmap Just) . encode . fmap P.fromJust
+        {-# INLINE fencode #-}
+
+_toCollA :: (P.Traversable f, P.Traversable t, P.Alternative t) => CollectionFormat -> (f (t a) -> [(b, t BC.ByteString)]) -> f (t [a]) -> [(b, t BC.ByteString)]
+_toCollA c encode xs = _toCollA' c encode BC.singleton xs
+
+_toCollA' :: (P.Monoid c, P.Traversable f, P.Traversable t, P.Alternative t) => CollectionFormat -> (f (t a) -> [(b, t c)]) -> (Char -> c) -> f (t [a]) -> [(b, t c)]
+_toCollA' c encode one xs = case c of
+  CommaSeparated -> go (one ',')
+  SpaceSeparated -> go (one ' ')
+  TabSeparated -> go (one '\t')
+  PipeSeparated -> go (one '|')
+  MultiParamArray -> expandList
+  where
+    go sep =
+      [P.foldl1 (\(sk, sv) (_, v) -> (sk, (combine sep <$> sv <*> v) <|> sv <|> v)) expandList]
+    combine sep x y = x <> sep <> y
+    expandList = (P.concatMap encode . (P.traverse . P.traverse) P.toList) xs
+    {-# INLINE go #-}
+    {-# INLINE expandList #-}
+    {-# INLINE combine #-}
+
+-- * AuthMethods
+
+-- | Provides a method to apply auth methods to requests
+class P.Typeable a =>
+      AuthMethod a  where
+  applyAuthMethod
+    :: G4fClientConfig
+    -> a
+    -> G4fClientRequest req contentType res accept
+    -> IO (G4fClientRequest req contentType res accept)
+
+-- | An existential wrapper for any AuthMethod
+data AnyAuthMethod = forall a. AuthMethod a => AnyAuthMethod a deriving (P.Typeable)
+
+instance AuthMethod AnyAuthMethod where applyAuthMethod config (AnyAuthMethod a) req = applyAuthMethod config a req
+
+-- | indicates exceptions related to AuthMethods
+data AuthMethodException = AuthMethodException String deriving (P.Show, P.Typeable)
+
+instance E.Exception AuthMethodException
+
+-- | apply all matching AuthMethods in config to request
+_applyAuthMethods
+  :: G4fClientRequest req contentType res accept
+  -> G4fClientConfig
+  -> IO (G4fClientRequest req contentType res accept)
+_applyAuthMethods req config@(G4fClientConfig {configAuthMethods = as}) =
+  foldlM go req as
+  where
+    go r (AnyAuthMethod a) = applyAuthMethod config a r
+
+-- * Utils
+
+-- | Removes Null fields.  (OpenAPI-Specification 2.0 does not allow Null in JSON)
+#if MIN_VERSION_aeson(2,0,0)
+_omitNulls :: [(A.Key, A.Value)] -> A.Value
+#else
+_omitNulls :: [(Text, A.Value)] -> A.Value
+#endif
+_omitNulls = A.object . P.filter notNull
+  where
+    notNull (_, A.Null) = False
+    notNull _ = True
+
+-- | Encodes fields using WH.toQueryParam
+_toFormItem :: (WH.ToHttpApiData a, Functor f) => t -> f a -> f (t, [Text])
+_toFormItem name x = (name,) . (:[]) . WH.toQueryParam <$> x
+
+-- | Collapse (Just "") to Nothing
+_emptyToNothing :: Maybe String -> Maybe String
+_emptyToNothing (Just "") = Nothing
+_emptyToNothing x = x
+{-# INLINE _emptyToNothing #-}
+
+-- | Collapse (Just mempty) to Nothing
+_memptyToNothing :: (P.Monoid a, P.Eq a) => Maybe a -> Maybe a
+_memptyToNothing (Just x) | x P.== P.mempty = Nothing
+_memptyToNothing x = x
+{-# INLINE _memptyToNothing #-}
+
+-- * DateTime Formatting
+
+newtype DateTime = DateTime { unDateTime :: TI.UTCTime }
+  deriving (P.Eq,P.Data,P.Ord,P.Typeable,NF.NFData)
+instance A.FromJSON DateTime where
+  parseJSON = A.withText "DateTime" (_readDateTime . T.unpack)
+instance A.ToJSON DateTime where
+  toJSON (DateTime t) = A.toJSON (_showDateTime t)
+instance WH.FromHttpApiData DateTime where
+  parseUrlPiece = P.maybe (P.Left "parseUrlPiece @DateTime") P.Right . _readDateTime . T.unpack
+instance WH.ToHttpApiData DateTime where
+  toUrlPiece (DateTime t) = T.pack (_showDateTime t)
+instance P.Show DateTime where
+  show (DateTime t) = _showDateTime t
+instance MimeRender MimeMultipartFormData DateTime where
+  mimeRender _ = mimeRenderDefaultMultipartFormData
+
+-- | @_parseISO8601@
+_readDateTime :: (MonadFail m, Alternative m) => String -> m DateTime
+_readDateTime s =
+  DateTime <$> _parseISO8601 s
+{-# INLINE _readDateTime #-}
+
+-- | @TI.formatISO8601Millis@
+_showDateTime :: (t ~ TI.UTCTime, TI.FormatTime t) => t -> String
+_showDateTime =
+  TI.formatISO8601Millis
+{-# INLINE _showDateTime #-}
+
+-- | parse an ISO8601 date-time string
+_parseISO8601 :: (TI.ParseTime t, MonadFail m, Alternative m) => String -> m t
+_parseISO8601 t =
+  P.asum $
+  P.flip (TI.parseTimeM True TI.defaultTimeLocale) t <$>
+  ["%FT%T%QZ", "%FT%T%Q%z", "%FT%T%Q%Z"]
+{-# INLINE _parseISO8601 #-}
+
+-- * Date Formatting
+
+newtype Date = Date { unDate :: TI.Day }
+  deriving (P.Enum,P.Eq,P.Data,P.Ord,P.Ix,NF.NFData)
+instance A.FromJSON Date where
+  parseJSON = A.withText "Date" (_readDate . T.unpack)
+instance A.ToJSON Date where
+  toJSON (Date t) = A.toJSON (_showDate t)
+instance WH.FromHttpApiData Date where
+  parseUrlPiece = P.maybe (P.Left "parseUrlPiece @Date") P.Right . _readDate . T.unpack
+instance WH.ToHttpApiData Date where
+  toUrlPiece (Date t) = T.pack (_showDate t)
+instance P.Show Date where
+  show (Date t) = _showDate t
+instance MimeRender MimeMultipartFormData Date where
+  mimeRender _ = mimeRenderDefaultMultipartFormData
+
+-- | @TI.parseTimeM True TI.defaultTimeLocale "%Y-%m-%d"@
+_readDate :: MonadFail m => String -> m Date
+_readDate s = Date <$> TI.parseTimeM True TI.defaultTimeLocale "%Y-%m-%d" s
+{-# INLINE _readDate #-}
+
+-- | @TI.formatTime TI.defaultTimeLocale "%Y-%m-%d"@
+_showDate :: TI.FormatTime t => t -> String
+_showDate =
+  TI.formatTime TI.defaultTimeLocale "%Y-%m-%d"
+{-# INLINE _showDate #-}
+
+-- * Byte/Binary Formatting
+
+
+-- | base64 encoded characters
+newtype ByteArray = ByteArray { unByteArray :: BL.ByteString }
+  deriving (P.Eq,P.Data,P.Ord,P.Typeable,NF.NFData)
+
+instance A.FromJSON ByteArray where
+  parseJSON = A.withText "ByteArray" _readByteArray
+instance A.ToJSON ByteArray where
+  toJSON = A.toJSON . _showByteArray
+instance WH.FromHttpApiData ByteArray where
+  parseUrlPiece = P.maybe (P.Left "parseUrlPiece @ByteArray") P.Right . _readByteArray
+instance WH.ToHttpApiData ByteArray where
+  toUrlPiece = _showByteArray
+instance P.Show ByteArray where
+  show = T.unpack . _showByteArray
+instance MimeRender MimeMultipartFormData ByteArray where
+  mimeRender _ = mimeRenderDefaultMultipartFormData
+
+-- | read base64 encoded characters
+_readByteArray :: MonadFail m => Text -> m ByteArray
+_readByteArray = P.either P.fail (pure . ByteArray) . BL64.decode . BL.fromStrict . T.encodeUtf8
+{-# INLINE _readByteArray #-}
+
+-- | show base64 encoded characters
+_showByteArray :: ByteArray -> Text
+_showByteArray = T.decodeUtf8 . BL.toStrict . BL64.encode . unByteArray
+{-# INLINE _showByteArray #-}
+
+-- | any sequence of octets
+newtype Binary = Binary { unBinary :: BL.ByteString }
+  deriving (P.Eq,P.Data,P.Ord,P.Typeable,NF.NFData)
+
+instance A.FromJSON Binary where
+  parseJSON = A.withText "Binary" _readBinaryBase64
+instance A.ToJSON Binary where
+  toJSON = A.toJSON . _showBinaryBase64
+instance WH.FromHttpApiData Binary where
+  parseUrlPiece = P.maybe (P.Left "parseUrlPiece @Binary") P.Right . _readBinaryBase64
+instance WH.ToHttpApiData Binary where
+  toUrlPiece = _showBinaryBase64
+instance P.Show Binary where
+  show = T.unpack . _showBinaryBase64
+instance MimeRender MimeMultipartFormData Binary where
+  mimeRender _ = unBinary
+
+_readBinaryBase64 :: MonadFail m => Text -> m Binary
+_readBinaryBase64 = P.either P.fail (pure . Binary) . BL64.decode . BL.fromStrict . T.encodeUtf8
+{-# INLINE _readBinaryBase64 #-}
+
+_showBinaryBase64 :: Binary -> Text
+_showBinaryBase64 = T.decodeUtf8 . BL.toStrict . BL64.encode . unBinary
+{-# INLINE _showBinaryBase64 #-}
+
+-- * Lens Type Aliases
+
+type Lens_' s a = Lens_ s s a a
+type Lens_ s t a b = forall (f :: K.Type -> K.Type). Functor f => (a -> f b) -> s -> f t
diff --git a/lib/G4fClient/Logging.hs b/lib/G4fClient/Logging.hs
new file mode 100644
index 0000000..ab7b449
--- /dev/null
+++ b/lib/G4fClient/Logging.hs
@@ -0,0 +1,33 @@
+{-
+   FastAPI
+
+   No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+   OpenAPI Version: 3.1.0
+   FastAPI API version: 0.1.0
+   Generated by OpenAPI Generator (https://openapi-generator.tech)
+-}
+
+{-|
+Module : G4fClient.Logging
+Logging functions
+-}
+{-# LANGUAGE CPP #-}
+
+#ifdef USE_KATIP
+
+module G4fClient.Logging
+  ( module G4fClient.LoggingKatip
+  ) where
+
+import G4fClient.LoggingKatip
+
+#else
+
+module G4fClient.Logging
+  ( module G4fClient.LoggingMonadLogger
+  ) where
+
+import G4fClient.LoggingMonadLogger
+
+#endif
diff --git a/lib/G4fClient/LoggingKatip.hs b/lib/G4fClient/LoggingKatip.hs
new file mode 100644
index 0000000..3d258f7
--- /dev/null
+++ b/lib/G4fClient/LoggingKatip.hs
@@ -0,0 +1,117 @@
+{-
+   FastAPI
+
+   No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+   OpenAPI Version: 3.1.0
+   FastAPI API version: 0.1.0
+   Generated by OpenAPI Generator (https://openapi-generator.tech)
+-}
+
+{-|
+Module : G4fClient.LoggingKatip
+Katip Logging functions
+-}
+
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE RankNTypes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+
+module G4fClient.LoggingKatip where
+
+import qualified Control.Exception.Safe as E
+import qualified Control.Monad.IO.Class as P
+import qualified Control.Monad.Trans.Reader as P
+import qualified Data.Text as T
+import qualified Lens.Micro as L
+import qualified System.IO as IO
+
+import Data.Text (Text)
+import GHC.Exts (IsString(..))
+
+import qualified Katip as LG
+
+-- * Type Aliases (for compatibility)
+
+-- | Runs a Katip logging block with the Log environment
+type LogExecWithContext = forall m a. P.MonadIO m =>
+                                      LogContext -> LogExec m a
+
+-- | A Katip logging block
+type LogExec m a = LG.KatipT m a -> m a
+
+-- | A Katip Log environment
+type LogContext = LG.LogEnv
+
+-- | A Katip Log severity
+type LogLevel = LG.Severity
+
+-- * default logger
+
+-- | the default log environment
+initLogContext :: IO LogContext
+initLogContext = LG.initLogEnv "G4fClient" "dev"
+
+-- | Runs a Katip logging block with the Log environment
+runDefaultLogExecWithContext :: LogExecWithContext
+runDefaultLogExecWithContext = LG.runKatipT
+
+-- * stdout logger
+
+-- | Runs a Katip logging block with the Log environment
+stdoutLoggingExec :: LogExecWithContext
+stdoutLoggingExec = runDefaultLogExecWithContext
+
+-- | A Katip Log environment which targets stdout
+stdoutLoggingContext :: LogContext -> IO LogContext
+stdoutLoggingContext cxt = do
+    handleScribe <- LG.mkHandleScribe LG.ColorIfTerminal IO.stdout (LG.permitItem LG.InfoS) LG.V2
+    LG.registerScribe "stdout" handleScribe LG.defaultScribeSettings cxt
+
+-- * stderr logger
+
+-- | Runs a Katip logging block with the Log environment
+stderrLoggingExec :: LogExecWithContext
+stderrLoggingExec = runDefaultLogExecWithContext
+
+-- | A Katip Log environment which targets stderr
+stderrLoggingContext :: LogContext -> IO LogContext
+stderrLoggingContext cxt = do
+    handleScribe <- LG.mkHandleScribe LG.ColorIfTerminal IO.stderr (LG.permitItem LG.InfoS) LG.V2
+    LG.registerScribe "stderr" handleScribe LG.defaultScribeSettings cxt
+
+-- * Null logger
+
+-- | Disables Katip logging
+runNullLogExec :: LogExecWithContext
+runNullLogExec le (LG.KatipT f) = P.runReaderT f (L.set LG.logEnvScribes mempty le)
+
+-- * Log Msg
+
+-- | Log a katip message
+_log :: (Applicative m, LG.Katip m) => Text -> LogLevel -> Text -> m ()
+_log src level msg = do
+  LG.logMsg (fromString $ T.unpack src) level (LG.logStr msg)
+
+-- * Log Exceptions
+
+-- | re-throws exceptions after logging them
+logExceptions
+  :: (LG.Katip m, E.MonadCatch m, Applicative m)
+  => Text -> m a -> m a
+logExceptions src =
+  E.handle
+    (\(e :: E.SomeException) -> do
+       _log src LG.ErrorS ((T.pack . show) e)
+       E.throw e)
+
+-- * Log Level
+
+levelInfo :: LogLevel
+levelInfo = LG.InfoS
+
+levelError :: LogLevel
+levelError = LG.ErrorS
+
+levelDebug :: LogLevel
+levelDebug = LG.DebugS
diff --git a/lib/G4fClient/LoggingMonadLogger.hs b/lib/G4fClient/LoggingMonadLogger.hs
new file mode 100644
index 0000000..70ab956
--- /dev/null
+++ b/lib/G4fClient/LoggingMonadLogger.hs
@@ -0,0 +1,126 @@
+{-
+   FastAPI
+
+   No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+   OpenAPI Version: 3.1.0
+   FastAPI API version: 0.1.0
+   Generated by OpenAPI Generator (https://openapi-generator.tech)
+-}
+
+{-|
+Module : G4fClient.LoggingMonadLogger
+monad-logger Logging functions
+-}
+
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE RankNTypes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+
+module G4fClient.LoggingMonadLogger where
+
+import qualified Control.Exception.Safe as E
+import qualified Control.Monad.IO.Class as P
+import qualified Data.Text as T
+import qualified Data.Time as TI
+
+import Data.Text (Text)
+
+import qualified Control.Monad.Logger as LG
+
+-- * Type Aliases (for compatibility)
+
+-- | Runs a monad-logger  block with the filter predicate
+type LogExecWithContext = forall m a. P.MonadIO m =>
+                                      LogContext -> LogExec m a
+
+-- | A monad-logger block
+type LogExec m a = LG.LoggingT m a -> m a
+
+-- | A monad-logger filter predicate
+type LogContext = LG.LogSource -> LG.LogLevel -> Bool
+
+-- | A monad-logger log level
+type LogLevel = LG.LogLevel
+
+-- * default logger
+
+-- | the default log environment
+initLogContext :: IO LogContext
+initLogContext = pure infoLevelFilter
+
+-- | Runs a monad-logger block with the filter predicate
+runDefaultLogExecWithContext :: LogExecWithContext
+runDefaultLogExecWithContext = runNullLogExec
+
+-- * stdout logger
+
+-- | Runs a monad-logger block targeting stdout, with the filter predicate
+stdoutLoggingExec :: LogExecWithContext
+stdoutLoggingExec cxt = LG.runStdoutLoggingT . LG.filterLogger cxt
+
+-- | @pure@
+stdoutLoggingContext :: LogContext -> IO LogContext
+stdoutLoggingContext = pure
+
+-- * stderr logger
+
+-- | Runs a monad-logger block targeting stderr, with the filter predicate
+stderrLoggingExec :: LogExecWithContext
+stderrLoggingExec cxt = LG.runStderrLoggingT . LG.filterLogger cxt
+
+-- | @pure@
+stderrLoggingContext :: LogContext -> IO LogContext
+stderrLoggingContext = pure
+
+-- * Null logger
+
+-- | Disables monad-logger logging
+runNullLogExec :: LogExecWithContext
+runNullLogExec = const (`LG.runLoggingT` nullLogger)
+
+-- | monad-logger which does nothing
+nullLogger :: LG.Loc -> LG.LogSource -> LG.LogLevel -> LG.LogStr -> IO ()
+nullLogger _ _ _ _ = return ()
+
+-- * Log Msg
+
+-- | Log a message using the current time
+_log :: (P.MonadIO m, LG.MonadLogger m) => Text -> LG.LogLevel -> Text -> m ()
+_log src level msg = do
+  now <- P.liftIO (formatTimeLog <$> TI.getCurrentTime)
+  LG.logOtherNS ("G4fClient." <> src) level ("[" <> now <> "] " <> msg)
+ where
+  formatTimeLog =
+    T.pack . TI.formatTime TI.defaultTimeLocale "%Y-%m-%dT%H:%M:%S%Z"
+
+-- * Log Exceptions
+
+-- | re-throws exceptions after logging them
+logExceptions
+   :: (LG.MonadLogger m, E.MonadCatch m, P.MonadIO m)
+   => Text -> m a -> m a
+logExceptions src =
+   E.handle
+     (\(e :: E.SomeException) -> do
+        _log src LG.LevelError ((T.pack . show) e)
+        E.throw e)
+
+-- * Log Level
+
+levelInfo :: LogLevel
+levelInfo = LG.LevelInfo
+
+levelError :: LogLevel
+levelError = LG.LevelError
+
+levelDebug :: LogLevel
+levelDebug = LG.LevelDebug
+
+-- * Level Filter
+
+minLevelFilter :: LG.LogLevel -> LG.LogSource -> LG.LogLevel -> Bool
+minLevelFilter l _ l' = l' >= l
+
+infoLevelFilter :: LG.LogSource -> LG.LogLevel -> Bool
+infoLevelFilter = minLevelFilter LG.LevelInfo
diff --git a/lib/G4fClient/MimeTypes.hs b/lib/G4fClient/MimeTypes.hs
new file mode 100644
index 0000000..8180529
--- /dev/null
+++ b/lib/G4fClient/MimeTypes.hs
@@ -0,0 +1,225 @@
+{-
+   FastAPI
+
+   No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+   OpenAPI Version: 3.1.0
+   FastAPI API version: 0.1.0
+   Generated by OpenAPI Generator (https://openapi-generator.tech)
+-}
+
+{-|
+Module : G4fClient.MimeTypes
+-}
+
+{-# LANGUAGE ConstraintKinds #-}
+{-# LANGUAGE ExistentialQuantification #-}
+{-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# OPTIONS_GHC -fno-warn-unused-binds -fno-warn-unused-imports #-}
+
+module G4fClient.MimeTypes where
+
+import qualified Control.Arrow as P (left)
+import qualified Data.Aeson as A
+import qualified Data.ByteString as B
+import qualified Data.ByteString.Builder as BB
+import qualified Data.ByteString.Char8 as BC
+import qualified Data.ByteString.Lazy as BL
+import qualified Data.ByteString.Lazy.Char8 as BCL
+import qualified Data.Data as P (Typeable)
+import qualified Data.Proxy as P (Proxy(..))
+import qualified Data.String as P
+import qualified Data.Text as T
+import qualified Data.Text.Encoding as T
+import qualified Network.HTTP.Media as ME
+import qualified Web.FormUrlEncoded as WH
+import qualified Web.HttpApiData as WH
+
+import Prelude (($), (.),(<$>),(<*>),Maybe(..),Bool(..),Char,Double,FilePath,Float,Int,Integer,String,fmap,undefined,mempty)
+import qualified Prelude as P
+
+-- * ContentType MimeType
+
+data ContentType a = MimeType a => ContentType { unContentType :: a }
+
+-- * Accept MimeType
+
+data Accept a = MimeType a => Accept { unAccept :: a }
+
+-- * Consumes Class
+
+class MimeType mtype => Consumes req mtype where
+
+-- * Produces Class
+
+class MimeType mtype => Produces req mtype where
+
+-- * Default Mime Types
+
+data MimeJSON = MimeJSON deriving (P.Typeable)
+data MimeXML = MimeXML deriving (P.Typeable)
+data MimePlainText = MimePlainText deriving (P.Typeable)
+data MimeFormUrlEncoded = MimeFormUrlEncoded deriving (P.Typeable)
+data MimeMultipartFormData = MimeMultipartFormData deriving (P.Typeable)
+data MimeOctetStream = MimeOctetStream deriving (P.Typeable)
+data MimeNoContent = MimeNoContent deriving (P.Typeable)
+data MimeAny = MimeAny deriving (P.Typeable)
+
+-- | A type for responses without content-body.
+data NoContent = NoContent
+  deriving (P.Show, P.Eq, P.Typeable)
+
+
+-- * MimeType Class
+
+class P.Typeable mtype => MimeType mtype  where
+  {-# MINIMAL mimeType | mimeTypes #-}
+
+  mimeTypes :: P.Proxy mtype -> [ME.MediaType]
+  mimeTypes p =
+    case mimeType p of
+      Just x -> [x]
+      Nothing -> []
+
+  mimeType :: P.Proxy mtype -> Maybe ME.MediaType
+  mimeType p =
+    case mimeTypes p of
+      [] -> Nothing
+      (x:_) -> Just x
+
+  mimeType' :: mtype -> Maybe ME.MediaType
+  mimeType' _ = mimeType (P.Proxy :: P.Proxy mtype)
+  mimeTypes' :: mtype -> [ME.MediaType]
+  mimeTypes' _ = mimeTypes (P.Proxy :: P.Proxy mtype)
+
+-- Default MimeType Instances
+
+-- | @application/json; charset=utf-8@
+instance MimeType MimeJSON where
+  mimeType _ = Just $ P.fromString "application/json"
+-- | @application/xml; charset=utf-8@
+instance MimeType MimeXML where
+  mimeType _ = Just $ P.fromString "application/xml"
+-- | @application/x-www-form-urlencoded@
+instance MimeType MimeFormUrlEncoded where
+  mimeType _ = Just $ P.fromString "application/x-www-form-urlencoded"
+-- | @multipart/form-data@
+instance MimeType MimeMultipartFormData where
+  mimeType _ = Just $ P.fromString "multipart/form-data"
+-- | @text/plain; charset=utf-8@
+instance MimeType MimePlainText where
+  mimeType _ = Just $ P.fromString "text/plain"
+-- | @application/octet-stream@
+instance MimeType MimeOctetStream where
+  mimeType _ = Just $ P.fromString "application/octet-stream"
+-- | @"*/*"@
+instance MimeType MimeAny where
+  mimeType _ = Just $ P.fromString "*/*"
+instance MimeType MimeNoContent where
+  mimeType _ = Nothing
+
+-- * MimeRender Class
+
+class MimeType mtype => MimeRender mtype x where
+    mimeRender  :: P.Proxy mtype -> x -> BL.ByteString
+    mimeRender' :: mtype -> x -> BL.ByteString
+    mimeRender' _ x = mimeRender (P.Proxy :: P.Proxy mtype) x
+
+
+mimeRenderDefaultMultipartFormData :: WH.ToHttpApiData a => a -> BL.ByteString
+mimeRenderDefaultMultipartFormData = BL.fromStrict . T.encodeUtf8 . WH.toQueryParam
+
+-- Default MimeRender Instances
+
+-- | `A.encode`
+instance A.ToJSON a => MimeRender MimeJSON a where mimeRender _ = A.encode
+-- | @WH.urlEncodeAsForm@
+instance WH.ToForm a => MimeRender MimeFormUrlEncoded a where mimeRender _ = WH.urlEncodeAsForm
+
+-- | @P.id@
+instance MimeRender MimePlainText BL.ByteString where mimeRender _ = P.id
+-- | @BL.fromStrict . T.encodeUtf8@
+instance MimeRender MimePlainText T.Text where mimeRender _ = BL.fromStrict . T.encodeUtf8
+-- | @BCL.pack@
+instance MimeRender MimePlainText String where mimeRender _ = BCL.pack
+
+-- | @P.id@
+instance MimeRender MimeOctetStream BL.ByteString where mimeRender _ = P.id
+-- | @BL.fromStrict . T.encodeUtf8@
+instance MimeRender MimeOctetStream T.Text where mimeRender _ = BL.fromStrict . T.encodeUtf8
+-- | @BCL.pack@
+instance MimeRender MimeOctetStream String where mimeRender _ = BCL.pack
+
+instance MimeRender MimeMultipartFormData BL.ByteString where mimeRender _ = P.id
+
+instance MimeRender MimeMultipartFormData Bool where mimeRender _ = mimeRenderDefaultMultipartFormData
+instance MimeRender MimeMultipartFormData Char where mimeRender _ = mimeRenderDefaultMultipartFormData
+instance MimeRender MimeMultipartFormData Double where mimeRender _ = mimeRenderDefaultMultipartFormData
+instance MimeRender MimeMultipartFormData Float where mimeRender _ = mimeRenderDefaultMultipartFormData
+instance MimeRender MimeMultipartFormData Int where mimeRender _ = mimeRenderDefaultMultipartFormData
+instance MimeRender MimeMultipartFormData Integer where mimeRender _ = mimeRenderDefaultMultipartFormData
+instance MimeRender MimeMultipartFormData String where mimeRender _ = mimeRenderDefaultMultipartFormData
+instance MimeRender MimeMultipartFormData T.Text where mimeRender _ = mimeRenderDefaultMultipartFormData
+
+-- | @P.Right . P.const NoContent@
+instance MimeRender MimeNoContent NoContent where mimeRender _ = P.const BCL.empty
+
+
+-- * MimeUnrender Class
+
+class MimeType mtype => MimeUnrender mtype o where
+    mimeUnrender :: P.Proxy mtype -> BL.ByteString -> P.Either String o
+    mimeUnrender' :: mtype -> BL.ByteString -> P.Either String o
+    mimeUnrender' _ x = mimeUnrender (P.Proxy :: P.Proxy mtype) x
+
+-- Default MimeUnrender Instances
+
+-- | @A.eitherDecode@
+instance A.FromJSON a => MimeUnrender MimeJSON a where mimeUnrender _ = A.eitherDecode
+-- | @P.left T.unpack . WH.urlDecodeAsForm@
+instance WH.FromForm a => MimeUnrender MimeFormUrlEncoded a where mimeUnrender _ = P.left T.unpack . WH.urlDecodeAsForm
+-- | @P.Right . P.id@
+
+instance MimeUnrender MimePlainText BL.ByteString where mimeUnrender _ = P.Right . P.id
+-- | @P.left P.show . TL.decodeUtf8'@
+instance MimeUnrender MimePlainText T.Text where mimeUnrender _ = P.left P.show . T.decodeUtf8' . BL.toStrict
+-- | @P.Right . BCL.unpack@
+instance MimeUnrender MimePlainText String where mimeUnrender _ = P.Right . BCL.unpack
+
+-- | @P.Right . P.id@
+instance MimeUnrender MimeOctetStream BL.ByteString where mimeUnrender _ = P.Right . P.id
+-- | @P.left P.show . T.decodeUtf8' . BL.toStrict@
+instance MimeUnrender MimeOctetStream T.Text where mimeUnrender _ = P.left P.show . T.decodeUtf8' . BL.toStrict
+-- | @P.Right . BCL.unpack@
+instance MimeUnrender MimeOctetStream String where mimeUnrender _ = P.Right . BCL.unpack
+
+-- | @P.Right . P.const NoContent@
+instance MimeUnrender MimeNoContent NoContent where mimeUnrender _ = P.Right . P.const NoContent
+
+
+-- * Custom Mime Types
+
+-- ** MimeAudio
+
+data MimeAudio = MimeAudio deriving (P.Typeable)
+
+-- | @audio/*@
+instance MimeType MimeAudio where
+  mimeType _ = Just $ P.fromString "audio/*"
+-- instance MimeRender MimeAudio T.Text where mimeRender _ = undefined
+-- instance MimeUnrender MimeAudio T.Text where mimeUnrender _ = undefined
+
+-- ** MimeImage
+
+data MimeImage = MimeImage deriving (P.Typeable)
+
+-- | @image/*@
+instance MimeType MimeImage where
+  mimeType _ = Just $ P.fromString "image/*"
+-- instance MimeRender MimeImage T.Text where mimeRender _ = undefined
+-- instance MimeUnrender MimeImage T.Text where mimeUnrender _ = undefined
+
diff --git a/lib/G4fClient/Model.hs b/lib/G4fClient/Model.hs
new file mode 100644
index 0000000..70cc4c5
--- /dev/null
+++ b/lib/G4fClient/Model.hs
@@ -0,0 +1,1513 @@
+{-
+   FastAPI
+
+   No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+   OpenAPI Version: 3.1.0
+   FastAPI API version: 0.1.0
+   Generated by OpenAPI Generator (https://openapi-generator.tech)
+-}
+
+{-|
+Module : G4fClient.Model
+-}
+
+{-# LANGUAGE DeriveDataTypeable #-}
+{-# LANGUAGE DeriveFoldable #-}
+{-# LANGUAGE DeriveGeneric #-}
+{-# LANGUAGE DeriveTraversable #-}
+{-# LANGUAGE DuplicateRecordFields #-}
+{-# LANGUAGE GeneralizedNewtypeDeriving #-}
+{-# LANGUAGE LambdaCase #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE NamedFieldPuns #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE RecordWildCards #-}
+{-# LANGUAGE TupleSections #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# OPTIONS_GHC -fno-warn-unused-matches -fno-warn-unused-binds -fno-warn-unused-imports #-}
+
+module G4fClient.Model where
+
+import G4fClient.Core
+import G4fClient.MimeTypes
+
+import Data.Aeson ((.:),(.:!),(.:?),(.=))
+
+import qualified Control.Arrow as P (left)
+import qualified Data.Aeson as A
+import qualified Data.ByteString as B
+import qualified Data.ByteString.Base64 as B64
+import qualified Data.ByteString.Char8 as BC
+import qualified Data.ByteString.Lazy as BL
+import qualified Data.Data as P (Typeable, TypeRep, typeOf, typeRep)
+import qualified Data.Foldable as P
+import qualified Data.HashMap.Lazy as HM
+import qualified Data.Map as Map
+import qualified Data.Maybe as P
+import qualified Data.Set as Set
+import qualified Data.Text as T
+import qualified Data.Text.Encoding as T
+import qualified Data.Time as TI
+import qualified Lens.Micro as L
+import qualified Web.FormUrlEncoded as WH
+import qualified Web.HttpApiData as WH
+
+import Control.Applicative ((<|>))
+import Control.Applicative (Alternative)
+import Data.Function ((&))
+import Data.Monoid ((<>))
+import Data.Text (Text)
+import Prelude (($),(/=),(.),(<$>),(<*>),(>>=),(=<<),Maybe(..),Bool(..),Char,Double,FilePath,Float,Int,Integer,String,fmap,undefined,mempty,maybe,pure,Monad,Applicative,Functor)
+
+import qualified Prelude as P
+
+
+
+-- * Parameter newtypes
+
+
+-- ** ConversationId
+newtype ConversationId = ConversationId { unConversationId :: Text } deriving (P.Eq, P.Show)
+
+-- ** File
+newtype File = File { unFile :: FilePath } deriving (P.Eq, P.Show)
+
+-- ** Filename
+newtype Filename = Filename { unFilename :: AnyType } deriving (P.Eq, P.Show)
+
+-- ** FilenameText
+newtype FilenameText = FilenameText { unFilenameText :: Text } deriving (P.Eq, P.Show)
+
+-- ** Files
+newtype Files = Files { unFiles :: [FilePath] } deriving (P.Eq, P.Show)
+
+-- ** Model
+newtype Model = Model { unModel :: Text } deriving (P.Eq, P.Show)
+
+-- ** ModelName
+newtype ModelName = ModelName { unModelName :: Text } deriving (P.Eq, P.Show)
+
+-- ** PathProvider
+newtype PathProvider = PathProvider { unPathProvider :: Text } deriving (P.Eq, P.Show)
+
+-- ** Prompt
+newtype Prompt = Prompt { unPrompt :: Text } deriving (P.Eq, P.Show)
+
+-- ** Provider
+newtype Provider = Provider { unProvider :: Text } deriving (P.Eq, P.Show)
+
+-- ** Thumbnail
+newtype Thumbnail = Thumbnail { unThumbnail :: Bool } deriving (P.Eq, P.Show)
+
+-- ** XUser
+newtype XUser = XUser { unXUser :: Text } deriving (P.Eq, P.Show)
+
+-- * Models
+
+
+-- ** ApiKey
+-- | ApiKey
+-- Api Key
+-- 
+data ApiKey = ApiKey
+  { 
+  } deriving (P.Show, P.Eq, P.Typeable)
+
+-- | FromJSON ApiKey
+instance A.FromJSON ApiKey where
+  parseJSON = A.withObject "ApiKey" $ \o ->
+    pure ApiKey
+      
+
+-- | ToJSON ApiKey
+instance A.ToJSON ApiKey where
+  toJSON ApiKey  =
+   _omitNulls
+      [ 
+      ]
+
+
+-- | Construct a value of type 'ApiKey' (by applying it's required fields, if any)
+mkApiKey
+  :: ApiKey
+mkApiKey =
+  ApiKey
+  { 
+  }
+
+-- ** AudioResponseModel
+-- | AudioResponseModel
+-- AudioResponseModel
+-- 
+data AudioResponseModel = AudioResponseModel
+  { audioResponseModelData :: !(Text) -- ^ /Required/ "data"
+  , audioResponseModelTranscript :: !(Maybe Text) -- ^ "transcript"
+  } deriving (P.Show, P.Eq, P.Typeable)
+
+-- | FromJSON AudioResponseModel
+instance A.FromJSON AudioResponseModel where
+  parseJSON = A.withObject "AudioResponseModel" $ \o ->
+    AudioResponseModel
+      <$> (o .:  "data")
+      <*> (o .:? "transcript")
+
+-- | ToJSON AudioResponseModel
+instance A.ToJSON AudioResponseModel where
+  toJSON AudioResponseModel {..} =
+   _omitNulls
+      [ "data" .= audioResponseModelData
+      , "transcript" .= audioResponseModelTranscript
+      ]
+
+
+-- | Construct a value of type 'AudioResponseModel' (by applying it's required fields, if any)
+mkAudioResponseModel
+  :: Text -- ^ 'audioResponseModelData' 
+  -> AudioResponseModel
+mkAudioResponseModel audioResponseModelData =
+  AudioResponseModel
+  { audioResponseModelData
+  , audioResponseModelTranscript = Nothing
+  }
+
+-- ** AudioSpeechConfig
+-- | AudioSpeechConfig
+-- AudioSpeechConfig
+-- 
+data AudioSpeechConfig = AudioSpeechConfig
+  { audioSpeechConfigInput :: !(Text) -- ^ /Required/ "input"
+  , audioSpeechConfigModel :: !(Maybe Text) -- ^ "model"
+  , audioSpeechConfigProvider :: !(Maybe Text) -- ^ "provider"
+  , audioSpeechConfigVoice :: !(Maybe Text) -- ^ "voice"
+  , audioSpeechConfigInstrcutions :: !(Maybe Text) -- ^ "instrcutions"
+  , audioSpeechConfigResponseFormat :: !(Maybe Text) -- ^ "response_format"
+  , audioSpeechConfigLanguage :: !(Maybe Text) -- ^ "language"
+  , audioSpeechConfigDownloadMedia :: !(Maybe Bool) -- ^ "download_media"
+  } deriving (P.Show, P.Eq, P.Typeable)
+
+-- | FromJSON AudioSpeechConfig
+instance A.FromJSON AudioSpeechConfig where
+  parseJSON = A.withObject "AudioSpeechConfig" $ \o ->
+    AudioSpeechConfig
+      <$> (o .:  "input")
+      <*> (o .:? "model")
+      <*> (o .:? "provider")
+      <*> (o .:? "voice")
+      <*> (o .:? "instrcutions")
+      <*> (o .:? "response_format")
+      <*> (o .:? "language")
+      <*> (o .:? "download_media")
+
+-- | ToJSON AudioSpeechConfig
+instance A.ToJSON AudioSpeechConfig where
+  toJSON AudioSpeechConfig {..} =
+   _omitNulls
+      [ "input" .= audioSpeechConfigInput
+      , "model" .= audioSpeechConfigModel
+      , "provider" .= audioSpeechConfigProvider
+      , "voice" .= audioSpeechConfigVoice
+      , "instrcutions" .= audioSpeechConfigInstrcutions
+      , "response_format" .= audioSpeechConfigResponseFormat
+      , "language" .= audioSpeechConfigLanguage
+      , "download_media" .= audioSpeechConfigDownloadMedia
+      ]
+
+
+-- | Construct a value of type 'AudioSpeechConfig' (by applying it's required fields, if any)
+mkAudioSpeechConfig
+  :: Text -- ^ 'audioSpeechConfigInput' 
+  -> AudioSpeechConfig
+mkAudioSpeechConfig audioSpeechConfigInput =
+  AudioSpeechConfig
+  { audioSpeechConfigInput
+  , audioSpeechConfigModel = Nothing
+  , audioSpeechConfigProvider = Nothing
+  , audioSpeechConfigVoice = Nothing
+  , audioSpeechConfigInstrcutions = Nothing
+  , audioSpeechConfigResponseFormat = Nothing
+  , audioSpeechConfigLanguage = Nothing
+  , audioSpeechConfigDownloadMedia = Nothing
+  }
+
+-- ** ChatCompletion
+-- | ChatCompletion
+-- ChatCompletion
+-- 
+data ChatCompletion = ChatCompletion
+  { chatCompletionId :: !(Text) -- ^ /Required/ "id"
+  , chatCompletionObject :: !(Text) -- ^ /Required/ "object"
+  , chatCompletionCreated :: !(Int) -- ^ /Required/ "created"
+  , chatCompletionModel :: !(Text) -- ^ /Required/ "model"
+  , chatCompletionProvider :: !(Text) -- ^ /Required/ "provider"
+  , chatCompletionChoices :: !([ChatCompletionChoice]) -- ^ /Required/ "choices"
+  , chatCompletionUsage :: !(UsageModel) -- ^ /Required/ "usage"
+  , chatCompletionConversation :: !((Map.Map String AnyType)) -- ^ /Required/ "conversation"
+  } deriving (P.Show, P.Eq, P.Typeable)
+
+-- | FromJSON ChatCompletion
+instance A.FromJSON ChatCompletion where
+  parseJSON = A.withObject "ChatCompletion" $ \o ->
+    ChatCompletion
+      <$> (o .:  "id")
+      <*> (o .:  "object")
+      <*> (o .:  "created")
+      <*> (o .:  "model")
+      <*> (o .:  "provider")
+      <*> (o .:  "choices")
+      <*> (o .:  "usage")
+      <*> (o .:  "conversation")
+
+-- | ToJSON ChatCompletion
+instance A.ToJSON ChatCompletion where
+  toJSON ChatCompletion {..} =
+   _omitNulls
+      [ "id" .= chatCompletionId
+      , "object" .= chatCompletionObject
+      , "created" .= chatCompletionCreated
+      , "model" .= chatCompletionModel
+      , "provider" .= chatCompletionProvider
+      , "choices" .= chatCompletionChoices
+      , "usage" .= chatCompletionUsage
+      , "conversation" .= chatCompletionConversation
+      ]
+
+
+-- | Construct a value of type 'ChatCompletion' (by applying it's required fields, if any)
+mkChatCompletion
+  :: Text -- ^ 'chatCompletionId' 
+  -> Text -- ^ 'chatCompletionObject' 
+  -> Int -- ^ 'chatCompletionCreated' 
+  -> Text -- ^ 'chatCompletionModel' 
+  -> Text -- ^ 'chatCompletionProvider' 
+  -> [ChatCompletionChoice] -- ^ 'chatCompletionChoices' 
+  -> UsageModel -- ^ 'chatCompletionUsage' 
+  -> (Map.Map String AnyType) -- ^ 'chatCompletionConversation' 
+  -> ChatCompletion
+mkChatCompletion chatCompletionId chatCompletionObject chatCompletionCreated chatCompletionModel chatCompletionProvider chatCompletionChoices chatCompletionUsage chatCompletionConversation =
+  ChatCompletion
+  { chatCompletionId
+  , chatCompletionObject
+  , chatCompletionCreated
+  , chatCompletionModel
+  , chatCompletionProvider
+  , chatCompletionChoices
+  , chatCompletionUsage
+  , chatCompletionConversation
+  }
+
+-- ** ChatCompletionChoice
+-- | ChatCompletionChoice
+-- ChatCompletionChoice
+-- 
+data ChatCompletionChoice = ChatCompletionChoice
+  { chatCompletionChoiceIndex :: !(Int) -- ^ /Required/ "index"
+  , chatCompletionChoiceMessage :: !(ChatCompletionMessage) -- ^ /Required/ "message"
+  , chatCompletionChoiceFinishReason :: !(Text) -- ^ /Required/ "finish_reason"
+  } deriving (P.Show, P.Eq, P.Typeable)
+
+-- | FromJSON ChatCompletionChoice
+instance A.FromJSON ChatCompletionChoice where
+  parseJSON = A.withObject "ChatCompletionChoice" $ \o ->
+    ChatCompletionChoice
+      <$> (o .:  "index")
+      <*> (o .:  "message")
+      <*> (o .:  "finish_reason")
+
+-- | ToJSON ChatCompletionChoice
+instance A.ToJSON ChatCompletionChoice where
+  toJSON ChatCompletionChoice {..} =
+   _omitNulls
+      [ "index" .= chatCompletionChoiceIndex
+      , "message" .= chatCompletionChoiceMessage
+      , "finish_reason" .= chatCompletionChoiceFinishReason
+      ]
+
+
+-- | Construct a value of type 'ChatCompletionChoice' (by applying it's required fields, if any)
+mkChatCompletionChoice
+  :: Int -- ^ 'chatCompletionChoiceIndex' 
+  -> ChatCompletionMessage -- ^ 'chatCompletionChoiceMessage' 
+  -> Text -- ^ 'chatCompletionChoiceFinishReason' 
+  -> ChatCompletionChoice
+mkChatCompletionChoice chatCompletionChoiceIndex chatCompletionChoiceMessage chatCompletionChoiceFinishReason =
+  ChatCompletionChoice
+  { chatCompletionChoiceIndex
+  , chatCompletionChoiceMessage
+  , chatCompletionChoiceFinishReason
+  }
+
+-- ** ChatCompletionMessage
+-- | ChatCompletionMessage
+-- ChatCompletionMessage
+-- 
+data ChatCompletionMessage = ChatCompletionMessage
+  { chatCompletionMessageRole :: !(Text) -- ^ /Required/ "role"
+  , chatCompletionMessageContent :: !(Text) -- ^ /Required/ "content"
+  , chatCompletionMessageReasoning :: !(Maybe Text) -- ^ "reasoning"
+  , chatCompletionMessageToolCalls :: !(Maybe [ToolCallModel]) -- ^ "tool_calls"
+  , chatCompletionMessageAudio :: !(Maybe AudioResponseModel) -- ^ "audio"
+  } deriving (P.Show, P.Eq, P.Typeable)
+
+-- | FromJSON ChatCompletionMessage
+instance A.FromJSON ChatCompletionMessage where
+  parseJSON = A.withObject "ChatCompletionMessage" $ \o ->
+    ChatCompletionMessage
+      <$> (o .:  "role")
+      <*> (o .:  "content")
+      <*> (o .:? "reasoning")
+      <*> (o .:? "tool_calls")
+      <*> (o .:? "audio")
+
+-- | ToJSON ChatCompletionMessage
+instance A.ToJSON ChatCompletionMessage where
+  toJSON ChatCompletionMessage {..} =
+   _omitNulls
+      [ "role" .= chatCompletionMessageRole
+      , "content" .= chatCompletionMessageContent
+      , "reasoning" .= chatCompletionMessageReasoning
+      , "tool_calls" .= chatCompletionMessageToolCalls
+      , "audio" .= chatCompletionMessageAudio
+      ]
+
+
+-- | Construct a value of type 'ChatCompletionMessage' (by applying it's required fields, if any)
+mkChatCompletionMessage
+  :: Text -- ^ 'chatCompletionMessageRole' 
+  -> Text -- ^ 'chatCompletionMessageContent' 
+  -> ChatCompletionMessage
+mkChatCompletionMessage chatCompletionMessageRole chatCompletionMessageContent =
+  ChatCompletionMessage
+  { chatCompletionMessageRole
+  , chatCompletionMessageContent
+  , chatCompletionMessageReasoning = Nothing
+  , chatCompletionMessageToolCalls = Nothing
+  , chatCompletionMessageAudio = Nothing
+  }
+
+-- ** ChatCompletionsConfig
+-- | ChatCompletionsConfig
+-- ChatCompletionsConfig
+-- 
+data ChatCompletionsConfig = ChatCompletionsConfig
+  { chatCompletionsConfigModel :: !(Maybe Text) -- ^ "model"
+  , chatCompletionsConfigProvider :: !(Maybe Text) -- ^ "provider"
+  , chatCompletionsConfigMedia :: !(Maybe [[AnyType]]) -- ^ "media"
+  , chatCompletionsConfigModalities :: !(Maybe [Text]) -- ^ "modalities"
+  , chatCompletionsConfigTemperature :: !(Maybe Double) -- ^ "temperature"
+  , chatCompletionsConfigPresencePenalty :: !(Maybe Double) -- ^ "presence_penalty"
+  , chatCompletionsConfigFrequencyPenalty :: !(Maybe Double) -- ^ "frequency_penalty"
+  , chatCompletionsConfigTopP :: !(Maybe Double) -- ^ "top_p"
+  , chatCompletionsConfigMaxTokens :: !(Maybe Int) -- ^ "max_tokens"
+  , chatCompletionsConfigStop :: !(Maybe Stop) -- ^ "stop"
+  , chatCompletionsConfigApiKey :: !(Maybe ApiKey) -- ^ "api_key"
+  , chatCompletionsConfigBaseUrl :: !(Maybe Text) -- ^ "base_url"
+  , chatCompletionsConfigWebSearch :: !(Maybe Bool) -- ^ "web_search"
+  , chatCompletionsConfigProxy :: !(Maybe Text) -- ^ "proxy"
+  , chatCompletionsConfigConversation :: !(Maybe (Map.Map String AnyType)) -- ^ "conversation"
+  , chatCompletionsConfigTimeout :: !(Maybe Int) -- ^ "timeout"
+  , chatCompletionsConfigStreamTimeout :: !(Maybe Int) -- ^ "stream_timeout"
+  , chatCompletionsConfigToolCalls :: !(Maybe [AnyType]) -- ^ "tool_calls"
+  , chatCompletionsConfigReasoningEffort :: !(Maybe Text) -- ^ "reasoning_effort"
+  , chatCompletionsConfigLogitBias :: !(Maybe (Map.Map String AnyType)) -- ^ "logit_bias"
+  , chatCompletionsConfigAudio :: !(Maybe (Map.Map String AnyType)) -- ^ "audio"
+  , chatCompletionsConfigResponseFormat :: !(Maybe (Map.Map String AnyType)) -- ^ "response_format"
+  , chatCompletionsConfigDownloadMedia :: !(Maybe Bool) -- ^ "download_media"
+  , chatCompletionsConfigRaw :: !(Maybe Bool) -- ^ "raw"
+  , chatCompletionsConfigExtraBody :: !(Maybe (Map.Map String AnyType)) -- ^ "extra_body"
+  , chatCompletionsConfigToolEmulation :: !(Maybe Bool) -- ^ "tool_emulation"
+  , chatCompletionsConfigMessages :: !([Message]) -- ^ /Required/ "messages"
+  , chatCompletionsConfigStream :: !(Maybe Bool) -- ^ "stream"
+  , chatCompletionsConfigImage :: !(Maybe Text) -- ^ "image"
+  , chatCompletionsConfigImageName :: !(Maybe Text) -- ^ "image_name"
+  , chatCompletionsConfigImages :: !(Maybe [[AnyType]]) -- ^ "images"
+  , chatCompletionsConfigTools :: !(Maybe [AnyType]) -- ^ "tools"
+  , chatCompletionsConfigParallelToolCalls :: !(Maybe Bool) -- ^ "parallel_tool_calls"
+  , chatCompletionsConfigToolChoice :: !(Maybe Text) -- ^ "tool_choice"
+  , chatCompletionsConfigConversationId :: !(Maybe Text) -- ^ "conversation_id"
+  } deriving (P.Show, P.Eq, P.Typeable)
+
+-- | FromJSON ChatCompletionsConfig
+instance A.FromJSON ChatCompletionsConfig where
+  parseJSON = A.withObject "ChatCompletionsConfig" $ \o ->
+    ChatCompletionsConfig
+      <$> (o .:? "model")
+      <*> (o .:? "provider")
+      <*> (o .:? "media")
+      <*> (o .:? "modalities")
+      <*> (o .:? "temperature")
+      <*> (o .:? "presence_penalty")
+      <*> (o .:? "frequency_penalty")
+      <*> (o .:? "top_p")
+      <*> (o .:? "max_tokens")
+      <*> (o .:? "stop")
+      <*> (o .:? "api_key")
+      <*> (o .:? "base_url")
+      <*> (o .:? "web_search")
+      <*> (o .:? "proxy")
+      <*> (o .:? "conversation")
+      <*> (o .:? "timeout")
+      <*> (o .:? "stream_timeout")
+      <*> (o .:? "tool_calls")
+      <*> (o .:? "reasoning_effort")
+      <*> (o .:? "logit_bias")
+      <*> (o .:? "audio")
+      <*> (o .:? "response_format")
+      <*> (o .:? "download_media")
+      <*> (o .:? "raw")
+      <*> (o .:? "extra_body")
+      <*> (o .:? "tool_emulation")
+      <*> (o .:  "messages")
+      <*> (o .:? "stream")
+      <*> (o .:? "image")
+      <*> (o .:? "image_name")
+      <*> (o .:? "images")
+      <*> (o .:? "tools")
+      <*> (o .:? "parallel_tool_calls")
+      <*> (o .:? "tool_choice")
+      <*> (o .:? "conversation_id")
+
+-- | ToJSON ChatCompletionsConfig
+instance A.ToJSON ChatCompletionsConfig where
+  toJSON ChatCompletionsConfig {..} =
+   _omitNulls
+      [ "model" .= chatCompletionsConfigModel
+      , "provider" .= chatCompletionsConfigProvider
+      , "media" .= chatCompletionsConfigMedia
+      , "modalities" .= chatCompletionsConfigModalities
+      , "temperature" .= chatCompletionsConfigTemperature
+      , "presence_penalty" .= chatCompletionsConfigPresencePenalty
+      , "frequency_penalty" .= chatCompletionsConfigFrequencyPenalty
+      , "top_p" .= chatCompletionsConfigTopP
+      , "max_tokens" .= chatCompletionsConfigMaxTokens
+      , "stop" .= chatCompletionsConfigStop
+      , "api_key" .= chatCompletionsConfigApiKey
+      , "base_url" .= chatCompletionsConfigBaseUrl
+      , "web_search" .= chatCompletionsConfigWebSearch
+      , "proxy" .= chatCompletionsConfigProxy
+      , "conversation" .= chatCompletionsConfigConversation
+      , "timeout" .= chatCompletionsConfigTimeout
+      , "stream_timeout" .= chatCompletionsConfigStreamTimeout
+      , "tool_calls" .= chatCompletionsConfigToolCalls
+      , "reasoning_effort" .= chatCompletionsConfigReasoningEffort
+      , "logit_bias" .= chatCompletionsConfigLogitBias
+      , "audio" .= chatCompletionsConfigAudio
+      , "response_format" .= chatCompletionsConfigResponseFormat
+      , "download_media" .= chatCompletionsConfigDownloadMedia
+      , "raw" .= chatCompletionsConfigRaw
+      , "extra_body" .= chatCompletionsConfigExtraBody
+      , "tool_emulation" .= chatCompletionsConfigToolEmulation
+      , "messages" .= chatCompletionsConfigMessages
+      , "stream" .= chatCompletionsConfigStream
+      , "image" .= chatCompletionsConfigImage
+      , "image_name" .= chatCompletionsConfigImageName
+      , "images" .= chatCompletionsConfigImages
+      , "tools" .= chatCompletionsConfigTools
+      , "parallel_tool_calls" .= chatCompletionsConfigParallelToolCalls
+      , "tool_choice" .= chatCompletionsConfigToolChoice
+      , "conversation_id" .= chatCompletionsConfigConversationId
+      ]
+
+
+-- | Construct a value of type 'ChatCompletionsConfig' (by applying it's required fields, if any)
+mkChatCompletionsConfig
+  :: [Message] -- ^ 'chatCompletionsConfigMessages' 
+  -> ChatCompletionsConfig
+mkChatCompletionsConfig chatCompletionsConfigMessages =
+  ChatCompletionsConfig
+  { chatCompletionsConfigModel = Nothing
+  , chatCompletionsConfigProvider = Nothing
+  , chatCompletionsConfigMedia = Nothing
+  , chatCompletionsConfigModalities = Nothing
+  , chatCompletionsConfigTemperature = Nothing
+  , chatCompletionsConfigPresencePenalty = Nothing
+  , chatCompletionsConfigFrequencyPenalty = Nothing
+  , chatCompletionsConfigTopP = Nothing
+  , chatCompletionsConfigMaxTokens = Nothing
+  , chatCompletionsConfigStop = Nothing
+  , chatCompletionsConfigApiKey = Nothing
+  , chatCompletionsConfigBaseUrl = Nothing
+  , chatCompletionsConfigWebSearch = Nothing
+  , chatCompletionsConfigProxy = Nothing
+  , chatCompletionsConfigConversation = Nothing
+  , chatCompletionsConfigTimeout = Nothing
+  , chatCompletionsConfigStreamTimeout = Nothing
+  , chatCompletionsConfigToolCalls = Nothing
+  , chatCompletionsConfigReasoningEffort = Nothing
+  , chatCompletionsConfigLogitBias = Nothing
+  , chatCompletionsConfigAudio = Nothing
+  , chatCompletionsConfigResponseFormat = Nothing
+  , chatCompletionsConfigDownloadMedia = Nothing
+  , chatCompletionsConfigRaw = Nothing
+  , chatCompletionsConfigExtraBody = Nothing
+  , chatCompletionsConfigToolEmulation = Nothing
+  , chatCompletionsConfigMessages
+  , chatCompletionsConfigStream = Nothing
+  , chatCompletionsConfigImage = Nothing
+  , chatCompletionsConfigImageName = Nothing
+  , chatCompletionsConfigImages = Nothing
+  , chatCompletionsConfigTools = Nothing
+  , chatCompletionsConfigParallelToolCalls = Nothing
+  , chatCompletionsConfigToolChoice = Nothing
+  , chatCompletionsConfigConversationId = Nothing
+  }
+
+-- ** CompletionTokenDetails
+-- | CompletionTokenDetails
+-- CompletionTokenDetails
+-- 
+data CompletionTokenDetails = CompletionTokenDetails
+  { completionTokenDetailsReasoningTokens :: !(Int) -- ^ /Required/ "reasoning_tokens"
+  , completionTokenDetailsImageTokens :: !(Int) -- ^ /Required/ "image_tokens"
+  , completionTokenDetailsAudioTokens :: !(Int) -- ^ /Required/ "audio_tokens"
+  } deriving (P.Show, P.Eq, P.Typeable)
+
+-- | FromJSON CompletionTokenDetails
+instance A.FromJSON CompletionTokenDetails where
+  parseJSON = A.withObject "CompletionTokenDetails" $ \o ->
+    CompletionTokenDetails
+      <$> (o .:  "reasoning_tokens")
+      <*> (o .:  "image_tokens")
+      <*> (o .:  "audio_tokens")
+
+-- | ToJSON CompletionTokenDetails
+instance A.ToJSON CompletionTokenDetails where
+  toJSON CompletionTokenDetails {..} =
+   _omitNulls
+      [ "reasoning_tokens" .= completionTokenDetailsReasoningTokens
+      , "image_tokens" .= completionTokenDetailsImageTokens
+      , "audio_tokens" .= completionTokenDetailsAudioTokens
+      ]
+
+
+-- | Construct a value of type 'CompletionTokenDetails' (by applying it's required fields, if any)
+mkCompletionTokenDetails
+  :: Int -- ^ 'completionTokenDetailsReasoningTokens' 
+  -> Int -- ^ 'completionTokenDetailsImageTokens' 
+  -> Int -- ^ 'completionTokenDetailsAudioTokens' 
+  -> CompletionTokenDetails
+mkCompletionTokenDetails completionTokenDetailsReasoningTokens completionTokenDetailsImageTokens completionTokenDetailsAudioTokens =
+  CompletionTokenDetails
+  { completionTokenDetailsReasoningTokens
+  , completionTokenDetailsImageTokens
+  , completionTokenDetailsAudioTokens
+  }
+
+-- ** Content
+-- | Content
+-- Content
+-- 
+data Content = Content
+  { 
+  } deriving (P.Show, P.Eq, P.Typeable)
+
+-- | FromJSON Content
+instance A.FromJSON Content where
+  parseJSON = A.withObject "Content" $ \o ->
+    pure Content
+      
+
+-- | ToJSON Content
+instance A.ToJSON Content where
+  toJSON Content  =
+   _omitNulls
+      [ 
+      ]
+
+
+-- | Construct a value of type 'Content' (by applying it's required fields, if any)
+mkContent
+  :: Content
+mkContent =
+  Content
+  { 
+  }
+
+-- ** ContentPart
+-- | ContentPart
+-- ContentPart
+-- 
+data ContentPart = ContentPart
+  { contentPartType :: !(Maybe Text) -- ^ "type"
+  , contentPartText :: !(Maybe Text) -- ^ "text"
+  , contentPartImageUrl :: !(Maybe (Map.Map String Text)) -- ^ "image_url"
+  , contentPartInputAudio :: !(Maybe (Map.Map String Text)) -- ^ "input_audio"
+  , contentPartBucketId :: !(Maybe Text) -- ^ "bucket_id"
+  , contentPartName :: !(Maybe Text) -- ^ "name"
+  } deriving (P.Show, P.Eq, P.Typeable)
+
+-- | FromJSON ContentPart
+instance A.FromJSON ContentPart where
+  parseJSON = A.withObject "ContentPart" $ \o ->
+    ContentPart
+      <$> (o .:? "type")
+      <*> (o .:? "text")
+      <*> (o .:? "image_url")
+      <*> (o .:? "input_audio")
+      <*> (o .:? "bucket_id")
+      <*> (o .:? "name")
+
+-- | ToJSON ContentPart
+instance A.ToJSON ContentPart where
+  toJSON ContentPart {..} =
+   _omitNulls
+      [ "type" .= contentPartType
+      , "text" .= contentPartText
+      , "image_url" .= contentPartImageUrl
+      , "input_audio" .= contentPartInputAudio
+      , "bucket_id" .= contentPartBucketId
+      , "name" .= contentPartName
+      ]
+
+
+-- | Construct a value of type 'ContentPart' (by applying it's required fields, if any)
+mkContentPart
+  :: ContentPart
+mkContentPart =
+  ContentPart
+  { contentPartType = Nothing
+  , contentPartText = Nothing
+  , contentPartImageUrl = Nothing
+  , contentPartInputAudio = Nothing
+  , contentPartBucketId = Nothing
+  , contentPartName = Nothing
+  }
+
+-- ** ErrorResponseMessageModel
+-- | ErrorResponseMessageModel
+-- ErrorResponseMessageModel
+-- 
+data ErrorResponseMessageModel = ErrorResponseMessageModel
+  { errorResponseMessageModelMessage :: !(Text) -- ^ /Required/ "message"
+  } deriving (P.Show, P.Eq, P.Typeable)
+
+-- | FromJSON ErrorResponseMessageModel
+instance A.FromJSON ErrorResponseMessageModel where
+  parseJSON = A.withObject "ErrorResponseMessageModel" $ \o ->
+    ErrorResponseMessageModel
+      <$> (o .:  "message")
+
+-- | ToJSON ErrorResponseMessageModel
+instance A.ToJSON ErrorResponseMessageModel where
+  toJSON ErrorResponseMessageModel {..} =
+   _omitNulls
+      [ "message" .= errorResponseMessageModelMessage
+      ]
+
+
+-- | Construct a value of type 'ErrorResponseMessageModel' (by applying it's required fields, if any)
+mkErrorResponseMessageModel
+  :: Text -- ^ 'errorResponseMessageModelMessage' 
+  -> ErrorResponseMessageModel
+mkErrorResponseMessageModel errorResponseMessageModelMessage =
+  ErrorResponseMessageModel
+  { errorResponseMessageModelMessage
+  }
+
+-- ** ErrorResponseModel
+-- | ErrorResponseModel
+-- ErrorResponseModel
+-- 
+data ErrorResponseModel = ErrorResponseModel
+  { errorResponseModelError :: !(ErrorResponseMessageModel) -- ^ /Required/ "error"
+  , errorResponseModelModel :: !(Maybe Text) -- ^ "model"
+  , errorResponseModelProvider :: !(Maybe Text) -- ^ "provider"
+  } deriving (P.Show, P.Eq, P.Typeable)
+
+-- | FromJSON ErrorResponseModel
+instance A.FromJSON ErrorResponseModel where
+  parseJSON = A.withObject "ErrorResponseModel" $ \o ->
+    ErrorResponseModel
+      <$> (o .:  "error")
+      <*> (o .:? "model")
+      <*> (o .:? "provider")
+
+-- | ToJSON ErrorResponseModel
+instance A.ToJSON ErrorResponseModel where
+  toJSON ErrorResponseModel {..} =
+   _omitNulls
+      [ "error" .= errorResponseModelError
+      , "model" .= errorResponseModelModel
+      , "provider" .= errorResponseModelProvider
+      ]
+
+
+-- | Construct a value of type 'ErrorResponseModel' (by applying it's required fields, if any)
+mkErrorResponseModel
+  :: ErrorResponseMessageModel -- ^ 'errorResponseModelError' 
+  -> ErrorResponseModel
+mkErrorResponseModel errorResponseModelError =
+  ErrorResponseModel
+  { errorResponseModelError
+  , errorResponseModelModel = Nothing
+  , errorResponseModelProvider = Nothing
+  }
+
+-- ** FileResponseModel
+-- | FileResponseModel
+-- FileResponseModel
+-- 
+data FileResponseModel = FileResponseModel
+  { fileResponseModelFilename :: !(Text) -- ^ /Required/ "filename"
+  } deriving (P.Show, P.Eq, P.Typeable)
+
+-- | FromJSON FileResponseModel
+instance A.FromJSON FileResponseModel where
+  parseJSON = A.withObject "FileResponseModel" $ \o ->
+    FileResponseModel
+      <$> (o .:  "filename")
+
+-- | ToJSON FileResponseModel
+instance A.ToJSON FileResponseModel where
+  toJSON FileResponseModel {..} =
+   _omitNulls
+      [ "filename" .= fileResponseModelFilename
+      ]
+
+
+-- | Construct a value of type 'FileResponseModel' (by applying it's required fields, if any)
+mkFileResponseModel
+  :: Text -- ^ 'fileResponseModelFilename' 
+  -> FileResponseModel
+mkFileResponseModel fileResponseModelFilename =
+  FileResponseModel
+  { fileResponseModelFilename
+  }
+
+-- ** HTTPValidationError
+-- | HTTPValidationError
+-- HTTPValidationError
+-- 
+data HTTPValidationError = HTTPValidationError
+  { hTTPValidationErrorDetail :: !(Maybe [ValidationError]) -- ^ "detail"
+  } deriving (P.Show, P.Eq, P.Typeable)
+
+-- | FromJSON HTTPValidationError
+instance A.FromJSON HTTPValidationError where
+  parseJSON = A.withObject "HTTPValidationError" $ \o ->
+    HTTPValidationError
+      <$> (o .:? "detail")
+
+-- | ToJSON HTTPValidationError
+instance A.ToJSON HTTPValidationError where
+  toJSON HTTPValidationError {..} =
+   _omitNulls
+      [ "detail" .= hTTPValidationErrorDetail
+      ]
+
+
+-- | Construct a value of type 'HTTPValidationError' (by applying it's required fields, if any)
+mkHTTPValidationError
+  :: HTTPValidationError
+mkHTTPValidationError =
+  HTTPValidationError
+  { hTTPValidationErrorDetail = Nothing
+  }
+
+-- ** Image
+-- | Image
+-- Image
+-- 
+data Image = Image
+  { imageUrl :: !(Text) -- ^ /Required/ "url"
+  , imageB64Json :: !(Text) -- ^ /Required/ "b64_json"
+  , imageRevisedPrompt :: !(Text) -- ^ /Required/ "revised_prompt"
+  } deriving (P.Show, P.Eq, P.Typeable)
+
+-- | FromJSON Image
+instance A.FromJSON Image where
+  parseJSON = A.withObject "Image" $ \o ->
+    Image
+      <$> (o .:  "url")
+      <*> (o .:  "b64_json")
+      <*> (o .:  "revised_prompt")
+
+-- | ToJSON Image
+instance A.ToJSON Image where
+  toJSON Image {..} =
+   _omitNulls
+      [ "url" .= imageUrl
+      , "b64_json" .= imageB64Json
+      , "revised_prompt" .= imageRevisedPrompt
+      ]
+
+
+-- | Construct a value of type 'Image' (by applying it's required fields, if any)
+mkImage
+  :: Text -- ^ 'imageUrl' 
+  -> Text -- ^ 'imageB64Json' 
+  -> Text -- ^ 'imageRevisedPrompt' 
+  -> Image
+mkImage imageUrl imageB64Json imageRevisedPrompt =
+  Image
+  { imageUrl
+  , imageB64Json
+  , imageRevisedPrompt
+  }
+
+-- ** ImageGenerationConfig
+-- | ImageGenerationConfig
+-- ImageGenerationConfig
+-- 
+data ImageGenerationConfig = ImageGenerationConfig
+  { imageGenerationConfigPrompt :: !(Text) -- ^ /Required/ "prompt"
+  , imageGenerationConfigModel :: !(Maybe Text) -- ^ "model"
+  , imageGenerationConfigProvider :: !(Maybe Text) -- ^ "provider"
+  , imageGenerationConfigResponseFormat :: !(Maybe Text) -- ^ "response_format"
+  , imageGenerationConfigApiKey :: !(Maybe Text) -- ^ "api_key"
+  , imageGenerationConfigProxy :: !(Maybe Text) -- ^ "proxy"
+  , imageGenerationConfigWidth :: !(Maybe Int) -- ^ "width"
+  , imageGenerationConfigHeight :: !(Maybe Int) -- ^ "height"
+  , imageGenerationConfigNumInferenceSteps :: !(Maybe Int) -- ^ "num_inference_steps"
+  , imageGenerationConfigSeed :: !(Maybe Int) -- ^ "seed"
+  , imageGenerationConfigGuidanceScale :: !(Maybe Int) -- ^ "guidance_scale"
+  , imageGenerationConfigAspectRatio :: !(Maybe Text) -- ^ "aspect_ratio"
+  , imageGenerationConfigN :: !(Maybe Int) -- ^ "n"
+  , imageGenerationConfigNegativePrompt :: !(Maybe Text) -- ^ "negative_prompt"
+  , imageGenerationConfigResolution :: !(Maybe Text) -- ^ "resolution"
+  , imageGenerationConfigAudio :: !(Maybe (Map.Map String AnyType)) -- ^ "audio"
+  , imageGenerationConfigDownloadMedia :: !(Maybe Bool) -- ^ "download_media"
+  } deriving (P.Show, P.Eq, P.Typeable)
+
+-- | FromJSON ImageGenerationConfig
+instance A.FromJSON ImageGenerationConfig where
+  parseJSON = A.withObject "ImageGenerationConfig" $ \o ->
+    ImageGenerationConfig
+      <$> (o .:  "prompt")
+      <*> (o .:? "model")
+      <*> (o .:? "provider")
+      <*> (o .:? "response_format")
+      <*> (o .:? "api_key")
+      <*> (o .:? "proxy")
+      <*> (o .:? "width")
+      <*> (o .:? "height")
+      <*> (o .:? "num_inference_steps")
+      <*> (o .:? "seed")
+      <*> (o .:? "guidance_scale")
+      <*> (o .:? "aspect_ratio")
+      <*> (o .:? "n")
+      <*> (o .:? "negative_prompt")
+      <*> (o .:? "resolution")
+      <*> (o .:? "audio")
+      <*> (o .:? "download_media")
+
+-- | ToJSON ImageGenerationConfig
+instance A.ToJSON ImageGenerationConfig where
+  toJSON ImageGenerationConfig {..} =
+   _omitNulls
+      [ "prompt" .= imageGenerationConfigPrompt
+      , "model" .= imageGenerationConfigModel
+      , "provider" .= imageGenerationConfigProvider
+      , "response_format" .= imageGenerationConfigResponseFormat
+      , "api_key" .= imageGenerationConfigApiKey
+      , "proxy" .= imageGenerationConfigProxy
+      , "width" .= imageGenerationConfigWidth
+      , "height" .= imageGenerationConfigHeight
+      , "num_inference_steps" .= imageGenerationConfigNumInferenceSteps
+      , "seed" .= imageGenerationConfigSeed
+      , "guidance_scale" .= imageGenerationConfigGuidanceScale
+      , "aspect_ratio" .= imageGenerationConfigAspectRatio
+      , "n" .= imageGenerationConfigN
+      , "negative_prompt" .= imageGenerationConfigNegativePrompt
+      , "resolution" .= imageGenerationConfigResolution
+      , "audio" .= imageGenerationConfigAudio
+      , "download_media" .= imageGenerationConfigDownloadMedia
+      ]
+
+
+-- | Construct a value of type 'ImageGenerationConfig' (by applying it's required fields, if any)
+mkImageGenerationConfig
+  :: Text -- ^ 'imageGenerationConfigPrompt' 
+  -> ImageGenerationConfig
+mkImageGenerationConfig imageGenerationConfigPrompt =
+  ImageGenerationConfig
+  { imageGenerationConfigPrompt
+  , imageGenerationConfigModel = Nothing
+  , imageGenerationConfigProvider = Nothing
+  , imageGenerationConfigResponseFormat = Nothing
+  , imageGenerationConfigApiKey = Nothing
+  , imageGenerationConfigProxy = Nothing
+  , imageGenerationConfigWidth = Nothing
+  , imageGenerationConfigHeight = Nothing
+  , imageGenerationConfigNumInferenceSteps = Nothing
+  , imageGenerationConfigSeed = Nothing
+  , imageGenerationConfigGuidanceScale = Nothing
+  , imageGenerationConfigAspectRatio = Nothing
+  , imageGenerationConfigN = Nothing
+  , imageGenerationConfigNegativePrompt = Nothing
+  , imageGenerationConfigResolution = Nothing
+  , imageGenerationConfigAudio = Nothing
+  , imageGenerationConfigDownloadMedia = Nothing
+  }
+
+-- ** ImagesResponse
+-- | ImagesResponse
+-- ImagesResponse
+-- 
+data ImagesResponse = ImagesResponse
+  { imagesResponseData :: !([Image]) -- ^ /Required/ "data"
+  , imagesResponseModel :: !(Text) -- ^ /Required/ "model"
+  , imagesResponseProvider :: !(Text) -- ^ /Required/ "provider"
+  , imagesResponseCreated :: !(Int) -- ^ /Required/ "created"
+  } deriving (P.Show, P.Eq, P.Typeable)
+
+-- | FromJSON ImagesResponse
+instance A.FromJSON ImagesResponse where
+  parseJSON = A.withObject "ImagesResponse" $ \o ->
+    ImagesResponse
+      <$> (o .:  "data")
+      <*> (o .:  "model")
+      <*> (o .:  "provider")
+      <*> (o .:  "created")
+
+-- | ToJSON ImagesResponse
+instance A.ToJSON ImagesResponse where
+  toJSON ImagesResponse {..} =
+   _omitNulls
+      [ "data" .= imagesResponseData
+      , "model" .= imagesResponseModel
+      , "provider" .= imagesResponseProvider
+      , "created" .= imagesResponseCreated
+      ]
+
+
+-- | Construct a value of type 'ImagesResponse' (by applying it's required fields, if any)
+mkImagesResponse
+  :: [Image] -- ^ 'imagesResponseData' 
+  -> Text -- ^ 'imagesResponseModel' 
+  -> Text -- ^ 'imagesResponseProvider' 
+  -> Int -- ^ 'imagesResponseCreated' 
+  -> ImagesResponse
+mkImagesResponse imagesResponseData imagesResponseModel imagesResponseProvider imagesResponseCreated =
+  ImagesResponse
+  { imagesResponseData
+  , imagesResponseModel
+  , imagesResponseProvider
+  , imagesResponseCreated
+  }
+
+-- ** Message
+-- | Message
+-- Message
+-- 
+data Message = Message
+  { messageRole :: !(Text) -- ^ /Required/ "role"
+  , messageContent :: !(Content) -- ^ /Required/ "content"
+  } deriving (P.Show, P.Eq, P.Typeable)
+
+-- | FromJSON Message
+instance A.FromJSON Message where
+  parseJSON = A.withObject "Message" $ \o ->
+    Message
+      <$> (o .:  "role")
+      <*> (o .:  "content")
+
+-- | ToJSON Message
+instance A.ToJSON Message where
+  toJSON Message {..} =
+   _omitNulls
+      [ "role" .= messageRole
+      , "content" .= messageContent
+      ]
+
+
+-- | Construct a value of type 'Message' (by applying it's required fields, if any)
+mkMessage
+  :: Text -- ^ 'messageRole' 
+  -> Content -- ^ 'messageContent' 
+  -> Message
+mkMessage messageRole messageContent =
+  Message
+  { messageRole
+  , messageContent
+  }
+
+-- ** ModelResponseModel
+-- | ModelResponseModel
+-- ModelResponseModel
+-- 
+data ModelResponseModel = ModelResponseModel
+  { modelResponseModelId :: !(Text) -- ^ /Required/ "id"
+  , modelResponseModelObject :: !(Maybe Text) -- ^ "object"
+  , modelResponseModelCreated :: !(Int) -- ^ /Required/ "created"
+  , modelResponseModelOwnedBy :: !(Text) -- ^ /Required/ "owned_by"
+  } deriving (P.Show, P.Eq, P.Typeable)
+
+-- | FromJSON ModelResponseModel
+instance A.FromJSON ModelResponseModel where
+  parseJSON = A.withObject "ModelResponseModel" $ \o ->
+    ModelResponseModel
+      <$> (o .:  "id")
+      <*> (o .:? "object")
+      <*> (o .:  "created")
+      <*> (o .:  "owned_by")
+
+-- | ToJSON ModelResponseModel
+instance A.ToJSON ModelResponseModel where
+  toJSON ModelResponseModel {..} =
+   _omitNulls
+      [ "id" .= modelResponseModelId
+      , "object" .= modelResponseModelObject
+      , "created" .= modelResponseModelCreated
+      , "owned_by" .= modelResponseModelOwnedBy
+      ]
+
+
+-- | Construct a value of type 'ModelResponseModel' (by applying it's required fields, if any)
+mkModelResponseModel
+  :: Text -- ^ 'modelResponseModelId' 
+  -> Int -- ^ 'modelResponseModelCreated' 
+  -> Text -- ^ 'modelResponseModelOwnedBy' 
+  -> ModelResponseModel
+mkModelResponseModel modelResponseModelId modelResponseModelCreated modelResponseModelOwnedBy =
+  ModelResponseModel
+  { modelResponseModelId
+  , modelResponseModelObject = Nothing
+  , modelResponseModelCreated
+  , modelResponseModelOwnedBy
+  }
+
+-- ** PromptTokenDetails
+-- | PromptTokenDetails
+-- PromptTokenDetails
+-- 
+data PromptTokenDetails = PromptTokenDetails
+  { promptTokenDetailsCachedTokens :: !(Int) -- ^ /Required/ "cached_tokens"
+  , promptTokenDetailsAudioTokens :: !(Int) -- ^ /Required/ "audio_tokens"
+  } deriving (P.Show, P.Eq, P.Typeable)
+
+-- | FromJSON PromptTokenDetails
+instance A.FromJSON PromptTokenDetails where
+  parseJSON = A.withObject "PromptTokenDetails" $ \o ->
+    PromptTokenDetails
+      <$> (o .:  "cached_tokens")
+      <*> (o .:  "audio_tokens")
+
+-- | ToJSON PromptTokenDetails
+instance A.ToJSON PromptTokenDetails where
+  toJSON PromptTokenDetails {..} =
+   _omitNulls
+      [ "cached_tokens" .= promptTokenDetailsCachedTokens
+      , "audio_tokens" .= promptTokenDetailsAudioTokens
+      ]
+
+
+-- | Construct a value of type 'PromptTokenDetails' (by applying it's required fields, if any)
+mkPromptTokenDetails
+  :: Int -- ^ 'promptTokenDetailsCachedTokens' 
+  -> Int -- ^ 'promptTokenDetailsAudioTokens' 
+  -> PromptTokenDetails
+mkPromptTokenDetails promptTokenDetailsCachedTokens promptTokenDetailsAudioTokens =
+  PromptTokenDetails
+  { promptTokenDetailsCachedTokens
+  , promptTokenDetailsAudioTokens
+  }
+
+-- ** ProviderResponseDetailModel
+-- | ProviderResponseDetailModel
+-- ProviderResponseDetailModel
+-- 
+data ProviderResponseDetailModel = ProviderResponseDetailModel
+  { providerResponseDetailModelId :: !(Text) -- ^ /Required/ "id"
+  , providerResponseDetailModelObject :: !(Maybe Text) -- ^ "object"
+  , providerResponseDetailModelCreated :: !(Int) -- ^ /Required/ "created"
+  , providerResponseDetailModelUrl :: !(Text) -- ^ /Required/ "url"
+  , providerResponseDetailModelLabel :: !(Text) -- ^ /Required/ "label"
+  , providerResponseDetailModelModels :: !([Text]) -- ^ /Required/ "models"
+  , providerResponseDetailModelImageModels :: !([Text]) -- ^ /Required/ "image_models"
+  , providerResponseDetailModelVisionModels :: !([Text]) -- ^ /Required/ "vision_models"
+  , providerResponseDetailModelParams :: !([Text]) -- ^ /Required/ "params"
+  } deriving (P.Show, P.Eq, P.Typeable)
+
+-- | FromJSON ProviderResponseDetailModel
+instance A.FromJSON ProviderResponseDetailModel where
+  parseJSON = A.withObject "ProviderResponseDetailModel" $ \o ->
+    ProviderResponseDetailModel
+      <$> (o .:  "id")
+      <*> (o .:? "object")
+      <*> (o .:  "created")
+      <*> (o .:  "url")
+      <*> (o .:  "label")
+      <*> (o .:  "models")
+      <*> (o .:  "image_models")
+      <*> (o .:  "vision_models")
+      <*> (o .:  "params")
+
+-- | ToJSON ProviderResponseDetailModel
+instance A.ToJSON ProviderResponseDetailModel where
+  toJSON ProviderResponseDetailModel {..} =
+   _omitNulls
+      [ "id" .= providerResponseDetailModelId
+      , "object" .= providerResponseDetailModelObject
+      , "created" .= providerResponseDetailModelCreated
+      , "url" .= providerResponseDetailModelUrl
+      , "label" .= providerResponseDetailModelLabel
+      , "models" .= providerResponseDetailModelModels
+      , "image_models" .= providerResponseDetailModelImageModels
+      , "vision_models" .= providerResponseDetailModelVisionModels
+      , "params" .= providerResponseDetailModelParams
+      ]
+
+
+-- | Construct a value of type 'ProviderResponseDetailModel' (by applying it's required fields, if any)
+mkProviderResponseDetailModel
+  :: Text -- ^ 'providerResponseDetailModelId' 
+  -> Int -- ^ 'providerResponseDetailModelCreated' 
+  -> Text -- ^ 'providerResponseDetailModelUrl' 
+  -> Text -- ^ 'providerResponseDetailModelLabel' 
+  -> [Text] -- ^ 'providerResponseDetailModelModels' 
+  -> [Text] -- ^ 'providerResponseDetailModelImageModels' 
+  -> [Text] -- ^ 'providerResponseDetailModelVisionModels' 
+  -> [Text] -- ^ 'providerResponseDetailModelParams' 
+  -> ProviderResponseDetailModel
+mkProviderResponseDetailModel providerResponseDetailModelId providerResponseDetailModelCreated providerResponseDetailModelUrl providerResponseDetailModelLabel providerResponseDetailModelModels providerResponseDetailModelImageModels providerResponseDetailModelVisionModels providerResponseDetailModelParams =
+  ProviderResponseDetailModel
+  { providerResponseDetailModelId
+  , providerResponseDetailModelObject = Nothing
+  , providerResponseDetailModelCreated
+  , providerResponseDetailModelUrl
+  , providerResponseDetailModelLabel
+  , providerResponseDetailModelModels
+  , providerResponseDetailModelImageModels
+  , providerResponseDetailModelVisionModels
+  , providerResponseDetailModelParams
+  }
+
+-- ** ProviderResponseModel
+-- | ProviderResponseModel
+-- ProviderResponseModel
+-- 
+data ProviderResponseModel = ProviderResponseModel
+  { providerResponseModelId :: !(Text) -- ^ /Required/ "id"
+  , providerResponseModelObject :: !(Maybe Text) -- ^ "object"
+  , providerResponseModelCreated :: !(Int) -- ^ /Required/ "created"
+  , providerResponseModelUrl :: !(Text) -- ^ /Required/ "url"
+  , providerResponseModelLabel :: !(Text) -- ^ /Required/ "label"
+  } deriving (P.Show, P.Eq, P.Typeable)
+
+-- | FromJSON ProviderResponseModel
+instance A.FromJSON ProviderResponseModel where
+  parseJSON = A.withObject "ProviderResponseModel" $ \o ->
+    ProviderResponseModel
+      <$> (o .:  "id")
+      <*> (o .:? "object")
+      <*> (o .:  "created")
+      <*> (o .:  "url")
+      <*> (o .:  "label")
+
+-- | ToJSON ProviderResponseModel
+instance A.ToJSON ProviderResponseModel where
+  toJSON ProviderResponseModel {..} =
+   _omitNulls
+      [ "id" .= providerResponseModelId
+      , "object" .= providerResponseModelObject
+      , "created" .= providerResponseModelCreated
+      , "url" .= providerResponseModelUrl
+      , "label" .= providerResponseModelLabel
+      ]
+
+
+-- | Construct a value of type 'ProviderResponseModel' (by applying it's required fields, if any)
+mkProviderResponseModel
+  :: Text -- ^ 'providerResponseModelId' 
+  -> Int -- ^ 'providerResponseModelCreated' 
+  -> Text -- ^ 'providerResponseModelUrl' 
+  -> Text -- ^ 'providerResponseModelLabel' 
+  -> ProviderResponseModel
+mkProviderResponseModel providerResponseModelId providerResponseModelCreated providerResponseModelUrl providerResponseModelLabel =
+  ProviderResponseModel
+  { providerResponseModelId
+  , providerResponseModelObject = Nothing
+  , providerResponseModelCreated
+  , providerResponseModelUrl
+  , providerResponseModelLabel
+  }
+
+-- ** Stop
+-- | Stop
+-- Stop
+-- 
+data Stop = Stop
+  { 
+  } deriving (P.Show, P.Eq, P.Typeable)
+
+-- | FromJSON Stop
+instance A.FromJSON Stop where
+  parseJSON = A.withObject "Stop" $ \o ->
+    pure Stop
+      
+
+-- | ToJSON Stop
+instance A.ToJSON Stop where
+  toJSON Stop  =
+   _omitNulls
+      [ 
+      ]
+
+
+-- | Construct a value of type 'Stop' (by applying it's required fields, if any)
+mkStop
+  :: Stop
+mkStop =
+  Stop
+  { 
+  }
+
+-- ** ToolCallModel
+-- | ToolCallModel
+-- ToolCallModel
+-- 
+data ToolCallModel = ToolCallModel
+  { toolCallModelId :: !(Text) -- ^ /Required/ "id"
+  , toolCallModelType :: !(Text) -- ^ /Required/ "type"
+  , toolCallModelFunction :: !(ToolFunctionModel) -- ^ /Required/ "function"
+  } deriving (P.Show, P.Eq, P.Typeable)
+
+-- | FromJSON ToolCallModel
+instance A.FromJSON ToolCallModel where
+  parseJSON = A.withObject "ToolCallModel" $ \o ->
+    ToolCallModel
+      <$> (o .:  "id")
+      <*> (o .:  "type")
+      <*> (o .:  "function")
+
+-- | ToJSON ToolCallModel
+instance A.ToJSON ToolCallModel where
+  toJSON ToolCallModel {..} =
+   _omitNulls
+      [ "id" .= toolCallModelId
+      , "type" .= toolCallModelType
+      , "function" .= toolCallModelFunction
+      ]
+
+
+-- | Construct a value of type 'ToolCallModel' (by applying it's required fields, if any)
+mkToolCallModel
+  :: Text -- ^ 'toolCallModelId' 
+  -> Text -- ^ 'toolCallModelType' 
+  -> ToolFunctionModel -- ^ 'toolCallModelFunction' 
+  -> ToolCallModel
+mkToolCallModel toolCallModelId toolCallModelType toolCallModelFunction =
+  ToolCallModel
+  { toolCallModelId
+  , toolCallModelType
+  , toolCallModelFunction
+  }
+
+-- ** ToolFunctionModel
+-- | ToolFunctionModel
+-- ToolFunctionModel
+-- 
+data ToolFunctionModel = ToolFunctionModel
+  { toolFunctionModelName :: !(Text) -- ^ /Required/ "name"
+  , toolFunctionModelArguments :: !(Text) -- ^ /Required/ "arguments"
+  } deriving (P.Show, P.Eq, P.Typeable)
+
+-- | FromJSON ToolFunctionModel
+instance A.FromJSON ToolFunctionModel where
+  parseJSON = A.withObject "ToolFunctionModel" $ \o ->
+    ToolFunctionModel
+      <$> (o .:  "name")
+      <*> (o .:  "arguments")
+
+-- | ToJSON ToolFunctionModel
+instance A.ToJSON ToolFunctionModel where
+  toJSON ToolFunctionModel {..} =
+   _omitNulls
+      [ "name" .= toolFunctionModelName
+      , "arguments" .= toolFunctionModelArguments
+      ]
+
+
+-- | Construct a value of type 'ToolFunctionModel' (by applying it's required fields, if any)
+mkToolFunctionModel
+  :: Text -- ^ 'toolFunctionModelName' 
+  -> Text -- ^ 'toolFunctionModelArguments' 
+  -> ToolFunctionModel
+mkToolFunctionModel toolFunctionModelName toolFunctionModelArguments =
+  ToolFunctionModel
+  { toolFunctionModelName
+  , toolFunctionModelArguments
+  }
+
+-- ** TranscriptionResponseModel
+-- | TranscriptionResponseModel
+-- TranscriptionResponseModel
+-- 
+data TranscriptionResponseModel = TranscriptionResponseModel
+  { transcriptionResponseModelText :: !(Text) -- ^ /Required/ "text"
+  , transcriptionResponseModelModel :: !(Text) -- ^ /Required/ "model"
+  , transcriptionResponseModelProvider :: !(Text) -- ^ /Required/ "provider"
+  } deriving (P.Show, P.Eq, P.Typeable)
+
+-- | FromJSON TranscriptionResponseModel
+instance A.FromJSON TranscriptionResponseModel where
+  parseJSON = A.withObject "TranscriptionResponseModel" $ \o ->
+    TranscriptionResponseModel
+      <$> (o .:  "text")
+      <*> (o .:  "model")
+      <*> (o .:  "provider")
+
+-- | ToJSON TranscriptionResponseModel
+instance A.ToJSON TranscriptionResponseModel where
+  toJSON TranscriptionResponseModel {..} =
+   _omitNulls
+      [ "text" .= transcriptionResponseModelText
+      , "model" .= transcriptionResponseModelModel
+      , "provider" .= transcriptionResponseModelProvider
+      ]
+
+
+-- | Construct a value of type 'TranscriptionResponseModel' (by applying it's required fields, if any)
+mkTranscriptionResponseModel
+  :: Text -- ^ 'transcriptionResponseModelText' 
+  -> Text -- ^ 'transcriptionResponseModelModel' 
+  -> Text -- ^ 'transcriptionResponseModelProvider' 
+  -> TranscriptionResponseModel
+mkTranscriptionResponseModel transcriptionResponseModelText transcriptionResponseModelModel transcriptionResponseModelProvider =
+  TranscriptionResponseModel
+  { transcriptionResponseModelText
+  , transcriptionResponseModelModel
+  , transcriptionResponseModelProvider
+  }
+
+-- ** UsageModel
+-- | UsageModel
+-- UsageModel
+-- 
+data UsageModel = UsageModel
+  { usageModelPromptTokens :: !(Int) -- ^ /Required/ "prompt_tokens"
+  , usageModelCompletionTokens :: !(Int) -- ^ /Required/ "completion_tokens"
+  , usageModelTotalTokens :: !(Int) -- ^ /Required/ "total_tokens"
+  , usageModelPromptTokensDetails :: !(PromptTokenDetails) -- ^ /Required/ "prompt_tokens_details"
+  , usageModelCompletionTokensDetails :: !(CompletionTokenDetails) -- ^ /Required/ "completion_tokens_details"
+  , usageModelCache :: !(Maybe Text) -- ^ "cache"
+  } deriving (P.Show, P.Eq, P.Typeable)
+
+-- | FromJSON UsageModel
+instance A.FromJSON UsageModel where
+  parseJSON = A.withObject "UsageModel" $ \o ->
+    UsageModel
+      <$> (o .:  "prompt_tokens")
+      <*> (o .:  "completion_tokens")
+      <*> (o .:  "total_tokens")
+      <*> (o .:  "prompt_tokens_details")
+      <*> (o .:  "completion_tokens_details")
+      <*> (o .:? "cache")
+
+-- | ToJSON UsageModel
+instance A.ToJSON UsageModel where
+  toJSON UsageModel {..} =
+   _omitNulls
+      [ "prompt_tokens" .= usageModelPromptTokens
+      , "completion_tokens" .= usageModelCompletionTokens
+      , "total_tokens" .= usageModelTotalTokens
+      , "prompt_tokens_details" .= usageModelPromptTokensDetails
+      , "completion_tokens_details" .= usageModelCompletionTokensDetails
+      , "cache" .= usageModelCache
+      ]
+
+
+-- | Construct a value of type 'UsageModel' (by applying it's required fields, if any)
+mkUsageModel
+  :: Int -- ^ 'usageModelPromptTokens' 
+  -> Int -- ^ 'usageModelCompletionTokens' 
+  -> Int -- ^ 'usageModelTotalTokens' 
+  -> PromptTokenDetails -- ^ 'usageModelPromptTokensDetails' 
+  -> CompletionTokenDetails -- ^ 'usageModelCompletionTokensDetails' 
+  -> UsageModel
+mkUsageModel usageModelPromptTokens usageModelCompletionTokens usageModelTotalTokens usageModelPromptTokensDetails usageModelCompletionTokensDetails =
+  UsageModel
+  { usageModelPromptTokens
+  , usageModelCompletionTokens
+  , usageModelTotalTokens
+  , usageModelPromptTokensDetails
+  , usageModelCompletionTokensDetails
+  , usageModelCache = Nothing
+  }
+
+-- ** ValidationError
+-- | ValidationError
+-- ValidationError
+-- 
+data ValidationError = ValidationError
+  { validationErrorLoc :: !([ValidationErrorLocInner]) -- ^ /Required/ "loc"
+  , validationErrorMsg :: !(Text) -- ^ /Required/ "msg"
+  , validationErrorType :: !(Text) -- ^ /Required/ "type"
+  , validationErrorInput :: !(AnyType) -- ^ /Required/ "input"
+  , validationErrorCtx :: !(AnyType) -- ^ /Required/ "ctx"
+  } deriving (P.Show, P.Eq, P.Typeable)
+
+-- | FromJSON ValidationError
+instance A.FromJSON ValidationError where
+  parseJSON = A.withObject "ValidationError" $ \o ->
+    ValidationError
+      <$> (o .:  "loc")
+      <*> (o .:  "msg")
+      <*> (o .:  "type")
+      <*> (o .:  "input")
+      <*> (o .:  "ctx")
+
+-- | ToJSON ValidationError
+instance A.ToJSON ValidationError where
+  toJSON ValidationError {..} =
+   _omitNulls
+      [ "loc" .= validationErrorLoc
+      , "msg" .= validationErrorMsg
+      , "type" .= validationErrorType
+      , "input" .= validationErrorInput
+      , "ctx" .= validationErrorCtx
+      ]
+
+
+-- | Construct a value of type 'ValidationError' (by applying it's required fields, if any)
+mkValidationError
+  :: [ValidationErrorLocInner] -- ^ 'validationErrorLoc' 
+  -> Text -- ^ 'validationErrorMsg' 
+  -> Text -- ^ 'validationErrorType' 
+  -> AnyType -- ^ 'validationErrorInput' 
+  -> AnyType -- ^ 'validationErrorCtx' 
+  -> ValidationError
+mkValidationError validationErrorLoc validationErrorMsg validationErrorType validationErrorInput validationErrorCtx =
+  ValidationError
+  { validationErrorLoc
+  , validationErrorMsg
+  , validationErrorType
+  , validationErrorInput
+  , validationErrorCtx
+  }
+
+-- ** ValidationErrorLocInner
+-- | ValidationErrorLocInner
+data ValidationErrorLocInner = ValidationErrorLocInner
+  { 
+  } deriving (P.Show, P.Eq, P.Typeable)
+
+-- | FromJSON ValidationErrorLocInner
+instance A.FromJSON ValidationErrorLocInner where
+  parseJSON = A.withObject "ValidationErrorLocInner" $ \o ->
+    pure ValidationErrorLocInner
+      
+
+-- | ToJSON ValidationErrorLocInner
+instance A.ToJSON ValidationErrorLocInner where
+  toJSON ValidationErrorLocInner  =
+   _omitNulls
+      [ 
+      ]
+
+
+-- | Construct a value of type 'ValidationErrorLocInner' (by applying it's required fields, if any)
+mkValidationErrorLocInner
+  :: ValidationErrorLocInner
+mkValidationErrorLocInner =
+  ValidationErrorLocInner
+  { 
+  }
+
+
+
+
+-- * Auth Methods
+
+
diff --git a/lib/G4fClient/ModelLens.hs b/lib/G4fClient/ModelLens.hs
new file mode 100644
index 0000000..c138add
--- /dev/null
+++ b/lib/G4fClient/ModelLens.hs
@@ -0,0 +1,858 @@
+{-
+   FastAPI
+
+   No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+   OpenAPI Version: 3.1.0
+   FastAPI API version: 0.1.0
+   Generated by OpenAPI Generator (https://openapi-generator.tech)
+-}
+
+{-|
+Module : G4fClient.Lens
+-}
+
+{-# LANGUAGE KindSignatures #-}
+{-# LANGUAGE NamedFieldPuns #-}
+{-# LANGUAGE RankNTypes #-}
+{-# LANGUAGE RecordWildCards #-}
+{-# OPTIONS_GHC -fno-warn-name-shadowing -fno-warn-unused-matches -fno-warn-unused-binds -fno-warn-unused-imports #-}
+
+module G4fClient.ModelLens where
+
+import qualified Data.Aeson as A
+import qualified Data.ByteString.Lazy as BL
+import qualified Data.Data as P (Data, Typeable)
+import qualified Data.Map as Map
+import qualified Data.Set as Set
+import qualified Data.Time as TI
+
+import Data.Text (Text)
+
+import Prelude (($), (.),(<$>),(<*>),(=<<),Maybe(..),Bool(..),Char,Double,FilePath,Float,Int,Integer,String,fmap,undefined,mempty,maybe,pure,Monad,Applicative,Functor)
+import qualified Prelude as P
+
+import G4fClient.Model
+import G4fClient.Core
+
+
+-- * ApiKey
+
+
+
+-- * AudioResponseModel
+
+-- | 'audioResponseModelData' Lens
+audioResponseModelDataL :: Lens_' AudioResponseModel (Text)
+audioResponseModelDataL f AudioResponseModel{..} = (\audioResponseModelData -> AudioResponseModel { audioResponseModelData, ..} ) <$> f audioResponseModelData
+{-# INLINE audioResponseModelDataL #-}
+
+-- | 'audioResponseModelTranscript' Lens
+audioResponseModelTranscriptL :: Lens_' AudioResponseModel (Maybe Text)
+audioResponseModelTranscriptL f AudioResponseModel{..} = (\audioResponseModelTranscript -> AudioResponseModel { audioResponseModelTranscript, ..} ) <$> f audioResponseModelTranscript
+{-# INLINE audioResponseModelTranscriptL #-}
+
+
+
+-- * AudioSpeechConfig
+
+-- | 'audioSpeechConfigInput' Lens
+audioSpeechConfigInputL :: Lens_' AudioSpeechConfig (Text)
+audioSpeechConfigInputL f AudioSpeechConfig{..} = (\audioSpeechConfigInput -> AudioSpeechConfig { audioSpeechConfigInput, ..} ) <$> f audioSpeechConfigInput
+{-# INLINE audioSpeechConfigInputL #-}
+
+-- | 'audioSpeechConfigModel' Lens
+audioSpeechConfigModelL :: Lens_' AudioSpeechConfig (Maybe Text)
+audioSpeechConfigModelL f AudioSpeechConfig{..} = (\audioSpeechConfigModel -> AudioSpeechConfig { audioSpeechConfigModel, ..} ) <$> f audioSpeechConfigModel
+{-# INLINE audioSpeechConfigModelL #-}
+
+-- | 'audioSpeechConfigProvider' Lens
+audioSpeechConfigProviderL :: Lens_' AudioSpeechConfig (Maybe Text)
+audioSpeechConfigProviderL f AudioSpeechConfig{..} = (\audioSpeechConfigProvider -> AudioSpeechConfig { audioSpeechConfigProvider, ..} ) <$> f audioSpeechConfigProvider
+{-# INLINE audioSpeechConfigProviderL #-}
+
+-- | 'audioSpeechConfigVoice' Lens
+audioSpeechConfigVoiceL :: Lens_' AudioSpeechConfig (Maybe Text)
+audioSpeechConfigVoiceL f AudioSpeechConfig{..} = (\audioSpeechConfigVoice -> AudioSpeechConfig { audioSpeechConfigVoice, ..} ) <$> f audioSpeechConfigVoice
+{-# INLINE audioSpeechConfigVoiceL #-}
+
+-- | 'audioSpeechConfigInstrcutions' Lens
+audioSpeechConfigInstrcutionsL :: Lens_' AudioSpeechConfig (Maybe Text)
+audioSpeechConfigInstrcutionsL f AudioSpeechConfig{..} = (\audioSpeechConfigInstrcutions -> AudioSpeechConfig { audioSpeechConfigInstrcutions, ..} ) <$> f audioSpeechConfigInstrcutions
+{-# INLINE audioSpeechConfigInstrcutionsL #-}
+
+-- | 'audioSpeechConfigResponseFormat' Lens
+audioSpeechConfigResponseFormatL :: Lens_' AudioSpeechConfig (Maybe Text)
+audioSpeechConfigResponseFormatL f AudioSpeechConfig{..} = (\audioSpeechConfigResponseFormat -> AudioSpeechConfig { audioSpeechConfigResponseFormat, ..} ) <$> f audioSpeechConfigResponseFormat
+{-# INLINE audioSpeechConfigResponseFormatL #-}
+
+-- | 'audioSpeechConfigLanguage' Lens
+audioSpeechConfigLanguageL :: Lens_' AudioSpeechConfig (Maybe Text)
+audioSpeechConfigLanguageL f AudioSpeechConfig{..} = (\audioSpeechConfigLanguage -> AudioSpeechConfig { audioSpeechConfigLanguage, ..} ) <$> f audioSpeechConfigLanguage
+{-# INLINE audioSpeechConfigLanguageL #-}
+
+-- | 'audioSpeechConfigDownloadMedia' Lens
+audioSpeechConfigDownloadMediaL :: Lens_' AudioSpeechConfig (Maybe Bool)
+audioSpeechConfigDownloadMediaL f AudioSpeechConfig{..} = (\audioSpeechConfigDownloadMedia -> AudioSpeechConfig { audioSpeechConfigDownloadMedia, ..} ) <$> f audioSpeechConfigDownloadMedia
+{-# INLINE audioSpeechConfigDownloadMediaL #-}
+
+
+
+-- * ChatCompletion
+
+-- | 'chatCompletionId' Lens
+chatCompletionIdL :: Lens_' ChatCompletion (Text)
+chatCompletionIdL f ChatCompletion{..} = (\chatCompletionId -> ChatCompletion { chatCompletionId, ..} ) <$> f chatCompletionId
+{-# INLINE chatCompletionIdL #-}
+
+-- | 'chatCompletionObject' Lens
+chatCompletionObjectL :: Lens_' ChatCompletion (Text)
+chatCompletionObjectL f ChatCompletion{..} = (\chatCompletionObject -> ChatCompletion { chatCompletionObject, ..} ) <$> f chatCompletionObject
+{-# INLINE chatCompletionObjectL #-}
+
+-- | 'chatCompletionCreated' Lens
+chatCompletionCreatedL :: Lens_' ChatCompletion (Int)
+chatCompletionCreatedL f ChatCompletion{..} = (\chatCompletionCreated -> ChatCompletion { chatCompletionCreated, ..} ) <$> f chatCompletionCreated
+{-# INLINE chatCompletionCreatedL #-}
+
+-- | 'chatCompletionModel' Lens
+chatCompletionModelL :: Lens_' ChatCompletion (Text)
+chatCompletionModelL f ChatCompletion{..} = (\chatCompletionModel -> ChatCompletion { chatCompletionModel, ..} ) <$> f chatCompletionModel
+{-# INLINE chatCompletionModelL #-}
+
+-- | 'chatCompletionProvider' Lens
+chatCompletionProviderL :: Lens_' ChatCompletion (Text)
+chatCompletionProviderL f ChatCompletion{..} = (\chatCompletionProvider -> ChatCompletion { chatCompletionProvider, ..} ) <$> f chatCompletionProvider
+{-# INLINE chatCompletionProviderL #-}
+
+-- | 'chatCompletionChoices' Lens
+chatCompletionChoicesL :: Lens_' ChatCompletion ([ChatCompletionChoice])
+chatCompletionChoicesL f ChatCompletion{..} = (\chatCompletionChoices -> ChatCompletion { chatCompletionChoices, ..} ) <$> f chatCompletionChoices
+{-# INLINE chatCompletionChoicesL #-}
+
+-- | 'chatCompletionUsage' Lens
+chatCompletionUsageL :: Lens_' ChatCompletion (UsageModel)
+chatCompletionUsageL f ChatCompletion{..} = (\chatCompletionUsage -> ChatCompletion { chatCompletionUsage, ..} ) <$> f chatCompletionUsage
+{-# INLINE chatCompletionUsageL #-}
+
+-- | 'chatCompletionConversation' Lens
+chatCompletionConversationL :: Lens_' ChatCompletion ((Map.Map String AnyType))
+chatCompletionConversationL f ChatCompletion{..} = (\chatCompletionConversation -> ChatCompletion { chatCompletionConversation, ..} ) <$> f chatCompletionConversation
+{-# INLINE chatCompletionConversationL #-}
+
+
+
+-- * ChatCompletionChoice
+
+-- | 'chatCompletionChoiceIndex' Lens
+chatCompletionChoiceIndexL :: Lens_' ChatCompletionChoice (Int)
+chatCompletionChoiceIndexL f ChatCompletionChoice{..} = (\chatCompletionChoiceIndex -> ChatCompletionChoice { chatCompletionChoiceIndex, ..} ) <$> f chatCompletionChoiceIndex
+{-# INLINE chatCompletionChoiceIndexL #-}
+
+-- | 'chatCompletionChoiceMessage' Lens
+chatCompletionChoiceMessageL :: Lens_' ChatCompletionChoice (ChatCompletionMessage)
+chatCompletionChoiceMessageL f ChatCompletionChoice{..} = (\chatCompletionChoiceMessage -> ChatCompletionChoice { chatCompletionChoiceMessage, ..} ) <$> f chatCompletionChoiceMessage
+{-# INLINE chatCompletionChoiceMessageL #-}
+
+-- | 'chatCompletionChoiceFinishReason' Lens
+chatCompletionChoiceFinishReasonL :: Lens_' ChatCompletionChoice (Text)
+chatCompletionChoiceFinishReasonL f ChatCompletionChoice{..} = (\chatCompletionChoiceFinishReason -> ChatCompletionChoice { chatCompletionChoiceFinishReason, ..} ) <$> f chatCompletionChoiceFinishReason
+{-# INLINE chatCompletionChoiceFinishReasonL #-}
+
+
+
+-- * ChatCompletionMessage
+
+-- | 'chatCompletionMessageRole' Lens
+chatCompletionMessageRoleL :: Lens_' ChatCompletionMessage (Text)
+chatCompletionMessageRoleL f ChatCompletionMessage{..} = (\chatCompletionMessageRole -> ChatCompletionMessage { chatCompletionMessageRole, ..} ) <$> f chatCompletionMessageRole
+{-# INLINE chatCompletionMessageRoleL #-}
+
+-- | 'chatCompletionMessageContent' Lens
+chatCompletionMessageContentL :: Lens_' ChatCompletionMessage (Text)
+chatCompletionMessageContentL f ChatCompletionMessage{..} = (\chatCompletionMessageContent -> ChatCompletionMessage { chatCompletionMessageContent, ..} ) <$> f chatCompletionMessageContent
+{-# INLINE chatCompletionMessageContentL #-}
+
+-- | 'chatCompletionMessageReasoning' Lens
+chatCompletionMessageReasoningL :: Lens_' ChatCompletionMessage (Maybe Text)
+chatCompletionMessageReasoningL f ChatCompletionMessage{..} = (\chatCompletionMessageReasoning -> ChatCompletionMessage { chatCompletionMessageReasoning, ..} ) <$> f chatCompletionMessageReasoning
+{-# INLINE chatCompletionMessageReasoningL #-}
+
+-- | 'chatCompletionMessageToolCalls' Lens
+chatCompletionMessageToolCallsL :: Lens_' ChatCompletionMessage (Maybe [ToolCallModel])
+chatCompletionMessageToolCallsL f ChatCompletionMessage{..} = (\chatCompletionMessageToolCalls -> ChatCompletionMessage { chatCompletionMessageToolCalls, ..} ) <$> f chatCompletionMessageToolCalls
+{-# INLINE chatCompletionMessageToolCallsL #-}
+
+-- | 'chatCompletionMessageAudio' Lens
+chatCompletionMessageAudioL :: Lens_' ChatCompletionMessage (Maybe AudioResponseModel)
+chatCompletionMessageAudioL f ChatCompletionMessage{..} = (\chatCompletionMessageAudio -> ChatCompletionMessage { chatCompletionMessageAudio, ..} ) <$> f chatCompletionMessageAudio
+{-# INLINE chatCompletionMessageAudioL #-}
+
+
+
+-- * ChatCompletionsConfig
+
+-- | 'chatCompletionsConfigModel' Lens
+chatCompletionsConfigModelL :: Lens_' ChatCompletionsConfig (Maybe Text)
+chatCompletionsConfigModelL f ChatCompletionsConfig{..} = (\chatCompletionsConfigModel -> ChatCompletionsConfig { chatCompletionsConfigModel, ..} ) <$> f chatCompletionsConfigModel
+{-# INLINE chatCompletionsConfigModelL #-}
+
+-- | 'chatCompletionsConfigProvider' Lens
+chatCompletionsConfigProviderL :: Lens_' ChatCompletionsConfig (Maybe Text)
+chatCompletionsConfigProviderL f ChatCompletionsConfig{..} = (\chatCompletionsConfigProvider -> ChatCompletionsConfig { chatCompletionsConfigProvider, ..} ) <$> f chatCompletionsConfigProvider
+{-# INLINE chatCompletionsConfigProviderL #-}
+
+-- | 'chatCompletionsConfigMedia' Lens
+chatCompletionsConfigMediaL :: Lens_' ChatCompletionsConfig (Maybe [[AnyType]])
+chatCompletionsConfigMediaL f ChatCompletionsConfig{..} = (\chatCompletionsConfigMedia -> ChatCompletionsConfig { chatCompletionsConfigMedia, ..} ) <$> f chatCompletionsConfigMedia
+{-# INLINE chatCompletionsConfigMediaL #-}
+
+-- | 'chatCompletionsConfigModalities' Lens
+chatCompletionsConfigModalitiesL :: Lens_' ChatCompletionsConfig (Maybe [Text])
+chatCompletionsConfigModalitiesL f ChatCompletionsConfig{..} = (\chatCompletionsConfigModalities -> ChatCompletionsConfig { chatCompletionsConfigModalities, ..} ) <$> f chatCompletionsConfigModalities
+{-# INLINE chatCompletionsConfigModalitiesL #-}
+
+-- | 'chatCompletionsConfigTemperature' Lens
+chatCompletionsConfigTemperatureL :: Lens_' ChatCompletionsConfig (Maybe Double)
+chatCompletionsConfigTemperatureL f ChatCompletionsConfig{..} = (\chatCompletionsConfigTemperature -> ChatCompletionsConfig { chatCompletionsConfigTemperature, ..} ) <$> f chatCompletionsConfigTemperature
+{-# INLINE chatCompletionsConfigTemperatureL #-}
+
+-- | 'chatCompletionsConfigPresencePenalty' Lens
+chatCompletionsConfigPresencePenaltyL :: Lens_' ChatCompletionsConfig (Maybe Double)
+chatCompletionsConfigPresencePenaltyL f ChatCompletionsConfig{..} = (\chatCompletionsConfigPresencePenalty -> ChatCompletionsConfig { chatCompletionsConfigPresencePenalty, ..} ) <$> f chatCompletionsConfigPresencePenalty
+{-# INLINE chatCompletionsConfigPresencePenaltyL #-}
+
+-- | 'chatCompletionsConfigFrequencyPenalty' Lens
+chatCompletionsConfigFrequencyPenaltyL :: Lens_' ChatCompletionsConfig (Maybe Double)
+chatCompletionsConfigFrequencyPenaltyL f ChatCompletionsConfig{..} = (\chatCompletionsConfigFrequencyPenalty -> ChatCompletionsConfig { chatCompletionsConfigFrequencyPenalty, ..} ) <$> f chatCompletionsConfigFrequencyPenalty
+{-# INLINE chatCompletionsConfigFrequencyPenaltyL #-}
+
+-- | 'chatCompletionsConfigTopP' Lens
+chatCompletionsConfigTopPL :: Lens_' ChatCompletionsConfig (Maybe Double)
+chatCompletionsConfigTopPL f ChatCompletionsConfig{..} = (\chatCompletionsConfigTopP -> ChatCompletionsConfig { chatCompletionsConfigTopP, ..} ) <$> f chatCompletionsConfigTopP
+{-# INLINE chatCompletionsConfigTopPL #-}
+
+-- | 'chatCompletionsConfigMaxTokens' Lens
+chatCompletionsConfigMaxTokensL :: Lens_' ChatCompletionsConfig (Maybe Int)
+chatCompletionsConfigMaxTokensL f ChatCompletionsConfig{..} = (\chatCompletionsConfigMaxTokens -> ChatCompletionsConfig { chatCompletionsConfigMaxTokens, ..} ) <$> f chatCompletionsConfigMaxTokens
+{-# INLINE chatCompletionsConfigMaxTokensL #-}
+
+-- | 'chatCompletionsConfigStop' Lens
+chatCompletionsConfigStopL :: Lens_' ChatCompletionsConfig (Maybe Stop)
+chatCompletionsConfigStopL f ChatCompletionsConfig{..} = (\chatCompletionsConfigStop -> ChatCompletionsConfig { chatCompletionsConfigStop, ..} ) <$> f chatCompletionsConfigStop
+{-# INLINE chatCompletionsConfigStopL #-}
+
+-- | 'chatCompletionsConfigApiKey' Lens
+chatCompletionsConfigApiKeyL :: Lens_' ChatCompletionsConfig (Maybe ApiKey)
+chatCompletionsConfigApiKeyL f ChatCompletionsConfig{..} = (\chatCompletionsConfigApiKey -> ChatCompletionsConfig { chatCompletionsConfigApiKey, ..} ) <$> f chatCompletionsConfigApiKey
+{-# INLINE chatCompletionsConfigApiKeyL #-}
+
+-- | 'chatCompletionsConfigBaseUrl' Lens
+chatCompletionsConfigBaseUrlL :: Lens_' ChatCompletionsConfig (Maybe Text)
+chatCompletionsConfigBaseUrlL f ChatCompletionsConfig{..} = (\chatCompletionsConfigBaseUrl -> ChatCompletionsConfig { chatCompletionsConfigBaseUrl, ..} ) <$> f chatCompletionsConfigBaseUrl
+{-# INLINE chatCompletionsConfigBaseUrlL #-}
+
+-- | 'chatCompletionsConfigWebSearch' Lens
+chatCompletionsConfigWebSearchL :: Lens_' ChatCompletionsConfig (Maybe Bool)
+chatCompletionsConfigWebSearchL f ChatCompletionsConfig{..} = (\chatCompletionsConfigWebSearch -> ChatCompletionsConfig { chatCompletionsConfigWebSearch, ..} ) <$> f chatCompletionsConfigWebSearch
+{-# INLINE chatCompletionsConfigWebSearchL #-}
+
+-- | 'chatCompletionsConfigProxy' Lens
+chatCompletionsConfigProxyL :: Lens_' ChatCompletionsConfig (Maybe Text)
+chatCompletionsConfigProxyL f ChatCompletionsConfig{..} = (\chatCompletionsConfigProxy -> ChatCompletionsConfig { chatCompletionsConfigProxy, ..} ) <$> f chatCompletionsConfigProxy
+{-# INLINE chatCompletionsConfigProxyL #-}
+
+-- | 'chatCompletionsConfigConversation' Lens
+chatCompletionsConfigConversationL :: Lens_' ChatCompletionsConfig (Maybe (Map.Map String AnyType))
+chatCompletionsConfigConversationL f ChatCompletionsConfig{..} = (\chatCompletionsConfigConversation -> ChatCompletionsConfig { chatCompletionsConfigConversation, ..} ) <$> f chatCompletionsConfigConversation
+{-# INLINE chatCompletionsConfigConversationL #-}
+
+-- | 'chatCompletionsConfigTimeout' Lens
+chatCompletionsConfigTimeoutL :: Lens_' ChatCompletionsConfig (Maybe Int)
+chatCompletionsConfigTimeoutL f ChatCompletionsConfig{..} = (\chatCompletionsConfigTimeout -> ChatCompletionsConfig { chatCompletionsConfigTimeout, ..} ) <$> f chatCompletionsConfigTimeout
+{-# INLINE chatCompletionsConfigTimeoutL #-}
+
+-- | 'chatCompletionsConfigStreamTimeout' Lens
+chatCompletionsConfigStreamTimeoutL :: Lens_' ChatCompletionsConfig (Maybe Int)
+chatCompletionsConfigStreamTimeoutL f ChatCompletionsConfig{..} = (\chatCompletionsConfigStreamTimeout -> ChatCompletionsConfig { chatCompletionsConfigStreamTimeout, ..} ) <$> f chatCompletionsConfigStreamTimeout
+{-# INLINE chatCompletionsConfigStreamTimeoutL #-}
+
+-- | 'chatCompletionsConfigToolCalls' Lens
+chatCompletionsConfigToolCallsL :: Lens_' ChatCompletionsConfig (Maybe [AnyType])
+chatCompletionsConfigToolCallsL f ChatCompletionsConfig{..} = (\chatCompletionsConfigToolCalls -> ChatCompletionsConfig { chatCompletionsConfigToolCalls, ..} ) <$> f chatCompletionsConfigToolCalls
+{-# INLINE chatCompletionsConfigToolCallsL #-}
+
+-- | 'chatCompletionsConfigReasoningEffort' Lens
+chatCompletionsConfigReasoningEffortL :: Lens_' ChatCompletionsConfig (Maybe Text)
+chatCompletionsConfigReasoningEffortL f ChatCompletionsConfig{..} = (\chatCompletionsConfigReasoningEffort -> ChatCompletionsConfig { chatCompletionsConfigReasoningEffort, ..} ) <$> f chatCompletionsConfigReasoningEffort
+{-# INLINE chatCompletionsConfigReasoningEffortL #-}
+
+-- | 'chatCompletionsConfigLogitBias' Lens
+chatCompletionsConfigLogitBiasL :: Lens_' ChatCompletionsConfig (Maybe (Map.Map String AnyType))
+chatCompletionsConfigLogitBiasL f ChatCompletionsConfig{..} = (\chatCompletionsConfigLogitBias -> ChatCompletionsConfig { chatCompletionsConfigLogitBias, ..} ) <$> f chatCompletionsConfigLogitBias
+{-# INLINE chatCompletionsConfigLogitBiasL #-}
+
+-- | 'chatCompletionsConfigAudio' Lens
+chatCompletionsConfigAudioL :: Lens_' ChatCompletionsConfig (Maybe (Map.Map String AnyType))
+chatCompletionsConfigAudioL f ChatCompletionsConfig{..} = (\chatCompletionsConfigAudio -> ChatCompletionsConfig { chatCompletionsConfigAudio, ..} ) <$> f chatCompletionsConfigAudio
+{-# INLINE chatCompletionsConfigAudioL #-}
+
+-- | 'chatCompletionsConfigResponseFormat' Lens
+chatCompletionsConfigResponseFormatL :: Lens_' ChatCompletionsConfig (Maybe (Map.Map String AnyType))
+chatCompletionsConfigResponseFormatL f ChatCompletionsConfig{..} = (\chatCompletionsConfigResponseFormat -> ChatCompletionsConfig { chatCompletionsConfigResponseFormat, ..} ) <$> f chatCompletionsConfigResponseFormat
+{-# INLINE chatCompletionsConfigResponseFormatL #-}
+
+-- | 'chatCompletionsConfigDownloadMedia' Lens
+chatCompletionsConfigDownloadMediaL :: Lens_' ChatCompletionsConfig (Maybe Bool)
+chatCompletionsConfigDownloadMediaL f ChatCompletionsConfig{..} = (\chatCompletionsConfigDownloadMedia -> ChatCompletionsConfig { chatCompletionsConfigDownloadMedia, ..} ) <$> f chatCompletionsConfigDownloadMedia
+{-# INLINE chatCompletionsConfigDownloadMediaL #-}
+
+-- | 'chatCompletionsConfigRaw' Lens
+chatCompletionsConfigRawL :: Lens_' ChatCompletionsConfig (Maybe Bool)
+chatCompletionsConfigRawL f ChatCompletionsConfig{..} = (\chatCompletionsConfigRaw -> ChatCompletionsConfig { chatCompletionsConfigRaw, ..} ) <$> f chatCompletionsConfigRaw
+{-# INLINE chatCompletionsConfigRawL #-}
+
+-- | 'chatCompletionsConfigExtraBody' Lens
+chatCompletionsConfigExtraBodyL :: Lens_' ChatCompletionsConfig (Maybe (Map.Map String AnyType))
+chatCompletionsConfigExtraBodyL f ChatCompletionsConfig{..} = (\chatCompletionsConfigExtraBody -> ChatCompletionsConfig { chatCompletionsConfigExtraBody, ..} ) <$> f chatCompletionsConfigExtraBody
+{-# INLINE chatCompletionsConfigExtraBodyL #-}
+
+-- | 'chatCompletionsConfigToolEmulation' Lens
+chatCompletionsConfigToolEmulationL :: Lens_' ChatCompletionsConfig (Maybe Bool)
+chatCompletionsConfigToolEmulationL f ChatCompletionsConfig{..} = (\chatCompletionsConfigToolEmulation -> ChatCompletionsConfig { chatCompletionsConfigToolEmulation, ..} ) <$> f chatCompletionsConfigToolEmulation
+{-# INLINE chatCompletionsConfigToolEmulationL #-}
+
+-- | 'chatCompletionsConfigMessages' Lens
+chatCompletionsConfigMessagesL :: Lens_' ChatCompletionsConfig ([Message])
+chatCompletionsConfigMessagesL f ChatCompletionsConfig{..} = (\chatCompletionsConfigMessages -> ChatCompletionsConfig { chatCompletionsConfigMessages, ..} ) <$> f chatCompletionsConfigMessages
+{-# INLINE chatCompletionsConfigMessagesL #-}
+
+-- | 'chatCompletionsConfigStream' Lens
+chatCompletionsConfigStreamL :: Lens_' ChatCompletionsConfig (Maybe Bool)
+chatCompletionsConfigStreamL f ChatCompletionsConfig{..} = (\chatCompletionsConfigStream -> ChatCompletionsConfig { chatCompletionsConfigStream, ..} ) <$> f chatCompletionsConfigStream
+{-# INLINE chatCompletionsConfigStreamL #-}
+
+-- | 'chatCompletionsConfigImage' Lens
+chatCompletionsConfigImageL :: Lens_' ChatCompletionsConfig (Maybe Text)
+chatCompletionsConfigImageL f ChatCompletionsConfig{..} = (\chatCompletionsConfigImage -> ChatCompletionsConfig { chatCompletionsConfigImage, ..} ) <$> f chatCompletionsConfigImage
+{-# INLINE chatCompletionsConfigImageL #-}
+
+-- | 'chatCompletionsConfigImageName' Lens
+chatCompletionsConfigImageNameL :: Lens_' ChatCompletionsConfig (Maybe Text)
+chatCompletionsConfigImageNameL f ChatCompletionsConfig{..} = (\chatCompletionsConfigImageName -> ChatCompletionsConfig { chatCompletionsConfigImageName, ..} ) <$> f chatCompletionsConfigImageName
+{-# INLINE chatCompletionsConfigImageNameL #-}
+
+-- | 'chatCompletionsConfigImages' Lens
+chatCompletionsConfigImagesL :: Lens_' ChatCompletionsConfig (Maybe [[AnyType]])
+chatCompletionsConfigImagesL f ChatCompletionsConfig{..} = (\chatCompletionsConfigImages -> ChatCompletionsConfig { chatCompletionsConfigImages, ..} ) <$> f chatCompletionsConfigImages
+{-# INLINE chatCompletionsConfigImagesL #-}
+
+-- | 'chatCompletionsConfigTools' Lens
+chatCompletionsConfigToolsL :: Lens_' ChatCompletionsConfig (Maybe [AnyType])
+chatCompletionsConfigToolsL f ChatCompletionsConfig{..} = (\chatCompletionsConfigTools -> ChatCompletionsConfig { chatCompletionsConfigTools, ..} ) <$> f chatCompletionsConfigTools
+{-# INLINE chatCompletionsConfigToolsL #-}
+
+-- | 'chatCompletionsConfigParallelToolCalls' Lens
+chatCompletionsConfigParallelToolCallsL :: Lens_' ChatCompletionsConfig (Maybe Bool)
+chatCompletionsConfigParallelToolCallsL f ChatCompletionsConfig{..} = (\chatCompletionsConfigParallelToolCalls -> ChatCompletionsConfig { chatCompletionsConfigParallelToolCalls, ..} ) <$> f chatCompletionsConfigParallelToolCalls
+{-# INLINE chatCompletionsConfigParallelToolCallsL #-}
+
+-- | 'chatCompletionsConfigToolChoice' Lens
+chatCompletionsConfigToolChoiceL :: Lens_' ChatCompletionsConfig (Maybe Text)
+chatCompletionsConfigToolChoiceL f ChatCompletionsConfig{..} = (\chatCompletionsConfigToolChoice -> ChatCompletionsConfig { chatCompletionsConfigToolChoice, ..} ) <$> f chatCompletionsConfigToolChoice
+{-# INLINE chatCompletionsConfigToolChoiceL #-}
+
+-- | 'chatCompletionsConfigConversationId' Lens
+chatCompletionsConfigConversationIdL :: Lens_' ChatCompletionsConfig (Maybe Text)
+chatCompletionsConfigConversationIdL f ChatCompletionsConfig{..} = (\chatCompletionsConfigConversationId -> ChatCompletionsConfig { chatCompletionsConfigConversationId, ..} ) <$> f chatCompletionsConfigConversationId
+{-# INLINE chatCompletionsConfigConversationIdL #-}
+
+
+
+-- * CompletionTokenDetails
+
+-- | 'completionTokenDetailsReasoningTokens' Lens
+completionTokenDetailsReasoningTokensL :: Lens_' CompletionTokenDetails (Int)
+completionTokenDetailsReasoningTokensL f CompletionTokenDetails{..} = (\completionTokenDetailsReasoningTokens -> CompletionTokenDetails { completionTokenDetailsReasoningTokens, ..} ) <$> f completionTokenDetailsReasoningTokens
+{-# INLINE completionTokenDetailsReasoningTokensL #-}
+
+-- | 'completionTokenDetailsImageTokens' Lens
+completionTokenDetailsImageTokensL :: Lens_' CompletionTokenDetails (Int)
+completionTokenDetailsImageTokensL f CompletionTokenDetails{..} = (\completionTokenDetailsImageTokens -> CompletionTokenDetails { completionTokenDetailsImageTokens, ..} ) <$> f completionTokenDetailsImageTokens
+{-# INLINE completionTokenDetailsImageTokensL #-}
+
+-- | 'completionTokenDetailsAudioTokens' Lens
+completionTokenDetailsAudioTokensL :: Lens_' CompletionTokenDetails (Int)
+completionTokenDetailsAudioTokensL f CompletionTokenDetails{..} = (\completionTokenDetailsAudioTokens -> CompletionTokenDetails { completionTokenDetailsAudioTokens, ..} ) <$> f completionTokenDetailsAudioTokens
+{-# INLINE completionTokenDetailsAudioTokensL #-}
+
+
+
+-- * Content
+
+
+
+-- * ContentPart
+
+-- | 'contentPartType' Lens
+contentPartTypeL :: Lens_' ContentPart (Maybe Text)
+contentPartTypeL f ContentPart{..} = (\contentPartType -> ContentPart { contentPartType, ..} ) <$> f contentPartType
+{-# INLINE contentPartTypeL #-}
+
+-- | 'contentPartText' Lens
+contentPartTextL :: Lens_' ContentPart (Maybe Text)
+contentPartTextL f ContentPart{..} = (\contentPartText -> ContentPart { contentPartText, ..} ) <$> f contentPartText
+{-# INLINE contentPartTextL #-}
+
+-- | 'contentPartImageUrl' Lens
+contentPartImageUrlL :: Lens_' ContentPart (Maybe (Map.Map String Text))
+contentPartImageUrlL f ContentPart{..} = (\contentPartImageUrl -> ContentPart { contentPartImageUrl, ..} ) <$> f contentPartImageUrl
+{-# INLINE contentPartImageUrlL #-}
+
+-- | 'contentPartInputAudio' Lens
+contentPartInputAudioL :: Lens_' ContentPart (Maybe (Map.Map String Text))
+contentPartInputAudioL f ContentPart{..} = (\contentPartInputAudio -> ContentPart { contentPartInputAudio, ..} ) <$> f contentPartInputAudio
+{-# INLINE contentPartInputAudioL #-}
+
+-- | 'contentPartBucketId' Lens
+contentPartBucketIdL :: Lens_' ContentPart (Maybe Text)
+contentPartBucketIdL f ContentPart{..} = (\contentPartBucketId -> ContentPart { contentPartBucketId, ..} ) <$> f contentPartBucketId
+{-# INLINE contentPartBucketIdL #-}
+
+-- | 'contentPartName' Lens
+contentPartNameL :: Lens_' ContentPart (Maybe Text)
+contentPartNameL f ContentPart{..} = (\contentPartName -> ContentPart { contentPartName, ..} ) <$> f contentPartName
+{-# INLINE contentPartNameL #-}
+
+
+
+-- * ErrorResponseMessageModel
+
+-- | 'errorResponseMessageModelMessage' Lens
+errorResponseMessageModelMessageL :: Lens_' ErrorResponseMessageModel (Text)
+errorResponseMessageModelMessageL f ErrorResponseMessageModel{..} = (\errorResponseMessageModelMessage -> ErrorResponseMessageModel { errorResponseMessageModelMessage, ..} ) <$> f errorResponseMessageModelMessage
+{-# INLINE errorResponseMessageModelMessageL #-}
+
+
+
+-- * ErrorResponseModel
+
+-- | 'errorResponseModelError' Lens
+errorResponseModelErrorL :: Lens_' ErrorResponseModel (ErrorResponseMessageModel)
+errorResponseModelErrorL f ErrorResponseModel{..} = (\errorResponseModelError -> ErrorResponseModel { errorResponseModelError, ..} ) <$> f errorResponseModelError
+{-# INLINE errorResponseModelErrorL #-}
+
+-- | 'errorResponseModelModel' Lens
+errorResponseModelModelL :: Lens_' ErrorResponseModel (Maybe Text)
+errorResponseModelModelL f ErrorResponseModel{..} = (\errorResponseModelModel -> ErrorResponseModel { errorResponseModelModel, ..} ) <$> f errorResponseModelModel
+{-# INLINE errorResponseModelModelL #-}
+
+-- | 'errorResponseModelProvider' Lens
+errorResponseModelProviderL :: Lens_' ErrorResponseModel (Maybe Text)
+errorResponseModelProviderL f ErrorResponseModel{..} = (\errorResponseModelProvider -> ErrorResponseModel { errorResponseModelProvider, ..} ) <$> f errorResponseModelProvider
+{-# INLINE errorResponseModelProviderL #-}
+
+
+
+-- * FileResponseModel
+
+-- | 'fileResponseModelFilename' Lens
+fileResponseModelFilenameL :: Lens_' FileResponseModel (Text)
+fileResponseModelFilenameL f FileResponseModel{..} = (\fileResponseModelFilename -> FileResponseModel { fileResponseModelFilename, ..} ) <$> f fileResponseModelFilename
+{-# INLINE fileResponseModelFilenameL #-}
+
+
+
+-- * HTTPValidationError
+
+-- | 'hTTPValidationErrorDetail' Lens
+hTTPValidationErrorDetailL :: Lens_' HTTPValidationError (Maybe [ValidationError])
+hTTPValidationErrorDetailL f HTTPValidationError{..} = (\hTTPValidationErrorDetail -> HTTPValidationError { hTTPValidationErrorDetail, ..} ) <$> f hTTPValidationErrorDetail
+{-# INLINE hTTPValidationErrorDetailL #-}
+
+
+
+-- * Image
+
+-- | 'imageUrl' Lens
+imageUrlL :: Lens_' Image (Text)
+imageUrlL f Image{..} = (\imageUrl -> Image { imageUrl, ..} ) <$> f imageUrl
+{-# INLINE imageUrlL #-}
+
+-- | 'imageB64Json' Lens
+imageB64JsonL :: Lens_' Image (Text)
+imageB64JsonL f Image{..} = (\imageB64Json -> Image { imageB64Json, ..} ) <$> f imageB64Json
+{-# INLINE imageB64JsonL #-}
+
+-- | 'imageRevisedPrompt' Lens
+imageRevisedPromptL :: Lens_' Image (Text)
+imageRevisedPromptL f Image{..} = (\imageRevisedPrompt -> Image { imageRevisedPrompt, ..} ) <$> f imageRevisedPrompt
+{-# INLINE imageRevisedPromptL #-}
+
+
+
+-- * ImageGenerationConfig
+
+-- | 'imageGenerationConfigPrompt' Lens
+imageGenerationConfigPromptL :: Lens_' ImageGenerationConfig (Text)
+imageGenerationConfigPromptL f ImageGenerationConfig{..} = (\imageGenerationConfigPrompt -> ImageGenerationConfig { imageGenerationConfigPrompt, ..} ) <$> f imageGenerationConfigPrompt
+{-# INLINE imageGenerationConfigPromptL #-}
+
+-- | 'imageGenerationConfigModel' Lens
+imageGenerationConfigModelL :: Lens_' ImageGenerationConfig (Maybe Text)
+imageGenerationConfigModelL f ImageGenerationConfig{..} = (\imageGenerationConfigModel -> ImageGenerationConfig { imageGenerationConfigModel, ..} ) <$> f imageGenerationConfigModel
+{-# INLINE imageGenerationConfigModelL #-}
+
+-- | 'imageGenerationConfigProvider' Lens
+imageGenerationConfigProviderL :: Lens_' ImageGenerationConfig (Maybe Text)
+imageGenerationConfigProviderL f ImageGenerationConfig{..} = (\imageGenerationConfigProvider -> ImageGenerationConfig { imageGenerationConfigProvider, ..} ) <$> f imageGenerationConfigProvider
+{-# INLINE imageGenerationConfigProviderL #-}
+
+-- | 'imageGenerationConfigResponseFormat' Lens
+imageGenerationConfigResponseFormatL :: Lens_' ImageGenerationConfig (Maybe Text)
+imageGenerationConfigResponseFormatL f ImageGenerationConfig{..} = (\imageGenerationConfigResponseFormat -> ImageGenerationConfig { imageGenerationConfigResponseFormat, ..} ) <$> f imageGenerationConfigResponseFormat
+{-# INLINE imageGenerationConfigResponseFormatL #-}
+
+-- | 'imageGenerationConfigApiKey' Lens
+imageGenerationConfigApiKeyL :: Lens_' ImageGenerationConfig (Maybe Text)
+imageGenerationConfigApiKeyL f ImageGenerationConfig{..} = (\imageGenerationConfigApiKey -> ImageGenerationConfig { imageGenerationConfigApiKey, ..} ) <$> f imageGenerationConfigApiKey
+{-# INLINE imageGenerationConfigApiKeyL #-}
+
+-- | 'imageGenerationConfigProxy' Lens
+imageGenerationConfigProxyL :: Lens_' ImageGenerationConfig (Maybe Text)
+imageGenerationConfigProxyL f ImageGenerationConfig{..} = (\imageGenerationConfigProxy -> ImageGenerationConfig { imageGenerationConfigProxy, ..} ) <$> f imageGenerationConfigProxy
+{-# INLINE imageGenerationConfigProxyL #-}
+
+-- | 'imageGenerationConfigWidth' Lens
+imageGenerationConfigWidthL :: Lens_' ImageGenerationConfig (Maybe Int)
+imageGenerationConfigWidthL f ImageGenerationConfig{..} = (\imageGenerationConfigWidth -> ImageGenerationConfig { imageGenerationConfigWidth, ..} ) <$> f imageGenerationConfigWidth
+{-# INLINE imageGenerationConfigWidthL #-}
+
+-- | 'imageGenerationConfigHeight' Lens
+imageGenerationConfigHeightL :: Lens_' ImageGenerationConfig (Maybe Int)
+imageGenerationConfigHeightL f ImageGenerationConfig{..} = (\imageGenerationConfigHeight -> ImageGenerationConfig { imageGenerationConfigHeight, ..} ) <$> f imageGenerationConfigHeight
+{-# INLINE imageGenerationConfigHeightL #-}
+
+-- | 'imageGenerationConfigNumInferenceSteps' Lens
+imageGenerationConfigNumInferenceStepsL :: Lens_' ImageGenerationConfig (Maybe Int)
+imageGenerationConfigNumInferenceStepsL f ImageGenerationConfig{..} = (\imageGenerationConfigNumInferenceSteps -> ImageGenerationConfig { imageGenerationConfigNumInferenceSteps, ..} ) <$> f imageGenerationConfigNumInferenceSteps
+{-# INLINE imageGenerationConfigNumInferenceStepsL #-}
+
+-- | 'imageGenerationConfigSeed' Lens
+imageGenerationConfigSeedL :: Lens_' ImageGenerationConfig (Maybe Int)
+imageGenerationConfigSeedL f ImageGenerationConfig{..} = (\imageGenerationConfigSeed -> ImageGenerationConfig { imageGenerationConfigSeed, ..} ) <$> f imageGenerationConfigSeed
+{-# INLINE imageGenerationConfigSeedL #-}
+
+-- | 'imageGenerationConfigGuidanceScale' Lens
+imageGenerationConfigGuidanceScaleL :: Lens_' ImageGenerationConfig (Maybe Int)
+imageGenerationConfigGuidanceScaleL f ImageGenerationConfig{..} = (\imageGenerationConfigGuidanceScale -> ImageGenerationConfig { imageGenerationConfigGuidanceScale, ..} ) <$> f imageGenerationConfigGuidanceScale
+{-# INLINE imageGenerationConfigGuidanceScaleL #-}
+
+-- | 'imageGenerationConfigAspectRatio' Lens
+imageGenerationConfigAspectRatioL :: Lens_' ImageGenerationConfig (Maybe Text)
+imageGenerationConfigAspectRatioL f ImageGenerationConfig{..} = (\imageGenerationConfigAspectRatio -> ImageGenerationConfig { imageGenerationConfigAspectRatio, ..} ) <$> f imageGenerationConfigAspectRatio
+{-# INLINE imageGenerationConfigAspectRatioL #-}
+
+-- | 'imageGenerationConfigN' Lens
+imageGenerationConfigNL :: Lens_' ImageGenerationConfig (Maybe Int)
+imageGenerationConfigNL f ImageGenerationConfig{..} = (\imageGenerationConfigN -> ImageGenerationConfig { imageGenerationConfigN, ..} ) <$> f imageGenerationConfigN
+{-# INLINE imageGenerationConfigNL #-}
+
+-- | 'imageGenerationConfigNegativePrompt' Lens
+imageGenerationConfigNegativePromptL :: Lens_' ImageGenerationConfig (Maybe Text)
+imageGenerationConfigNegativePromptL f ImageGenerationConfig{..} = (\imageGenerationConfigNegativePrompt -> ImageGenerationConfig { imageGenerationConfigNegativePrompt, ..} ) <$> f imageGenerationConfigNegativePrompt
+{-# INLINE imageGenerationConfigNegativePromptL #-}
+
+-- | 'imageGenerationConfigResolution' Lens
+imageGenerationConfigResolutionL :: Lens_' ImageGenerationConfig (Maybe Text)
+imageGenerationConfigResolutionL f ImageGenerationConfig{..} = (\imageGenerationConfigResolution -> ImageGenerationConfig { imageGenerationConfigResolution, ..} ) <$> f imageGenerationConfigResolution
+{-# INLINE imageGenerationConfigResolutionL #-}
+
+-- | 'imageGenerationConfigAudio' Lens
+imageGenerationConfigAudioL :: Lens_' ImageGenerationConfig (Maybe (Map.Map String AnyType))
+imageGenerationConfigAudioL f ImageGenerationConfig{..} = (\imageGenerationConfigAudio -> ImageGenerationConfig { imageGenerationConfigAudio, ..} ) <$> f imageGenerationConfigAudio
+{-# INLINE imageGenerationConfigAudioL #-}
+
+-- | 'imageGenerationConfigDownloadMedia' Lens
+imageGenerationConfigDownloadMediaL :: Lens_' ImageGenerationConfig (Maybe Bool)
+imageGenerationConfigDownloadMediaL f ImageGenerationConfig{..} = (\imageGenerationConfigDownloadMedia -> ImageGenerationConfig { imageGenerationConfigDownloadMedia, ..} ) <$> f imageGenerationConfigDownloadMedia
+{-# INLINE imageGenerationConfigDownloadMediaL #-}
+
+
+
+-- * ImagesResponse
+
+-- | 'imagesResponseData' Lens
+imagesResponseDataL :: Lens_' ImagesResponse ([Image])
+imagesResponseDataL f ImagesResponse{..} = (\imagesResponseData -> ImagesResponse { imagesResponseData, ..} ) <$> f imagesResponseData
+{-# INLINE imagesResponseDataL #-}
+
+-- | 'imagesResponseModel' Lens
+imagesResponseModelL :: Lens_' ImagesResponse (Text)
+imagesResponseModelL f ImagesResponse{..} = (\imagesResponseModel -> ImagesResponse { imagesResponseModel, ..} ) <$> f imagesResponseModel
+{-# INLINE imagesResponseModelL #-}
+
+-- | 'imagesResponseProvider' Lens
+imagesResponseProviderL :: Lens_' ImagesResponse (Text)
+imagesResponseProviderL f ImagesResponse{..} = (\imagesResponseProvider -> ImagesResponse { imagesResponseProvider, ..} ) <$> f imagesResponseProvider
+{-# INLINE imagesResponseProviderL #-}
+
+-- | 'imagesResponseCreated' Lens
+imagesResponseCreatedL :: Lens_' ImagesResponse (Int)
+imagesResponseCreatedL f ImagesResponse{..} = (\imagesResponseCreated -> ImagesResponse { imagesResponseCreated, ..} ) <$> f imagesResponseCreated
+{-# INLINE imagesResponseCreatedL #-}
+
+
+
+-- * Message
+
+-- | 'messageRole' Lens
+messageRoleL :: Lens_' Message (Text)
+messageRoleL f Message{..} = (\messageRole -> Message { messageRole, ..} ) <$> f messageRole
+{-# INLINE messageRoleL #-}
+
+-- | 'messageContent' Lens
+messageContentL :: Lens_' Message (Content)
+messageContentL f Message{..} = (\messageContent -> Message { messageContent, ..} ) <$> f messageContent
+{-# INLINE messageContentL #-}
+
+
+
+-- * ModelResponseModel
+
+-- | 'modelResponseModelId' Lens
+modelResponseModelIdL :: Lens_' ModelResponseModel (Text)
+modelResponseModelIdL f ModelResponseModel{..} = (\modelResponseModelId -> ModelResponseModel { modelResponseModelId, ..} ) <$> f modelResponseModelId
+{-# INLINE modelResponseModelIdL #-}
+
+-- | 'modelResponseModelObject' Lens
+modelResponseModelObjectL :: Lens_' ModelResponseModel (Maybe Text)
+modelResponseModelObjectL f ModelResponseModel{..} = (\modelResponseModelObject -> ModelResponseModel { modelResponseModelObject, ..} ) <$> f modelResponseModelObject
+{-# INLINE modelResponseModelObjectL #-}
+
+-- | 'modelResponseModelCreated' Lens
+modelResponseModelCreatedL :: Lens_' ModelResponseModel (Int)
+modelResponseModelCreatedL f ModelResponseModel{..} = (\modelResponseModelCreated -> ModelResponseModel { modelResponseModelCreated, ..} ) <$> f modelResponseModelCreated
+{-# INLINE modelResponseModelCreatedL #-}
+
+-- | 'modelResponseModelOwnedBy' Lens
+modelResponseModelOwnedByL :: Lens_' ModelResponseModel (Text)
+modelResponseModelOwnedByL f ModelResponseModel{..} = (\modelResponseModelOwnedBy -> ModelResponseModel { modelResponseModelOwnedBy, ..} ) <$> f modelResponseModelOwnedBy
+{-# INLINE modelResponseModelOwnedByL #-}
+
+
+
+-- * PromptTokenDetails
+
+-- | 'promptTokenDetailsCachedTokens' Lens
+promptTokenDetailsCachedTokensL :: Lens_' PromptTokenDetails (Int)
+promptTokenDetailsCachedTokensL f PromptTokenDetails{..} = (\promptTokenDetailsCachedTokens -> PromptTokenDetails { promptTokenDetailsCachedTokens, ..} ) <$> f promptTokenDetailsCachedTokens
+{-# INLINE promptTokenDetailsCachedTokensL #-}
+
+-- | 'promptTokenDetailsAudioTokens' Lens
+promptTokenDetailsAudioTokensL :: Lens_' PromptTokenDetails (Int)
+promptTokenDetailsAudioTokensL f PromptTokenDetails{..} = (\promptTokenDetailsAudioTokens -> PromptTokenDetails { promptTokenDetailsAudioTokens, ..} ) <$> f promptTokenDetailsAudioTokens
+{-# INLINE promptTokenDetailsAudioTokensL #-}
+
+
+
+-- * ProviderResponseDetailModel
+
+-- | 'providerResponseDetailModelId' Lens
+providerResponseDetailModelIdL :: Lens_' ProviderResponseDetailModel (Text)
+providerResponseDetailModelIdL f ProviderResponseDetailModel{..} = (\providerResponseDetailModelId -> ProviderResponseDetailModel { providerResponseDetailModelId, ..} ) <$> f providerResponseDetailModelId
+{-# INLINE providerResponseDetailModelIdL #-}
+
+-- | 'providerResponseDetailModelObject' Lens
+providerResponseDetailModelObjectL :: Lens_' ProviderResponseDetailModel (Maybe Text)
+providerResponseDetailModelObjectL f ProviderResponseDetailModel{..} = (\providerResponseDetailModelObject -> ProviderResponseDetailModel { providerResponseDetailModelObject, ..} ) <$> f providerResponseDetailModelObject
+{-# INLINE providerResponseDetailModelObjectL #-}
+
+-- | 'providerResponseDetailModelCreated' Lens
+providerResponseDetailModelCreatedL :: Lens_' ProviderResponseDetailModel (Int)
+providerResponseDetailModelCreatedL f ProviderResponseDetailModel{..} = (\providerResponseDetailModelCreated -> ProviderResponseDetailModel { providerResponseDetailModelCreated, ..} ) <$> f providerResponseDetailModelCreated
+{-# INLINE providerResponseDetailModelCreatedL #-}
+
+-- | 'providerResponseDetailModelUrl' Lens
+providerResponseDetailModelUrlL :: Lens_' ProviderResponseDetailModel (Text)
+providerResponseDetailModelUrlL f ProviderResponseDetailModel{..} = (\providerResponseDetailModelUrl -> ProviderResponseDetailModel { providerResponseDetailModelUrl, ..} ) <$> f providerResponseDetailModelUrl
+{-# INLINE providerResponseDetailModelUrlL #-}
+
+-- | 'providerResponseDetailModelLabel' Lens
+providerResponseDetailModelLabelL :: Lens_' ProviderResponseDetailModel (Text)
+providerResponseDetailModelLabelL f ProviderResponseDetailModel{..} = (\providerResponseDetailModelLabel -> ProviderResponseDetailModel { providerResponseDetailModelLabel, ..} ) <$> f providerResponseDetailModelLabel
+{-# INLINE providerResponseDetailModelLabelL #-}
+
+-- | 'providerResponseDetailModelModels' Lens
+providerResponseDetailModelModelsL :: Lens_' ProviderResponseDetailModel ([Text])
+providerResponseDetailModelModelsL f ProviderResponseDetailModel{..} = (\providerResponseDetailModelModels -> ProviderResponseDetailModel { providerResponseDetailModelModels, ..} ) <$> f providerResponseDetailModelModels
+{-# INLINE providerResponseDetailModelModelsL #-}
+
+-- | 'providerResponseDetailModelImageModels' Lens
+providerResponseDetailModelImageModelsL :: Lens_' ProviderResponseDetailModel ([Text])
+providerResponseDetailModelImageModelsL f ProviderResponseDetailModel{..} = (\providerResponseDetailModelImageModels -> ProviderResponseDetailModel { providerResponseDetailModelImageModels, ..} ) <$> f providerResponseDetailModelImageModels
+{-# INLINE providerResponseDetailModelImageModelsL #-}
+
+-- | 'providerResponseDetailModelVisionModels' Lens
+providerResponseDetailModelVisionModelsL :: Lens_' ProviderResponseDetailModel ([Text])
+providerResponseDetailModelVisionModelsL f ProviderResponseDetailModel{..} = (\providerResponseDetailModelVisionModels -> ProviderResponseDetailModel { providerResponseDetailModelVisionModels, ..} ) <$> f providerResponseDetailModelVisionModels
+{-# INLINE providerResponseDetailModelVisionModelsL #-}
+
+-- | 'providerResponseDetailModelParams' Lens
+providerResponseDetailModelParamsL :: Lens_' ProviderResponseDetailModel ([Text])
+providerResponseDetailModelParamsL f ProviderResponseDetailModel{..} = (\providerResponseDetailModelParams -> ProviderResponseDetailModel { providerResponseDetailModelParams, ..} ) <$> f providerResponseDetailModelParams
+{-# INLINE providerResponseDetailModelParamsL #-}
+
+
+
+-- * ProviderResponseModel
+
+-- | 'providerResponseModelId' Lens
+providerResponseModelIdL :: Lens_' ProviderResponseModel (Text)
+providerResponseModelIdL f ProviderResponseModel{..} = (\providerResponseModelId -> ProviderResponseModel { providerResponseModelId, ..} ) <$> f providerResponseModelId
+{-# INLINE providerResponseModelIdL #-}
+
+-- | 'providerResponseModelObject' Lens
+providerResponseModelObjectL :: Lens_' ProviderResponseModel (Maybe Text)
+providerResponseModelObjectL f ProviderResponseModel{..} = (\providerResponseModelObject -> ProviderResponseModel { providerResponseModelObject, ..} ) <$> f providerResponseModelObject
+{-# INLINE providerResponseModelObjectL #-}
+
+-- | 'providerResponseModelCreated' Lens
+providerResponseModelCreatedL :: Lens_' ProviderResponseModel (Int)
+providerResponseModelCreatedL f ProviderResponseModel{..} = (\providerResponseModelCreated -> ProviderResponseModel { providerResponseModelCreated, ..} ) <$> f providerResponseModelCreated
+{-# INLINE providerResponseModelCreatedL #-}
+
+-- | 'providerResponseModelUrl' Lens
+providerResponseModelUrlL :: Lens_' ProviderResponseModel (Text)
+providerResponseModelUrlL f ProviderResponseModel{..} = (\providerResponseModelUrl -> ProviderResponseModel { providerResponseModelUrl, ..} ) <$> f providerResponseModelUrl
+{-# INLINE providerResponseModelUrlL #-}
+
+-- | 'providerResponseModelLabel' Lens
+providerResponseModelLabelL :: Lens_' ProviderResponseModel (Text)
+providerResponseModelLabelL f ProviderResponseModel{..} = (\providerResponseModelLabel -> ProviderResponseModel { providerResponseModelLabel, ..} ) <$> f providerResponseModelLabel
+{-# INLINE providerResponseModelLabelL #-}
+
+
+
+-- * Stop
+
+
+
+-- * ToolCallModel
+
+-- | 'toolCallModelId' Lens
+toolCallModelIdL :: Lens_' ToolCallModel (Text)
+toolCallModelIdL f ToolCallModel{..} = (\toolCallModelId -> ToolCallModel { toolCallModelId, ..} ) <$> f toolCallModelId
+{-# INLINE toolCallModelIdL #-}
+
+-- | 'toolCallModelType' Lens
+toolCallModelTypeL :: Lens_' ToolCallModel (Text)
+toolCallModelTypeL f ToolCallModel{..} = (\toolCallModelType -> ToolCallModel { toolCallModelType, ..} ) <$> f toolCallModelType
+{-# INLINE toolCallModelTypeL #-}
+
+-- | 'toolCallModelFunction' Lens
+toolCallModelFunctionL :: Lens_' ToolCallModel (ToolFunctionModel)
+toolCallModelFunctionL f ToolCallModel{..} = (\toolCallModelFunction -> ToolCallModel { toolCallModelFunction, ..} ) <$> f toolCallModelFunction
+{-# INLINE toolCallModelFunctionL #-}
+
+
+
+-- * ToolFunctionModel
+
+-- | 'toolFunctionModelName' Lens
+toolFunctionModelNameL :: Lens_' ToolFunctionModel (Text)
+toolFunctionModelNameL f ToolFunctionModel{..} = (\toolFunctionModelName -> ToolFunctionModel { toolFunctionModelName, ..} ) <$> f toolFunctionModelName
+{-# INLINE toolFunctionModelNameL #-}
+
+-- | 'toolFunctionModelArguments' Lens
+toolFunctionModelArgumentsL :: Lens_' ToolFunctionModel (Text)
+toolFunctionModelArgumentsL f ToolFunctionModel{..} = (\toolFunctionModelArguments -> ToolFunctionModel { toolFunctionModelArguments, ..} ) <$> f toolFunctionModelArguments
+{-# INLINE toolFunctionModelArgumentsL #-}
+
+
+
+-- * TranscriptionResponseModel
+
+-- | 'transcriptionResponseModelText' Lens
+transcriptionResponseModelTextL :: Lens_' TranscriptionResponseModel (Text)
+transcriptionResponseModelTextL f TranscriptionResponseModel{..} = (\transcriptionResponseModelText -> TranscriptionResponseModel { transcriptionResponseModelText, ..} ) <$> f transcriptionResponseModelText
+{-# INLINE transcriptionResponseModelTextL #-}
+
+-- | 'transcriptionResponseModelModel' Lens
+transcriptionResponseModelModelL :: Lens_' TranscriptionResponseModel (Text)
+transcriptionResponseModelModelL f TranscriptionResponseModel{..} = (\transcriptionResponseModelModel -> TranscriptionResponseModel { transcriptionResponseModelModel, ..} ) <$> f transcriptionResponseModelModel
+{-# INLINE transcriptionResponseModelModelL #-}
+
+-- | 'transcriptionResponseModelProvider' Lens
+transcriptionResponseModelProviderL :: Lens_' TranscriptionResponseModel (Text)
+transcriptionResponseModelProviderL f TranscriptionResponseModel{..} = (\transcriptionResponseModelProvider -> TranscriptionResponseModel { transcriptionResponseModelProvider, ..} ) <$> f transcriptionResponseModelProvider
+{-# INLINE transcriptionResponseModelProviderL #-}
+
+
+
+-- * UsageModel
+
+-- | 'usageModelPromptTokens' Lens
+usageModelPromptTokensL :: Lens_' UsageModel (Int)
+usageModelPromptTokensL f UsageModel{..} = (\usageModelPromptTokens -> UsageModel { usageModelPromptTokens, ..} ) <$> f usageModelPromptTokens
+{-# INLINE usageModelPromptTokensL #-}
+
+-- | 'usageModelCompletionTokens' Lens
+usageModelCompletionTokensL :: Lens_' UsageModel (Int)
+usageModelCompletionTokensL f UsageModel{..} = (\usageModelCompletionTokens -> UsageModel { usageModelCompletionTokens, ..} ) <$> f usageModelCompletionTokens
+{-# INLINE usageModelCompletionTokensL #-}
+
+-- | 'usageModelTotalTokens' Lens
+usageModelTotalTokensL :: Lens_' UsageModel (Int)
+usageModelTotalTokensL f UsageModel{..} = (\usageModelTotalTokens -> UsageModel { usageModelTotalTokens, ..} ) <$> f usageModelTotalTokens
+{-# INLINE usageModelTotalTokensL #-}
+
+-- | 'usageModelPromptTokensDetails' Lens
+usageModelPromptTokensDetailsL :: Lens_' UsageModel (PromptTokenDetails)
+usageModelPromptTokensDetailsL f UsageModel{..} = (\usageModelPromptTokensDetails -> UsageModel { usageModelPromptTokensDetails, ..} ) <$> f usageModelPromptTokensDetails
+{-# INLINE usageModelPromptTokensDetailsL #-}
+
+-- | 'usageModelCompletionTokensDetails' Lens
+usageModelCompletionTokensDetailsL :: Lens_' UsageModel (CompletionTokenDetails)
+usageModelCompletionTokensDetailsL f UsageModel{..} = (\usageModelCompletionTokensDetails -> UsageModel { usageModelCompletionTokensDetails, ..} ) <$> f usageModelCompletionTokensDetails
+{-# INLINE usageModelCompletionTokensDetailsL #-}
+
+-- | 'usageModelCache' Lens
+usageModelCacheL :: Lens_' UsageModel (Maybe Text)
+usageModelCacheL f UsageModel{..} = (\usageModelCache -> UsageModel { usageModelCache, ..} ) <$> f usageModelCache
+{-# INLINE usageModelCacheL #-}
+
+
+
+-- * ValidationError
+
+-- | 'validationErrorLoc' Lens
+validationErrorLocL :: Lens_' ValidationError ([ValidationErrorLocInner])
+validationErrorLocL f ValidationError{..} = (\validationErrorLoc -> ValidationError { validationErrorLoc, ..} ) <$> f validationErrorLoc
+{-# INLINE validationErrorLocL #-}
+
+-- | 'validationErrorMsg' Lens
+validationErrorMsgL :: Lens_' ValidationError (Text)
+validationErrorMsgL f ValidationError{..} = (\validationErrorMsg -> ValidationError { validationErrorMsg, ..} ) <$> f validationErrorMsg
+{-# INLINE validationErrorMsgL #-}
+
+-- | 'validationErrorType' Lens
+validationErrorTypeL :: Lens_' ValidationError (Text)
+validationErrorTypeL f ValidationError{..} = (\validationErrorType -> ValidationError { validationErrorType, ..} ) <$> f validationErrorType
+{-# INLINE validationErrorTypeL #-}
+
+-- | 'validationErrorInput' Lens
+validationErrorInputL :: Lens_' ValidationError (AnyType)
+validationErrorInputL f ValidationError{..} = (\validationErrorInput -> ValidationError { validationErrorInput, ..} ) <$> f validationErrorInput
+{-# INLINE validationErrorInputL #-}
+
+-- | 'validationErrorCtx' Lens
+validationErrorCtxL :: Lens_' ValidationError (AnyType)
+validationErrorCtxL f ValidationError{..} = (\validationErrorCtx -> ValidationError { validationErrorCtx, ..} ) <$> f validationErrorCtx
+{-# INLINE validationErrorCtxL #-}
+
+
+
+-- * ValidationErrorLocInner
+
+