openapi-client-codegen 0.1.0__py3-none-any.whl

openapi_client_codegen/__init__.py

@@ -0,0 +1,15 @@
+from .client import generate_client
+from .downgrade import downgrade_openapi_3_1_to_3_0
+from .naming import ClientNaming, DefaultNamingPolicy, NamingPolicy
+from .templates import regenerate_templates
+from .unity import write_unity_package_metadata
+
+__all__ = [
+    "ClientNaming",
+    "DefaultNamingPolicy",
+    "NamingPolicy",
+    "downgrade_openapi_3_1_to_3_0",
+    "generate_client",
+    "regenerate_templates",
+    "write_unity_package_metadata",
+]

openapi_client_codegen/_data/configs/csharp.json

@@ -0,0 +1,24 @@
+{
+  "generatorName": "csharp",
+  "globalProperties": {
+    "apiTests": false,
+    "modelTests": false,
+    "modelDocs": false,
+    "apiDocs": false
+  },
+  "additionalProperties": {
+    "library": "httpclient",
+    "packageVersion": "0.1.0",
+    "targetFramework": "netstandard2.1",
+    "validatable": false,
+    "conditionalSerialization": true,
+    "nullableReferenceTypes": true,
+    "sortModelPropertiesByRequiredFlag": true,
+    "sortParamsByRequiredFlag": true,
+    "caseInsensitiveResponseHeaders": true,
+    "examples": false
+  },
+  "typeMappings": {
+    "number": "double"
+  }
+}

openapi_client_codegen/_data/configs/python.json

@@ -0,0 +1,22 @@
+{
+  "generatorName": "python",
+  "globalProperties": {
+    "apiTests": false,
+    "modelTests": false,
+    "modelDocs": false,
+    "apiDocs": false
+  },
+  "additionalProperties": {
+    "library": "httpx",
+    "packageVersion": "0.1.0",
+    "generateSourceCodeOnly": false,
+    "hideGenerationTimestamp": true,
+    "disallowAdditionalPropertiesIfNotPresent": false,
+    "mapNumberTo": "Union[StrictFloat, StrictInt]",
+    "useOneOfDiscriminatorLookup": false,
+    "examples": false
+  },
+  "typeMappings": {
+    "number": "float"
+  }
+}

openapi_client_codegen/_data/openapi-generator-ignore

@@ -0,0 +1,3 @@
+# prevent OpenAPI Generator from writing gitignores
+.gitignore
+**/.gitignore

openapi_client_codegen/_data/templates-patches/csharp/0001-csharp-remove-errant-comma.patch

@@ -0,0 +1,14 @@
+# Fix errant comma in generated C# AnyOf classes
+diff --git a/csharp/modelAnyOf.mustache b/csharp/modelAnyOf.mustache
+index f3eac97..036b383 100644
+--- a/csharp/modelAnyOf.mustache
++++ b/csharp/modelAnyOf.mustache
+@@ -10,7 +10,7 @@
+     {{/vendorExtensions.x-com-visible}}
+     [JsonConverter(typeof({{classname}}JsonConverter))]
+     [DataContract(Name = "{{{name}}}")]
+-    {{>visibility}} partial class {{classname}} : AbstractOpenAPISchema, {{#lambda.joinWithComma}}{{#parent}}{{{.}}}  {{/parent}}{{#equatable}}IEquatable<{{classname}}>  {{/equatable}}{{#validatable}}IValidatableObject  {{/validatable}}{{/lambda.joinWithComma}}
++    {{>visibility}} partial class {{classname}} : {{#lambda.joinWithComma}}AbstractOpenAPISchema  {{#parent}}{{{.}}}  {{/parent}}{{#equatable}}IEquatable<{{classname}}>  {{/equatable}}{{#validatable}}IValidatableObject  {{/validatable}}{{/lambda.joinWithComma}}
+     {
+         {{#isNullable}}
+         /// <summary>

openapi_client_codegen/_data/templates-patches/csharp/0002-csharp-models-required-only-constructors.patch

@@ -0,0 +1,75 @@
+# Generate constructors with only required params, allowing optional params to be set via property setters
+diff --git a/csharp/modelGeneric.mustache b/csharp/modelGeneric.mustache
+index 5a95ada..f0f6ba4 100644
+--- a/csharp/modelGeneric.mustache
++++ b/csharp/modelGeneric.mustache
+@@ -140,38 +141,20 @@
+     {{#hasOnlyReadOnly}}
+         [JsonConstructorAttribute]
+     {{/hasOnlyReadOnly}}
+-        public {{classname}}({{#readWriteVars}}{{{datatypeWithEnum}}}{{#isEnum}}{{^isContainer}}{{^required}}?{{/required}}{{/isContainer}}{{/isEnum}} {{#lambda.camelcase_sanitize_param}}{{name}}{{/lambda.camelcase_sanitize_param}} = {{#defaultValue}}{{^isDateTime}}{{#isString}}{{^isEnum}}@{{/isEnum}}{{/isString}}{{{defaultValue}}}{{/isDateTime}}{{#isDateTime}}default{{/isDateTime}}{{/defaultValue}}{{^defaultValue}}default{{/defaultValue}}{{^-last}}, {{/-last}}{{/readWriteVars}}){{#parent}} : base({{#parentVars}}{{#lambda.camelcase_sanitize_param}}{{name}}{{/lambda.camelcase_sanitize_param}}{{^-last}}, {{/-last}}{{/parentVars}}){{/parent}}
++        public {{classname}}({{#requiredVars}}{{{datatypeWithEnum}}} {{#lambda.camelcase_sanitize_param}}{{name}}{{/lambda.camelcase_sanitize_param}}{{^-last}}, {{/-last}}{{/requiredVars}}){{#parent}} : base({{#parentVars}}{{#lambda.camelcase_sanitize_param}}{{name}}{{/lambda.camelcase_sanitize_param}}{{^-last}}, {{/-last}}{{/parentVars}}){{/parent}}
+         {
+             {{#vars}}
+             {{^isInherited}}
+             {{^isReadOnly}}
+             {{#required}}
+-            {{^conditionalSerialization}}
+             {{^vendorExtensions.x-csharp-value-type}}
+             // to ensure "{{#lambda.camelcase_sanitize_param}}{{name}}{{/lambda.camelcase_sanitize_param}}" is required (not null)
+             if ({{#lambda.camelcase_sanitize_param}}{{name}}{{/lambda.camelcase_sanitize_param}} == null)
+             {
+                 throw new ArgumentNullException("{{#lambda.camelcase_sanitize_param}}{{name}}{{/lambda.camelcase_sanitize_param}} is a required property for {{classname}} and cannot be null");
+             }
+-            this.{{name}} = {{#lambda.camelcase_sanitize_param}}{{name}}{{/lambda.camelcase_sanitize_param}};
+             {{/vendorExtensions.x-csharp-value-type}}
+-            {{#vendorExtensions.x-csharp-value-type}}
+             this.{{name}} = {{#lambda.camelcase_sanitize_param}}{{name}}{{/lambda.camelcase_sanitize_param}};
+-            {{/vendorExtensions.x-csharp-value-type}}
+-            {{/conditionalSerialization}}
+-            {{#conditionalSerialization}}
+-            {{^vendorExtensions.x-csharp-value-type}}
+-            // to ensure "{{#lambda.camelcase_sanitize_param}}{{name}}{{/lambda.camelcase_sanitize_param}}" is required (not null)
+-            if ({{#lambda.camelcase_sanitize_param}}{{name}}{{/lambda.camelcase_sanitize_param}} == null)
+-            {
+-                throw new ArgumentNullException("{{#lambda.camelcase_sanitize_param}}{{name}}{{/lambda.camelcase_sanitize_param}} is a required property for {{classname}} and cannot be null");
+-            }
+-            this._{{name}} = {{#lambda.camelcase_sanitize_param}}{{name}}{{/lambda.camelcase_sanitize_param}};
+-            {{/vendorExtensions.x-csharp-value-type}}
+-            {{#vendorExtensions.x-csharp-value-type}}
+-            this._{{name}} = {{#lambda.camelcase_sanitize_param}}{{name}}{{/lambda.camelcase_sanitize_param}};
+-            {{/vendorExtensions.x-csharp-value-type}}
+-            {{/conditionalSerialization}}
+             {{/required}}
+             {{/isReadOnly}}
+             {{/isInherited}}
+@@ -180,29 +163,6 @@
+             {{^isInherited}}
+             {{^isReadOnly}}
+             {{^required}}
+-            {{#defaultValue}}
+-            {{^conditionalSerialization}}
+-            {{^vendorExtensions.x-csharp-value-type}}
+-            // use default value if no "{{#lambda.camelcase_sanitize_param}}{{name}}{{/lambda.camelcase_sanitize_param}}" provided
+-            this.{{name}} = {{#lambda.camelcase_sanitize_param}}{{name}}{{/lambda.camelcase_sanitize_param}} ?? {{#isString}}@{{/isString}}{{{defaultValue}}};
+-            {{/vendorExtensions.x-csharp-value-type}}
+-            {{#vendorExtensions.x-csharp-value-type}}
+-            this.{{name}} = {{#lambda.camelcase_sanitize_param}}{{name}}{{/lambda.camelcase_sanitize_param}};
+-            {{/vendorExtensions.x-csharp-value-type}}
+-            {{/conditionalSerialization}}
+-            {{/defaultValue}}
+-            {{^defaultValue}}
+-            {{^conditionalSerialization}}
+-            this.{{name}} = {{#lambda.camelcase_sanitize_param}}{{name}}{{/lambda.camelcase_sanitize_param}};
+-            {{/conditionalSerialization}}
+-            {{#conditionalSerialization}}
+-            this._{{name}} = {{#lambda.camelcase_sanitize_param}}{{name}}{{/lambda.camelcase_sanitize_param}};
+-            if (this.{{name}} != null)
+-            {
+-                this._flag{{name}} = true;
+-            }
+-            {{/conditionalSerialization}}
+-            {{/defaultValue}}
+             {{/required}}
+             {{/isReadOnly}}
+             {{/isInherited}}

openapi_client_codegen/_data/templates-patches/csharp/0003-csharp-httpclient-use-defaultT.patch

@@ -0,0 +1,14 @@
+# Fix issue with target-typed `default` in generic error paths by using `default(T)` for broader C# language version compatibility.
+diff --git a/csharp/libraries/httpclient/ApiClient.mustache b/csharp/libraries/httpclient/ApiClient.mustache
+index fb521d0..9db72d9 100644
+--- a/csharp/libraries/httpclient/ApiClient.mustache
++++ b/csharp/libraries/httpclient/ApiClient.mustache
+@@ -555,7 +555,7 @@ namespace {{packageName}}.Client
+ 
+                 if (!response.IsSuccessStatusCode)
+                 {
+-                    return await ToApiResponse<T>(response, default, req.RequestUri).ConfigureAwait(false);
++                    return await ToApiResponse<T>(response, default(T), req.RequestUri).ConfigureAwait(false);
+                 }
+ 
+                 object responseData = await deserializer.Deserialize<T>(response).ConfigureAwait(false);

openapi_client_codegen/_data/templates-patches/csharp/0004-csharp-support-hybrid-multipart-payloads.patch

@@ -0,0 +1,144 @@
+# Serialize complex objects as JSON parts in multipart/form-data requests, enabling hybrid payloads alongside binary files
+diff --git a/csharp/libraries/httpclient/ApiClient.mustache b/csharp/libraries/httpclient/ApiClient.mustache
+index 9db72d9..179dcda 100644
+--- a/csharp/libraries/httpclient/ApiClient.mustache
++++ b/csharp/libraries/httpclient/ApiClient.mustache
+@@ -312,7 +312,17 @@ namespace {{packageName}}.Client
+                     {
+                         var content = new StreamContent(file.Content);
+                         content.Headers.ContentType = new MediaTypeHeaderValue(file.ContentType);
+-                        multipartContent.Add(content, fileParam.Key, file.Name);
++
++                        if (string.IsNullOrEmpty(file.Name))
++                        {
++                            // Add as a normal form part (but with our custom Content-Type)
++                            multipartContent.Add(content, fileParam.Key);
++                        }
++                        else
++                        {
++                            // Add as a file upload (with filename)
++                            multipartContent.Add(content, fileParam.Key, file.Name);
++                        }
+                     }
+                 }
+             }
+diff --git a/csharp/libraries/httpclient/api.mustache b/csharp/libraries/httpclient/api.mustache
+index f7330c2..de9cc90 100644
+--- a/csharp/libraries/httpclient/api.mustache
++++ b/csharp/libraries/httpclient/api.mustache
+@@ -445,7 +445,27 @@ namespace {{packageName}}.{{apiPackage}}
+             localVarRequestOptions.FileParameters.Add("{{baseName}}", {{paramName}});
+             {{/isFile}}
+             {{^isFile}}
+-            localVarRequestOptions.FormParameters.Add("{{baseName}}", {{packageName}}.Client.ClientUtils.ParameterToString({{paramName}})); // form parameter
++            {{#isPrimitiveType}}
++            // Primitive types (int, string, bool) go as standard form fields
++            localVarRequestOptions.FormParameters.Add("{{baseName}}", {{packageName}}.Client.ClientUtils.ParameterToString({{paramName}}));
++            {{/isPrimitiveType}}
++            {{^isPrimitiveType}}
++            {{#isEnum}}
++            // Enums are treated as strings
++            localVarRequestOptions.FormParameters.Add("{{baseName}}", {{packageName}}.Client.ClientUtils.ParameterToString({{paramName}}));
++            {{/isEnum}}
++            {{^isEnum}}
++            // COMPLEX TYPE: Serialize to JSON and add as a "File" with application/json header
++            if ({{paramName}} != null)
++            {
++                var _json_{{paramName}} = Newtonsoft.Json.JsonConvert.SerializeObject({{paramName}}, this.ApiClient.SerializerSettings);
++                var _stream_{{paramName}} = new System.IO.MemoryStream(System.Text.Encoding.UTF8.GetBytes(_json_{{paramName}}));
++
++                // Add as a file parameter with null filename and application/json content type
++                localVarRequestOptions.FileParameters.Add("{{baseName}}", new {{packageName}}.Client.FileParameter(null, "application/json", _stream_{{paramName}}));
++            }
++            {{/isEnum}}
++            {{/isPrimitiveType}}
+             {{/isFile}}
+             {{/required}}
+             {{^required}}
+@@ -455,7 +475,27 @@ namespace {{packageName}}.{{apiPackage}}
+                 localVarRequestOptions.FileParameters.Add("{{baseName}}", {{paramName}});
+                 {{/isFile}}
+                 {{^isFile}}
+-                localVarRequestOptions.FormParameters.Add("{{baseName}}", {{packageName}}.Client.ClientUtils.ParameterToString({{paramName}})); // form parameter
++                {{#isPrimitiveType}}
++                // Primitive types (int, string, bool) go as standard form fields
++                localVarRequestOptions.FormParameters.Add("{{baseName}}", {{packageName}}.Client.ClientUtils.ParameterToString({{paramName}}));
++                {{/isPrimitiveType}}
++                {{^isPrimitiveType}}
++                {{#isEnum}}
++                // Enums are treated as strings
++                localVarRequestOptions.FormParameters.Add("{{baseName}}", {{packageName}}.Client.ClientUtils.ParameterToString({{paramName}}));
++                {{/isEnum}}
++                {{^isEnum}}
++                // COMPLEX TYPE: Serialize to JSON and add as a "File" with application/json header
++                if ({{paramName}} != null)
++                {
++                    var _json_{{paramName}} = Newtonsoft.Json.JsonConvert.SerializeObject({{paramName}}, this.ApiClient.SerializerSettings);
++                    var _stream_{{paramName}} = new System.IO.MemoryStream(System.Text.Encoding.UTF8.GetBytes(_json_{{paramName}}));
++
++                    // Add as a file parameter with null filename and application/json content type
++                    localVarRequestOptions.FileParameters.Add("{{baseName}}", new {{packageName}}.Client.FileParameter(null, "application/json", _stream_{{paramName}}));
++                }
++                {{/isEnum}}
++                {{/isPrimitiveType}}
+                 {{/isFile}}
+             }
+             {{/required}}
+@@ -662,7 +702,27 @@ namespace {{packageName}}.{{apiPackage}}
+             localVarRequestOptions.FileParameters.Add("{{baseName}}", {{paramName}});
+             {{/isFile}}
+             {{^isFile}}
+-            localVarRequestOptions.FormParameters.Add("{{baseName}}", {{packageName}}.Client.ClientUtils.ParameterToString({{paramName}})); // form parameter
++            {{#isPrimitiveType}}
++            // Primitive types (int, string, bool) go as standard form fields
++            localVarRequestOptions.FormParameters.Add("{{baseName}}", {{packageName}}.Client.ClientUtils.ParameterToString({{paramName}}));
++            {{/isPrimitiveType}}
++            {{^isPrimitiveType}}
++            {{#isEnum}}
++            // Enums are treated as strings
++            localVarRequestOptions.FormParameters.Add("{{baseName}}", {{packageName}}.Client.ClientUtils.ParameterToString({{paramName}}));
++            {{/isEnum}}
++            {{^isEnum}}
++            // COMPLEX TYPE: Serialize to JSON and add as a "File" with application/json header
++            if ({{paramName}} != null)
++            {
++                var _json_{{paramName}} = Newtonsoft.Json.JsonConvert.SerializeObject({{paramName}}, this.ApiClient.SerializerSettings);
++                var _stream_{{paramName}} = new System.IO.MemoryStream(System.Text.Encoding.UTF8.GetBytes(_json_{{paramName}}));
++
++                // Add as a file parameter with null filename and application/json content type
++                localVarRequestOptions.FileParameters.Add("{{baseName}}", new {{packageName}}.Client.FileParameter(null, "application/json", _stream_{{paramName}}));
++            }
++            {{/isEnum}}
++            {{/isPrimitiveType}}
+             {{/isFile}}
+             {{/required}}
+             {{^required}}
+@@ -672,7 +732,27 @@ namespace {{packageName}}.{{apiPackage}}
+                 localVarRequestOptions.FileParameters.Add("{{baseName}}", {{paramName}});
+                 {{/isFile}}
+                 {{^isFile}}
+-                localVarRequestOptions.FormParameters.Add("{{baseName}}", {{packageName}}.Client.ClientUtils.ParameterToString({{paramName}})); // form parameter
++                {{#isPrimitiveType}}
++                // Primitive types (int, string, bool) go as standard form fields
++                localVarRequestOptions.FormParameters.Add("{{baseName}}", {{packageName}}.Client.ClientUtils.ParameterToString({{paramName}}));
++                {{/isPrimitiveType}}
++                {{^isPrimitiveType}}
++                {{#isEnum}}
++                // Enums are treated as strings
++                localVarRequestOptions.FormParameters.Add("{{baseName}}", {{packageName}}.Client.ClientUtils.ParameterToString({{paramName}}));
++                {{/isEnum}}
++                {{^isEnum}}
++                // COMPLEX TYPE: Serialize to JSON and add as a "File" with application/json header
++                if ({{paramName}} != null)
++                {
++                    var _json_{{paramName}} = Newtonsoft.Json.JsonConvert.SerializeObject({{paramName}}, this.ApiClient.SerializerSettings);
++                    var _stream_{{paramName}} = new System.IO.MemoryStream(System.Text.Encoding.UTF8.GetBytes(_json_{{paramName}}));
++
++                    // Add as a file parameter with null filename and application/json content type
++                    localVarRequestOptions.FileParameters.Add("{{baseName}}", new {{packageName}}.Client.FileParameter(null, "application/json", _stream_{{paramName}}));
++                }
++                {{/isEnum}}
++                {{/isPrimitiveType}}
+                 {{/isFile}}
+             }
+             {{/required}}

openapi_client_codegen/_data/templates-patches/csharp/0006-csharp-streaming-download-response.patch

@@ -0,0 +1,34 @@
+# Stream HTTP response bodies through the generated client: switch SendAsync to ResponseHeadersRead so the body isn't pre-buffered, and skip the rawContent ReadAsStringAsync in ToApiResponse for Stream/FileParameter results whose body has already been consumed by Deserialize via ReadAsStreamAsync.
+diff --git a/csharp/libraries/httpclient/ApiClient.mustache b/csharp/libraries/httpclient/ApiClient.mustache
+index 7177eb4b..e4e0bded 100644
+--- a/csharp/libraries/httpclient/ApiClient.mustache
++++ b/csharp/libraries/httpclient/ApiClient.mustache
+@@ -445,7 +445,9 @@ namespace {{packageName}}.Client
+         private async Task<ApiResponse<T>> ToApiResponse<T>(HttpResponseMessage response, object responseData, Uri uri)
+         {
+             T result = (T)responseData;
+-            string rawContent = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
++            string rawContent = typeof(T) == typeof(Stream) || typeof(T) == typeof(FileParameter)
++                ? null
++                : await response.Content.ReadAsStringAsync().ConfigureAwait(false);
+ 
+             var transformed = new ApiResponse<T>(response.StatusCode, new Multimap<string, string>({{#caseInsensitiveResponseHeaders}}StringComparer.OrdinalIgnoreCase{{/caseInsensitiveResponseHeaders}}), result, rawContent)
+             {
+@@ -546,7 +548,7 @@ namespace {{packageName}}.Client
+                 {
+                     var policy = RetryConfiguration.AsyncRetryPolicy;
+                     var policyResult = await policy
+-                        .ExecuteAndCaptureAsync(() => _httpClient.SendAsync(req, finalToken))
++                        .ExecuteAndCaptureAsync(() => _httpClient.SendAsync(req, HttpCompletionOption.ResponseHeadersRead, finalToken))
+                         .ConfigureAwait(false);
+                     response = (policyResult.Outcome == OutcomeType.Successful) ?
+                         policyResult.Result : new HttpResponseMessage()
+@@ -558,7 +560,7 @@ namespace {{packageName}}.Client
+                 else
+                 {
+                 {{/supportsRetry}}
+-                    response = await _httpClient.SendAsync(req, finalToken).ConfigureAwait(false);
++                    response = await _httpClient.SendAsync(req, HttpCompletionOption.ResponseHeadersRead, finalToken).ConfigureAwait(false);
+                 {{#supportsRetry}}
+                 }
+                 {{/supportsRetry}}

openapi_client_codegen/_data/templates-patches/csharp/0007-csharp-model-default-initializers.patch

@@ -0,0 +1,13 @@
+# Initialize each non-required, non-enum backing field to the OpenAPI default value when one is declared, so `new T()` carries the schema-declared defaults instead of `default(T)`. No cast needed: `float` fields are tagged `format: double` in the spec via `common.litestar.FloatFormatPlugin`, so `toDefaultValue` emits a `D`-suffixed literal that C# accepts as `double` directly; `int` and `bool` defaults are already type-correct.
+diff --git a/csharp/modelGeneric.mustache b/csharp/modelGeneric.mustache
+--- a/csharp/modelGeneric.mustache
++++ b/csharp/modelGeneric.mustache
+@@ -243,7 +243,7 @@
+                 _flag{{name}} = true;
+             }
+         }
+-        private {{{dataType}}} _{{name}};
++        private {{{dataType}}} _{{name}}{{#defaultValue}} = {{{defaultValue}}}{{/defaultValue}};
+         private bool _flag{{name}};
+
+         /// <summary>

openapi_client_codegen/_data/templates-patches/csharp/0008-csharp-redirect-documentation-file.patch

@@ -0,0 +1,18 @@
+# The csproj ships inside the UPM package as the nuget pack input, and Directory.Build.props
+# (written by unity.write_unity_package_metadata) relocates MSBuild's BaseOutputPath outside the
+# package root. Point DocumentationFile at that relocated base so the docs XML — the one stock
+# template output with a hardwired package-local bin\ path — stops recreating bin/ inside the
+# package on every build. $(BaseOutputPath) is defined by Directory.Build.props, which MSBuild
+# imports before the project body, so it is visible at this property's evaluation point.
+diff --git a/csharp/netcore_project.mustache b/csharp/netcore_project.mustache
+--- a/csharp/netcore_project.mustache
++++ b/csharp/netcore_project.mustache
+@@ -14,7 +14,7 @@
+     <Copyright>{{packageCopyright}}</Copyright>
+     <RootNamespace>{{packageName}}</RootNamespace>
+     <Version>{{packageVersion}}</Version>
+-    <DocumentationFile>bin\$(Configuration)\$(TargetFramework)\{{packageName}}.xml</DocumentationFile>{{#licenseId}}
++    <DocumentationFile>$(BaseOutputPath)$(Configuration)\$(TargetFramework)\{{packageName}}.xml</DocumentationFile>{{#licenseId}}
+     <PackageLicenseExpression>{{.}}</PackageLicenseExpression>{{/licenseId}}
+     <RepositoryUrl>https://{{{gitHost}}}/{{{gitUserId}}}/{{{gitRepoId}}}.git</RepositoryUrl>
+     <RepositoryType>git</RepositoryType>{{#releaseNote}}

openapi_client_codegen/cli.py

@@ -0,0 +1,53 @@
+import json
+from pathlib import Path
+from tempfile import TemporaryDirectory
+from typing import Annotated
+
+from typer import Argument, Option, Typer
+
+from .client import generate_client
+from .downgrade import downgrade_openapi_3_1_to_3_0
+from .naming import DefaultNamingPolicy
+from .templates import regenerate_templates
+
+app = Typer(pretty_exceptions_show_locals=False)
+
+
+@app.command()
+def downgrade(
+    input_file: Annotated[Path, Argument(help="OpenAPI 3.1 JSON to downgrade to 3.0.3")],
+    output_file: Annotated[Path | None, Argument(help="Write here instead of overwriting input_file")] = None,
+) -> None:
+    schema = json.loads(input_file.read_text(encoding="utf-8"))
+    downgrade_openapi_3_1_to_3_0(schema)
+    destination = output_file if output_file is not None else input_file
+    destination.write_text(json.dumps(schema, indent=2), encoding="utf-8")
+
+
+@app.command()
+def generate(
+    spec_file: Annotated[Path, Argument(help="OpenAPI 3.0 spec JSON to generate from")],
+    output_dir: Annotated[Path, Argument(help="Directory to sync the generated client into")],
+    root_name: Annotated[str, Option(help="Root name handed to DefaultNamingPolicy")],
+    project: Annotated[str, Option(help="Project path; its last segment names the client")],
+    generator: Annotated[str, Option(help="openapi-generator generator name")] = "csharp",
+    npm_scope: Annotated[str | None, Option(help="npm scope composing the UPM package identity")] = None,
+    license_spdx: Annotated[str | None, Option(help="SPDX license id written to package.json")] = None,
+    repository_url: Annotated[str | None, Option(help="git repository URL written to package.json")] = None,
+) -> None:
+    with TemporaryDirectory() as templates_directory_string:
+        templates_directory = Path(templates_directory_string)
+        templates_dir = templates_directory if generator == "csharp" else None
+        if templates_dir is not None:
+            regenerate_templates(templates_dir)
+
+        generate_client(
+            spec_file.read_text(encoding="utf-8"),
+            generator,
+            output_dir,
+            DefaultNamingPolicy(root_name)(project),
+            templates_dir=templates_dir,
+            npm_scope=npm_scope,
+            license_spdx=license_spdx,
+            repository_url=repository_url,
+        )

openapi_client_codegen/client.py

@@ -0,0 +1,115 @@
+import json
+from os import walk
+from pathlib import Path
+from shutil import copytree
+from tempfile import NamedTemporaryFile, TemporaryDirectory
+
+from bashrun import bash
+
+from .resources import CONFIGS_DIR, IGNORE_FILE, OPENAPI_GENERATOR_CLI_VERSION
+from .naming import ClientNaming
+from .unity import write_unity_package_metadata
+
+_HTTP_METHODS = ("get", "put", "post", "delete", "patch", "options", "head", "trace")
+
+
+def generate_client(
+    spec: str,
+    generator: str,
+    output_dir: Path,
+    names: ClientNaming,
+    templates_dir: Path | None = None,
+    extra_references: list[str] | None = None,
+    npm_scope: str | None = None,
+    license_spdx: str | None = None,
+    repository_url: str | None = None,
+) -> None:
+    if generator == "csharp" and templates_dir is None:
+        msg = "csharp client generation requires templates_dir (call regenerate_templates first)"
+        raise ValueError(msg)
+
+    client_config = json.loads((CONFIGS_DIR / f"{generator}.json").read_text(encoding="utf-8"))
+
+    if generator == "csharp":
+        client_config["additionalProperties"]["packageName"] = names.camel
+    else:
+        client_config["additionalProperties"]["projectName"] = names.dashed
+        client_config["additionalProperties"]["packageName"] = names.underscored
+
+    with (
+        NamedTemporaryFile("w+", encoding="utf-8", suffix=".json", delete=False) as temporary_spec_file,
+        NamedTemporaryFile("w+", encoding="utf-8", suffix=".json", delete=False) as temporary_config_file,
+        TemporaryDirectory() as temporary_directory_string,
+    ):
+        temporary_directory = Path(temporary_directory_string)
+
+        # Force every operation onto a single "Default" tag so the generator emits one API class
+        spec_json = json.loads(spec)
+        for path_item in spec_json.get("paths", {}).values():
+            for method in _HTTP_METHODS:
+                operation = path_item.get(method)
+                if isinstance(operation, dict):
+                    operation["tags"] = ["Default"]
+
+        json.dump(spec_json, temporary_spec_file)
+        temporary_spec_file.flush()
+
+        json.dump(client_config, temporary_config_file)
+        temporary_config_file.flush()
+
+        command = (
+            f"uvx --from 'openapi-generator-cli[jdk4py]=={OPENAPI_GENERATOR_CLI_VERSION}' openapi-generator-cli generate "
+            f"-g {generator} "
+            f"-i {Path(temporary_spec_file.name).resolve().as_posix()} "
+            f"-o {temporary_directory.resolve().as_posix()} "
+            f"-c {Path(temporary_config_file.name).resolve().as_posix()} "
+            f"--ignore-file-override {IGNORE_FILE.resolve().as_posix()} "
+        )
+
+        if generator == "csharp" and templates_dir is not None:
+            command += f" -t {(templates_dir / 'csharp').resolve().as_posix()}"
+
+        bash(command, env={"JAVA_OPTS": "-Dlog.level=warn"})
+
+        print(f"Generated {generator} client (temp) at {temporary_directory}")
+
+        if generator == "csharp":
+            npm_name = None if npm_scope is None else f"{npm_scope}.{names.base.replace('-', '')}"
+            write_unity_package_metadata(
+                temporary_directory / "src" / names.camel,
+                names.camel,
+                extra_references,
+                npm_name=npm_name,
+                license_spdx=license_spdx,
+                repository_url=repository_url,
+            )
+
+        print(f"Syncing to {output_dir}...")
+
+        output_dir.mkdir(parents=True, exist_ok=True)
+
+        # Delete files that no longer exist in the freshly-generated tree
+        for target_file in output_dir.rglob("*"):
+            if not target_file.is_file():
+                continue
+
+            relative_path = target_file.relative_to(output_dir)
+
+            # A Unity .meta file shadows a real file; map it back to decide staleness
+            if target_file.name.endswith(".meta"):
+                relative_path = relative_path.with_name(target_file.name[:-5])
+
+            if not (temporary_directory / relative_path).exists():
+                target_file.unlink()
+
+        # Delete directories that no longer exist in the freshly-generated tree
+        for root, directories, _ in walk(output_dir, topdown=False):
+            for name in directories:
+                target_directory = Path(root) / name
+                if not (temporary_directory / target_directory.relative_to(output_dir)).exists():
+                    target_directory.rmdir()
+
+        copytree(temporary_directory, output_dir, dirs_exist_ok=True)
+
+    if generator == "python":
+        bash(f"uv pip install {output_dir.resolve().as_posix()}")

openapi_client_codegen/downgrade.py

@@ -0,0 +1,132 @@
+# Vibe code: Gemini 3
+# Convert an OpenAPI 3.1.0 schema to a 3.0.3-compatible one in place. openapi-generator
+# only accepts 3.0.x, while Litestar emits 3.1.0. Handles nullable type-arrays, oneOf/anyOf
+# null members, const, exclusive bounds, examples->example, and binary contentEncoding.
+
+type JsonPrimitive = str | int | float | bool | None
+type JsonValue = JsonPrimitive | JsonDict | JsonList
+type JsonDict = dict[str, JsonValue]
+type JsonList = list[JsonValue]
+
+
+def downgrade_openapi_3_1_to_3_0(schema: JsonDict) -> JsonDict:
+    if schema.get("openapi") == "3.1.0":
+        schema["openapi"] = "3.0.3"
+
+    _process_node(schema)
+
+    return schema
+
+
+def _process_node(node: JsonValue) -> None:
+    if isinstance(node, dict):
+        _convert_dict_node(node)
+        for value in node.values():
+            _process_node(value)
+    elif isinstance(node, list):
+        for item in node:
+            _process_node(item)
+
+
+def _convert_dict_node(node: JsonDict) -> None:
+    # `type: ["null", "string"]` -> `type: "string", nullable: true`
+    type_value = node.get("type")
+    if isinstance(type_value, list):
+        types: list[str] = [t for t in type_value if isinstance(t, str)]
+        has_null = "null" in types
+        non_null_types = [t for t in types if t != "null"]
+
+        if len(non_null_types) == 1:
+            node["type"] = non_null_types[0]
+            if has_null:
+                node["nullable"] = True
+        elif len(non_null_types) > 1:
+            any_of_items: JsonList = []
+            for t in non_null_types:
+                item: JsonDict = {"type": t}
+                # Array types require items in 3.0.3
+                if t == "array":
+                    item["items"] = {}
+                any_of_items.append(item)
+            del node["type"]
+            node["anyOf"] = any_of_items
+            if has_null:
+                node["nullable"] = True
+        elif has_null and len(non_null_types) == 0:
+            # Only null type - use object as fallback
+            node["type"] = "object"
+            node["nullable"] = True
+
+    # Ensure array types have items (required in 3.0.3)
+    if node.get("type") == "array" and "items" not in node:
+        node["items"] = {}
+
+    # Handle oneOf/anyOf with {"type": "null"}
+    for key in ["oneOf", "anyOf"]:
+        key_value = node.get(key)
+        if isinstance(key_value, list):
+            items = key_value
+            null_items: list[JsonDict] = [
+                item for item in items if isinstance(item, dict) and item.get("type") == "null"
+            ]
+            non_null_items: list[JsonDict] = [
+                item for item in items if isinstance(item, dict) and item.get("type") != "null"
+            ]
+
+            if null_items:
+                node["nullable"] = True
+
+                if len(non_null_items) == 0:
+                    # Only had null - remove oneOf/anyOf entirely, set as nullable object
+                    del node[key]
+                    if "type" not in node:
+                        node["type"] = "object"
+                elif len(non_null_items) == 1:
+                    # Single non-null item - inline it and remove oneOf/anyOf
+                    del node[key]
+                    single_item = non_null_items[0]
+                    for k, v in single_item.items():
+                        if k not in node:  # Don't overwrite nullable we just set
+                            node[k] = v
+                else:
+                    # Multiple non-null items - keep oneOf/anyOf without null
+                    node[key] = list(non_null_items)
+
+    # Convert `examples` (3.1.0) to `example` (3.0.3), but only in schema context (no "value" key)
+    examples_value = node.get("examples")
+    if isinstance(examples_value, list) and len(examples_value) > 0:
+        first_example = examples_value[0]
+        if not isinstance(first_example, dict) or "value" not in first_example:
+            node["example"] = first_example
+            del node["examples"]
+
+    # const (3.1.0) -> enum with a single value (3.0.3)
+    if "const" in node:
+        node["enum"] = [node["const"]]
+        del node["const"]
+
+    # In 3.1.0 exclusiveMinimum/Maximum are numbers; in 3.0.3 they are booleans paired with minimum/maximum
+    exclusive_min = node.get("exclusiveMinimum")
+    if isinstance(exclusive_min, (int, float)):
+        node["minimum"] = exclusive_min
+        node["exclusiveMinimum"] = True
+
+    exclusive_max = node.get("exclusiveMaximum")
+    if isinstance(exclusive_max, (int, float)):
+        node["maximum"] = exclusive_max
+        node["exclusiveMaximum"] = True
+
+    # `contentEncoding: "binary"` (3.1) is equivalent to `{type: string, format: binary}` (3.0.3).
+    # The containing response's media type already carries the `contentMediaType`, so that field is
+    # just dropped.
+    if node.get("contentEncoding") == "binary":
+        if "format" not in node:
+            node["format"] = "binary"
+        if "type" not in node:
+            node["type"] = "string"
+
+    # Remove 3.1.0-only properties that aren't supported in 3.0.3
+    unsupported_keys = ["contentMediaType", "contentEncoding", "$comment"]
+    for key in unsupported_keys:
+        if key in node:
+            del node[key]

openapi_client_codegen/naming.py

@@ -0,0 +1,26 @@
+from dataclasses import dataclass
+from typing import Protocol
+
+
+@dataclass(frozen=True)
+class ClientNaming:
+    base: str
+    dashed: str
+    underscored: str
+    camel: str
+
+
+class NamingPolicy(Protocol):
+    def __call__(self, project: str) -> ClientNaming: ...
+
+
+@dataclass(frozen=True)
+class DefaultNamingPolicy:
+    root_name: str
+
+    def __call__(self, project: str) -> ClientNaming:
+        base = f"{project.rsplit('/', maxsplit=1)[-1]}-client"
+        dashed = f"{self.root_name}-{base}"
+        underscored = dashed.replace("-", "_")
+        camel = f"{self.root_name.capitalize()}{''.join(part.capitalize() for part in base.split('-'))}"
+        return ClientNaming(base=base, dashed=dashed, underscored=underscored, camel=camel)

openapi_client_codegen/resources.py

@@ -0,0 +1,8 @@
+from pathlib import Path
+
+OPENAPI_GENERATOR_CLI_VERSION = "7.22.0"
+
+_DATA_DIR = Path(__file__).parent / "_data"
+CONFIGS_DIR = _DATA_DIR / "configs"
+IGNORE_FILE = _DATA_DIR / "openapi-generator-ignore"
+SHIPPED_PATCHES_DIR = _DATA_DIR / "templates-patches" / "csharp"

openapi_client_codegen/templates.py

@@ -0,0 +1,30 @@
+from pathlib import Path
+
+from bashrun import bash
+
+from .resources import OPENAPI_GENERATOR_CLI_VERSION, SHIPPED_PATCHES_DIR
+
+
+def regenerate_templates(target_dir: Path, extra_patches_dir: Path | None = None) -> None:
+    csharp_target = target_dir / "csharp"
+    csharp_target.mkdir(parents=True, exist_ok=True)
+
+    bash(
+        f"uvx --from 'openapi-generator-cli[jdk4py]=={OPENAPI_GENERATOR_CLI_VERSION}' "
+        f"openapi-generator-cli author template -g csharp --library httpclient "
+        f"-o {csharp_target.resolve().as_posix()}",
+        env={"JAVA_OPTS": "-Dlog.level=warn"},
+    )
+
+    patch_directories = [SHIPPED_PATCHES_DIR]
+    if extra_patches_dir is not None:
+        patch_directories.append(extra_patches_dir)
+
+    # Patches carry generic `csharp/...` paths; applying with cwd=target_dir and -p1 lands them on
+    # the authored tree without needing a surrounding git repository.
+    for patch_directory in patch_directories:
+        for patch_file in sorted(patch_directory.glob("*.patch")):
+            bash(
+                f"git apply --ignore-space-change --ignore-whitespace -p1 {patch_file.resolve().as_posix()}",
+                cwd=target_dir,
+            )

openapi_client_codegen/unity.py

@@ -0,0 +1,75 @@
+import json
+from pathlib import Path
+
+BASE_REFERENCES = ["Newtonsoft.Json", "Polly", "JsonSubTypes"]
+
+# UPM dual of BASE_REFERENCES: the asmdef compiles against the assembly names, the manifest
+# resolves the same runtime support as packages. Newtonsoft maps to the Unity-blessed package
+# instead of the UnityNuGet mirror identity, which collides with the assembly Unity itself
+# provides. Exact versions, not ranges: UPM's package.json dependencies accept SemVer values
+# only — the resolver rejects every range syntax (comparators, x-wildcards) with "Version 'X'
+# is invalid" — and it treats a value as a minimum when resolving, so consumer manifests
+# carrying newer minors still resolve without conflict.
+BASE_DEPENDENCIES = {
+    "com.unity.nuget.newtonsoft-json": "3.2.1",
+    "org.nuget.polly": "8.1.0",
+    "org.nuget.jsonsubtypes": "2.0.1",
+}
+
+# The csproj stays in the package (it is the nuget pack input), so MSBuild output is redirected
+# two levels up, outside the package root: bin/obj inside a UPM package lack .meta files (Unity
+# errors on import) and would ride the npm tarball. Two levels up is the client grouping dir in
+# a repo checkout and Unity's Library/ (asset-import-invisible) under PackageCache consumption.
+DIRECTORY_BUILD_PROPS = """<Project>
+  <PropertyGroup>
+    <BaseIntermediateOutputPath>$(MSBuildThisFileDirectory)../../obj/$(MSBuildProjectName)/</BaseIntermediateOutputPath>
+    <BaseOutputPath>$(MSBuildThisFileDirectory)../../bin/$(MSBuildProjectName)/</BaseOutputPath>
+  </PropertyGroup>
+</Project>
+"""
+
+
+def write_unity_package_metadata(
+    package_dir: Path,
+    package_name: str,
+    extra_references: list[str] | None = None,
+    npm_name: str | None = None,
+    license_spdx: str | None = None,
+    repository_url: str | None = None,
+) -> None:
+    references = BASE_REFERENCES if not extra_references else [*BASE_REFERENCES, *extra_references]
+
+    manifest: dict[str, object] = {
+        "name": npm_name if npm_name is not None else f"org.nuget.{package_name.lower()}",
+        "displayName": package_name,
+        "version": "0.0.0-local",
+        "dependencies": BASE_DEPENDENCIES,
+    }
+    if license_spdx is not None:
+        manifest["license"] = license_spdx
+    if repository_url is not None:
+        manifest["repository"] = {"type": "git", "url": repository_url}
+
+    (package_dir / "package.json").write_text(json.dumps(manifest, indent=2), encoding="utf-8")
+    (package_dir / f"{package_name}.asmdef").write_text(
+        json.dumps(
+            {
+                "name": package_name,
+                "references": references,
+                "includePlatforms": [],
+                "excludePlatforms": [],
+                "allowUnsafeCode": False,
+                "overrideReferences": False,
+                "precompiledReferences": [],
+                "autoReferenced": True,
+                "defineConstraints": [],
+                "versionDefines": [],
+                "noEngineReferences": False,
+            },
+            indent=2,
+        ),
+        encoding="utf-8",
+    )
+    # Tell the C# compiler to enable nullable annotations
+    (package_dir / "csc.rsp").write_text("-nullable:annotations", encoding="utf-8")
+    (package_dir / "Directory.Build.props").write_text(DIRECTORY_BUILD_PROPS, encoding="utf-8")

openapi_client_codegen-0.1.0.dist-info/METADATA

@@ -0,0 +1,9 @@
+Metadata-Version: 2.5
+Name: openapi-client-codegen
+Version: 0.1.0
+Summary: OpenAPI client-generation wrapper: Litestar spec dump, 3.1->3.0 downgrade, patched openapi-generator templates, Unity package metadata
+License-File: LICENSE
+License-File: NOTICE
+Requires-Python: >=3.13
+Requires-Dist: bashrun>=0.1.0
+Requires-Dist: typer>=0.17.4

openapi_client_codegen-0.1.0.dist-info/RECORD

@@ -0,0 +1,25 @@
+openapi_client_codegen/__init__.py,sha256=05SuI_ZEDw6LtioM_7EyY2ji-S8XnxbGxvtXfN0kOKY,453
+openapi_client_codegen/cli.py,sha256=Msvwen2juPp3HyRIvgJuBpEPewty0LfkN0jBk4Og1jA,2317
+openapi_client_codegen/client.py,sha256=9U7-310NYovMm1z7WZ8hGKNOfcY0EzR7BnAQ309wFtM,4633
+openapi_client_codegen/downgrade.py,sha256=7cxQZJRgWR5lNpvyJT-6pg4lVj72LsMRfdYzsNF9DtY,5230
+openapi_client_codegen/naming.py,sha256=c-GmnQk0zb2bsOi0gXOaUD5P_1c-dLfw8FaaNLQxb1I,742
+openapi_client_codegen/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+openapi_client_codegen/resources.py,sha256=Vavy0_zqot1eDrFpDJ_BT4Sbx47vh7zuclPjQtW3QMw,266
+openapi_client_codegen/templates.py,sha256=jixH6nefW58qHGfd5b0QT7fX9z5sHeOd1l5io3i5IxU,1193
+openapi_client_codegen/unity.py,sha256=CLFoNjKJNq-InkaXoqUIJ3q293pWoaLdFNn39D-avgc,3292
+openapi_client_codegen/_data/openapi-generator-ignore,sha256=EckS2MSJlfHzvb6rug11ionYoXnsXSJOkQGdHP6jz98,76
+openapi_client_codegen/_data/configs/csharp.json,sha256=_uezrromftc2dNmDH6JLhKO3MswWXWIesBYOnv8SqFc,587
+openapi_client_codegen/_data/configs/python.json,sha256=Phhny76qY4nVTcdPczBRCn0qgTdsR4WRgjHYslRRxp0,534
+openapi_client_codegen/_data/templates-patches/csharp/0001-csharp-remove-errant-comma.patch,sha256=2AdRZk0L_QXcr08eEzABLBFA-w4er1zGGL_BUbmWojk,952
+openapi_client_codegen/_data/templates-patches/csharp/0002-csharp-models-required-only-constructors.patch,sha256=FrZ1Z1SA9JS1wlYk7h7zFgHNikUcMCWMr5dLhKshykc,5118
+openapi_client_codegen/_data/templates-patches/csharp/0003-csharp-httpclient-use-defaultT.patch,sha256=7DHEQ1yOfg12p7a0b5wJSRGush4ChupB6UNoyilrU9o,851
+openapi_client_codegen/_data/templates-patches/csharp/0004-csharp-support-hybrid-multipart-payloads.patch,sha256=6EvDMYFqNDJsqugLkJFsUjhs8OWOS_dXIhTrcIaH6Pc,8797
+openapi_client_codegen/_data/templates-patches/csharp/0006-csharp-streaming-download-response.patch,sha256=ma-QkJA94jmN3scbJifaVPMcg_NNZ8klVO2HUrLMz_Y,2417
+openapi_client_codegen/_data/templates-patches/csharp/0007-csharp-model-default-initializers.patch,sha256=_fIimm7K0Gh1IYE3_fYyhUom_g-Bm4HlN9jLgsP27IE,862
+openapi_client_codegen/_data/templates-patches/csharp/0008-csharp-redirect-documentation-file.patch,sha256=HQXDgm_CzFYK4oxOoqBkYAz4wrKKPlYpLgTNHI_0IYc,1363
+openapi_client_codegen-0.1.0.dist-info/METADATA,sha256=wqCRN9OSNXcNGMk6KvQrAbQT1HYFslweIfem5fYCmPQ,336
+openapi_client_codegen-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+openapi_client_codegen-0.1.0.dist-info/entry_points.txt,sha256=mw8FL3PBefHSxRjhBJunBk9G1efUKgxNXwAlghbc31E,74
+openapi_client_codegen-0.1.0.dist-info/licenses/LICENSE,sha256=RFhQPdSOiMTguUX7JSoIuTxA7HVzCbj_p8WU36HjUQQ,10947
+openapi_client_codegen-0.1.0.dist-info/licenses/NOTICE,sha256=jvglZza3GCdN7v4_TLuXUqX9C_uABlwAKUkcIeKwk_8,26
+openapi_client_codegen-0.1.0.dist-info/RECORD,,

openapi_client_codegen-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

openapi_client_codegen-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+openapi-client-codegen = openapi_client_codegen.cli:app

openapi_client_codegen-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1.  Definitions.
+
+    "License" shall mean the terms and conditions for use, reproduction,
+    and distribution as defined by Sections 1 through 9 of this document.
+
+    "Licensor" shall mean the copyright owner or entity authorized by
+    the copyright owner that is granting the License.
+
+    "Legal Entity" shall mean the union of the acting entity and all
+    other entities that control, are controlled by, or are under common
+    control with that entity. For the purposes of this definition,
+    "control" means (i) the power, direct or indirect, to cause the
+    direction or management of such entity, whether by contract or
+    otherwise, or (ii) ownership of fifty percent (50%) or more of the
+    outstanding shares, or (iii) beneficial ownership of such entity.
+
+    "You" (or "Your") shall mean an individual or Legal Entity
+    exercising permissions granted by this License.
+
+    "Source" form shall mean the preferred form for making modifications,
+    including but not limited to software source code, documentation
+    source, and configuration files.
+
+    "Object" form shall mean any form resulting from mechanical
+    transformation or translation of a Source form, including but
+    not limited to compiled object code, generated documentation,
+    and conversions to other media types.
+
+    "Work" shall mean the work of authorship, whether in Source or
+    Object form, made available under the License, as indicated by a
+    copyright notice that is included in or attached to the work
+    (an example is provided in the Appendix below).
+
+    "Derivative Works" shall mean any work, whether in Source or Object
+    form, that is based on (or derived from) the Work and for which the
+    editorial revisions, annotations, elaborations, or other modifications
+    represent, as a whole, an original work of authorship. For the purposes
+    of this License, Derivative Works shall not include works that remain
+    separable from, or merely link (or bind by name) to the interfaces of,
+    the Work and Derivative Works thereof.
+
+    "Contribution" shall mean any work of authorship, including
+    the original version of the Work and any modifications or additions
+    to that Work or Derivative Works thereof, that is intentionally
+    submitted to Licensor for inclusion in the Work by the copyright owner
+    or by an individual or Legal Entity authorized to submit on behalf of
+    the copyright owner. For the purposes of this definition, "submitted"
+    means any form of electronic, verbal, or written communication sent
+    to the Licensor or its representatives, including but not limited to
+    communication on electronic mailing lists, source code control systems,
+    and issue tracking systems that are managed by, or on behalf of, the
+    Licensor for the purpose of discussing and improving the Work, but
+    excluding communication that is conspicuously marked or otherwise
+    designated in writing by the copyright owner as "Not a Contribution."
+
+    "Contributor" shall mean Licensor and any individual or Legal Entity
+    on behalf of whom a Contribution has been received by Licensor and
+    subsequently incorporated within the Work.
+
+2.  Grant of Copyright License. Subject to the terms and conditions of
+    this License, each Contributor hereby grants to You a perpetual,
+    worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+    copyright license to reproduce, prepare Derivative Works of,
+    publicly display, publicly perform, sublicense, and distribute the
+    Work and such Derivative Works in Source or Object form.
+
+3.  Grant of Patent License. Subject to the terms and conditions of
+    this License, each Contributor hereby grants to You a perpetual,
+    worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+    (except as stated in this section) patent license to make, have made,
+    use, offer to sell, sell, import, and otherwise transfer the Work,
+    where such license applies only to those patent claims licensable
+    by such Contributor that are necessarily infringed by their
+    Contribution(s) alone or by combination of their Contribution(s)
+    with the Work to which such Contribution(s) was submitted. If You
+    institute patent litigation against any entity (including a
+    cross-claim or counterclaim in a lawsuit) alleging that the Work
+    or a Contribution incorporated within the Work constitutes direct
+    or contributory patent infringement, then any patent licenses
+    granted to You under this License for that Work shall terminate
+    as of the date such litigation is filed.
+
+4.  Redistribution. You may reproduce and distribute copies of the
+    Work or Derivative Works thereof in any medium, with or without
+    modifications, and in Source or Object form, provided that You
+    meet the following conditions:
+
+    (a) You must give any other recipients of the Work or
+    Derivative Works a copy of this License; and
+
+    (b) You must cause any modified files to carry prominent notices
+    stating that You changed the files; and
+
+    (c) You must retain, in the Source form of any Derivative Works
+    that You distribute, all copyright, patent, trademark, and
+    attribution notices from the Source form of the Work,
+    excluding those notices that do not pertain to any part of
+    the Derivative Works; and
+
+    (d) If the Work includes a "NOTICE" text file as part of its
+    distribution, then any Derivative Works that You distribute must
+    include a readable copy of the attribution notices contained
+    within such NOTICE file, excluding those notices that do not
+    pertain to any part of the Derivative Works, in at least one
+    of the following places: within a NOTICE text file distributed
+    as part of the Derivative Works; within the Source form or
+    documentation, if provided along with the Derivative Works; or,
+    within a display generated by the Derivative Works, if and
+    wherever such third-party notices normally appear. The contents
+    of the NOTICE file are for informational purposes only and
+    do not modify the License. You may add Your own attribution
+    notices within Derivative Works that You distribute, alongside
+    or as an addendum to the NOTICE text from the Work, provided
+    that such additional attribution notices cannot be construed
+    as modifying the License.
+
+    You may add Your own copyright statement to Your modifications and
+    may provide additional or different license terms and conditions
+    for use, reproduction, or distribution of Your modifications, or
+    for any such Derivative Works as a whole, provided Your use,
+    reproduction, and distribution of the Work otherwise complies with
+    the conditions stated in this License.
+
+5.  Submission of Contributions. Unless You explicitly state otherwise,
+    any Contribution intentionally submitted for inclusion in the Work
+    by You to the Licensor shall be under the terms and conditions of
+    this License, without any additional terms or conditions.
+    Notwithstanding the above, nothing herein shall supersede or modify
+    the terms of any separate license agreement you may have executed
+    with Licensor regarding such Contributions.
+
+6.  Trademarks. This License does not grant permission to use the trade
+    names, trademarks, service marks, or product names of the Licensor,
+    except as required for reasonable and customary use in describing the
+    origin of the Work and reproducing the content of the NOTICE file.
+
+7.  Disclaimer of Warranty. Unless required by applicable law or
+    agreed to in writing, Licensor provides the Work (and each
+    Contributor provides its Contributions) on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+    implied, including, without limitation, any warranties or conditions
+    of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+    PARTICULAR PURPOSE. You are solely responsible for determining the
+    appropriateness of using or redistributing the Work and assume any
+    risks associated with Your exercise of permissions under this License.
+
+8.  Limitation of Liability. In no event and under no legal theory,
+    whether in tort (including negligence), contract, or otherwise,
+    unless required by applicable law (such as deliberate and grossly
+    negligent acts) or agreed to in writing, shall any Contributor be
+    liable to You for damages, including any direct, indirect, special,
+    incidental, or consequential damages of any character arising as a
+    result of this License or out of the use or inability to use the
+    Work (including but not limited to damages for loss of goodwill,
+    work stoppage, computer failure or malfunction, or any and all
+    other commercial damages or losses), even if such Contributor
+    has been advised of the possibility of such damages.
+
+9.  Accepting Warranty or Additional Liability. While redistributing
+    the Work or Derivative Works thereof, You may choose to offer,
+    and charge a fee for, acceptance of support, warranty, indemnity,
+    or other liability obligations and/or rights consistent with this
+    License. However, in accepting such obligations, You may act only
+    on Your own behalf and on Your sole responsibility, not on behalf
+    of any other Contributor, and only if You agree to indemnify,
+    defend, and hold each Contributor harmless for any liability
+    incurred by, or claims asserted against, such Contributor by reason
+    of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

openapi_client_codegen-0.1.0.dist-info/licenses/NOTICE

@@ -0,0 +1 @@
+Copyright 2026 Tyler Hatch