From 55d42f1dd83b428aa0f1352bc0ea1402b9c2b811 Mon Sep 17 00:00:00 2001 From: tv Date: Sat, 21 Feb 2026 14:18:13 +0100 Subject: 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 --- lib/G4fClient/API.hs | 19 + lib/G4fClient/API/ApiDefault.hs | 680 ++++++++++++++++ lib/G4fClient/Client.hs | 223 ++++++ lib/G4fClient/Core.hs | 589 ++++++++++++++ lib/G4fClient/Logging.hs | 33 + lib/G4fClient/LoggingKatip.hs | 117 +++ lib/G4fClient/LoggingMonadLogger.hs | 126 +++ lib/G4fClient/MimeTypes.hs | 225 ++++++ lib/G4fClient/Model.hs | 1513 +++++++++++++++++++++++++++++++++++ lib/G4fClient/ModelLens.hs | 858 ++++++++++++++++++++ 10 files changed, 4383 insertions(+) create mode 100644 lib/G4fClient/API.hs create mode 100644 lib/G4fClient/API/ApiDefault.hs create mode 100644 lib/G4fClient/Client.hs create mode 100644 lib/G4fClient/Core.hs create mode 100644 lib/G4fClient/Logging.hs create mode 100644 lib/G4fClient/LoggingKatip.hs create mode 100644 lib/G4fClient/LoggingMonadLogger.hs create mode 100644 lib/G4fClient/MimeTypes.hs create mode 100644 lib/G4fClient/Model.hs create mode 100644 lib/G4fClient/ModelLens.hs (limited to 'lib/G4fClient') 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) + _ -> "") + 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 + + -- cgit v1.3.1 [cgit] Unable to lock slot /tmp/cgit/ea300000.lock: No such file or directory (2)