Add C++ UE4 client generator (#6399)

* Added new language: UE4 C++ client

* rename generator

* add copyright

* update doc

* fix with Locale.ROOT

* add new file

* minor improvements

* remove postProcessModels

Co-authored-by: Samuel Kahn <samuel@kahncode.com>

samples/client/petstore/cpp-ue4/.openapi-generator-ignore

@@ -0,0 +1,23 @@
+# OpenAPI Generator Ignore
+# Generated by openapi-generator https://github.com/openapitools/openapi-generator
+
+# Use this file to prevent files from being overwritten by the generator.
+# The patterns follow closely to .gitignore or .dockerignore.
+
+# As an example, the C# client generator defines ApiClient.cs.
+# You can make changes and tell OpenAPI Generator to ignore just this file by uncommenting the following line:
+#ApiClient.cs
+
+# You can match any string of characters against a directory, file or extension with a single asterisk (*):
+#foo/*/qux
+# The above matches foo/bar/qux and foo/baz/qux, but not foo/bar/baz/qux
+
+# You can recursively match patterns against a directory, file or extension with a double asterisk (**):
+#foo/**/qux
+# This matches foo/bar/qux, foo/baz/qux, and foo/bar/baz/qux
+
+# You can also negate patterns with an exclamation (!).
+# For example, you can ignore all files in a docs folder with the file extension .md:
+#docs/*.md
+# Then explicitly reverse the ignore rule for a single file:
+#!docs/README.md

samples/client/petstore/cpp-ue4/.openapi-generator/VERSION

@@ -0,0 +1 @@
+5.0.0-SNAPSHOT

samples/client/petstore/cpp-ue4/OpenAPI.Build.cs

@@ -0,0 +1,30 @@
+/**
+ * OpenAPI Petstore
+ * This is a sample server Petstore server. For this sample, you can use the api key `special-key` to test the authorization filters.
+ *
+ * OpenAPI spec version: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator
+ * https://github.com/OpenAPITools/openapi-generator
+ * Do not edit the class manually.
+ */
+
+using System;
+using System.IO;
+using UnrealBuildTool;
+
+public class OpenAPI : ModuleRules
+{
+    public OpenAPI(ReadOnlyTargetRules Target) : base(Target)
+    {
+        PublicDependencyModuleNames.AddRange(
+            new string[]
+            {
+                "Core",
+                "Http",
+                "Json",
+            }
+        );
+    }
+}

samples/client/petstore/cpp-ue4/OpenAPIApiResponse.cpp

@@ -0,0 +1,51 @@
+/**
+ * OpenAPI Petstore
+ * This is a sample server Petstore server. For this sample, you can use the api key `special-key` to test the authorization filters.
+ *
+ * OpenAPI spec version: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator
+ * https://github.com/OpenAPITools/openapi-generator
+ * Do not edit the class manually.
+ */
+
+#include "OpenAPIApiResponse.h"
+
+#include "OpenAPIModule.h"
+#include "OpenAPIHelpers.h"
+
+#include "Templates/SharedPointer.h"
+
+namespace OpenAPI 
+{
+
+void OpenAPIApiResponse::WriteJson(JsonWriter& Writer) const
+{
+	Writer->WriteObjectStart();
+	if (Code.IsSet())
+	{
+		Writer->WriteIdentifierPrefix(TEXT("code")); WriteJsonValue(Writer, Code.GetValue());	
+	}
+	if (Type.IsSet())
+	{
+		Writer->WriteIdentifierPrefix(TEXT("type")); WriteJsonValue(Writer, Type.GetValue());	
+	}
+	if (Message.IsSet())
+	{
+		Writer->WriteIdentifierPrefix(TEXT("message")); WriteJsonValue(Writer, Message.GetValue());	
+	}
+	Writer->WriteObjectEnd();
+}
+
+bool OpenAPIApiResponse::FromJson(const TSharedPtr<FJsonObject>& JsonObject)
+{
+	bool ParseSuccess = true;
+
+	ParseSuccess &= TryGetJsonValue(JsonObject, TEXT("code"), Code);
+	ParseSuccess &= TryGetJsonValue(JsonObject, TEXT("type"), Type);
+	ParseSuccess &= TryGetJsonValue(JsonObject, TEXT("message"), Message);
+
+	return ParseSuccess;
+}
+}

samples/client/petstore/cpp-ue4/OpenAPIApiResponse.h

@@ -0,0 +1,37 @@
+/**
+ * OpenAPI Petstore
+ * This is a sample server Petstore server. For this sample, you can use the api key `special-key` to test the authorization filters.
+ *
+ * OpenAPI spec version: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator
+ * https://github.com/OpenAPITools/openapi-generator
+ * Do not edit the class manually.
+ */
+
+#pragma once
+
+#include "OpenAPIBaseModel.h"
+
+namespace OpenAPI 
+{
+
+/*
+ * OpenAPIApiResponse
+ *
+ * Describes the result of uploading an image resource
+ */
+class OPENAPI_API OpenAPIApiResponse : public Model
+{
+public:
+    virtual ~OpenAPIApiResponse() {}
+	bool FromJson(const TSharedPtr<FJsonObject>& JsonObject) final;
+	void WriteJson(JsonWriter& Writer) const final;
+
+	TOptional<int32> Code;
+	TOptional<FString> Type;
+	TOptional<FString> Message;
+};
+
+}

samples/client/petstore/cpp-ue4/OpenAPICategory.cpp

@@ -0,0 +1,46 @@
+/**
+ * OpenAPI Petstore
+ * This is a sample server Petstore server. For this sample, you can use the api key `special-key` to test the authorization filters.
+ *
+ * OpenAPI spec version: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator
+ * https://github.com/OpenAPITools/openapi-generator
+ * Do not edit the class manually.
+ */
+
+#include "OpenAPICategory.h"
+
+#include "OpenAPIModule.h"
+#include "OpenAPIHelpers.h"
+
+#include "Templates/SharedPointer.h"
+
+namespace OpenAPI 
+{
+
+void OpenAPICategory::WriteJson(JsonWriter& Writer) const
+{
+	Writer->WriteObjectStart();
+	if (Id.IsSet())
+	{
+		Writer->WriteIdentifierPrefix(TEXT("id")); WriteJsonValue(Writer, Id.GetValue());	
+	}
+	if (Name.IsSet())
+	{
+		Writer->WriteIdentifierPrefix(TEXT("name")); WriteJsonValue(Writer, Name.GetValue());	
+	}
+	Writer->WriteObjectEnd();
+}
+
+bool OpenAPICategory::FromJson(const TSharedPtr<FJsonObject>& JsonObject)
+{
+	bool ParseSuccess = true;
+
+	ParseSuccess &= TryGetJsonValue(JsonObject, TEXT("id"), Id);
+	ParseSuccess &= TryGetJsonValue(JsonObject, TEXT("name"), Name);
+
+	return ParseSuccess;
+}
+}

samples/client/petstore/cpp-ue4/OpenAPICategory.h

@@ -0,0 +1,36 @@
+/**
+ * OpenAPI Petstore
+ * This is a sample server Petstore server. For this sample, you can use the api key `special-key` to test the authorization filters.
+ *
+ * OpenAPI spec version: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator
+ * https://github.com/OpenAPITools/openapi-generator
+ * Do not edit the class manually.
+ */
+
+#pragma once
+
+#include "OpenAPIBaseModel.h"
+
+namespace OpenAPI 
+{
+
+/*
+ * OpenAPICategory
+ *
+ * A category for a pet
+ */
+class OPENAPI_API OpenAPICategory : public Model
+{
+public:
+    virtual ~OpenAPICategory() {}
+	bool FromJson(const TSharedPtr<FJsonObject>& JsonObject) final;
+	void WriteJson(JsonWriter& Writer) const final;
+
+	TOptional<int64> Id;
+	TOptional<FString> Name;
+};
+
+}

samples/client/petstore/cpp-ue4/OpenAPIOrder.cpp

@@ -0,0 +1,109 @@
+/**
+ * OpenAPI Petstore
+ * This is a sample server Petstore server. For this sample, you can use the api key `special-key` to test the authorization filters.
+ *
+ * OpenAPI spec version: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator
+ * https://github.com/OpenAPITools/openapi-generator
+ * Do not edit the class manually.
+ */
+
+#include "OpenAPIOrder.h"
+
+#include "OpenAPIModule.h"
+#include "OpenAPIHelpers.h"
+
+#include "Templates/SharedPointer.h"
+
+namespace OpenAPI 
+{
+
+inline FString ToString(const OpenAPIOrder::StatusEnum& Value)
+{
+	switch (Value)
+	{
+	case OpenAPIOrder::StatusEnum::Placed:
+		return TEXT("placed");
+	case OpenAPIOrder::StatusEnum::Approved:
+		return TEXT("approved");
+	case OpenAPIOrder::StatusEnum::Delivered:
+		return TEXT("delivered");
+	}
+
+	UE_LOG(LogOpenAPI, Error, TEXT("Invalid OpenAPIOrder::StatusEnum Value (%d)"), (int)Value);	
+	return TEXT("");
+}
+
+inline FStringFormatArg ToStringFormatArg(const OpenAPIOrder::StatusEnum& Value)
+{
+	return FStringFormatArg(ToString(Value));
+}
+
+inline void WriteJsonValue(JsonWriter& Writer, const OpenAPIOrder::StatusEnum& Value)
+{
+	WriteJsonValue(Writer, ToString(Value));
+}
+
+inline bool TryGetJsonValue(const TSharedPtr<FJsonValue>& JsonValue, OpenAPIOrder::StatusEnum& Value)
+{
+	FString TmpValue;
+	if (JsonValue->TryGetString(TmpValue))
+	{
+		static TMap<FString, OpenAPIOrder::StatusEnum> StringToEnum = {  };
+
+		const auto Found = StringToEnum.Find(TmpValue);
+		if(Found)
+		{
+			Value = *Found;
+			return true;
+		}
+	}
+	return false;
+}
+
+void OpenAPIOrder::WriteJson(JsonWriter& Writer) const
+{
+	Writer->WriteObjectStart();
+	if (Id.IsSet())
+	{
+		Writer->WriteIdentifierPrefix(TEXT("id")); WriteJsonValue(Writer, Id.GetValue());	
+	}
+	if (PetId.IsSet())
+	{
+		Writer->WriteIdentifierPrefix(TEXT("petId")); WriteJsonValue(Writer, PetId.GetValue());	
+	}
+	if (Quantity.IsSet())
+	{
+		Writer->WriteIdentifierPrefix(TEXT("quantity")); WriteJsonValue(Writer, Quantity.GetValue());	
+	}
+	if (ShipDate.IsSet())
+	{
+		Writer->WriteIdentifierPrefix(TEXT("shipDate")); WriteJsonValue(Writer, ShipDate.GetValue());	
+	}
+	if (Status.IsSet())
+	{
+		Writer->WriteIdentifierPrefix(TEXT("status")); WriteJsonValue(Writer, Status.GetValue());	
+	}
+	if (Complete.IsSet())
+	{
+		Writer->WriteIdentifierPrefix(TEXT("complete")); WriteJsonValue(Writer, Complete.GetValue());	
+	}
+	Writer->WriteObjectEnd();
+}
+
+bool OpenAPIOrder::FromJson(const TSharedPtr<FJsonObject>& JsonObject)
+{
+	bool ParseSuccess = true;
+
+	ParseSuccess &= TryGetJsonValue(JsonObject, TEXT("id"), Id);
+	ParseSuccess &= TryGetJsonValue(JsonObject, TEXT("petId"), PetId);
+	ParseSuccess &= TryGetJsonValue(JsonObject, TEXT("quantity"), Quantity);
+	ParseSuccess &= TryGetJsonValue(JsonObject, TEXT("shipDate"), ShipDate);
+	ParseSuccess &= TryGetJsonValue(JsonObject, TEXT("status"), Status);
+	ParseSuccess &= TryGetJsonValue(JsonObject, TEXT("complete"), Complete);
+
+	return ParseSuccess;
+}
+}

samples/client/petstore/cpp-ue4/OpenAPIOrder.h

@@ -0,0 +1,47 @@
+/**
+ * OpenAPI Petstore
+ * This is a sample server Petstore server. For this sample, you can use the api key `special-key` to test the authorization filters.
+ *
+ * OpenAPI spec version: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator
+ * https://github.com/OpenAPITools/openapi-generator
+ * Do not edit the class manually.
+ */
+
+#pragma once
+
+#include "OpenAPIBaseModel.h"
+
+namespace OpenAPI 
+{
+
+/*
+ * OpenAPIOrder
+ *
+ * An order for a pets from the pet store
+ */
+class OPENAPI_API OpenAPIOrder : public Model
+{
+public:
+    virtual ~OpenAPIOrder() {}
+	bool FromJson(const TSharedPtr<FJsonObject>& JsonObject) final;
+	void WriteJson(JsonWriter& Writer) const final;
+
+	TOptional<int64> Id;
+	TOptional<int64> PetId;
+	TOptional<int32> Quantity;
+	TOptional<FDateTime> ShipDate;
+	enum class StatusEnum
+	{
+		Placed,
+		Approved,
+		Delivered,
+  	};
+	/* Order Status */
+	TOptional<StatusEnum> Status;
+	TOptional<bool> Complete;
+};
+
+}

samples/client/petstore/cpp-ue4/OpenAPIPet.cpp

@@ -0,0 +1,103 @@
+/**
+ * OpenAPI Petstore
+ * This is a sample server Petstore server. For this sample, you can use the api key `special-key` to test the authorization filters.
+ *
+ * OpenAPI spec version: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator
+ * https://github.com/OpenAPITools/openapi-generator
+ * Do not edit the class manually.
+ */
+
+#include "OpenAPIPet.h"
+
+#include "OpenAPIModule.h"
+#include "OpenAPIHelpers.h"
+
+#include "Templates/SharedPointer.h"
+
+namespace OpenAPI 
+{
+
+inline FString ToString(const OpenAPIPet::StatusEnum& Value)
+{
+	switch (Value)
+	{
+	case OpenAPIPet::StatusEnum::Available:
+		return TEXT("available");
+	case OpenAPIPet::StatusEnum::Pending:
+		return TEXT("pending");
+	case OpenAPIPet::StatusEnum::Sold:
+		return TEXT("sold");
+	}
+
+	UE_LOG(LogOpenAPI, Error, TEXT("Invalid OpenAPIPet::StatusEnum Value (%d)"), (int)Value);	
+	return TEXT("");
+}
+
+inline FStringFormatArg ToStringFormatArg(const OpenAPIPet::StatusEnum& Value)
+{
+	return FStringFormatArg(ToString(Value));
+}
+
+inline void WriteJsonValue(JsonWriter& Writer, const OpenAPIPet::StatusEnum& Value)
+{
+	WriteJsonValue(Writer, ToString(Value));
+}
+
+inline bool TryGetJsonValue(const TSharedPtr<FJsonValue>& JsonValue, OpenAPIPet::StatusEnum& Value)
+{
+	FString TmpValue;
+	if (JsonValue->TryGetString(TmpValue))
+	{
+		static TMap<FString, OpenAPIPet::StatusEnum> StringToEnum = {  };
+
+		const auto Found = StringToEnum.Find(TmpValue);
+		if(Found)
+		{
+			Value = *Found;
+			return true;
+		}
+	}
+	return false;
+}
+
+void OpenAPIPet::WriteJson(JsonWriter& Writer) const
+{
+	Writer->WriteObjectStart();
+	if (Id.IsSet())
+	{
+		Writer->WriteIdentifierPrefix(TEXT("id")); WriteJsonValue(Writer, Id.GetValue());	
+	}
+	if (Category.IsSet())
+	{
+		Writer->WriteIdentifierPrefix(TEXT("category")); WriteJsonValue(Writer, Category.GetValue());	
+	}
+	Writer->WriteIdentifierPrefix(TEXT("name")); WriteJsonValue(Writer, Name);
+	Writer->WriteIdentifierPrefix(TEXT("photoUrls")); WriteJsonValue(Writer, PhotoUrls);
+	if (Tags.IsSet())
+	{
+		Writer->WriteIdentifierPrefix(TEXT("tags")); WriteJsonValue(Writer, Tags.GetValue());	
+	}
+	if (Status.IsSet())
+	{
+		Writer->WriteIdentifierPrefix(TEXT("status")); WriteJsonValue(Writer, Status.GetValue());	
+	}
+	Writer->WriteObjectEnd();
+}
+
+bool OpenAPIPet::FromJson(const TSharedPtr<FJsonObject>& JsonObject)
+{
+	bool ParseSuccess = true;
+
+	ParseSuccess &= TryGetJsonValue(JsonObject, TEXT("id"), Id);
+	ParseSuccess &= TryGetJsonValue(JsonObject, TEXT("category"), Category);
+	ParseSuccess &= TryGetJsonValue(JsonObject, TEXT("name"), Name);
+	ParseSuccess &= TryGetJsonValue(JsonObject, TEXT("photoUrls"), PhotoUrls);
+	ParseSuccess &= TryGetJsonValue(JsonObject, TEXT("tags"), Tags);
+	ParseSuccess &= TryGetJsonValue(JsonObject, TEXT("status"), Status);
+
+	return ParseSuccess;
+}
+}

samples/client/petstore/cpp-ue4/OpenAPIPet.h

@@ -0,0 +1,49 @@
+/**
+ * OpenAPI Petstore
+ * This is a sample server Petstore server. For this sample, you can use the api key `special-key` to test the authorization filters.
+ *
+ * OpenAPI spec version: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator
+ * https://github.com/OpenAPITools/openapi-generator
+ * Do not edit the class manually.
+ */
+
+#pragma once
+
+#include "OpenAPIBaseModel.h"
+#include "OpenAPICategory.h"
+#include "OpenAPITag.h"
+
+namespace OpenAPI 
+{
+
+/*
+ * OpenAPIPet
+ *
+ * A pet for sale in the pet store
+ */
+class OPENAPI_API OpenAPIPet : public Model
+{
+public:
+    virtual ~OpenAPIPet() {}
+	bool FromJson(const TSharedPtr<FJsonObject>& JsonObject) final;
+	void WriteJson(JsonWriter& Writer) const final;
+
+	TOptional<int64> Id;
+	TOptional<OpenAPICategory> Category;
+	FString Name;
+	TArray<std::shared_ptr<FString>> PhotoUrls;
+	TOptional<TArray<std::shared_ptr<OpenAPIOpenAPITag>>> Tags;
+	enum class StatusEnum
+	{
+		Available,
+		Pending,
+		Sold,
+  	};
+	/* pet status in the store */
+	TOptional<StatusEnum> Status;
+};
+
+}

samples/client/petstore/cpp-ue4/OpenAPITag.cpp

@@ -0,0 +1,46 @@
+/**
+ * OpenAPI Petstore
+ * This is a sample server Petstore server. For this sample, you can use the api key `special-key` to test the authorization filters.
+ *
+ * OpenAPI spec version: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator
+ * https://github.com/OpenAPITools/openapi-generator
+ * Do not edit the class manually.
+ */
+
+#include "OpenAPITag.h"
+
+#include "OpenAPIModule.h"
+#include "OpenAPIHelpers.h"
+
+#include "Templates/SharedPointer.h"
+
+namespace OpenAPI 
+{
+
+void OpenAPITag::WriteJson(JsonWriter& Writer) const
+{
+	Writer->WriteObjectStart();
+	if (Id.IsSet())
+	{
+		Writer->WriteIdentifierPrefix(TEXT("id")); WriteJsonValue(Writer, Id.GetValue());	
+	}
+	if (Name.IsSet())
+	{
+		Writer->WriteIdentifierPrefix(TEXT("name")); WriteJsonValue(Writer, Name.GetValue());	
+	}
+	Writer->WriteObjectEnd();
+}
+
+bool OpenAPITag::FromJson(const TSharedPtr<FJsonObject>& JsonObject)
+{
+	bool ParseSuccess = true;
+
+	ParseSuccess &= TryGetJsonValue(JsonObject, TEXT("id"), Id);
+	ParseSuccess &= TryGetJsonValue(JsonObject, TEXT("name"), Name);
+
+	return ParseSuccess;
+}
+}

samples/client/petstore/cpp-ue4/OpenAPITag.h

@@ -0,0 +1,36 @@
+/**
+ * OpenAPI Petstore
+ * This is a sample server Petstore server. For this sample, you can use the api key `special-key` to test the authorization filters.
+ *
+ * OpenAPI spec version: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator
+ * https://github.com/OpenAPITools/openapi-generator
+ * Do not edit the class manually.
+ */
+
+#pragma once
+
+#include "OpenAPIBaseModel.h"
+
+namespace OpenAPI 
+{
+
+/*
+ * OpenAPITag
+ *
+ * A tag for a pet
+ */
+class OPENAPI_API OpenAPITag : public Model
+{
+public:
+    virtual ~OpenAPITag() {}
+	bool FromJson(const TSharedPtr<FJsonObject>& JsonObject) final;
+	void WriteJson(JsonWriter& Writer) const final;
+
+	TOptional<int64> Id;
+	TOptional<FString> Name;
+};
+
+}

samples/client/petstore/cpp-ue4/OpenAPIUser.cpp

@@ -0,0 +1,76 @@
+/**
+ * OpenAPI Petstore
+ * This is a sample server Petstore server. For this sample, you can use the api key `special-key` to test the authorization filters.
+ *
+ * OpenAPI spec version: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator
+ * https://github.com/OpenAPITools/openapi-generator
+ * Do not edit the class manually.
+ */
+
+#include "OpenAPIUser.h"
+
+#include "OpenAPIModule.h"
+#include "OpenAPIHelpers.h"
+
+#include "Templates/SharedPointer.h"
+
+namespace OpenAPI 
+{
+
+void OpenAPIUser::WriteJson(JsonWriter& Writer) const
+{
+	Writer->WriteObjectStart();
+	if (Id.IsSet())
+	{
+		Writer->WriteIdentifierPrefix(TEXT("id")); WriteJsonValue(Writer, Id.GetValue());	
+	}
+	if (Username.IsSet())
+	{
+		Writer->WriteIdentifierPrefix(TEXT("username")); WriteJsonValue(Writer, Username.GetValue());	
+	}
+	if (FirstName.IsSet())
+	{
+		Writer->WriteIdentifierPrefix(TEXT("firstName")); WriteJsonValue(Writer, FirstName.GetValue());	
+	}
+	if (LastName.IsSet())
+	{
+		Writer->WriteIdentifierPrefix(TEXT("lastName")); WriteJsonValue(Writer, LastName.GetValue());	
+	}
+	if (Email.IsSet())
+	{
+		Writer->WriteIdentifierPrefix(TEXT("email")); WriteJsonValue(Writer, Email.GetValue());	
+	}
+	if (Password.IsSet())
+	{
+		Writer->WriteIdentifierPrefix(TEXT("password")); WriteJsonValue(Writer, Password.GetValue());	
+	}
+	if (Phone.IsSet())
+	{
+		Writer->WriteIdentifierPrefix(TEXT("phone")); WriteJsonValue(Writer, Phone.GetValue());	
+	}
+	if (UserStatus.IsSet())
+	{
+		Writer->WriteIdentifierPrefix(TEXT("userStatus")); WriteJsonValue(Writer, UserStatus.GetValue());	
+	}
+	Writer->WriteObjectEnd();
+}
+
+bool OpenAPIUser::FromJson(const TSharedPtr<FJsonObject>& JsonObject)
+{
+	bool ParseSuccess = true;
+
+	ParseSuccess &= TryGetJsonValue(JsonObject, TEXT("id"), Id);
+	ParseSuccess &= TryGetJsonValue(JsonObject, TEXT("username"), Username);
+	ParseSuccess &= TryGetJsonValue(JsonObject, TEXT("firstName"), FirstName);
+	ParseSuccess &= TryGetJsonValue(JsonObject, TEXT("lastName"), LastName);
+	ParseSuccess &= TryGetJsonValue(JsonObject, TEXT("email"), Email);
+	ParseSuccess &= TryGetJsonValue(JsonObject, TEXT("password"), Password);
+	ParseSuccess &= TryGetJsonValue(JsonObject, TEXT("phone"), Phone);
+	ParseSuccess &= TryGetJsonValue(JsonObject, TEXT("userStatus"), UserStatus);
+
+	return ParseSuccess;
+}
+}

samples/client/petstore/cpp-ue4/OpenAPIUser.h

@@ -0,0 +1,43 @@
+/**
+ * OpenAPI Petstore
+ * This is a sample server Petstore server. For this sample, you can use the api key `special-key` to test the authorization filters.
+ *
+ * OpenAPI spec version: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator
+ * https://github.com/OpenAPITools/openapi-generator
+ * Do not edit the class manually.
+ */
+
+#pragma once
+
+#include "OpenAPIBaseModel.h"
+
+namespace OpenAPI 
+{
+
+/*
+ * OpenAPIUser
+ *
+ * A User who is purchasing from the pet store
+ */
+class OPENAPI_API OpenAPIUser : public Model
+{
+public:
+    virtual ~OpenAPIUser() {}
+	bool FromJson(const TSharedPtr<FJsonObject>& JsonObject) final;
+	void WriteJson(JsonWriter& Writer) const final;
+
+	TOptional<int64> Id;
+	TOptional<FString> Username;
+	TOptional<FString> FirstName;
+	TOptional<FString> LastName;
+	TOptional<FString> Email;
+	TOptional<FString> Password;
+	TOptional<FString> Phone;
+	/* User Status */
+	TOptional<int32> UserStatus;
+};
+
+}

samples/client/petstore/cpp-ue4/Private/OpenAPIBaseModel.cpp

@@ -0,0 +1,28 @@
+/**
+ * OpenAPI Petstore
+ * This is a sample server Petstore server. For this sample, you can use the api key `special-key` to test the authorization filters.
+ *
+ * OpenAPI spec version: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator
+ * https://github.com/OpenAPITools/openapi-generator
+ * Do not edit the class manually.
+ */
+
+#include "OpenAPIBaseModel.h"
+
+namespace OpenAPI 
+{
+
+void Response::SetHttpResponseCode(EHttpResponseCodes::Type InHttpResponseCode)
+{
+    ResponseCode = InHttpResponseCode;
+    SetSuccessful(EHttpResponseCodes::IsOk(InHttpResponseCode));
+    if(InHttpResponseCode == EHttpResponseCodes::RequestTimeout)
+    {
+        SetResponseString(TEXT("Request Timeout"));
+    }
+}
+
+}

samples/client/petstore/cpp-ue4/Private/OpenAPIHelpers.cpp

@@ -0,0 +1,194 @@
+/**
+ * OpenAPI Petstore
+ * This is a sample server Petstore server. For this sample, you can use the api key `special-key` to test the authorization filters.
+ *
+ * OpenAPI spec version: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator
+ * https://github.com/OpenAPITools/openapi-generator
+ * Do not edit the class manually.
+ */
+
+#include "OpenAPIHelpers.h"
+
+#include "OpenAPIModule.h"
+
+#include "Interfaces/IHttpRequest.h"
+#include "PlatformHttp.h"
+#include "Misc/FileHelper.h"
+
+namespace OpenAPI 
+{
+
+HttpFileInput::HttpFileInput(const TCHAR* InFilePath)
+{
+	SetFilePath(InFilePath);
+}
+
+HttpFileInput::HttpFileInput(const FString& InFilePath)
+{
+	SetFilePath(InFilePath);
+}
+
+void HttpFileInput::SetFilePath(const TCHAR* InFilePath)
+{
+	FilePath = InFilePath;
+	if(ContentType.IsEmpty())
+	{
+		ContentType = FPlatformHttp::GetMimeType(InFilePath);
+	}
+}
+
+void HttpFileInput::SetFilePath(const FString& InFilePath)
+{
+	SetFilePath(*InFilePath);
+}
+
+void HttpFileInput::SetContentType(const TCHAR* InContentType)
+{
+	ContentType = InContentType;
+}
+
+FString HttpFileInput::GetFilename() const
+{
+	return FPaths::GetCleanFilename(FilePath);
+}
+
+//////////////////////////////////////////////////////////////////////////
+
+const TCHAR* HttpMultipartFormData::Delimiter = TEXT("--");
+const TCHAR* HttpMultipartFormData::Newline = TEXT("\r\n");
+
+void HttpMultipartFormData::SetBoundary(const TCHAR* InBoundary)
+{
+	checkf(Boundary.IsEmpty(), TEXT("Boundary must be set before usage"));
+	Boundary = InBoundary;
+}
+
+const FString& HttpMultipartFormData::GetBoundary() const
+{
+	if (Boundary.IsEmpty())
+	{
+		// Generate a random boundary with enough entropy, should avoid occurences of the boundary in the data.
+		// Since the boundary is generated at every request, in case of failure, retries should succeed.
+		Boundary = FGuid::NewGuid().ToString(EGuidFormats::Short);
+	}
+
+	return Boundary;
+}
+
+void HttpMultipartFormData::SetupHttpRequest(const TSharedRef<IHttpRequest>& HttpRequest)
+{
+	if(HttpRequest->GetVerb() != TEXT("POST"))
+	{
+		UE_LOG(LogOpenAPI, Error, TEXT("Expected POST verb when using multipart form data"));
+	}
+
+	// Append final boundary
+	AppendString(Delimiter);
+	AppendString(*GetBoundary());
+	AppendString(Delimiter);
+
+	HttpRequest->SetHeader("Content-Type", FString::Printf(TEXT("multipart/form-data; boundary=%s"), *GetBoundary()));
+	HttpRequest->SetContent(FormData);
+}
+
+void HttpMultipartFormData::AddStringPart(const TCHAR* Name, const TCHAR* Data)
+{
+	// Add boundary
+	AppendString(Delimiter);
+	AppendString(*GetBoundary());
+	AppendString(Newline);
+
+	// Add header
+	AppendString(*FString::Printf(TEXT("Content-Disposition: form-data; name = \"%s\""), Name));
+	AppendString(Newline);
+	AppendString(*FString::Printf(TEXT("Content-Type: text/plain; charset=utf-8")));
+	AppendString(Newline);
+
+	// Add header to body splitter
+	AppendString(Newline);
+
+	// Add Data
+	AppendString(Data);
+	AppendString(Newline);
+}
+
+void HttpMultipartFormData::AddJsonPart(const TCHAR* Name, const FString& JsonString)
+{
+	// Add boundary
+	AppendString(Delimiter);
+	AppendString(*GetBoundary());
+	AppendString(Newline);
+
+	// Add header
+	AppendString(*FString::Printf(TEXT("Content-Disposition: form-data; name=\"%s\""), Name));
+	AppendString(Newline);
+	AppendString(*FString::Printf(TEXT("Content-Type: application/json; charset=utf-8")));
+	AppendString(Newline);
+
+	// Add header to body splitter
+	AppendString(Newline);
+
+	// Add Data
+	AppendString(*JsonString);
+	AppendString(Newline);
+}
+
+void HttpMultipartFormData::AddBinaryPart(const TCHAR* Name, const TArray<uint8>& ByteArray)
+{
+	// Add boundary
+	AppendString(Delimiter);
+	AppendString(*GetBoundary());
+	AppendString(Newline);
+
+	// Add header
+	AppendString(*FString::Printf(TEXT("Content-Disposition: form-data; name=\"%s\""), Name));
+	AppendString(Newline);
+	AppendString(*FString::Printf(TEXT("Content-Type: application/octet-stream")));
+	AppendString(Newline);
+
+	// Add header to body splitter
+	AppendString(Newline);
+
+	// Add Data
+	FormData.Append(ByteArray);
+	AppendString(Newline);
+}
+
+void HttpMultipartFormData::AddFilePart(const TCHAR* Name, const HttpFileInput& File)
+{
+	TArray<uint8> FileContents;
+	if (!FFileHelper::LoadFileToArray(FileContents, *File.GetFilePath()))
+	{
+		UE_LOG(LogOpenAPI, Error, TEXT("Failed to load file (%s)"), *File.GetFilePath());
+		return;
+	}
+
+	// Add boundary
+	AppendString(Delimiter);
+	AppendString(*GetBoundary());
+	AppendString(Newline);
+
+	// Add header
+	AppendString(*FString::Printf(TEXT("Content-Disposition: form-data; name=\"%s\"; filename=\"%s\""), Name, *File.GetFilename()));
+	AppendString(Newline);
+	AppendString(*FString::Printf(TEXT("Content-Type: %s"), *File.GetContentType()));
+	AppendString(Newline);
+
+	// Add header to body splitter
+	AppendString(Newline);
+
+	// Add Data
+	FormData.Append(FileContents);
+	AppendString(Newline);
+}
+
+void HttpMultipartFormData::AppendString(const TCHAR* Str)
+{
+	FTCHARToUTF8 utf8Str(Str);
+	FormData.Append((uint8*)utf8Str.Get(), utf8Str.Length());
+}
+
+}

samples/client/petstore/cpp-ue4/Private/OpenAPIModule.cpp

@@ -0,0 +1,25 @@
+/**
+ * OpenAPI Petstore
+ * This is a sample server Petstore server. For this sample, you can use the api key `special-key` to test the authorization filters.
+ *
+ * OpenAPI spec version: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator
+ * https://github.com/OpenAPITools/openapi-generator
+ * Do not edit the class manually.
+ */
+
+#include "OpenAPIModule.h"
+
+IMPLEMENT_MODULE(OpenAPIModule, OpenAPI);
+DEFINE_LOG_CATEGORY(LogOpenAPI);
+
+void OpenAPIModule::StartupModule()
+{
+}
+
+void OpenAPIModule::ShutdownModule()
+{
+}
+

samples/client/petstore/cpp-ue4/Private/OpenAPIModule.h

@@ -0,0 +1,26 @@
+/**
+ * OpenAPI Petstore
+ * This is a sample server Petstore server. For this sample, you can use the api key `special-key` to test the authorization filters.
+ *
+ * OpenAPI spec version: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator
+ * https://github.com/OpenAPITools/openapi-generator
+ * Do not edit the class manually.
+ */
+
+#pragma once
+
+#include "Modules/ModuleInterface.h"
+#include "Modules/ModuleManager.h"
+#include "Logging/LogMacros.h"
+
+DECLARE_LOG_CATEGORY_EXTERN(LogOpenAPI, Log, All);
+
+class OPENAPI_API OpenAPIModule : public IModuleInterface
+{
+public:
+	void StartupModule() final;
+	void ShutdownModule() final;
+};

samples/client/petstore/cpp-ue4/Private/OpenAPIPetApi.cpp

@@ -0,0 +1,305 @@
+/**
+ * OpenAPI Petstore
+ * This is a sample server Petstore server. For this sample, you can use the api key `special-key` to test the authorization filters.
+ *
+ * OpenAPI spec version: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator
+ * https://github.com/OpenAPITools/openapi-generator
+ * Do not edit the class manually.
+ */
+
+#include "OpenAPIPetApi.h"
+
+#include "OpenAPIPetApiOperations.h"
+#include "OpenAPIModule.h"
+
+#include "HttpModule.h"
+#include "Serialization/JsonSerializer.h"
+
+namespace OpenAPI 
+{
+
+OpenAPIPetApi::OpenAPIPetApi() 
+: Url(TEXT("http://petstore.swagger.io/v2"))
+{
+}
+
+OpenAPIPetApi::~OpenAPIPetApi() {}
+
+void OpenAPIPetApi::SetURL(const FString& InUrl)
+{
+	Url = InUrl;
+}
+
+void OpenAPIPetApi::AddHeaderParam(const FString& Key, const FString& Value)
+{
+	AdditionalHeaderParams.Add(Key, Value);
+}
+
+void OpenAPIPetApi::ClearHeaderParams()
+{
+	AdditionalHeaderParams.Reset();
+}
+
+bool OpenAPIPetApi::IsValid() const
+{
+	if (Url.IsEmpty())
+	{
+		UE_LOG(LogOpenAPI, Error, TEXT("OpenAPIPetApi: Endpoint Url is not set, request cannot be performed"));
+		return false;
+	}
+
+	return true;
+}
+
+void OpenAPIPetApi::HandleResponse(FHttpResponsePtr HttpResponse, bool bSucceeded, Response& InOutResponse) const
+{
+	InOutResponse.SetHttpResponse(HttpResponse);
+	InOutResponse.SetSuccessful(bSucceeded);
+
+	if (bSucceeded && HttpResponse.IsValid())
+	{
+		InOutResponse.SetHttpResponseCode((EHttpResponseCodes::Type)HttpResponse->GetResponseCode());
+		FString ContentType = HttpResponse->GetContentType();
+		FString Content;
+
+		if (ContentType == TEXT("application/json"))
+		{
+			Content = HttpResponse->GetContentAsString();
+
+			TSharedPtr<FJsonValue> JsonValue;
+			auto Reader = TJsonReaderFactory<>::Create(Content);
+
+			if (FJsonSerializer::Deserialize(Reader, JsonValue) && JsonValue.IsValid())
+			{
+				if (InOutResponse.FromJson(JsonValue))
+					return; // Successfully parsed
+			}
+		}
+		else if(ContentType == TEXT("text/plain"))
+		{
+			Content = HttpResponse->GetContentAsString();
+			InOutResponse.SetResponseString(Content);
+			return; // Successfully parsed
+		}
+
+		// Report the parse error but do not mark the request as unsuccessful. Data could be partial or malformed, but the request succeeded.
+		UE_LOG(LogOpenAPI, Error, TEXT("Failed to deserialize Http response content (type:%s):\n%s"), *ContentType , *Content);
+		return;
+	}
+
+	// By default, assume we failed to establish connection
+	InOutResponse.SetHttpResponseCode(EHttpResponseCodes::RequestTimeout);
+}
+
+bool OpenAPIPetApi::AddPet(const AddPetRequest& Request, const FAddPetDelegate& Delegate /*= FAddPetDelegate()*/) const
+{
+	if (!IsValid())
+		return false;
+
+	TSharedRef<IHttpRequest> HttpRequest = FHttpModule::Get().CreateRequest();
+	HttpRequest->SetURL(*(Url + Request.ComputePath()));
+
+	for(const auto& It : AdditionalHeaderParams)
+	{
+		HttpRequest->SetHeader(It.Key, It.Value);
+	}
+
+	Request.SetupHttpRequest(HttpRequest);
+	
+	HttpRequest->OnProcessRequestComplete().BindRaw(this, &OpenAPIPetApi::OnAddPetResponse, Delegate);
+	return HttpRequest->ProcessRequest();
+}
+
+void OpenAPIPetApi::OnAddPetResponse(FHttpRequestPtr HttpRequest, FHttpResponsePtr HttpResponse, bool bSucceeded, FAddPetDelegate Delegate) const
+{
+	AddPetResponse Response;
+	HandleResponse(HttpResponse, bSucceeded, Response);
+	Delegate.ExecuteIfBound(Response);
+}
+
+bool OpenAPIPetApi::DeletePet(const DeletePetRequest& Request, const FDeletePetDelegate& Delegate /*= FDeletePetDelegate()*/) const
+{
+	if (!IsValid())
+		return false;
+
+	TSharedRef<IHttpRequest> HttpRequest = FHttpModule::Get().CreateRequest();
+	HttpRequest->SetURL(*(Url + Request.ComputePath()));
+
+	for(const auto& It : AdditionalHeaderParams)
+	{
+		HttpRequest->SetHeader(It.Key, It.Value);
+	}
+
+	Request.SetupHttpRequest(HttpRequest);
+	
+	HttpRequest->OnProcessRequestComplete().BindRaw(this, &OpenAPIPetApi::OnDeletePetResponse, Delegate);
+	return HttpRequest->ProcessRequest();
+}
+
+void OpenAPIPetApi::OnDeletePetResponse(FHttpRequestPtr HttpRequest, FHttpResponsePtr HttpResponse, bool bSucceeded, FDeletePetDelegate Delegate) const
+{
+	DeletePetResponse Response;
+	HandleResponse(HttpResponse, bSucceeded, Response);
+	Delegate.ExecuteIfBound(Response);
+}
+
+bool OpenAPIPetApi::FindPetsByStatus(const FindPetsByStatusRequest& Request, const FFindPetsByStatusDelegate& Delegate /*= FFindPetsByStatusDelegate()*/) const
+{
+	if (!IsValid())
+		return false;
+
+	TSharedRef<IHttpRequest> HttpRequest = FHttpModule::Get().CreateRequest();
+	HttpRequest->SetURL(*(Url + Request.ComputePath()));
+
+	for(const auto& It : AdditionalHeaderParams)
+	{
+		HttpRequest->SetHeader(It.Key, It.Value);
+	}
+
+	Request.SetupHttpRequest(HttpRequest);
+	
+	HttpRequest->OnProcessRequestComplete().BindRaw(this, &OpenAPIPetApi::OnFindPetsByStatusResponse, Delegate);
+	return HttpRequest->ProcessRequest();
+}
+
+void OpenAPIPetApi::OnFindPetsByStatusResponse(FHttpRequestPtr HttpRequest, FHttpResponsePtr HttpResponse, bool bSucceeded, FFindPetsByStatusDelegate Delegate) const
+{
+	FindPetsByStatusResponse Response;
+	HandleResponse(HttpResponse, bSucceeded, Response);
+	Delegate.ExecuteIfBound(Response);
+}
+
+bool OpenAPIPetApi::FindPetsByTags(const FindPetsByTagsRequest& Request, const FFindPetsByTagsDelegate& Delegate /*= FFindPetsByTagsDelegate()*/) const
+{
+	if (!IsValid())
+		return false;
+
+	TSharedRef<IHttpRequest> HttpRequest = FHttpModule::Get().CreateRequest();
+	HttpRequest->SetURL(*(Url + Request.ComputePath()));
+
+	for(const auto& It : AdditionalHeaderParams)
+	{
+		HttpRequest->SetHeader(It.Key, It.Value);
+	}
+
+	Request.SetupHttpRequest(HttpRequest);
+	
+	HttpRequest->OnProcessRequestComplete().BindRaw(this, &OpenAPIPetApi::OnFindPetsByTagsResponse, Delegate);
+	return HttpRequest->ProcessRequest();
+}
+
+void OpenAPIPetApi::OnFindPetsByTagsResponse(FHttpRequestPtr HttpRequest, FHttpResponsePtr HttpResponse, bool bSucceeded, FFindPetsByTagsDelegate Delegate) const
+{
+	FindPetsByTagsResponse Response;
+	HandleResponse(HttpResponse, bSucceeded, Response);
+	Delegate.ExecuteIfBound(Response);
+}
+
+bool OpenAPIPetApi::GetPetById(const GetPetByIdRequest& Request, const FGetPetByIdDelegate& Delegate /*= FGetPetByIdDelegate()*/) const
+{
+	if (!IsValid())
+		return false;
+
+	TSharedRef<IHttpRequest> HttpRequest = FHttpModule::Get().CreateRequest();
+	HttpRequest->SetURL(*(Url + Request.ComputePath()));
+
+	for(const auto& It : AdditionalHeaderParams)
+	{
+		HttpRequest->SetHeader(It.Key, It.Value);
+	}
+
+	Request.SetupHttpRequest(HttpRequest);
+	
+	HttpRequest->OnProcessRequestComplete().BindRaw(this, &OpenAPIPetApi::OnGetPetByIdResponse, Delegate);
+	return HttpRequest->ProcessRequest();
+}
+
+void OpenAPIPetApi::OnGetPetByIdResponse(FHttpRequestPtr HttpRequest, FHttpResponsePtr HttpResponse, bool bSucceeded, FGetPetByIdDelegate Delegate) const
+{
+	GetPetByIdResponse Response;
+	HandleResponse(HttpResponse, bSucceeded, Response);
+	Delegate.ExecuteIfBound(Response);
+}
+
+bool OpenAPIPetApi::UpdatePet(const UpdatePetRequest& Request, const FUpdatePetDelegate& Delegate /*= FUpdatePetDelegate()*/) const
+{
+	if (!IsValid())
+		return false;
+
+	TSharedRef<IHttpRequest> HttpRequest = FHttpModule::Get().CreateRequest();
+	HttpRequest->SetURL(*(Url + Request.ComputePath()));
+
+	for(const auto& It : AdditionalHeaderParams)
+	{
+		HttpRequest->SetHeader(It.Key, It.Value);
+	}
+
+	Request.SetupHttpRequest(HttpRequest);
+	
+	HttpRequest->OnProcessRequestComplete().BindRaw(this, &OpenAPIPetApi::OnUpdatePetResponse, Delegate);
+	return HttpRequest->ProcessRequest();
+}
+
+void OpenAPIPetApi::OnUpdatePetResponse(FHttpRequestPtr HttpRequest, FHttpResponsePtr HttpResponse, bool bSucceeded, FUpdatePetDelegate Delegate) const
+{
+	UpdatePetResponse Response;
+	HandleResponse(HttpResponse, bSucceeded, Response);
+	Delegate.ExecuteIfBound(Response);
+}
+
+bool OpenAPIPetApi::UpdatePetWithForm(const UpdatePetWithFormRequest& Request, const FUpdatePetWithFormDelegate& Delegate /*= FUpdatePetWithFormDelegate()*/) const
+{
+	if (!IsValid())
+		return false;
+
+	TSharedRef<IHttpRequest> HttpRequest = FHttpModule::Get().CreateRequest();
+	HttpRequest->SetURL(*(Url + Request.ComputePath()));
+
+	for(const auto& It : AdditionalHeaderParams)
+	{
+		HttpRequest->SetHeader(It.Key, It.Value);
+	}
+
+	Request.SetupHttpRequest(HttpRequest);
+	
+	HttpRequest->OnProcessRequestComplete().BindRaw(this, &OpenAPIPetApi::OnUpdatePetWithFormResponse, Delegate);
+	return HttpRequest->ProcessRequest();
+}
+
+void OpenAPIPetApi::OnUpdatePetWithFormResponse(FHttpRequestPtr HttpRequest, FHttpResponsePtr HttpResponse, bool bSucceeded, FUpdatePetWithFormDelegate Delegate) const
+{
+	UpdatePetWithFormResponse Response;
+	HandleResponse(HttpResponse, bSucceeded, Response);
+	Delegate.ExecuteIfBound(Response);
+}
+
+bool OpenAPIPetApi::UploadFile(const UploadFileRequest& Request, const FUploadFileDelegate& Delegate /*= FUploadFileDelegate()*/) const
+{
+	if (!IsValid())
+		return false;
+
+	TSharedRef<IHttpRequest> HttpRequest = FHttpModule::Get().CreateRequest();
+	HttpRequest->SetURL(*(Url + Request.ComputePath()));
+
+	for(const auto& It : AdditionalHeaderParams)
+	{
+		HttpRequest->SetHeader(It.Key, It.Value);
+	}
+
+	Request.SetupHttpRequest(HttpRequest);
+	
+	HttpRequest->OnProcessRequestComplete().BindRaw(this, &OpenAPIPetApi::OnUploadFileResponse, Delegate);
+	return HttpRequest->ProcessRequest();
+}
+
+void OpenAPIPetApi::OnUploadFileResponse(FHttpRequestPtr HttpRequest, FHttpResponsePtr HttpResponse, bool bSucceeded, FUploadFileDelegate Delegate) const
+{
+	UploadFileResponse Response;
+	HandleResponse(HttpResponse, bSucceeded, Response);
+	Delegate.ExecuteIfBound(Response);
+}
+
+}

samples/client/petstore/cpp-ue4/Private/OpenAPIPetApiOperations.cpp

@@ -0,0 +1,560 @@
+/**
+ * OpenAPI Petstore
+ * This is a sample server Petstore server. For this sample, you can use the api key `special-key` to test the authorization filters.
+ *
+ * OpenAPI spec version: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator
+ * https://github.com/OpenAPITools/openapi-generator
+ * Do not edit the class manually.
+ */
+
+#include "OpenAPIPetApiOperations.h"
+
+#include "OpenAPIModule.h"
+#include "OpenAPIHelpers.h"
+
+#include "Dom/JsonObject.h"
+#include "Templates/SharedPointer.h"
+#include "HttpModule.h"
+#include "PlatformHttp.h"
+
+namespace OpenAPI 
+{
+
+FString OpenAPIPetApi::AddPetRequest::ComputePath() const
+{
+	FString Path(TEXT("/pet"));
+	return Path;
+}
+
+void OpenAPIPetApi::AddPetRequest::SetupHttpRequest(const TSharedRef<IHttpRequest>& HttpRequest) const
+{
+	static const TArray<FString> Consumes = { TEXT("application/json"), TEXT("application/xml") };
+	//static const TArray<FString> Produces = {  };
+
+	HttpRequest->SetVerb(TEXT("POST"));
+
+	// Default to Json Body request
+	if (Consumes.Num() == 0 || Consumes.Contains(TEXT("application/json")))
+	{
+		// Body parameters
+		FString JsonBody;
+		JsonWriter Writer = TJsonWriterFactory<>::Create(&JsonBody);
+
+		Writer->WriteObjectStart();
+		Writer->WriteIdentifierPrefix(TEXT("body")); WriteJsonValue(Writer, Body);
+		Writer->WriteObjectEnd();
+		Writer->Close();
+
+		HttpRequest->SetHeader(TEXT("Content-Type"), TEXT("application/json; charset=utf-8"));
+		HttpRequest->SetContentAsString(JsonBody);
+	}
+	else if (Consumes.Contains(TEXT("multipart/form-data")))
+	{
+		UE_LOG(LogOpenAPI, Error, TEXT("Body parameter (body) was ignored, not supported in multipart form"));
+	}
+	else if (Consumes.Contains(TEXT("application/x-www-form-urlencoded")))
+	{
+		UE_LOG(LogOpenAPI, Error, TEXT("Body parameter (body) was ignored, not supported in urlencoded requests"));
+	}
+	else
+	{
+		UE_LOG(LogOpenAPI, Error, TEXT("Request ContentType not supported (%s)"), *FString::Join(Consumes, TEXT(",")));
+	}
+}
+
+void OpenAPIPetApi::AddPetResponse::SetHttpResponseCode(EHttpResponseCodes::Type InHttpResponseCode)
+{
+	Response::SetHttpResponseCode(InHttpResponseCode);
+	switch ((int)InHttpResponseCode)
+	{
+	case 405:
+		SetResponseString(TEXT("Invalid input"));
+		break;
+	}
+}
+
+bool OpenAPIPetApi::AddPetResponse::FromJson(const TSharedPtr<FJsonValue>& JsonValue)
+{
+	return true;
+}
+
+FString OpenAPIPetApi::DeletePetRequest::ComputePath() const
+{
+	TMap<FString, FStringFormatArg> PathParams = { 
+	{ TEXT("petId"), ToStringFormatArg(PetId) } };
+
+	FString Path = FString::Format(TEXT("/pet/{petId}"), PathParams);
+	
+	return Path;
+}
+
+void OpenAPIPetApi::DeletePetRequest::SetupHttpRequest(const TSharedRef<IHttpRequest>& HttpRequest) const
+{
+	static const TArray<FString> Consumes = {  };
+	//static const TArray<FString> Produces = {  };
+
+	HttpRequest->SetVerb(TEXT("DELETE"));
+
+	// Header parameters
+	if (ApiKey.IsSet())
+	{
+		HttpRequest->SetHeader(TEXT("api_key"), ApiKey.GetValue());
+	}
+
+	// Default to Json Body request
+	if (Consumes.Num() == 0 || Consumes.Contains(TEXT("application/json")))
+	{
+	}
+	else if (Consumes.Contains(TEXT("multipart/form-data")))
+	{
+	}
+	else if (Consumes.Contains(TEXT("application/x-www-form-urlencoded")))
+	{
+	}
+	else
+	{
+		UE_LOG(LogOpenAPI, Error, TEXT("Request ContentType not supported (%s)"), *FString::Join(Consumes, TEXT(",")));
+	}
+}
+
+void OpenAPIPetApi::DeletePetResponse::SetHttpResponseCode(EHttpResponseCodes::Type InHttpResponseCode)
+{
+	Response::SetHttpResponseCode(InHttpResponseCode);
+	switch ((int)InHttpResponseCode)
+	{
+	case 400:
+		SetResponseString(TEXT("Invalid pet value"));
+		break;
+	}
+}
+
+bool OpenAPIPetApi::DeletePetResponse::FromJson(const TSharedPtr<FJsonValue>& JsonValue)
+{
+	return true;
+}
+
+inline FString ToString(const OpenAPIPetApi::FindPetsByStatusRequest::StatusEnum& Value)
+{
+	switch (Value)
+	{
+	case OpenAPIPetApi::FindPetsByStatusRequest::StatusEnum::Available:
+		return TEXT("available");
+	case OpenAPIPetApi::FindPetsByStatusRequest::StatusEnum::Pending:
+		return TEXT("pending");
+	case OpenAPIPetApi::FindPetsByStatusRequest::StatusEnum::Sold:
+		return TEXT("sold");
+	}
+
+	UE_LOG(LogOpenAPI, Error, TEXT("Invalid OpenAPIPetApi::FindPetsByStatusRequest::StatusEnum Value (%d)"), (int)Value);	
+	return TEXT("");
+}
+
+inline FStringFormatArg ToStringFormatArg(const OpenAPIPetApi::FindPetsByStatusRequest::StatusEnum& Value)
+{
+	return FStringFormatArg(ToString(Value));
+}
+
+inline void WriteJsonValue(JsonWriter& Writer, const OpenAPIPetApi::FindPetsByStatusRequest::StatusEnum& Value)
+{
+	WriteJsonValue(Writer, ToString(Value));
+}
+
+inline bool TryGetJsonValue(const TSharedPtr<FJsonValue>& JsonValue, OpenAPIPetApi::FindPetsByStatusRequest::StatusEnum& Value)
+{
+	FString TmpValue;
+	if (JsonValue->TryGetString(TmpValue))
+	{
+		static TMap<FString, OpenAPIPetApi::FindPetsByStatusRequest::StatusEnum> StringToEnum = { 
+			{ TEXT("available"), OpenAPIPetApi::FindPetsByStatusRequest::StatusEnum::Available },
+			{ TEXT("pending"), OpenAPIPetApi::FindPetsByStatusRequest::StatusEnum::Pending },
+			{ TEXT("sold"), OpenAPIPetApi::FindPetsByStatusRequest::StatusEnum::Sold }, };
+
+		const auto Found = StringToEnum.Find(TmpValue);
+		if(Found)
+		{
+			Value = *Found;
+			return true;
+		}
+	}
+	return false;
+}
+
+FString OpenAPIPetApi::FindPetsByStatusRequest::ComputePath() const
+{
+	FString Path(TEXT("/pet/findByStatus"));
+	TArray<FString> QueryParams;
+	QueryParams.Add(FString(TEXT("status=")) + CollectionToUrlString_csv(Status, TEXT("status")));
+	Path += TCHAR('?');
+	Path += FString::Join(QueryParams, TEXT("&"));
+
+	return Path;
+}
+
+void OpenAPIPetApi::FindPetsByStatusRequest::SetupHttpRequest(const TSharedRef<IHttpRequest>& HttpRequest) const
+{
+	static const TArray<FString> Consumes = {  };
+	//static const TArray<FString> Produces = { TEXT("application/xml"), TEXT("application/json") };
+
+	HttpRequest->SetVerb(TEXT("GET"));
+
+	// Default to Json Body request
+	if (Consumes.Num() == 0 || Consumes.Contains(TEXT("application/json")))
+	{
+	}
+	else if (Consumes.Contains(TEXT("multipart/form-data")))
+	{
+	}
+	else if (Consumes.Contains(TEXT("application/x-www-form-urlencoded")))
+	{
+	}
+	else
+	{
+		UE_LOG(LogOpenAPI, Error, TEXT("Request ContentType not supported (%s)"), *FString::Join(Consumes, TEXT(",")));
+	}
+}
+
+void OpenAPIPetApi::FindPetsByStatusResponse::SetHttpResponseCode(EHttpResponseCodes::Type InHttpResponseCode)
+{
+	Response::SetHttpResponseCode(InHttpResponseCode);
+	switch ((int)InHttpResponseCode)
+	{
+	case 200:
+	default:
+		SetResponseString(TEXT("successful operation"));
+		break;
+	case 400:
+		SetResponseString(TEXT("Invalid status value"));
+		break;
+	}
+}
+
+bool OpenAPIPetApi::FindPetsByStatusResponse::FromJson(const TSharedPtr<FJsonValue>& JsonValue)
+{
+	return TryGetJsonValue(JsonValue, Content);
+}
+
+FString OpenAPIPetApi::FindPetsByTagsRequest::ComputePath() const
+{
+	FString Path(TEXT("/pet/findByTags"));
+	TArray<FString> QueryParams;
+	QueryParams.Add(FString(TEXT("tags=")) + CollectionToUrlString_csv(Tags, TEXT("tags")));
+	Path += TCHAR('?');
+	Path += FString::Join(QueryParams, TEXT("&"));
+
+	return Path;
+}
+
+void OpenAPIPetApi::FindPetsByTagsRequest::SetupHttpRequest(const TSharedRef<IHttpRequest>& HttpRequest) const
+{
+	static const TArray<FString> Consumes = {  };
+	//static const TArray<FString> Produces = { TEXT("application/xml"), TEXT("application/json") };
+
+	HttpRequest->SetVerb(TEXT("GET"));
+
+	// Default to Json Body request
+	if (Consumes.Num() == 0 || Consumes.Contains(TEXT("application/json")))
+	{
+	}
+	else if (Consumes.Contains(TEXT("multipart/form-data")))
+	{
+	}
+	else if (Consumes.Contains(TEXT("application/x-www-form-urlencoded")))
+	{
+	}
+	else
+	{
+		UE_LOG(LogOpenAPI, Error, TEXT("Request ContentType not supported (%s)"), *FString::Join(Consumes, TEXT(",")));
+	}
+}
+
+void OpenAPIPetApi::FindPetsByTagsResponse::SetHttpResponseCode(EHttpResponseCodes::Type InHttpResponseCode)
+{
+	Response::SetHttpResponseCode(InHttpResponseCode);
+	switch ((int)InHttpResponseCode)
+	{
+	case 200:
+	default:
+		SetResponseString(TEXT("successful operation"));
+		break;
+	case 400:
+		SetResponseString(TEXT("Invalid tag value"));
+		break;
+	}
+}
+
+bool OpenAPIPetApi::FindPetsByTagsResponse::FromJson(const TSharedPtr<FJsonValue>& JsonValue)
+{
+	return TryGetJsonValue(JsonValue, Content);
+}
+
+FString OpenAPIPetApi::GetPetByIdRequest::ComputePath() const
+{
+	TMap<FString, FStringFormatArg> PathParams = { 
+	{ TEXT("petId"), ToStringFormatArg(PetId) } };
+
+	FString Path = FString::Format(TEXT("/pet/{petId}"), PathParams);
+	
+	return Path;
+}
+
+void OpenAPIPetApi::GetPetByIdRequest::SetupHttpRequest(const TSharedRef<IHttpRequest>& HttpRequest) const
+{
+	static const TArray<FString> Consumes = {  };
+	//static const TArray<FString> Produces = { TEXT("application/xml"), TEXT("application/json") };
+
+	HttpRequest->SetVerb(TEXT("GET"));
+
+	// Default to Json Body request
+	if (Consumes.Num() == 0 || Consumes.Contains(TEXT("application/json")))
+	{
+	}
+	else if (Consumes.Contains(TEXT("multipart/form-data")))
+	{
+	}
+	else if (Consumes.Contains(TEXT("application/x-www-form-urlencoded")))
+	{
+	}
+	else
+	{
+		UE_LOG(LogOpenAPI, Error, TEXT("Request ContentType not supported (%s)"), *FString::Join(Consumes, TEXT(",")));
+	}
+}
+
+void OpenAPIPetApi::GetPetByIdResponse::SetHttpResponseCode(EHttpResponseCodes::Type InHttpResponseCode)
+{
+	Response::SetHttpResponseCode(InHttpResponseCode);
+	switch ((int)InHttpResponseCode)
+	{
+	case 200:
+	default:
+		SetResponseString(TEXT("successful operation"));
+		break;
+	case 400:
+		SetResponseString(TEXT("Invalid ID supplied"));
+		break;
+	case 404:
+		SetResponseString(TEXT("Pet not found"));
+		break;
+	}
+}
+
+bool OpenAPIPetApi::GetPetByIdResponse::FromJson(const TSharedPtr<FJsonValue>& JsonValue)
+{
+	return TryGetJsonValue(JsonValue, Content);
+}
+
+FString OpenAPIPetApi::UpdatePetRequest::ComputePath() const
+{
+	FString Path(TEXT("/pet"));
+	return Path;
+}
+
+void OpenAPIPetApi::UpdatePetRequest::SetupHttpRequest(const TSharedRef<IHttpRequest>& HttpRequest) const
+{
+	static const TArray<FString> Consumes = { TEXT("application/json"), TEXT("application/xml") };
+	//static const TArray<FString> Produces = {  };
+
+	HttpRequest->SetVerb(TEXT("PUT"));
+
+	// Default to Json Body request
+	if (Consumes.Num() == 0 || Consumes.Contains(TEXT("application/json")))
+	{
+		// Body parameters
+		FString JsonBody;
+		JsonWriter Writer = TJsonWriterFactory<>::Create(&JsonBody);
+
+		Writer->WriteObjectStart();
+		Writer->WriteIdentifierPrefix(TEXT("body")); WriteJsonValue(Writer, Body);
+		Writer->WriteObjectEnd();
+		Writer->Close();
+
+		HttpRequest->SetHeader(TEXT("Content-Type"), TEXT("application/json; charset=utf-8"));
+		HttpRequest->SetContentAsString(JsonBody);
+	}
+	else if (Consumes.Contains(TEXT("multipart/form-data")))
+	{
+		UE_LOG(LogOpenAPI, Error, TEXT("Body parameter (body) was ignored, not supported in multipart form"));
+	}
+	else if (Consumes.Contains(TEXT("application/x-www-form-urlencoded")))
+	{
+		UE_LOG(LogOpenAPI, Error, TEXT("Body parameter (body) was ignored, not supported in urlencoded requests"));
+	}
+	else
+	{
+		UE_LOG(LogOpenAPI, Error, TEXT("Request ContentType not supported (%s)"), *FString::Join(Consumes, TEXT(",")));
+	}
+}
+
+void OpenAPIPetApi::UpdatePetResponse::SetHttpResponseCode(EHttpResponseCodes::Type InHttpResponseCode)
+{
+	Response::SetHttpResponseCode(InHttpResponseCode);
+	switch ((int)InHttpResponseCode)
+	{
+	case 400:
+		SetResponseString(TEXT("Invalid ID supplied"));
+		break;
+	case 404:
+		SetResponseString(TEXT("Pet not found"));
+		break;
+	case 405:
+		SetResponseString(TEXT("Validation exception"));
+		break;
+	}
+}
+
+bool OpenAPIPetApi::UpdatePetResponse::FromJson(const TSharedPtr<FJsonValue>& JsonValue)
+{
+	return true;
+}
+
+FString OpenAPIPetApi::UpdatePetWithFormRequest::ComputePath() const
+{
+	TMap<FString, FStringFormatArg> PathParams = { 
+	{ TEXT("petId"), ToStringFormatArg(PetId) } };
+
+	FString Path = FString::Format(TEXT("/pet/{petId}"), PathParams);
+	
+	return Path;
+}
+
+void OpenAPIPetApi::UpdatePetWithFormRequest::SetupHttpRequest(const TSharedRef<IHttpRequest>& HttpRequest) const
+{
+	static const TArray<FString> Consumes = { TEXT("application/x-www-form-urlencoded") };
+	//static const TArray<FString> Produces = {  };
+
+	HttpRequest->SetVerb(TEXT("POST"));
+
+	// Default to Json Body request
+	if (Consumes.Num() == 0 || Consumes.Contains(TEXT("application/json")))
+	{
+		UE_LOG(LogOpenAPI, Error, TEXT("Form parameter (name) was ignored, cannot be used in JsonBody"));
+		UE_LOG(LogOpenAPI, Error, TEXT("Form parameter (status) was ignored, cannot be used in JsonBody"));
+	}
+	else if (Consumes.Contains(TEXT("multipart/form-data")))
+	{
+		HttpMultipartFormData FormData;
+		if(Name.IsSet())
+		{
+			FormData.AddStringPart(TEXT("name"), *ToUrlString(Name.GetValue()));
+		}
+		if(Status.IsSet())
+		{
+			FormData.AddStringPart(TEXT("status"), *ToUrlString(Status.GetValue()));
+		}
+
+		FormData.SetupHttpRequest(HttpRequest);
+	}
+	else if (Consumes.Contains(TEXT("application/x-www-form-urlencoded")))
+	{
+		TArray<FString> FormParams;
+		if(Name.IsSet())
+		{
+			FormParams.Add(FString(TEXT("name=")) + ToUrlString(Name.GetValue()));
+		}
+		if(Status.IsSet())
+		{
+			FormParams.Add(FString(TEXT("status=")) + ToUrlString(Status.GetValue()));
+		}
+		
+		HttpRequest->SetHeader(TEXT("Content-Type"), TEXT("application/x-www-form-urlencoded; charset=utf-8"));
+		HttpRequest->SetContentAsString(FString::Join(FormParams, TEXT("&")));
+	}
+	else
+	{
+		UE_LOG(LogOpenAPI, Error, TEXT("Request ContentType not supported (%s)"), *FString::Join(Consumes, TEXT(",")));
+	}
+}
+
+void OpenAPIPetApi::UpdatePetWithFormResponse::SetHttpResponseCode(EHttpResponseCodes::Type InHttpResponseCode)
+{
+	Response::SetHttpResponseCode(InHttpResponseCode);
+	switch ((int)InHttpResponseCode)
+	{
+	case 405:
+		SetResponseString(TEXT("Invalid input"));
+		break;
+	}
+}
+
+bool OpenAPIPetApi::UpdatePetWithFormResponse::FromJson(const TSharedPtr<FJsonValue>& JsonValue)
+{
+	return true;
+}
+
+FString OpenAPIPetApi::UploadFileRequest::ComputePath() const
+{
+	TMap<FString, FStringFormatArg> PathParams = { 
+	{ TEXT("petId"), ToStringFormatArg(PetId) } };
+
+	FString Path = FString::Format(TEXT("/pet/{petId}/uploadImage"), PathParams);
+	
+	return Path;
+}
+
+void OpenAPIPetApi::UploadFileRequest::SetupHttpRequest(const TSharedRef<IHttpRequest>& HttpRequest) const
+{
+	static const TArray<FString> Consumes = { TEXT("multipart/form-data") };
+	//static const TArray<FString> Produces = { TEXT("application/json") };
+
+	HttpRequest->SetVerb(TEXT("POST"));
+
+	// Default to Json Body request
+	if (Consumes.Num() == 0 || Consumes.Contains(TEXT("application/json")))
+	{
+		UE_LOG(LogOpenAPI, Error, TEXT("Form parameter (additionalMetadata) was ignored, cannot be used in JsonBody"));
+		UE_LOG(LogOpenAPI, Error, TEXT("Form parameter (file) was ignored, cannot be used in JsonBody"));
+	}
+	else if (Consumes.Contains(TEXT("multipart/form-data")))
+	{
+		HttpMultipartFormData FormData;
+		if(AdditionalMetadata.IsSet())
+		{
+			FormData.AddStringPart(TEXT("additionalMetadata"), *ToUrlString(AdditionalMetadata.GetValue()));
+		}
+		if(File.IsSet())
+		{
+			FormData.AddFilePart(TEXT("file"), File.GetValue());
+			FormData.AddBinaryPart(TEXT("file"), File.GetValue());
+		}
+
+		FormData.SetupHttpRequest(HttpRequest);
+	}
+	else if (Consumes.Contains(TEXT("application/x-www-form-urlencoded")))
+	{
+		TArray<FString> FormParams;
+		if(AdditionalMetadata.IsSet())
+		{
+			FormParams.Add(FString(TEXT("additionalMetadata=")) + ToUrlString(AdditionalMetadata.GetValue()));
+		}
+		UE_LOG(LogOpenAPI, Error, TEXT("Form parameter (file) was ignored, Files are not supported in urlencoded requests"));
+		
+		HttpRequest->SetHeader(TEXT("Content-Type"), TEXT("application/x-www-form-urlencoded; charset=utf-8"));
+		HttpRequest->SetContentAsString(FString::Join(FormParams, TEXT("&")));
+	}
+	else
+	{
+		UE_LOG(LogOpenAPI, Error, TEXT("Request ContentType not supported (%s)"), *FString::Join(Consumes, TEXT(",")));
+	}
+}
+
+void OpenAPIPetApi::UploadFileResponse::SetHttpResponseCode(EHttpResponseCodes::Type InHttpResponseCode)
+{
+	Response::SetHttpResponseCode(InHttpResponseCode);
+	switch ((int)InHttpResponseCode)
+	{
+	case 200:
+	default:
+		SetResponseString(TEXT("successful operation"));
+		break;
+	}
+}
+
+bool OpenAPIPetApi::UploadFileResponse::FromJson(const TSharedPtr<FJsonValue>& JsonValue)
+{
+	return TryGetJsonValue(JsonValue, Content);
+}
+
+}

samples/client/petstore/cpp-ue4/Private/OpenAPIStoreApi.cpp

@@ -0,0 +1,201 @@
+/**
+ * OpenAPI Petstore
+ * This is a sample server Petstore server. For this sample, you can use the api key `special-key` to test the authorization filters.
+ *
+ * OpenAPI spec version: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator
+ * https://github.com/OpenAPITools/openapi-generator
+ * Do not edit the class manually.
+ */
+
+#include "OpenAPIStoreApi.h"
+
+#include "OpenAPIStoreApiOperations.h"
+#include "OpenAPIModule.h"
+
+#include "HttpModule.h"
+#include "Serialization/JsonSerializer.h"
+
+namespace OpenAPI 
+{
+
+OpenAPIStoreApi::OpenAPIStoreApi() 
+: Url(TEXT("http://petstore.swagger.io/v2"))
+{
+}
+
+OpenAPIStoreApi::~OpenAPIStoreApi() {}
+
+void OpenAPIStoreApi::SetURL(const FString& InUrl)
+{
+	Url = InUrl;
+}
+
+void OpenAPIStoreApi::AddHeaderParam(const FString& Key, const FString& Value)
+{
+	AdditionalHeaderParams.Add(Key, Value);
+}
+
+void OpenAPIStoreApi::ClearHeaderParams()
+{
+	AdditionalHeaderParams.Reset();
+}
+
+bool OpenAPIStoreApi::IsValid() const
+{
+	if (Url.IsEmpty())
+	{
+		UE_LOG(LogOpenAPI, Error, TEXT("OpenAPIStoreApi: Endpoint Url is not set, request cannot be performed"));
+		return false;
+	}
+
+	return true;
+}
+
+void OpenAPIStoreApi::HandleResponse(FHttpResponsePtr HttpResponse, bool bSucceeded, Response& InOutResponse) const
+{
+	InOutResponse.SetHttpResponse(HttpResponse);
+	InOutResponse.SetSuccessful(bSucceeded);
+
+	if (bSucceeded && HttpResponse.IsValid())
+	{
+		InOutResponse.SetHttpResponseCode((EHttpResponseCodes::Type)HttpResponse->GetResponseCode());
+		FString ContentType = HttpResponse->GetContentType();
+		FString Content;
+
+		if (ContentType == TEXT("application/json"))
+		{
+			Content = HttpResponse->GetContentAsString();
+
+			TSharedPtr<FJsonValue> JsonValue;
+			auto Reader = TJsonReaderFactory<>::Create(Content);
+
+			if (FJsonSerializer::Deserialize(Reader, JsonValue) && JsonValue.IsValid())
+			{
+				if (InOutResponse.FromJson(JsonValue))
+					return; // Successfully parsed
+			}
+		}
+		else if(ContentType == TEXT("text/plain"))
+		{
+			Content = HttpResponse->GetContentAsString();
+			InOutResponse.SetResponseString(Content);
+			return; // Successfully parsed
+		}
+
+		// Report the parse error but do not mark the request as unsuccessful. Data could be partial or malformed, but the request succeeded.
+		UE_LOG(LogOpenAPI, Error, TEXT("Failed to deserialize Http response content (type:%s):\n%s"), *ContentType , *Content);
+		return;
+	}
+
+	// By default, assume we failed to establish connection
+	InOutResponse.SetHttpResponseCode(EHttpResponseCodes::RequestTimeout);
+}
+
+bool OpenAPIStoreApi::DeleteOrder(const DeleteOrderRequest& Request, const FDeleteOrderDelegate& Delegate /*= FDeleteOrderDelegate()*/) const
+{
+	if (!IsValid())
+		return false;
+
+	TSharedRef<IHttpRequest> HttpRequest = FHttpModule::Get().CreateRequest();
+	HttpRequest->SetURL(*(Url + Request.ComputePath()));
+
+	for(const auto& It : AdditionalHeaderParams)
+	{
+		HttpRequest->SetHeader(It.Key, It.Value);
+	}
+
+	Request.SetupHttpRequest(HttpRequest);
+	
+	HttpRequest->OnProcessRequestComplete().BindRaw(this, &OpenAPIStoreApi::OnDeleteOrderResponse, Delegate);
+	return HttpRequest->ProcessRequest();
+}
+
+void OpenAPIStoreApi::OnDeleteOrderResponse(FHttpRequestPtr HttpRequest, FHttpResponsePtr HttpResponse, bool bSucceeded, FDeleteOrderDelegate Delegate) const
+{
+	DeleteOrderResponse Response;
+	HandleResponse(HttpResponse, bSucceeded, Response);
+	Delegate.ExecuteIfBound(Response);
+}
+
+bool OpenAPIStoreApi::GetInventory(const GetInventoryRequest& Request, const FGetInventoryDelegate& Delegate /*= FGetInventoryDelegate()*/) const
+{
+	if (!IsValid())
+		return false;
+
+	TSharedRef<IHttpRequest> HttpRequest = FHttpModule::Get().CreateRequest();
+	HttpRequest->SetURL(*(Url + Request.ComputePath()));
+
+	for(const auto& It : AdditionalHeaderParams)
+	{
+		HttpRequest->SetHeader(It.Key, It.Value);
+	}
+
+	Request.SetupHttpRequest(HttpRequest);
+	
+	HttpRequest->OnProcessRequestComplete().BindRaw(this, &OpenAPIStoreApi::OnGetInventoryResponse, Delegate);
+	return HttpRequest->ProcessRequest();
+}
+
+void OpenAPIStoreApi::OnGetInventoryResponse(FHttpRequestPtr HttpRequest, FHttpResponsePtr HttpResponse, bool bSucceeded, FGetInventoryDelegate Delegate) const
+{
+	GetInventoryResponse Response;
+	HandleResponse(HttpResponse, bSucceeded, Response);
+	Delegate.ExecuteIfBound(Response);
+}
+
+bool OpenAPIStoreApi::GetOrderById(const GetOrderByIdRequest& Request, const FGetOrderByIdDelegate& Delegate /*= FGetOrderByIdDelegate()*/) const
+{
+	if (!IsValid())
+		return false;
+
+	TSharedRef<IHttpRequest> HttpRequest = FHttpModule::Get().CreateRequest();
+	HttpRequest->SetURL(*(Url + Request.ComputePath()));
+
+	for(const auto& It : AdditionalHeaderParams)
+	{
+		HttpRequest->SetHeader(It.Key, It.Value);
+	}
+
+	Request.SetupHttpRequest(HttpRequest);
+	
+	HttpRequest->OnProcessRequestComplete().BindRaw(this, &OpenAPIStoreApi::OnGetOrderByIdResponse, Delegate);
+	return HttpRequest->ProcessRequest();
+}
+
+void OpenAPIStoreApi::OnGetOrderByIdResponse(FHttpRequestPtr HttpRequest, FHttpResponsePtr HttpResponse, bool bSucceeded, FGetOrderByIdDelegate Delegate) const
+{
+	GetOrderByIdResponse Response;
+	HandleResponse(HttpResponse, bSucceeded, Response);
+	Delegate.ExecuteIfBound(Response);
+}
+
+bool OpenAPIStoreApi::PlaceOrder(const PlaceOrderRequest& Request, const FPlaceOrderDelegate& Delegate /*= FPlaceOrderDelegate()*/) const
+{
+	if (!IsValid())
+		return false;
+
+	TSharedRef<IHttpRequest> HttpRequest = FHttpModule::Get().CreateRequest();
+	HttpRequest->SetURL(*(Url + Request.ComputePath()));
+
+	for(const auto& It : AdditionalHeaderParams)
+	{
+		HttpRequest->SetHeader(It.Key, It.Value);
+	}
+
+	Request.SetupHttpRequest(HttpRequest);
+	
+	HttpRequest->OnProcessRequestComplete().BindRaw(this, &OpenAPIStoreApi::OnPlaceOrderResponse, Delegate);
+	return HttpRequest->ProcessRequest();
+}
+
+void OpenAPIStoreApi::OnPlaceOrderResponse(FHttpRequestPtr HttpRequest, FHttpResponsePtr HttpResponse, bool bSucceeded, FPlaceOrderDelegate Delegate) const
+{
+	PlaceOrderResponse Response;
+	HandleResponse(HttpResponse, bSucceeded, Response);
+	Delegate.ExecuteIfBound(Response);
+}
+
+}

samples/client/petstore/cpp-ue4/Private/OpenAPIStoreApiOperations.cpp

@@ -0,0 +1,242 @@
+/**
+ * OpenAPI Petstore
+ * This is a sample server Petstore server. For this sample, you can use the api key `special-key` to test the authorization filters.
+ *
+ * OpenAPI spec version: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator
+ * https://github.com/OpenAPITools/openapi-generator
+ * Do not edit the class manually.
+ */
+
+#include "OpenAPIStoreApiOperations.h"
+
+#include "OpenAPIModule.h"
+#include "OpenAPIHelpers.h"
+
+#include "Dom/JsonObject.h"
+#include "Templates/SharedPointer.h"
+#include "HttpModule.h"
+#include "PlatformHttp.h"
+
+namespace OpenAPI 
+{
+
+FString OpenAPIStoreApi::DeleteOrderRequest::ComputePath() const
+{
+	TMap<FString, FStringFormatArg> PathParams = { 
+	{ TEXT("orderId"), ToStringFormatArg(OrderId) } };
+
+	FString Path = FString::Format(TEXT("/store/order/{orderId}"), PathParams);
+	
+	return Path;
+}
+
+void OpenAPIStoreApi::DeleteOrderRequest::SetupHttpRequest(const TSharedRef<IHttpRequest>& HttpRequest) const
+{
+	static const TArray<FString> Consumes = {  };
+	//static const TArray<FString> Produces = {  };
+
+	HttpRequest->SetVerb(TEXT("DELETE"));
+
+	// Default to Json Body request
+	if (Consumes.Num() == 0 || Consumes.Contains(TEXT("application/json")))
+	{
+	}
+	else if (Consumes.Contains(TEXT("multipart/form-data")))
+	{
+	}
+	else if (Consumes.Contains(TEXT("application/x-www-form-urlencoded")))
+	{
+	}
+	else
+	{
+		UE_LOG(LogOpenAPI, Error, TEXT("Request ContentType not supported (%s)"), *FString::Join(Consumes, TEXT(",")));
+	}
+}
+
+void OpenAPIStoreApi::DeleteOrderResponse::SetHttpResponseCode(EHttpResponseCodes::Type InHttpResponseCode)
+{
+	Response::SetHttpResponseCode(InHttpResponseCode);
+	switch ((int)InHttpResponseCode)
+	{
+	case 400:
+		SetResponseString(TEXT("Invalid ID supplied"));
+		break;
+	case 404:
+		SetResponseString(TEXT("Order not found"));
+		break;
+	}
+}
+
+bool OpenAPIStoreApi::DeleteOrderResponse::FromJson(const TSharedPtr<FJsonValue>& JsonValue)
+{
+	return true;
+}
+
+FString OpenAPIStoreApi::GetInventoryRequest::ComputePath() const
+{
+	FString Path(TEXT("/store/inventory"));
+	return Path;
+}
+
+void OpenAPIStoreApi::GetInventoryRequest::SetupHttpRequest(const TSharedRef<IHttpRequest>& HttpRequest) const
+{
+	static const TArray<FString> Consumes = {  };
+	//static const TArray<FString> Produces = { TEXT("application/json") };
+
+	HttpRequest->SetVerb(TEXT("GET"));
+
+	// Default to Json Body request
+	if (Consumes.Num() == 0 || Consumes.Contains(TEXT("application/json")))
+	{
+	}
+	else if (Consumes.Contains(TEXT("multipart/form-data")))
+	{
+	}
+	else if (Consumes.Contains(TEXT("application/x-www-form-urlencoded")))
+	{
+	}
+	else
+	{
+		UE_LOG(LogOpenAPI, Error, TEXT("Request ContentType not supported (%s)"), *FString::Join(Consumes, TEXT(",")));
+	}
+}
+
+void OpenAPIStoreApi::GetInventoryResponse::SetHttpResponseCode(EHttpResponseCodes::Type InHttpResponseCode)
+{
+	Response::SetHttpResponseCode(InHttpResponseCode);
+	switch ((int)InHttpResponseCode)
+	{
+	case 200:
+	default:
+		SetResponseString(TEXT("successful operation"));
+		break;
+	}
+}
+
+bool OpenAPIStoreApi::GetInventoryResponse::FromJson(const TSharedPtr<FJsonValue>& JsonValue)
+{
+	return TryGetJsonValue(JsonValue, Content);
+}
+
+FString OpenAPIStoreApi::GetOrderByIdRequest::ComputePath() const
+{
+	TMap<FString, FStringFormatArg> PathParams = { 
+	{ TEXT("orderId"), ToStringFormatArg(OrderId) } };
+
+	FString Path = FString::Format(TEXT("/store/order/{orderId}"), PathParams);
+	
+	return Path;
+}
+
+void OpenAPIStoreApi::GetOrderByIdRequest::SetupHttpRequest(const TSharedRef<IHttpRequest>& HttpRequest) const
+{
+	static const TArray<FString> Consumes = {  };
+	//static const TArray<FString> Produces = { TEXT("application/xml"), TEXT("application/json") };
+
+	HttpRequest->SetVerb(TEXT("GET"));
+
+	// Default to Json Body request
+	if (Consumes.Num() == 0 || Consumes.Contains(TEXT("application/json")))
+	{
+	}
+	else if (Consumes.Contains(TEXT("multipart/form-data")))
+	{
+	}
+	else if (Consumes.Contains(TEXT("application/x-www-form-urlencoded")))
+	{
+	}
+	else
+	{
+		UE_LOG(LogOpenAPI, Error, TEXT("Request ContentType not supported (%s)"), *FString::Join(Consumes, TEXT(",")));
+	}
+}
+
+void OpenAPIStoreApi::GetOrderByIdResponse::SetHttpResponseCode(EHttpResponseCodes::Type InHttpResponseCode)
+{
+	Response::SetHttpResponseCode(InHttpResponseCode);
+	switch ((int)InHttpResponseCode)
+	{
+	case 200:
+	default:
+		SetResponseString(TEXT("successful operation"));
+		break;
+	case 400:
+		SetResponseString(TEXT("Invalid ID supplied"));
+		break;
+	case 404:
+		SetResponseString(TEXT("Order not found"));
+		break;
+	}
+}
+
+bool OpenAPIStoreApi::GetOrderByIdResponse::FromJson(const TSharedPtr<FJsonValue>& JsonValue)
+{
+	return TryGetJsonValue(JsonValue, Content);
+}
+
+FString OpenAPIStoreApi::PlaceOrderRequest::ComputePath() const
+{
+	FString Path(TEXT("/store/order"));
+	return Path;
+}
+
+void OpenAPIStoreApi::PlaceOrderRequest::SetupHttpRequest(const TSharedRef<IHttpRequest>& HttpRequest) const
+{
+	static const TArray<FString> Consumes = {  };
+	//static const TArray<FString> Produces = { TEXT("application/xml"), TEXT("application/json") };
+
+	HttpRequest->SetVerb(TEXT("POST"));
+
+	// Default to Json Body request
+	if (Consumes.Num() == 0 || Consumes.Contains(TEXT("application/json")))
+	{
+		// Body parameters
+		FString JsonBody;
+		JsonWriter Writer = TJsonWriterFactory<>::Create(&JsonBody);
+
+		Writer->WriteObjectStart();
+		Writer->WriteIdentifierPrefix(TEXT("body")); WriteJsonValue(Writer, Body);
+		Writer->WriteObjectEnd();
+		Writer->Close();
+
+		HttpRequest->SetHeader(TEXT("Content-Type"), TEXT("application/json; charset=utf-8"));
+		HttpRequest->SetContentAsString(JsonBody);
+	}
+	else if (Consumes.Contains(TEXT("multipart/form-data")))
+	{
+		UE_LOG(LogOpenAPI, Error, TEXT("Body parameter (body) was ignored, not supported in multipart form"));
+	}
+	else if (Consumes.Contains(TEXT("application/x-www-form-urlencoded")))
+	{
+		UE_LOG(LogOpenAPI, Error, TEXT("Body parameter (body) was ignored, not supported in urlencoded requests"));
+	}
+	else
+	{
+		UE_LOG(LogOpenAPI, Error, TEXT("Request ContentType not supported (%s)"), *FString::Join(Consumes, TEXT(",")));
+	}
+}
+
+void OpenAPIStoreApi::PlaceOrderResponse::SetHttpResponseCode(EHttpResponseCodes::Type InHttpResponseCode)
+{
+	Response::SetHttpResponseCode(InHttpResponseCode);
+	switch ((int)InHttpResponseCode)
+	{
+	case 200:
+	default:
+		SetResponseString(TEXT("successful operation"));
+		break;
+	case 400:
+		SetResponseString(TEXT("Invalid Order"));
+		break;
+	}
+}
+
+bool OpenAPIStoreApi::PlaceOrderResponse::FromJson(const TSharedPtr<FJsonValue>& JsonValue)
+{
+	return TryGetJsonValue(JsonValue, Content);
+}
+
+}

samples/client/petstore/cpp-ue4/Private/OpenAPIUserApi.cpp

@@ -0,0 +1,305 @@
+/**
+ * OpenAPI Petstore
+ * This is a sample server Petstore server. For this sample, you can use the api key `special-key` to test the authorization filters.
+ *
+ * OpenAPI spec version: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator
+ * https://github.com/OpenAPITools/openapi-generator
+ * Do not edit the class manually.
+ */
+
+#include "OpenAPIUserApi.h"
+
+#include "OpenAPIUserApiOperations.h"
+#include "OpenAPIModule.h"
+
+#include "HttpModule.h"
+#include "Serialization/JsonSerializer.h"
+
+namespace OpenAPI 
+{
+
+OpenAPIUserApi::OpenAPIUserApi() 
+: Url(TEXT("http://petstore.swagger.io/v2"))
+{
+}
+
+OpenAPIUserApi::~OpenAPIUserApi() {}
+
+void OpenAPIUserApi::SetURL(const FString& InUrl)
+{
+	Url = InUrl;
+}
+
+void OpenAPIUserApi::AddHeaderParam(const FString& Key, const FString& Value)
+{
+	AdditionalHeaderParams.Add(Key, Value);
+}
+
+void OpenAPIUserApi::ClearHeaderParams()
+{
+	AdditionalHeaderParams.Reset();
+}
+
+bool OpenAPIUserApi::IsValid() const
+{
+	if (Url.IsEmpty())
+	{
+		UE_LOG(LogOpenAPI, Error, TEXT("OpenAPIUserApi: Endpoint Url is not set, request cannot be performed"));
+		return false;
+	}
+
+	return true;
+}
+
+void OpenAPIUserApi::HandleResponse(FHttpResponsePtr HttpResponse, bool bSucceeded, Response& InOutResponse) const
+{
+	InOutResponse.SetHttpResponse(HttpResponse);
+	InOutResponse.SetSuccessful(bSucceeded);
+
+	if (bSucceeded && HttpResponse.IsValid())
+	{
+		InOutResponse.SetHttpResponseCode((EHttpResponseCodes::Type)HttpResponse->GetResponseCode());
+		FString ContentType = HttpResponse->GetContentType();
+		FString Content;
+
+		if (ContentType == TEXT("application/json"))
+		{
+			Content = HttpResponse->GetContentAsString();
+
+			TSharedPtr<FJsonValue> JsonValue;
+			auto Reader = TJsonReaderFactory<>::Create(Content);
+
+			if (FJsonSerializer::Deserialize(Reader, JsonValue) && JsonValue.IsValid())
+			{
+				if (InOutResponse.FromJson(JsonValue))
+					return; // Successfully parsed
+			}
+		}
+		else if(ContentType == TEXT("text/plain"))
+		{
+			Content = HttpResponse->GetContentAsString();
+			InOutResponse.SetResponseString(Content);
+			return; // Successfully parsed
+		}
+
+		// Report the parse error but do not mark the request as unsuccessful. Data could be partial or malformed, but the request succeeded.
+		UE_LOG(LogOpenAPI, Error, TEXT("Failed to deserialize Http response content (type:%s):\n%s"), *ContentType , *Content);
+		return;
+	}
+
+	// By default, assume we failed to establish connection
+	InOutResponse.SetHttpResponseCode(EHttpResponseCodes::RequestTimeout);
+}
+
+bool OpenAPIUserApi::CreateUser(const CreateUserRequest& Request, const FCreateUserDelegate& Delegate /*= FCreateUserDelegate()*/) const
+{
+	if (!IsValid())
+		return false;
+
+	TSharedRef<IHttpRequest> HttpRequest = FHttpModule::Get().CreateRequest();
+	HttpRequest->SetURL(*(Url + Request.ComputePath()));
+
+	for(const auto& It : AdditionalHeaderParams)
+	{
+		HttpRequest->SetHeader(It.Key, It.Value);
+	}
+
+	Request.SetupHttpRequest(HttpRequest);
+	
+	HttpRequest->OnProcessRequestComplete().BindRaw(this, &OpenAPIUserApi::OnCreateUserResponse, Delegate);
+	return HttpRequest->ProcessRequest();
+}
+
+void OpenAPIUserApi::OnCreateUserResponse(FHttpRequestPtr HttpRequest, FHttpResponsePtr HttpResponse, bool bSucceeded, FCreateUserDelegate Delegate) const
+{
+	CreateUserResponse Response;
+	HandleResponse(HttpResponse, bSucceeded, Response);
+	Delegate.ExecuteIfBound(Response);
+}
+
+bool OpenAPIUserApi::CreateUsersWithArrayInput(const CreateUsersWithArrayInputRequest& Request, const FCreateUsersWithArrayInputDelegate& Delegate /*= FCreateUsersWithArrayInputDelegate()*/) const
+{
+	if (!IsValid())
+		return false;
+
+	TSharedRef<IHttpRequest> HttpRequest = FHttpModule::Get().CreateRequest();
+	HttpRequest->SetURL(*(Url + Request.ComputePath()));
+
+	for(const auto& It : AdditionalHeaderParams)
+	{
+		HttpRequest->SetHeader(It.Key, It.Value);
+	}
+
+	Request.SetupHttpRequest(HttpRequest);
+	
+	HttpRequest->OnProcessRequestComplete().BindRaw(this, &OpenAPIUserApi::OnCreateUsersWithArrayInputResponse, Delegate);
+	return HttpRequest->ProcessRequest();
+}
+
+void OpenAPIUserApi::OnCreateUsersWithArrayInputResponse(FHttpRequestPtr HttpRequest, FHttpResponsePtr HttpResponse, bool bSucceeded, FCreateUsersWithArrayInputDelegate Delegate) const
+{
+	CreateUsersWithArrayInputResponse Response;
+	HandleResponse(HttpResponse, bSucceeded, Response);
+	Delegate.ExecuteIfBound(Response);
+}
+
+bool OpenAPIUserApi::CreateUsersWithListInput(const CreateUsersWithListInputRequest& Request, const FCreateUsersWithListInputDelegate& Delegate /*= FCreateUsersWithListInputDelegate()*/) const
+{
+	if (!IsValid())
+		return false;
+
+	TSharedRef<IHttpRequest> HttpRequest = FHttpModule::Get().CreateRequest();
+	HttpRequest->SetURL(*(Url + Request.ComputePath()));
+
+	for(const auto& It : AdditionalHeaderParams)
+	{
+		HttpRequest->SetHeader(It.Key, It.Value);
+	}
+
+	Request.SetupHttpRequest(HttpRequest);
+	
+	HttpRequest->OnProcessRequestComplete().BindRaw(this, &OpenAPIUserApi::OnCreateUsersWithListInputResponse, Delegate);
+	return HttpRequest->ProcessRequest();
+}
+
+void OpenAPIUserApi::OnCreateUsersWithListInputResponse(FHttpRequestPtr HttpRequest, FHttpResponsePtr HttpResponse, bool bSucceeded, FCreateUsersWithListInputDelegate Delegate) const
+{
+	CreateUsersWithListInputResponse Response;
+	HandleResponse(HttpResponse, bSucceeded, Response);
+	Delegate.ExecuteIfBound(Response);
+}
+
+bool OpenAPIUserApi::DeleteUser(const DeleteUserRequest& Request, const FDeleteUserDelegate& Delegate /*= FDeleteUserDelegate()*/) const
+{
+	if (!IsValid())
+		return false;
+
+	TSharedRef<IHttpRequest> HttpRequest = FHttpModule::Get().CreateRequest();
+	HttpRequest->SetURL(*(Url + Request.ComputePath()));
+
+	for(const auto& It : AdditionalHeaderParams)
+	{
+		HttpRequest->SetHeader(It.Key, It.Value);
+	}
+
+	Request.SetupHttpRequest(HttpRequest);
+	
+	HttpRequest->OnProcessRequestComplete().BindRaw(this, &OpenAPIUserApi::OnDeleteUserResponse, Delegate);
+	return HttpRequest->ProcessRequest();
+}
+
+void OpenAPIUserApi::OnDeleteUserResponse(FHttpRequestPtr HttpRequest, FHttpResponsePtr HttpResponse, bool bSucceeded, FDeleteUserDelegate Delegate) const
+{
+	DeleteUserResponse Response;
+	HandleResponse(HttpResponse, bSucceeded, Response);
+	Delegate.ExecuteIfBound(Response);
+}
+
+bool OpenAPIUserApi::GetUserByName(const GetUserByNameRequest& Request, const FGetUserByNameDelegate& Delegate /*= FGetUserByNameDelegate()*/) const
+{
+	if (!IsValid())
+		return false;
+
+	TSharedRef<IHttpRequest> HttpRequest = FHttpModule::Get().CreateRequest();
+	HttpRequest->SetURL(*(Url + Request.ComputePath()));
+
+	for(const auto& It : AdditionalHeaderParams)
+	{
+		HttpRequest->SetHeader(It.Key, It.Value);
+	}
+
+	Request.SetupHttpRequest(HttpRequest);
+	
+	HttpRequest->OnProcessRequestComplete().BindRaw(this, &OpenAPIUserApi::OnGetUserByNameResponse, Delegate);
+	return HttpRequest->ProcessRequest();
+}
+
+void OpenAPIUserApi::OnGetUserByNameResponse(FHttpRequestPtr HttpRequest, FHttpResponsePtr HttpResponse, bool bSucceeded, FGetUserByNameDelegate Delegate) const
+{
+	GetUserByNameResponse Response;
+	HandleResponse(HttpResponse, bSucceeded, Response);
+	Delegate.ExecuteIfBound(Response);
+}
+
+bool OpenAPIUserApi::LoginUser(const LoginUserRequest& Request, const FLoginUserDelegate& Delegate /*= FLoginUserDelegate()*/) const
+{
+	if (!IsValid())
+		return false;
+
+	TSharedRef<IHttpRequest> HttpRequest = FHttpModule::Get().CreateRequest();
+	HttpRequest->SetURL(*(Url + Request.ComputePath()));
+
+	for(const auto& It : AdditionalHeaderParams)
+	{
+		HttpRequest->SetHeader(It.Key, It.Value);
+	}
+
+	Request.SetupHttpRequest(HttpRequest);
+	
+	HttpRequest->OnProcessRequestComplete().BindRaw(this, &OpenAPIUserApi::OnLoginUserResponse, Delegate);
+	return HttpRequest->ProcessRequest();
+}
+
+void OpenAPIUserApi::OnLoginUserResponse(FHttpRequestPtr HttpRequest, FHttpResponsePtr HttpResponse, bool bSucceeded, FLoginUserDelegate Delegate) const
+{
+	LoginUserResponse Response;
+	HandleResponse(HttpResponse, bSucceeded, Response);
+	Delegate.ExecuteIfBound(Response);
+}
+
+bool OpenAPIUserApi::LogoutUser(const LogoutUserRequest& Request, const FLogoutUserDelegate& Delegate /*= FLogoutUserDelegate()*/) const
+{
+	if (!IsValid())
+		return false;
+
+	TSharedRef<IHttpRequest> HttpRequest = FHttpModule::Get().CreateRequest();
+	HttpRequest->SetURL(*(Url + Request.ComputePath()));
+
+	for(const auto& It : AdditionalHeaderParams)
+	{
+		HttpRequest->SetHeader(It.Key, It.Value);
+	}
+
+	Request.SetupHttpRequest(HttpRequest);
+	
+	HttpRequest->OnProcessRequestComplete().BindRaw(this, &OpenAPIUserApi::OnLogoutUserResponse, Delegate);
+	return HttpRequest->ProcessRequest();
+}
+
+void OpenAPIUserApi::OnLogoutUserResponse(FHttpRequestPtr HttpRequest, FHttpResponsePtr HttpResponse, bool bSucceeded, FLogoutUserDelegate Delegate) const
+{
+	LogoutUserResponse Response;
+	HandleResponse(HttpResponse, bSucceeded, Response);
+	Delegate.ExecuteIfBound(Response);
+}
+
+bool OpenAPIUserApi::UpdateUser(const UpdateUserRequest& Request, const FUpdateUserDelegate& Delegate /*= FUpdateUserDelegate()*/) const
+{
+	if (!IsValid())
+		return false;
+
+	TSharedRef<IHttpRequest> HttpRequest = FHttpModule::Get().CreateRequest();
+	HttpRequest->SetURL(*(Url + Request.ComputePath()));
+
+	for(const auto& It : AdditionalHeaderParams)
+	{
+		HttpRequest->SetHeader(It.Key, It.Value);
+	}
+
+	Request.SetupHttpRequest(HttpRequest);
+	
+	HttpRequest->OnProcessRequestComplete().BindRaw(this, &OpenAPIUserApi::OnUpdateUserResponse, Delegate);
+	return HttpRequest->ProcessRequest();
+}
+
+void OpenAPIUserApi::OnUpdateUserResponse(FHttpRequestPtr HttpRequest, FHttpResponsePtr HttpResponse, bool bSucceeded, FUpdateUserDelegate Delegate) const
+{
+	UpdateUserResponse Response;
+	HandleResponse(HttpResponse, bSucceeded, Response);
+	Delegate.ExecuteIfBound(Response);
+}
+
+}

samples/client/petstore/cpp-ue4/Private/OpenAPIUserApiOperations.cpp

@@ -0,0 +1,477 @@
+/**
+ * OpenAPI Petstore
+ * This is a sample server Petstore server. For this sample, you can use the api key `special-key` to test the authorization filters.
+ *
+ * OpenAPI spec version: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator
+ * https://github.com/OpenAPITools/openapi-generator
+ * Do not edit the class manually.
+ */
+
+#include "OpenAPIUserApiOperations.h"
+
+#include "OpenAPIModule.h"
+#include "OpenAPIHelpers.h"
+
+#include "Dom/JsonObject.h"
+#include "Templates/SharedPointer.h"
+#include "HttpModule.h"
+#include "PlatformHttp.h"
+
+namespace OpenAPI 
+{
+
+FString OpenAPIUserApi::CreateUserRequest::ComputePath() const
+{
+	FString Path(TEXT("/user"));
+	return Path;
+}
+
+void OpenAPIUserApi::CreateUserRequest::SetupHttpRequest(const TSharedRef<IHttpRequest>& HttpRequest) const
+{
+	static const TArray<FString> Consumes = {  };
+	//static const TArray<FString> Produces = {  };
+
+	HttpRequest->SetVerb(TEXT("POST"));
+
+	// Default to Json Body request
+	if (Consumes.Num() == 0 || Consumes.Contains(TEXT("application/json")))
+	{
+		// Body parameters
+		FString JsonBody;
+		JsonWriter Writer = TJsonWriterFactory<>::Create(&JsonBody);
+
+		Writer->WriteObjectStart();
+		Writer->WriteIdentifierPrefix(TEXT("body")); WriteJsonValue(Writer, Body);
+		Writer->WriteObjectEnd();
+		Writer->Close();
+
+		HttpRequest->SetHeader(TEXT("Content-Type"), TEXT("application/json; charset=utf-8"));
+		HttpRequest->SetContentAsString(JsonBody);
+	}
+	else if (Consumes.Contains(TEXT("multipart/form-data")))
+	{
+		UE_LOG(LogOpenAPI, Error, TEXT("Body parameter (body) was ignored, not supported in multipart form"));
+	}
+	else if (Consumes.Contains(TEXT("application/x-www-form-urlencoded")))
+	{
+		UE_LOG(LogOpenAPI, Error, TEXT("Body parameter (body) was ignored, not supported in urlencoded requests"));
+	}
+	else
+	{
+		UE_LOG(LogOpenAPI, Error, TEXT("Request ContentType not supported (%s)"), *FString::Join(Consumes, TEXT(",")));
+	}
+}
+
+void OpenAPIUserApi::CreateUserResponse::SetHttpResponseCode(EHttpResponseCodes::Type InHttpResponseCode)
+{
+	Response::SetHttpResponseCode(InHttpResponseCode);
+	switch ((int)InHttpResponseCode)
+	{
+	case 0:
+	default:
+		SetResponseString(TEXT("successful operation"));
+		break;
+	}
+}
+
+bool OpenAPIUserApi::CreateUserResponse::FromJson(const TSharedPtr<FJsonValue>& JsonValue)
+{
+	return true;
+}
+
+FString OpenAPIUserApi::CreateUsersWithArrayInputRequest::ComputePath() const
+{
+	FString Path(TEXT("/user/createWithArray"));
+	return Path;
+}
+
+void OpenAPIUserApi::CreateUsersWithArrayInputRequest::SetupHttpRequest(const TSharedRef<IHttpRequest>& HttpRequest) const
+{
+	static const TArray<FString> Consumes = {  };
+	//static const TArray<FString> Produces = {  };
+
+	HttpRequest->SetVerb(TEXT("POST"));
+
+	// Default to Json Body request
+	if (Consumes.Num() == 0 || Consumes.Contains(TEXT("application/json")))
+	{
+		// Body parameters
+		FString JsonBody;
+		JsonWriter Writer = TJsonWriterFactory<>::Create(&JsonBody);
+
+		Writer->WriteObjectStart();
+		Writer->WriteIdentifierPrefix(TEXT("body")); WriteJsonValue(Writer, Body);
+		Writer->WriteObjectEnd();
+		Writer->Close();
+
+		HttpRequest->SetHeader(TEXT("Content-Type"), TEXT("application/json; charset=utf-8"));
+		HttpRequest->SetContentAsString(JsonBody);
+	}
+	else if (Consumes.Contains(TEXT("multipart/form-data")))
+	{
+		UE_LOG(LogOpenAPI, Error, TEXT("Body parameter (body) was ignored, not supported in multipart form"));
+	}
+	else if (Consumes.Contains(TEXT("application/x-www-form-urlencoded")))
+	{
+		UE_LOG(LogOpenAPI, Error, TEXT("Body parameter (body) was ignored, not supported in urlencoded requests"));
+	}
+	else
+	{
+		UE_LOG(LogOpenAPI, Error, TEXT("Request ContentType not supported (%s)"), *FString::Join(Consumes, TEXT(",")));
+	}
+}
+
+void OpenAPIUserApi::CreateUsersWithArrayInputResponse::SetHttpResponseCode(EHttpResponseCodes::Type InHttpResponseCode)
+{
+	Response::SetHttpResponseCode(InHttpResponseCode);
+	switch ((int)InHttpResponseCode)
+	{
+	case 0:
+	default:
+		SetResponseString(TEXT("successful operation"));
+		break;
+	}
+}
+
+bool OpenAPIUserApi::CreateUsersWithArrayInputResponse::FromJson(const TSharedPtr<FJsonValue>& JsonValue)
+{
+	return true;
+}
+
+FString OpenAPIUserApi::CreateUsersWithListInputRequest::ComputePath() const
+{
+	FString Path(TEXT("/user/createWithList"));
+	return Path;
+}
+
+void OpenAPIUserApi::CreateUsersWithListInputRequest::SetupHttpRequest(const TSharedRef<IHttpRequest>& HttpRequest) const
+{
+	static const TArray<FString> Consumes = {  };
+	//static const TArray<FString> Produces = {  };
+
+	HttpRequest->SetVerb(TEXT("POST"));
+
+	// Default to Json Body request
+	if (Consumes.Num() == 0 || Consumes.Contains(TEXT("application/json")))
+	{
+		// Body parameters
+		FString JsonBody;
+		JsonWriter Writer = TJsonWriterFactory<>::Create(&JsonBody);
+
+		Writer->WriteObjectStart();
+		Writer->WriteIdentifierPrefix(TEXT("body")); WriteJsonValue(Writer, Body);
+		Writer->WriteObjectEnd();
+		Writer->Close();
+
+		HttpRequest->SetHeader(TEXT("Content-Type"), TEXT("application/json; charset=utf-8"));
+		HttpRequest->SetContentAsString(JsonBody);
+	}
+	else if (Consumes.Contains(TEXT("multipart/form-data")))
+	{
+		UE_LOG(LogOpenAPI, Error, TEXT("Body parameter (body) was ignored, not supported in multipart form"));
+	}
+	else if (Consumes.Contains(TEXT("application/x-www-form-urlencoded")))
+	{
+		UE_LOG(LogOpenAPI, Error, TEXT("Body parameter (body) was ignored, not supported in urlencoded requests"));
+	}
+	else
+	{
+		UE_LOG(LogOpenAPI, Error, TEXT("Request ContentType not supported (%s)"), *FString::Join(Consumes, TEXT(",")));
+	}
+}
+
+void OpenAPIUserApi::CreateUsersWithListInputResponse::SetHttpResponseCode(EHttpResponseCodes::Type InHttpResponseCode)
+{
+	Response::SetHttpResponseCode(InHttpResponseCode);
+	switch ((int)InHttpResponseCode)
+	{
+	case 0:
+	default:
+		SetResponseString(TEXT("successful operation"));
+		break;
+	}
+}
+
+bool OpenAPIUserApi::CreateUsersWithListInputResponse::FromJson(const TSharedPtr<FJsonValue>& JsonValue)
+{
+	return true;
+}
+
+FString OpenAPIUserApi::DeleteUserRequest::ComputePath() const
+{
+	TMap<FString, FStringFormatArg> PathParams = { 
+	{ TEXT("username"), ToStringFormatArg(Username) } };
+
+	FString Path = FString::Format(TEXT("/user/{username}"), PathParams);
+	
+	return Path;
+}
+
+void OpenAPIUserApi::DeleteUserRequest::SetupHttpRequest(const TSharedRef<IHttpRequest>& HttpRequest) const
+{
+	static const TArray<FString> Consumes = {  };
+	//static const TArray<FString> Produces = {  };
+
+	HttpRequest->SetVerb(TEXT("DELETE"));
+
+	// Default to Json Body request
+	if (Consumes.Num() == 0 || Consumes.Contains(TEXT("application/json")))
+	{
+	}
+	else if (Consumes.Contains(TEXT("multipart/form-data")))
+	{
+	}
+	else if (Consumes.Contains(TEXT("application/x-www-form-urlencoded")))
+	{
+	}
+	else
+	{
+		UE_LOG(LogOpenAPI, Error, TEXT("Request ContentType not supported (%s)"), *FString::Join(Consumes, TEXT(",")));
+	}
+}
+
+void OpenAPIUserApi::DeleteUserResponse::SetHttpResponseCode(EHttpResponseCodes::Type InHttpResponseCode)
+{
+	Response::SetHttpResponseCode(InHttpResponseCode);
+	switch ((int)InHttpResponseCode)
+	{
+	case 400:
+		SetResponseString(TEXT("Invalid username supplied"));
+		break;
+	case 404:
+		SetResponseString(TEXT("User not found"));
+		break;
+	}
+}
+
+bool OpenAPIUserApi::DeleteUserResponse::FromJson(const TSharedPtr<FJsonValue>& JsonValue)
+{
+	return true;
+}
+
+FString OpenAPIUserApi::GetUserByNameRequest::ComputePath() const
+{
+	TMap<FString, FStringFormatArg> PathParams = { 
+	{ TEXT("username"), ToStringFormatArg(Username) } };
+
+	FString Path = FString::Format(TEXT("/user/{username}"), PathParams);
+	
+	return Path;
+}
+
+void OpenAPIUserApi::GetUserByNameRequest::SetupHttpRequest(const TSharedRef<IHttpRequest>& HttpRequest) const
+{
+	static const TArray<FString> Consumes = {  };
+	//static const TArray<FString> Produces = { TEXT("application/xml"), TEXT("application/json") };
+
+	HttpRequest->SetVerb(TEXT("GET"));
+
+	// Default to Json Body request
+	if (Consumes.Num() == 0 || Consumes.Contains(TEXT("application/json")))
+	{
+	}
+	else if (Consumes.Contains(TEXT("multipart/form-data")))
+	{
+	}
+	else if (Consumes.Contains(TEXT("application/x-www-form-urlencoded")))
+	{
+	}
+	else
+	{
+		UE_LOG(LogOpenAPI, Error, TEXT("Request ContentType not supported (%s)"), *FString::Join(Consumes, TEXT(",")));
+	}
+}
+
+void OpenAPIUserApi::GetUserByNameResponse::SetHttpResponseCode(EHttpResponseCodes::Type InHttpResponseCode)
+{
+	Response::SetHttpResponseCode(InHttpResponseCode);
+	switch ((int)InHttpResponseCode)
+	{
+	case 200:
+	default:
+		SetResponseString(TEXT("successful operation"));
+		break;
+	case 400:
+		SetResponseString(TEXT("Invalid username supplied"));
+		break;
+	case 404:
+		SetResponseString(TEXT("User not found"));
+		break;
+	}
+}
+
+bool OpenAPIUserApi::GetUserByNameResponse::FromJson(const TSharedPtr<FJsonValue>& JsonValue)
+{
+	return TryGetJsonValue(JsonValue, Content);
+}
+
+FString OpenAPIUserApi::LoginUserRequest::ComputePath() const
+{
+	FString Path(TEXT("/user/login"));
+	TArray<FString> QueryParams;
+	QueryParams.Add(FString(TEXT("username=")) + ToUrlString(Username));
+	QueryParams.Add(FString(TEXT("password=")) + ToUrlString(Password));
+	Path += TCHAR('?');
+	Path += FString::Join(QueryParams, TEXT("&"));
+
+	return Path;
+}
+
+void OpenAPIUserApi::LoginUserRequest::SetupHttpRequest(const TSharedRef<IHttpRequest>& HttpRequest) const
+{
+	static const TArray<FString> Consumes = {  };
+	//static const TArray<FString> Produces = { TEXT("application/xml"), TEXT("application/json") };
+
+	HttpRequest->SetVerb(TEXT("GET"));
+
+	// Default to Json Body request
+	if (Consumes.Num() == 0 || Consumes.Contains(TEXT("application/json")))
+	{
+	}
+	else if (Consumes.Contains(TEXT("multipart/form-data")))
+	{
+	}
+	else if (Consumes.Contains(TEXT("application/x-www-form-urlencoded")))
+	{
+	}
+	else
+	{
+		UE_LOG(LogOpenAPI, Error, TEXT("Request ContentType not supported (%s)"), *FString::Join(Consumes, TEXT(",")));
+	}
+}
+
+void OpenAPIUserApi::LoginUserResponse::SetHttpResponseCode(EHttpResponseCodes::Type InHttpResponseCode)
+{
+	Response::SetHttpResponseCode(InHttpResponseCode);
+	switch ((int)InHttpResponseCode)
+	{
+	case 200:
+	default:
+		SetResponseString(TEXT("successful operation"));
+		break;
+	case 400:
+		SetResponseString(TEXT("Invalid username/password supplied"));
+		break;
+	}
+}
+
+bool OpenAPIUserApi::LoginUserResponse::FromJson(const TSharedPtr<FJsonValue>& JsonValue)
+{
+	return TryGetJsonValue(JsonValue, Content);
+}
+
+FString OpenAPIUserApi::LogoutUserRequest::ComputePath() const
+{
+	FString Path(TEXT("/user/logout"));
+	return Path;
+}
+
+void OpenAPIUserApi::LogoutUserRequest::SetupHttpRequest(const TSharedRef<IHttpRequest>& HttpRequest) const
+{
+	static const TArray<FString> Consumes = {  };
+	//static const TArray<FString> Produces = {  };
+
+	HttpRequest->SetVerb(TEXT("GET"));
+
+	// Default to Json Body request
+	if (Consumes.Num() == 0 || Consumes.Contains(TEXT("application/json")))
+	{
+	}
+	else if (Consumes.Contains(TEXT("multipart/form-data")))
+	{
+	}
+	else if (Consumes.Contains(TEXT("application/x-www-form-urlencoded")))
+	{
+	}
+	else
+	{
+		UE_LOG(LogOpenAPI, Error, TEXT("Request ContentType not supported (%s)"), *FString::Join(Consumes, TEXT(",")));
+	}
+}
+
+void OpenAPIUserApi::LogoutUserResponse::SetHttpResponseCode(EHttpResponseCodes::Type InHttpResponseCode)
+{
+	Response::SetHttpResponseCode(InHttpResponseCode);
+	switch ((int)InHttpResponseCode)
+	{
+	case 0:
+	default:
+		SetResponseString(TEXT("successful operation"));
+		break;
+	}
+}
+
+bool OpenAPIUserApi::LogoutUserResponse::FromJson(const TSharedPtr<FJsonValue>& JsonValue)
+{
+	return true;
+}
+
+FString OpenAPIUserApi::UpdateUserRequest::ComputePath() const
+{
+	TMap<FString, FStringFormatArg> PathParams = { 
+	{ TEXT("username"), ToStringFormatArg(Username) } };
+
+	FString Path = FString::Format(TEXT("/user/{username}"), PathParams);
+	
+	return Path;
+}
+
+void OpenAPIUserApi::UpdateUserRequest::SetupHttpRequest(const TSharedRef<IHttpRequest>& HttpRequest) const
+{
+	static const TArray<FString> Consumes = {  };
+	//static const TArray<FString> Produces = {  };
+
+	HttpRequest->SetVerb(TEXT("PUT"));
+
+	// Default to Json Body request
+	if (Consumes.Num() == 0 || Consumes.Contains(TEXT("application/json")))
+	{
+		// Body parameters
+		FString JsonBody;
+		JsonWriter Writer = TJsonWriterFactory<>::Create(&JsonBody);
+
+		Writer->WriteObjectStart();
+		Writer->WriteIdentifierPrefix(TEXT("body")); WriteJsonValue(Writer, Body);
+		Writer->WriteObjectEnd();
+		Writer->Close();
+
+		HttpRequest->SetHeader(TEXT("Content-Type"), TEXT("application/json; charset=utf-8"));
+		HttpRequest->SetContentAsString(JsonBody);
+	}
+	else if (Consumes.Contains(TEXT("multipart/form-data")))
+	{
+		UE_LOG(LogOpenAPI, Error, TEXT("Body parameter (body) was ignored, not supported in multipart form"));
+	}
+	else if (Consumes.Contains(TEXT("application/x-www-form-urlencoded")))
+	{
+		UE_LOG(LogOpenAPI, Error, TEXT("Body parameter (body) was ignored, not supported in urlencoded requests"));
+	}
+	else
+	{
+		UE_LOG(LogOpenAPI, Error, TEXT("Request ContentType not supported (%s)"), *FString::Join(Consumes, TEXT(",")));
+	}
+}
+
+void OpenAPIUserApi::UpdateUserResponse::SetHttpResponseCode(EHttpResponseCodes::Type InHttpResponseCode)
+{
+	Response::SetHttpResponseCode(InHttpResponseCode);
+	switch ((int)InHttpResponseCode)
+	{
+	case 400:
+		SetResponseString(TEXT("Invalid user supplied"));
+		break;
+	case 404:
+		SetResponseString(TEXT("User not found"));
+		break;
+	}
+}
+
+bool OpenAPIUserApi::UpdateUserResponse::FromJson(const TSharedPtr<FJsonValue>& JsonValue)
+{
+	return true;
+}
+
+}

samples/client/petstore/cpp-ue4/Public/OpenAPIBaseModel.h

@@ -0,0 +1,66 @@
+/**
+ * OpenAPI Petstore
+ * This is a sample server Petstore server. For this sample, you can use the api key `special-key` to test the authorization filters.
+ *
+ * OpenAPI spec version: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator
+ * https://github.com/OpenAPITools/openapi-generator
+ * Do not edit the class manually.
+ */
+
+#pragma once
+
+#include "Interfaces/IHttpRequest.h"
+#include "Interfaces/IHttpResponse.h"
+#include "Serialization/JsonWriter.h"
+#include "Dom/JsonObject.h"
+
+namespace OpenAPI 
+{
+
+typedef TSharedRef<TJsonWriter<>> JsonWriter;
+
+class OPENAPI_API Model
+{ 
+public:
+	virtual ~Model() {}
+	virtual void WriteJson(JsonWriter& Writer) const = 0;
+	virtual bool FromJson(const TSharedPtr<FJsonObject>& JsonObject) = 0;
+};
+
+class OPENAPI_API Request
+{
+public:
+	virtual ~Request() {}
+	virtual void SetupHttpRequest(const TSharedRef<IHttpRequest>& HttpRequest) const = 0;
+	virtual FString ComputePath() const = 0;
+};
+
+class OPENAPI_API Response
+{
+public:
+	virtual ~Response() {}
+	virtual bool FromJson(const TSharedPtr<FJsonValue>& JsonObject) = 0;
+
+	void SetSuccessful(bool InSuccessful) { Successful = InSuccessful; }
+	bool IsSuccessful() const { return Successful; }
+
+	virtual void SetHttpResponseCode(EHttpResponseCodes::Type InHttpResponseCode);
+	EHttpResponseCodes::Type GetHttpResponseCode() const { return ResponseCode; }
+
+	void SetResponseString(const FString& InResponseString) { ResponseString = InResponseString; }
+	const FString& GetResponseString() const { return ResponseString; }
+
+	void SetHttpResponse(const FHttpResponsePtr& InHttpResponse) { HttpResponse = InHttpResponse; }
+	const FHttpResponsePtr& GetHttpResponse() const { return HttpResponse; }
+
+private:
+	bool Successful;
+	EHttpResponseCodes::Type ResponseCode;
+	FString ResponseString;
+	FHttpResponsePtr HttpResponse;
+};
+
+}

samples/client/petstore/cpp-ue4/Public/OpenAPIHelpers.h

@@ -0,0 +1,412 @@
+/**
+ * OpenAPI Petstore
+ * This is a sample server Petstore server. For this sample, you can use the api key `special-key` to test the authorization filters.
+ *
+ * OpenAPI spec version: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator
+ * https://github.com/OpenAPITools/openapi-generator
+ * Do not edit the class manually.
+ */
+
+#pragma once
+
+#include "OpenAPIBaseModel.h"
+
+#include "Serialization/JsonSerializer.h"
+#include "Dom/JsonObject.h"
+#include "Misc/Base64.h"
+
+class IHttpRequest;
+
+namespace OpenAPI 
+{
+
+typedef TSharedRef<TJsonWriter<>> JsonWriter;
+
+//////////////////////////////////////////////////////////////////////////
+
+class OPENAPI_API HttpFileInput
+{
+public:
+	HttpFileInput(const TCHAR* InFilePath);
+	HttpFileInput(const FString& InFilePath);
+
+	// This will automatically set the content type if not already set
+    void SetFilePath(const TCHAR* InFilePath);
+	void SetFilePath(const FString& InFilePath);
+
+    // Optional if it can be deduced from the FilePath
+    void SetContentType(const TCHAR* ContentType);
+
+	HttpFileInput& operator=(const HttpFileInput& Other) = default;
+	HttpFileInput& operator=(const FString& InFilePath) { SetFilePath(*InFilePath); return*this; }
+	HttpFileInput& operator=(const TCHAR* InFilePath) { SetFilePath(InFilePath); return*this; }
+
+	const FString& GetFilePath() const { return FilePath; }
+	const FString& GetContentType() const { return ContentType; }
+
+	// Returns the filename with extension
+	FString GetFilename() const;
+
+private:
+    FString FilePath;
+    FString ContentType;
+};
+
+//////////////////////////////////////////////////////////////////////////
+
+class HttpMultipartFormData
+{
+public:
+	void SetBoundary(const TCHAR* InBoundary);
+	void SetupHttpRequest(const TSharedRef<IHttpRequest>& HttpRequest);
+
+	void AddStringPart(const TCHAR* Name, const TCHAR* Data);
+	void AddJsonPart(const TCHAR* Name, const FString& JsonString);
+	void AddBinaryPart(const TCHAR* Name, const TArray<uint8>& ByteArray);
+	void AddFilePart(const TCHAR* Name, const HttpFileInput& File);
+
+private:
+	void AppendString(const TCHAR* Str);
+	const FString& GetBoundary() const;
+
+	mutable FString Boundary;
+	TArray<uint8> FormData;
+
+	static const TCHAR* Delimiter;
+	static const TCHAR* Newline;
+};
+
+//////////////////////////////////////////////////////////////////////////
+
+// Decodes Base64Url encoded strings, see https://en.wikipedia.org/wiki/Base64#Variants_summary_table
+template<typename T>
+bool Base64UrlDecode(const FString& Base64String, T& Value)
+{
+	FString TmpCopy(Base64String);
+	TmpCopy.ReplaceInline(TEXT("-"), TEXT("+"));
+	TmpCopy.ReplaceInline(TEXT("_"), TEXT("/"));
+
+	return FBase64::Decode(TmpCopy, Value);
+}
+
+// Encodes strings in Base64Url, see https://en.wikipedia.org/wiki/Base64#Variants_summary_table
+template<typename T>
+FString Base64UrlEncode(const T& Value)
+{
+	FString Base64String = FBase64::Encode(Value);
+	Base64String.ReplaceInline(TEXT("+"), TEXT("-"));
+	Base64String.ReplaceInline(TEXT("/"), TEXT("_"));
+	return Base64String;
+}
+
+template<typename T>
+inline FStringFormatArg ToStringFormatArg(const T& Value)
+{
+	return FStringFormatArg(Value);
+}
+
+inline FStringFormatArg ToStringFormatArg(const FDateTime& Value)
+{
+	return FStringFormatArg(Value.ToIso8601());
+}
+
+inline FStringFormatArg ToStringFormatArg(const TArray<uint8>& Value)
+{
+	return FStringFormatArg(Base64UrlEncode(Value));
+}
+
+template<typename T, typename std::enable_if<!std::is_base_of<Model, T>::value, int>::type = 0>
+inline FString ToString(const T& Value)
+{
+	return FString::Format(TEXT("{0}"), { ToStringFormatArg(Value) });
+}
+
+inline FString ToString(const FString& Value)
+{
+	return Value;
+}
+
+inline FString ToString(const TArray<uint8>& Value)
+{
+	return Base64UrlEncode(Value);
+}
+
+inline FString ToString(const Model& Value)
+{
+	FString String;
+	JsonWriter Writer = TJsonWriterFactory<>::Create(&String);
+	Value.WriteJson(Writer);
+	Writer->Close();
+	return String;
+}
+
+template<typename T>
+inline FString ToUrlString(const T& Value)
+{
+	return FPlatformHttp::UrlEncode(ToString(Value));
+}
+
+template<typename T>
+inline FString CollectionToUrlString(const TArray<T>& Collection, const TCHAR* Separator)
+{
+	FString Output;
+	if(Collection.Num() == 0)
+		return Output;
+
+	Output += ToUrlString(Collection[0]);
+	for(int i = 1; i < Collection.Num(); i++)
+	{
+		Output += FString::Format(TEXT("{0}{1}"), { Separator, *ToUrlString(Collection[i]) });
+	}
+	return Output;
+}
+
+template<typename T>
+inline FString CollectionToUrlString_csv(const TArray<T>& Collection, const TCHAR* BaseName)
+{
+	return CollectionToUrlString(Collection, TEXT(","));
+}
+
+template<typename T>
+inline FString CollectionToUrlString_ssv(const TArray<T>& Collection, const TCHAR* BaseName)
+{
+	return CollectionToUrlString(Collection, TEXT(" "));
+}
+
+template<typename T>
+inline FString CollectionToUrlString_tsv(const TArray<T>& Collection, const TCHAR* BaseName)
+{
+	return CollectionToUrlString(Collection, TEXT("\t"));
+}
+
+template<typename T>
+inline FString CollectionToUrlString_pipes(const TArray<T>& Collection, const TCHAR* BaseName)
+{
+	return CollectionToUrlString(Collection, TEXT("|"));
+}
+
+template<typename T>
+inline FString CollectionToUrlString_multi(const TArray<T>& Collection, const TCHAR* BaseName)
+{
+	FString Output;
+	if(Collection.Num() == 0)
+		return Output;
+
+	Output += FString::Format(TEXT("{0}={1}"), { FStringFormatArg(BaseName), ToUrlString(Collection[0]) });
+	for(int i = 1; i < Collection.Num(); i++)
+	{
+		Output += FString::Format(TEXT("&{0}={1}"), { FStringFormatArg(BaseName), ToUrlString(Collection[i]) });
+	}
+	return Output;
+}
+
+//////////////////////////////////////////////////////////////////////////
+
+template<typename T, typename std::enable_if<!std::is_base_of<Model, T>::value, int>::type = 0>
+inline void WriteJsonValue(JsonWriter& Writer, const T& Value)
+{
+	Writer->WriteValue(Value);
+}
+
+inline void WriteJsonValue(JsonWriter& Writer, const FDateTime& Value)
+{
+	Writer->WriteValue(Value.ToIso8601());
+}
+
+inline void WriteJsonValue(JsonWriter& Writer, const Model& Value)
+{
+	Value.WriteJson(Writer);
+}
+
+template<typename T>
+inline void WriteJsonValue(JsonWriter& Writer, const TArray<T>& Value)
+{
+	Writer->WriteArrayStart();
+	for (const auto& Element : Value)
+	{
+		WriteJsonValue(Writer, Element);
+	}
+	Writer->WriteArrayEnd();
+}
+
+template<typename T>
+inline void WriteJsonValue(JsonWriter& Writer, const TMap<FString, T>& Value)
+{
+	Writer->WriteObjectStart();
+	for (const auto& It : Value)
+	{
+		Writer->WriteIdentifierPrefix(It.Key);
+		WriteJsonValue(Writer, It.Value);
+	}
+	Writer->WriteObjectEnd();
+}
+
+inline void WriteJsonValue(JsonWriter& Writer, const TSharedPtr<FJsonObject>& Value)
+{
+	if (Value.IsValid())
+	{
+		FJsonSerializer::Serialize(Value.ToSharedRef(), Writer, false);
+	}
+	else
+	{
+		Writer->WriteObjectStart();
+		Writer->WriteObjectEnd();
+	}
+}
+
+inline void WriteJsonValue(JsonWriter& Writer, const TArray<uint8>& Value)
+{
+	Writer->WriteValue(ToString(Value));
+}
+
+//////////////////////////////////////////////////////////////////////////
+
+template<typename T>
+inline bool TryGetJsonValue(const TSharedPtr<FJsonObject>& JsonObject, const FString& Key, T& Value)
+{
+	const TSharedPtr<FJsonValue> JsonValue = JsonObject->TryGetField(Key);
+	if (JsonValue.IsValid() && !JsonValue->IsNull())
+	{
+		return TryGetJsonValue(JsonValue, Value);
+	}
+	return false;
+}
+
+template<typename T>
+inline bool TryGetJsonValue(const TSharedPtr<FJsonObject>& JsonObject, const FString& Key, TOptional<T>& OptionalValue)
+{
+	if(JsonObject->HasField(Key))
+	{
+		T Value;
+		if (TryGetJsonValue(JsonObject, Key, Value))
+		{
+			OptionalValue = Value;
+			return true;
+		}
+		else
+			return false;
+	}
+	return true; // Absence of optional value is not a parsing error
+}
+
+inline bool TryGetJsonValue(const TSharedPtr<FJsonValue>& JsonValue, FString& Value)
+{
+	FString TmpValue;
+	if (JsonValue->TryGetString(TmpValue))
+	{
+		Value = TmpValue;
+		return true;
+	}
+	else
+		return false;
+}
+
+inline bool TryGetJsonValue(const TSharedPtr<FJsonValue>& JsonValue, FDateTime& Value)
+{
+	FString TmpValue;
+	if (JsonValue->TryGetString(TmpValue))
+		return FDateTime::Parse(TmpValue, Value);
+	else
+		return false;
+}
+
+inline bool TryGetJsonValue(const TSharedPtr<FJsonValue>& JsonValue, bool& Value)
+{
+	bool TmpValue;
+	if (JsonValue->TryGetBool(TmpValue))
+	{
+		Value = TmpValue;
+		return true;
+	}
+	else
+		return false;
+}
+
+template<typename T, typename std::enable_if<!std::is_base_of<Model, T>::value, int>::type = 0>
+inline bool TryGetJsonValue(const TSharedPtr<FJsonValue>& JsonValue, T& Value)
+{
+	T TmpValue;
+	if (JsonValue->TryGetNumber(TmpValue))
+	{
+		Value = TmpValue;
+		return true;
+	}
+	else
+		return false;
+}
+
+inline bool TryGetJsonValue(const TSharedPtr<FJsonValue>& JsonValue, Model& Value)
+{
+	const TSharedPtr<FJsonObject>* Object;
+	if (JsonValue->TryGetObject(Object))
+		return Value.FromJson(*Object);
+	else
+		return false;
+}
+
+template<typename T>
+inline bool TryGetJsonValue(const TSharedPtr<FJsonValue>& JsonValue, TArray<T>& ArrayValue)
+{
+	const TArray<TSharedPtr<FJsonValue>>* JsonArray;
+	if (JsonValue->TryGetArray(JsonArray))
+	{
+		bool ParseSuccess = true;
+		const int32 Count = JsonArray->Num();
+		ArrayValue.Reset(Count);
+		for (int i = 0; i < Count; i++)
+		{
+			T TmpValue;
+			ParseSuccess &= TryGetJsonValue((*JsonArray)[i], TmpValue);
+			ArrayValue.Emplace(MoveTemp(TmpValue));
+		}
+		return ParseSuccess;
+	}
+	return false;
+}
+
+template<typename T>
+inline bool TryGetJsonValue(const TSharedPtr<FJsonValue>& JsonValue, TMap<FString, T>& MapValue)
+{
+	const TSharedPtr<FJsonObject>* Object;
+	if (JsonValue->TryGetObject(Object))
+	{
+		MapValue.Reset();
+		bool ParseSuccess = true;
+		for (const auto& It : (*Object)->Values)
+		{
+			T TmpValue;
+			ParseSuccess &= TryGetJsonValue(It.Value, TmpValue);
+			MapValue.Emplace(It.Key, MoveTemp(TmpValue));
+		}
+		return ParseSuccess;
+	}
+	return false;
+}
+
+inline bool TryGetJsonValue(const TSharedPtr<FJsonValue>& JsonValue, TSharedPtr<FJsonObject>& JsonObjectValue)
+{
+	const TSharedPtr<FJsonObject>* Object;
+	if (JsonValue->TryGetObject(Object))
+	{
+		JsonObjectValue = *Object;
+		return true;
+	}
+	return false;
+}
+
+inline bool TryGetJsonValue(const TSharedPtr<FJsonValue>& JsonValue, TArray<uint8>& Value)
+{
+	FString TmpValue;
+	if (JsonValue->TryGetString(TmpValue))
+	{
+		Base64UrlDecode(TmpValue, Value);
+		return true;
+	}
+	else
+		return false;
+}
+
+}

samples/client/petstore/cpp-ue4/Public/OpenAPIPetApi.h

@@ -0,0 +1,83 @@
+/**
+ * OpenAPI Petstore
+ * This is a sample server Petstore server. For this sample, you can use the api key `special-key` to test the authorization filters.
+ *
+ * OpenAPI spec version: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator
+ * https://github.com/OpenAPITools/openapi-generator
+ * Do not edit the class manually.
+ */
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "OpenAPIBaseModel.h"
+
+namespace OpenAPI 
+{
+
+class OPENAPI_API OpenAPIPetApi
+{
+public:
+	OpenAPIPetApi();
+	~OpenAPIPetApi();
+
+	void SetURL(const FString& Url);
+	void AddHeaderParam(const FString& Key, const FString& Value);
+	void ClearHeaderParams();
+
+	class AddPetRequest;
+	class AddPetResponse;
+	class DeletePetRequest;
+	class DeletePetResponse;
+	class FindPetsByStatusRequest;
+	class FindPetsByStatusResponse;
+	class FindPetsByTagsRequest;
+	class FindPetsByTagsResponse;
+	class GetPetByIdRequest;
+	class GetPetByIdResponse;
+	class UpdatePetRequest;
+	class UpdatePetResponse;
+	class UpdatePetWithFormRequest;
+	class UpdatePetWithFormResponse;
+	class UploadFileRequest;
+	class UploadFileResponse;
+	
+    DECLARE_DELEGATE_OneParam(FAddPetDelegate, const AddPetResponse&);
+    DECLARE_DELEGATE_OneParam(FDeletePetDelegate, const DeletePetResponse&);
+    DECLARE_DELEGATE_OneParam(FFindPetsByStatusDelegate, const FindPetsByStatusResponse&);
+    DECLARE_DELEGATE_OneParam(FFindPetsByTagsDelegate, const FindPetsByTagsResponse&);
+    DECLARE_DELEGATE_OneParam(FGetPetByIdDelegate, const GetPetByIdResponse&);
+    DECLARE_DELEGATE_OneParam(FUpdatePetDelegate, const UpdatePetResponse&);
+    DECLARE_DELEGATE_OneParam(FUpdatePetWithFormDelegate, const UpdatePetWithFormResponse&);
+    DECLARE_DELEGATE_OneParam(FUploadFileDelegate, const UploadFileResponse&);
+    
+    bool AddPet(const AddPetRequest& Request, const FAddPetDelegate& Delegate = FAddPetDelegate()) const;
+    bool DeletePet(const DeletePetRequest& Request, const FDeletePetDelegate& Delegate = FDeletePetDelegate()) const;
+    bool FindPetsByStatus(const FindPetsByStatusRequest& Request, const FFindPetsByStatusDelegate& Delegate = FFindPetsByStatusDelegate()) const;
+    bool FindPetsByTags(const FindPetsByTagsRequest& Request, const FFindPetsByTagsDelegate& Delegate = FFindPetsByTagsDelegate()) const;
+    bool GetPetById(const GetPetByIdRequest& Request, const FGetPetByIdDelegate& Delegate = FGetPetByIdDelegate()) const;
+    bool UpdatePet(const UpdatePetRequest& Request, const FUpdatePetDelegate& Delegate = FUpdatePetDelegate()) const;
+    bool UpdatePetWithForm(const UpdatePetWithFormRequest& Request, const FUpdatePetWithFormDelegate& Delegate = FUpdatePetWithFormDelegate()) const;
+    bool UploadFile(const UploadFileRequest& Request, const FUploadFileDelegate& Delegate = FUploadFileDelegate()) const;
+    
+private:
+    void OnAddPetResponse(FHttpRequestPtr HttpRequest, FHttpResponsePtr HttpResponse, bool bSucceeded, FAddPetDelegate Delegate) const;
+    void OnDeletePetResponse(FHttpRequestPtr HttpRequest, FHttpResponsePtr HttpResponse, bool bSucceeded, FDeletePetDelegate Delegate) const;
+    void OnFindPetsByStatusResponse(FHttpRequestPtr HttpRequest, FHttpResponsePtr HttpResponse, bool bSucceeded, FFindPetsByStatusDelegate Delegate) const;
+    void OnFindPetsByTagsResponse(FHttpRequestPtr HttpRequest, FHttpResponsePtr HttpResponse, bool bSucceeded, FFindPetsByTagsDelegate Delegate) const;
+    void OnGetPetByIdResponse(FHttpRequestPtr HttpRequest, FHttpResponsePtr HttpResponse, bool bSucceeded, FGetPetByIdDelegate Delegate) const;
+    void OnUpdatePetResponse(FHttpRequestPtr HttpRequest, FHttpResponsePtr HttpResponse, bool bSucceeded, FUpdatePetDelegate Delegate) const;
+    void OnUpdatePetWithFormResponse(FHttpRequestPtr HttpRequest, FHttpResponsePtr HttpResponse, bool bSucceeded, FUpdatePetWithFormDelegate Delegate) const;
+    void OnUploadFileResponse(FHttpRequestPtr HttpRequest, FHttpResponsePtr HttpResponse, bool bSucceeded, FUploadFileDelegate Delegate) const;
+    
+	bool IsValid() const;
+	void HandleResponse(FHttpResponsePtr HttpResponse, bool bSucceeded, Response& InOutResponse) const;
+
+	FString Url;
+	TMap<FString,FString> AdditionalHeaderParams;
+};
+	
+}

samples/client/petstore/cpp-ue4/Public/OpenAPIPetApiOperations.h

@@ -0,0 +1,235 @@
+/**
+ * OpenAPI Petstore
+ * This is a sample server Petstore server. For this sample, you can use the api key `special-key` to test the authorization filters.
+ *
+ * OpenAPI spec version: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator
+ * https://github.com/OpenAPITools/openapi-generator
+ * Do not edit the class manually.
+ */
+
+#pragma once
+
+#include "OpenAPIBaseModel.h"
+#include "OpenAPIPetApi.h"
+
+#include "OpenAPIHelpers.h"
+#include "OpenAPIApiResponse.h"
+#include "OpenAPIPet.h"
+
+namespace OpenAPI 
+{
+
+/* Add a new pet to the store
+
+*/
+class OPENAPI_API OpenAPIPetApi::AddPetRequest : public Request
+{
+public:
+    virtual ~AddPetRequest() {}
+	void SetupHttpRequest(const TSharedRef<IHttpRequest>& HttpRequest) const final;
+	FString ComputePath() const final;
+    
+	/* Pet object that needs to be added to the store */
+	std::shared_ptr<OpenAPIOpenAPIPet> Body;
+};
+
+class OPENAPI_API OpenAPIPetApi::AddPetResponse : public Response
+{
+public:
+    virtual ~AddPetResponse() {}
+	void SetHttpResponseCode(EHttpResponseCodes::Type InHttpResponseCode) final;
+	bool FromJson(const TSharedPtr<FJsonValue>& JsonObject) final;
+    
+    
+};
+
+/* Deletes a pet
+
+*/
+class OPENAPI_API OpenAPIPetApi::DeletePetRequest : public Request
+{
+public:
+    virtual ~DeletePetRequest() {}
+	void SetupHttpRequest(const TSharedRef<IHttpRequest>& HttpRequest) const final;
+	FString ComputePath() const final;
+    
+	/* Pet id to delete */
+	int64 PetId = 0;
+	TOptional<FString> ApiKey;
+};
+
+class OPENAPI_API OpenAPIPetApi::DeletePetResponse : public Response
+{
+public:
+    virtual ~DeletePetResponse() {}
+	void SetHttpResponseCode(EHttpResponseCodes::Type InHttpResponseCode) final;
+	bool FromJson(const TSharedPtr<FJsonValue>& JsonObject) final;
+    
+    
+};
+
+/* Finds Pets by status
+ *
+ * Multiple status values can be provided with comma separated strings
+*/
+class OPENAPI_API OpenAPIPetApi::FindPetsByStatusRequest : public Request
+{
+public:
+    virtual ~FindPetsByStatusRequest() {}
+	void SetupHttpRequest(const TSharedRef<IHttpRequest>& HttpRequest) const final;
+	FString ComputePath() const final;
+    
+	enum class StatusEnum
+	{
+		Available,
+		Pending,
+		Sold,
+  	};
+	/* Status values that need to be considered for filter */
+	TArray<std::shared_ptr<StatusEnum>> Status;
+};
+
+class OPENAPI_API OpenAPIPetApi::FindPetsByStatusResponse : public Response
+{
+public:
+    virtual ~FindPetsByStatusResponse() {}
+	void SetHttpResponseCode(EHttpResponseCodes::Type InHttpResponseCode) final;
+	bool FromJson(const TSharedPtr<FJsonValue>& JsonObject) final;
+    
+    TArray<std::shared_ptr<OpenAPIOpenAPIPet>> Content;
+};
+
+/* Finds Pets by tags
+ *
+ * Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing.
+*/
+class OPENAPI_API OpenAPIPetApi::FindPetsByTagsRequest : public Request
+{
+public:
+    virtual ~FindPetsByTagsRequest() {}
+	void SetupHttpRequest(const TSharedRef<IHttpRequest>& HttpRequest) const final;
+	FString ComputePath() const final;
+    
+	/* Tags to filter by */
+	TArray<std::shared_ptr<FString>> Tags;
+};
+
+class OPENAPI_API OpenAPIPetApi::FindPetsByTagsResponse : public Response
+{
+public:
+    virtual ~FindPetsByTagsResponse() {}
+	void SetHttpResponseCode(EHttpResponseCodes::Type InHttpResponseCode) final;
+	bool FromJson(const TSharedPtr<FJsonValue>& JsonObject) final;
+    
+    TArray<std::shared_ptr<OpenAPIOpenAPIPet>> Content;
+};
+
+/* Find pet by ID
+ *
+ * Returns a single pet
+*/
+class OPENAPI_API OpenAPIPetApi::GetPetByIdRequest : public Request
+{
+public:
+    virtual ~GetPetByIdRequest() {}
+	void SetupHttpRequest(const TSharedRef<IHttpRequest>& HttpRequest) const final;
+	FString ComputePath() const final;
+    
+	/* ID of pet to return */
+	int64 PetId = 0;
+};
+
+class OPENAPI_API OpenAPIPetApi::GetPetByIdResponse : public Response
+{
+public:
+    virtual ~GetPetByIdResponse() {}
+	void SetHttpResponseCode(EHttpResponseCodes::Type InHttpResponseCode) final;
+	bool FromJson(const TSharedPtr<FJsonValue>& JsonObject) final;
+    
+    OpenAPIPet Content;
+};
+
+/* Update an existing pet
+
+*/
+class OPENAPI_API OpenAPIPetApi::UpdatePetRequest : public Request
+{
+public:
+    virtual ~UpdatePetRequest() {}
+	void SetupHttpRequest(const TSharedRef<IHttpRequest>& HttpRequest) const final;
+	FString ComputePath() const final;
+    
+	/* Pet object that needs to be added to the store */
+	std::shared_ptr<OpenAPIOpenAPIPet> Body;
+};
+
+class OPENAPI_API OpenAPIPetApi::UpdatePetResponse : public Response
+{
+public:
+    virtual ~UpdatePetResponse() {}
+	void SetHttpResponseCode(EHttpResponseCodes::Type InHttpResponseCode) final;
+	bool FromJson(const TSharedPtr<FJsonValue>& JsonObject) final;
+    
+    
+};
+
+/* Updates a pet in the store with form data
+
+*/
+class OPENAPI_API OpenAPIPetApi::UpdatePetWithFormRequest : public Request
+{
+public:
+    virtual ~UpdatePetWithFormRequest() {}
+	void SetupHttpRequest(const TSharedRef<IHttpRequest>& HttpRequest) const final;
+	FString ComputePath() const final;
+    
+	/* ID of pet that needs to be updated */
+	int64 PetId = 0;
+	/* Updated name of the pet */
+	TOptional<FString> Name;
+	/* Updated status of the pet */
+	TOptional<FString> Status;
+};
+
+class OPENAPI_API OpenAPIPetApi::UpdatePetWithFormResponse : public Response
+{
+public:
+    virtual ~UpdatePetWithFormResponse() {}
+	void SetHttpResponseCode(EHttpResponseCodes::Type InHttpResponseCode) final;
+	bool FromJson(const TSharedPtr<FJsonValue>& JsonObject) final;
+    
+    
+};
+
+/* uploads an image
+
+*/
+class OPENAPI_API OpenAPIPetApi::UploadFileRequest : public Request
+{
+public:
+    virtual ~UploadFileRequest() {}
+	void SetupHttpRequest(const TSharedRef<IHttpRequest>& HttpRequest) const final;
+	FString ComputePath() const final;
+    
+	/* ID of pet to update */
+	int64 PetId = 0;
+	/* Additional data to pass to server */
+	TOptional<FString> AdditionalMetadata;
+	/* file to upload */
+	TOptional<HttpFileInput> File;
+};
+
+class OPENAPI_API OpenAPIPetApi::UploadFileResponse : public Response
+{
+public:
+    virtual ~UploadFileResponse() {}
+	void SetHttpResponseCode(EHttpResponseCodes::Type InHttpResponseCode) final;
+	bool FromJson(const TSharedPtr<FJsonValue>& JsonObject) final;
+    
+    OpenAPIApiResponse Content;
+};
+
+}

samples/client/petstore/cpp-ue4/Public/OpenAPIStoreApi.h

@@ -0,0 +1,63 @@
+/**
+ * OpenAPI Petstore
+ * This is a sample server Petstore server. For this sample, you can use the api key `special-key` to test the authorization filters.
+ *
+ * OpenAPI spec version: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator
+ * https://github.com/OpenAPITools/openapi-generator
+ * Do not edit the class manually.
+ */
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "OpenAPIBaseModel.h"
+
+namespace OpenAPI 
+{
+
+class OPENAPI_API OpenAPIStoreApi
+{
+public:
+	OpenAPIStoreApi();
+	~OpenAPIStoreApi();
+
+	void SetURL(const FString& Url);
+	void AddHeaderParam(const FString& Key, const FString& Value);
+	void ClearHeaderParams();
+
+	class DeleteOrderRequest;
+	class DeleteOrderResponse;
+	class GetInventoryRequest;
+	class GetInventoryResponse;
+	class GetOrderByIdRequest;
+	class GetOrderByIdResponse;
+	class PlaceOrderRequest;
+	class PlaceOrderResponse;
+	
+    DECLARE_DELEGATE_OneParam(FDeleteOrderDelegate, const DeleteOrderResponse&);
+    DECLARE_DELEGATE_OneParam(FGetInventoryDelegate, const GetInventoryResponse&);
+    DECLARE_DELEGATE_OneParam(FGetOrderByIdDelegate, const GetOrderByIdResponse&);
+    DECLARE_DELEGATE_OneParam(FPlaceOrderDelegate, const PlaceOrderResponse&);
+    
+    bool DeleteOrder(const DeleteOrderRequest& Request, const FDeleteOrderDelegate& Delegate = FDeleteOrderDelegate()) const;
+    bool GetInventory(const GetInventoryRequest& Request, const FGetInventoryDelegate& Delegate = FGetInventoryDelegate()) const;
+    bool GetOrderById(const GetOrderByIdRequest& Request, const FGetOrderByIdDelegate& Delegate = FGetOrderByIdDelegate()) const;
+    bool PlaceOrder(const PlaceOrderRequest& Request, const FPlaceOrderDelegate& Delegate = FPlaceOrderDelegate()) const;
+    
+private:
+    void OnDeleteOrderResponse(FHttpRequestPtr HttpRequest, FHttpResponsePtr HttpResponse, bool bSucceeded, FDeleteOrderDelegate Delegate) const;
+    void OnGetInventoryResponse(FHttpRequestPtr HttpRequest, FHttpResponsePtr HttpResponse, bool bSucceeded, FGetInventoryDelegate Delegate) const;
+    void OnGetOrderByIdResponse(FHttpRequestPtr HttpRequest, FHttpResponsePtr HttpResponse, bool bSucceeded, FGetOrderByIdDelegate Delegate) const;
+    void OnPlaceOrderResponse(FHttpRequestPtr HttpRequest, FHttpResponsePtr HttpResponse, bool bSucceeded, FPlaceOrderDelegate Delegate) const;
+    
+	bool IsValid() const;
+	void HandleResponse(FHttpResponsePtr HttpResponse, bool bSucceeded, Response& InOutResponse) const;
+
+	FString Url;
+	TMap<FString,FString> AdditionalHeaderParams;
+};
+	
+}

samples/client/petstore/cpp-ue4/Public/OpenAPIStoreApiOperations.h

@@ -0,0 +1,120 @@
+/**
+ * OpenAPI Petstore
+ * This is a sample server Petstore server. For this sample, you can use the api key `special-key` to test the authorization filters.
+ *
+ * OpenAPI spec version: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator
+ * https://github.com/OpenAPITools/openapi-generator
+ * Do not edit the class manually.
+ */
+
+#pragma once
+
+#include "OpenAPIBaseModel.h"
+#include "OpenAPIStoreApi.h"
+
+#include "OpenAPIOrder.h"
+
+namespace OpenAPI 
+{
+
+/* Delete purchase order by ID
+ *
+ * For valid response try integer IDs with value < 1000. Anything above 1000 or nonintegers will generate API errors
+*/
+class OPENAPI_API OpenAPIStoreApi::DeleteOrderRequest : public Request
+{
+public:
+    virtual ~DeleteOrderRequest() {}
+	void SetupHttpRequest(const TSharedRef<IHttpRequest>& HttpRequest) const final;
+	FString ComputePath() const final;
+    
+	/* ID of the order that needs to be deleted */
+	FString OrderId;
+};
+
+class OPENAPI_API OpenAPIStoreApi::DeleteOrderResponse : public Response
+{
+public:
+    virtual ~DeleteOrderResponse() {}
+	void SetHttpResponseCode(EHttpResponseCodes::Type InHttpResponseCode) final;
+	bool FromJson(const TSharedPtr<FJsonValue>& JsonObject) final;
+    
+    
+};
+
+/* Returns pet inventories by status
+ *
+ * Returns a map of status codes to quantities
+*/
+class OPENAPI_API OpenAPIStoreApi::GetInventoryRequest : public Request
+{
+public:
+    virtual ~GetInventoryRequest() {}
+	void SetupHttpRequest(const TSharedRef<IHttpRequest>& HttpRequest) const final;
+	FString ComputePath() const final;
+    
+};
+
+class OPENAPI_API OpenAPIStoreApi::GetInventoryResponse : public Response
+{
+public:
+    virtual ~GetInventoryResponse() {}
+	void SetHttpResponseCode(EHttpResponseCodes::Type InHttpResponseCode) final;
+	bool FromJson(const TSharedPtr<FJsonValue>& JsonObject) final;
+    
+    TMap<FString, std::shared_ptr<int32>> Content;
+};
+
+/* Find purchase order by ID
+ *
+ * For valid response try integer IDs with value &lt;&#x3D; 5 or &gt; 10. Other values will generated exceptions
+*/
+class OPENAPI_API OpenAPIStoreApi::GetOrderByIdRequest : public Request
+{
+public:
+    virtual ~GetOrderByIdRequest() {}
+	void SetupHttpRequest(const TSharedRef<IHttpRequest>& HttpRequest) const final;
+	FString ComputePath() const final;
+    
+	/* ID of pet that needs to be fetched */
+	int64 OrderId = 0;
+};
+
+class OPENAPI_API OpenAPIStoreApi::GetOrderByIdResponse : public Response
+{
+public:
+    virtual ~GetOrderByIdResponse() {}
+	void SetHttpResponseCode(EHttpResponseCodes::Type InHttpResponseCode) final;
+	bool FromJson(const TSharedPtr<FJsonValue>& JsonObject) final;
+    
+    OpenAPIOrder Content;
+};
+
+/* Place an order for a pet
+
+*/
+class OPENAPI_API OpenAPIStoreApi::PlaceOrderRequest : public Request
+{
+public:
+    virtual ~PlaceOrderRequest() {}
+	void SetupHttpRequest(const TSharedRef<IHttpRequest>& HttpRequest) const final;
+	FString ComputePath() const final;
+    
+	/* order placed for purchasing the pet */
+	std::shared_ptr<OpenAPIOpenAPIOrder> Body;
+};
+
+class OPENAPI_API OpenAPIStoreApi::PlaceOrderResponse : public Response
+{
+public:
+    virtual ~PlaceOrderResponse() {}
+	void SetHttpResponseCode(EHttpResponseCodes::Type InHttpResponseCode) final;
+	bool FromJson(const TSharedPtr<FJsonValue>& JsonObject) final;
+    
+    OpenAPIOrder Content;
+};
+
+}

samples/client/petstore/cpp-ue4/Public/OpenAPIUserApi.h

@@ -0,0 +1,83 @@
+/**
+ * OpenAPI Petstore
+ * This is a sample server Petstore server. For this sample, you can use the api key `special-key` to test the authorization filters.
+ *
+ * OpenAPI spec version: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator
+ * https://github.com/OpenAPITools/openapi-generator
+ * Do not edit the class manually.
+ */
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "OpenAPIBaseModel.h"
+
+namespace OpenAPI 
+{
+
+class OPENAPI_API OpenAPIUserApi
+{
+public:
+	OpenAPIUserApi();
+	~OpenAPIUserApi();
+
+	void SetURL(const FString& Url);
+	void AddHeaderParam(const FString& Key, const FString& Value);
+	void ClearHeaderParams();
+
+	class CreateUserRequest;
+	class CreateUserResponse;
+	class CreateUsersWithArrayInputRequest;
+	class CreateUsersWithArrayInputResponse;
+	class CreateUsersWithListInputRequest;
+	class CreateUsersWithListInputResponse;
+	class DeleteUserRequest;
+	class DeleteUserResponse;
+	class GetUserByNameRequest;
+	class GetUserByNameResponse;
+	class LoginUserRequest;
+	class LoginUserResponse;
+	class LogoutUserRequest;
+	class LogoutUserResponse;
+	class UpdateUserRequest;
+	class UpdateUserResponse;
+	
+    DECLARE_DELEGATE_OneParam(FCreateUserDelegate, const CreateUserResponse&);
+    DECLARE_DELEGATE_OneParam(FCreateUsersWithArrayInputDelegate, const CreateUsersWithArrayInputResponse&);
+    DECLARE_DELEGATE_OneParam(FCreateUsersWithListInputDelegate, const CreateUsersWithListInputResponse&);
+    DECLARE_DELEGATE_OneParam(FDeleteUserDelegate, const DeleteUserResponse&);
+    DECLARE_DELEGATE_OneParam(FGetUserByNameDelegate, const GetUserByNameResponse&);
+    DECLARE_DELEGATE_OneParam(FLoginUserDelegate, const LoginUserResponse&);
+    DECLARE_DELEGATE_OneParam(FLogoutUserDelegate, const LogoutUserResponse&);
+    DECLARE_DELEGATE_OneParam(FUpdateUserDelegate, const UpdateUserResponse&);
+    
+    bool CreateUser(const CreateUserRequest& Request, const FCreateUserDelegate& Delegate = FCreateUserDelegate()) const;
+    bool CreateUsersWithArrayInput(const CreateUsersWithArrayInputRequest& Request, const FCreateUsersWithArrayInputDelegate& Delegate = FCreateUsersWithArrayInputDelegate()) const;
+    bool CreateUsersWithListInput(const CreateUsersWithListInputRequest& Request, const FCreateUsersWithListInputDelegate& Delegate = FCreateUsersWithListInputDelegate()) const;
+    bool DeleteUser(const DeleteUserRequest& Request, const FDeleteUserDelegate& Delegate = FDeleteUserDelegate()) const;
+    bool GetUserByName(const GetUserByNameRequest& Request, const FGetUserByNameDelegate& Delegate = FGetUserByNameDelegate()) const;
+    bool LoginUser(const LoginUserRequest& Request, const FLoginUserDelegate& Delegate = FLoginUserDelegate()) const;
+    bool LogoutUser(const LogoutUserRequest& Request, const FLogoutUserDelegate& Delegate = FLogoutUserDelegate()) const;
+    bool UpdateUser(const UpdateUserRequest& Request, const FUpdateUserDelegate& Delegate = FUpdateUserDelegate()) const;
+    
+private:
+    void OnCreateUserResponse(FHttpRequestPtr HttpRequest, FHttpResponsePtr HttpResponse, bool bSucceeded, FCreateUserDelegate Delegate) const;
+    void OnCreateUsersWithArrayInputResponse(FHttpRequestPtr HttpRequest, FHttpResponsePtr HttpResponse, bool bSucceeded, FCreateUsersWithArrayInputDelegate Delegate) const;
+    void OnCreateUsersWithListInputResponse(FHttpRequestPtr HttpRequest, FHttpResponsePtr HttpResponse, bool bSucceeded, FCreateUsersWithListInputDelegate Delegate) const;
+    void OnDeleteUserResponse(FHttpRequestPtr HttpRequest, FHttpResponsePtr HttpResponse, bool bSucceeded, FDeleteUserDelegate Delegate) const;
+    void OnGetUserByNameResponse(FHttpRequestPtr HttpRequest, FHttpResponsePtr HttpResponse, bool bSucceeded, FGetUserByNameDelegate Delegate) const;
+    void OnLoginUserResponse(FHttpRequestPtr HttpRequest, FHttpResponsePtr HttpResponse, bool bSucceeded, FLoginUserDelegate Delegate) const;
+    void OnLogoutUserResponse(FHttpRequestPtr HttpRequest, FHttpResponsePtr HttpResponse, bool bSucceeded, FLogoutUserDelegate Delegate) const;
+    void OnUpdateUserResponse(FHttpRequestPtr HttpRequest, FHttpResponsePtr HttpResponse, bool bSucceeded, FUpdateUserDelegate Delegate) const;
+    
+	bool IsValid() const;
+	void HandleResponse(FHttpResponsePtr HttpResponse, bool bSucceeded, Response& InOutResponse) const;
+
+	FString Url;
+	TMap<FString,FString> AdditionalHeaderParams;
+};
+	
+}

samples/client/petstore/cpp-ue4/Public/OpenAPIUserApiOperations.h

@@ -0,0 +1,220 @@
+/**
+ * OpenAPI Petstore
+ * This is a sample server Petstore server. For this sample, you can use the api key `special-key` to test the authorization filters.
+ *
+ * OpenAPI spec version: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator
+ * https://github.com/OpenAPITools/openapi-generator
+ * Do not edit the class manually.
+ */
+
+#pragma once
+
+#include "OpenAPIBaseModel.h"
+#include "OpenAPIUserApi.h"
+
+#include "OpenAPIUser.h"
+
+namespace OpenAPI 
+{
+
+/* Create user
+ *
+ * This can only be done by the logged in user.
+*/
+class OPENAPI_API OpenAPIUserApi::CreateUserRequest : public Request
+{
+public:
+    virtual ~CreateUserRequest() {}
+	void SetupHttpRequest(const TSharedRef<IHttpRequest>& HttpRequest) const final;
+	FString ComputePath() const final;
+    
+	/* Created user object */
+	std::shared_ptr<OpenAPIOpenAPIUser> Body;
+};
+
+class OPENAPI_API OpenAPIUserApi::CreateUserResponse : public Response
+{
+public:
+    virtual ~CreateUserResponse() {}
+	void SetHttpResponseCode(EHttpResponseCodes::Type InHttpResponseCode) final;
+	bool FromJson(const TSharedPtr<FJsonValue>& JsonObject) final;
+    
+    
+};
+
+/* Creates list of users with given input array
+
+*/
+class OPENAPI_API OpenAPIUserApi::CreateUsersWithArrayInputRequest : public Request
+{
+public:
+    virtual ~CreateUsersWithArrayInputRequest() {}
+	void SetupHttpRequest(const TSharedRef<IHttpRequest>& HttpRequest) const final;
+	FString ComputePath() const final;
+    
+	/* List of user object */
+	TArray<std::shared_ptr<OpenAPIOpenAPIUser>> Body;
+};
+
+class OPENAPI_API OpenAPIUserApi::CreateUsersWithArrayInputResponse : public Response
+{
+public:
+    virtual ~CreateUsersWithArrayInputResponse() {}
+	void SetHttpResponseCode(EHttpResponseCodes::Type InHttpResponseCode) final;
+	bool FromJson(const TSharedPtr<FJsonValue>& JsonObject) final;
+    
+    
+};
+
+/* Creates list of users with given input array
+
+*/
+class OPENAPI_API OpenAPIUserApi::CreateUsersWithListInputRequest : public Request
+{
+public:
+    virtual ~CreateUsersWithListInputRequest() {}
+	void SetupHttpRequest(const TSharedRef<IHttpRequest>& HttpRequest) const final;
+	FString ComputePath() const final;
+    
+	/* List of user object */
+	TArray<std::shared_ptr<OpenAPIOpenAPIUser>> Body;
+};
+
+class OPENAPI_API OpenAPIUserApi::CreateUsersWithListInputResponse : public Response
+{
+public:
+    virtual ~CreateUsersWithListInputResponse() {}
+	void SetHttpResponseCode(EHttpResponseCodes::Type InHttpResponseCode) final;
+	bool FromJson(const TSharedPtr<FJsonValue>& JsonObject) final;
+    
+    
+};
+
+/* Delete user
+ *
+ * This can only be done by the logged in user.
+*/
+class OPENAPI_API OpenAPIUserApi::DeleteUserRequest : public Request
+{
+public:
+    virtual ~DeleteUserRequest() {}
+	void SetupHttpRequest(const TSharedRef<IHttpRequest>& HttpRequest) const final;
+	FString ComputePath() const final;
+    
+	/* The name that needs to be deleted */
+	FString Username;
+};
+
+class OPENAPI_API OpenAPIUserApi::DeleteUserResponse : public Response
+{
+public:
+    virtual ~DeleteUserResponse() {}
+	void SetHttpResponseCode(EHttpResponseCodes::Type InHttpResponseCode) final;
+	bool FromJson(const TSharedPtr<FJsonValue>& JsonObject) final;
+    
+    
+};
+
+/* Get user by user name
+
+*/
+class OPENAPI_API OpenAPIUserApi::GetUserByNameRequest : public Request
+{
+public:
+    virtual ~GetUserByNameRequest() {}
+	void SetupHttpRequest(const TSharedRef<IHttpRequest>& HttpRequest) const final;
+	FString ComputePath() const final;
+    
+	/* The name that needs to be fetched. Use user1 for testing. */
+	FString Username;
+};
+
+class OPENAPI_API OpenAPIUserApi::GetUserByNameResponse : public Response
+{
+public:
+    virtual ~GetUserByNameResponse() {}
+	void SetHttpResponseCode(EHttpResponseCodes::Type InHttpResponseCode) final;
+	bool FromJson(const TSharedPtr<FJsonValue>& JsonObject) final;
+    
+    OpenAPIUser Content;
+};
+
+/* Logs user into the system
+
+*/
+class OPENAPI_API OpenAPIUserApi::LoginUserRequest : public Request
+{
+public:
+    virtual ~LoginUserRequest() {}
+	void SetupHttpRequest(const TSharedRef<IHttpRequest>& HttpRequest) const final;
+	FString ComputePath() const final;
+    
+	/* The user name for login */
+	FString Username;
+	/* The password for login in clear text */
+	FString Password;
+};
+
+class OPENAPI_API OpenAPIUserApi::LoginUserResponse : public Response
+{
+public:
+    virtual ~LoginUserResponse() {}
+	void SetHttpResponseCode(EHttpResponseCodes::Type InHttpResponseCode) final;
+	bool FromJson(const TSharedPtr<FJsonValue>& JsonObject) final;
+    
+    FString Content;
+};
+
+/* Logs out current logged in user session
+
+*/
+class OPENAPI_API OpenAPIUserApi::LogoutUserRequest : public Request
+{
+public:
+    virtual ~LogoutUserRequest() {}
+	void SetupHttpRequest(const TSharedRef<IHttpRequest>& HttpRequest) const final;
+	FString ComputePath() const final;
+    
+};
+
+class OPENAPI_API OpenAPIUserApi::LogoutUserResponse : public Response
+{
+public:
+    virtual ~LogoutUserResponse() {}
+	void SetHttpResponseCode(EHttpResponseCodes::Type InHttpResponseCode) final;
+	bool FromJson(const TSharedPtr<FJsonValue>& JsonObject) final;
+    
+    
+};
+
+/* Updated user
+ *
+ * This can only be done by the logged in user.
+*/
+class OPENAPI_API OpenAPIUserApi::UpdateUserRequest : public Request
+{
+public:
+    virtual ~UpdateUserRequest() {}
+	void SetupHttpRequest(const TSharedRef<IHttpRequest>& HttpRequest) const final;
+	FString ComputePath() const final;
+    
+	/* name that need to be deleted */
+	FString Username;
+	/* Updated user object */
+	std::shared_ptr<OpenAPIOpenAPIUser> Body;
+};
+
+class OPENAPI_API OpenAPIUserApi::UpdateUserResponse : public Response
+{
+public:
+    virtual ~UpdateUserResponse() {}
+	void SetHttpResponseCode(EHttpResponseCodes::Type InHttpResponseCode) final;
+	bool FromJson(const TSharedPtr<FJsonValue>& JsonObject) final;
+    
+    
+};
+
+}