@goast/kotlin 0.1.17 → 0.2.0

package/esm/lib/generators/services/okhttp3-clients/okhttp3-client-generator.js

@@ -1,345 +1,250 @@
+/* eslint-disable unused-imports/no-unused-vars */
 import { writeFileSync } from 'fs';
 import { dirname } from 'path';
 import { ensureDirSync } from 'fs-extra';
-import { toCasing } from '@goast/core';
+import { SourceBuilder, appendValueGroup, builderTemplate as s, createOverwriteProxy, toCasing, } from '@goast/core';
+import { kt } from '../../../ast';
 import { KotlinFileBuilder } from '../../../file-builder';
-import { modifyString, toKotlinStringLiteral } from '../../../utils';
+import { modifyString } from '../../../utils';
 import { KotlinFileGenerator } from '../../file-generator';
 export class DefaultKotlinOkHttp3Generator extends KotlinFileGenerator {
     generate(ctx) {
-        const typeName = this.getApiClientName(ctx);
-        const packageName = this.getPackageName(ctx, ctx.service);
-        const filePath = this.getFilePath(ctx, packageName);
+        const typeName = this.getApiClientName(ctx, {});
+        const packageName = this.getPackageName(ctx, {});
+        const filePath = this.getFilePath(ctx, { packageName });
         ensureDirSync(dirname(filePath));
         console.log(`Generating client for service ${ctx.service.name} to ${filePath}...`);
         const builder = new KotlinFileBuilder(packageName, ctx.config);
-        this.generateApiClientFileContent(ctx, builder);
+        builder.append(this.getClientFileContent(ctx, {}));
         writeFileSync(filePath, builder.toString());
         return { typeName, packageName };
     }
-    generateApiClientFileContent(ctx, builder) {
-        builder
-            .append((builder) => this.generateApiClientClassAnnotations(ctx, builder))
-            .ensureCurrentLineEmpty()
-            .append((builder) => this.generateApiClientClassSignature(ctx, builder))
-            .append(' ')
-            .parenthesize('{}', (builder) => this.generateApiClientClassContent(ctx, builder), { multiline: true });
-    }
-    generateApiClientClassAnnotations(ctx, builder) {
-        // None for now
-    }
-    generateApiClientClassSignature(ctx, builder) {
-        builder
-            .append('class ')
-            .append(this.getApiClientName(ctx))
-            .parenthesize('()', (builder) => builder
-            .appendLine('basePath: String = defaultBasePath,')
-            .appendLine('client: OkHttpClient = ApiClient.defaultClient')
-            .addImport('OkHttpClient', 'okhttp3')
-            .addImport('ApiClient', ctx.infrastructurePackageName), { multiline: true })
-            .append(' : ')
-            .append('ApiClient(basePath, client)');
-    }
-    generateApiClientClassContent(ctx, builder) {
-        builder
-            .append((builder) => this.generateApiClientCompanionObject(ctx, builder))
-            .forEach(ctx.service.endpoints, (builder, endpoint) => builder
-            .ensurePreviousLineEmpty()
-            .append((builder) => this.generateApiClientMethod(ctx, builder, endpoint))
-            .ensurePreviousLineEmpty()
-            .append((builder) => this.generateApiClientHttpInfoMethod(ctx, builder, endpoint))
-            .ensurePreviousLineEmpty()
-            .append((builder) => this.generateApiClientRequestConfigMethod(ctx, builder, endpoint)))
-            .ensurePreviousLineEmpty()
-            .append((builder) => this.generateAdditionalMethods(ctx, builder));
-    }
-    generateApiClientCompanionObject(ctx, builder) {
-        builder
-            .append('companion object ')
-            .parenthesize('{}', (builder) => this.generateApiClientCompanionObjectContent(ctx, builder), { multiline: true });
-    }
-    generateApiClientCompanionObjectContent(ctx, builder) {
-        this.generateApiClientCompanionObjectDefaultBasePathProperty(ctx, builder);
-    }
-    generateApiClientCompanionObjectDefaultBasePathProperty(ctx, builder) {
-        builder
-            .appendAnnotation('JvmStatic')
-            .append('val defaultBasePath: String by lazy ')
-            .parenthesize('{}', (builder) => builder
-            .appendLine(`System.getProperties().getProperty(ApiClient.baseUrlKey, ${this.toStringLiteral(ctx, this.getBasePath(ctx))})`)
-            .addImport('ApiClient', ctx.infrastructurePackageName), { multiline: true });
-    }
-    generateApiClientMethod(ctx, builder, endpoint) {
-        builder
-            .append((builder) => this.generateApiClientMethodDocumentation(ctx, builder, endpoint))
-            .ensureCurrentLineEmpty()
-            .append((builder) => this.generateApiClientMethodAnnotations(ctx, builder, endpoint))
-            .ensureCurrentLineEmpty()
-            .append((builder) => this.generateApiClientMethodSignature(ctx, builder, endpoint))
-            .append(' ')
-            .parenthesize('{}', (builder) => this.generateApiClientMethodContent(ctx, builder, endpoint), {
-            multiline: true,
+    getClientFileContent(ctx, args) {
+        return appendValueGroup([this.getClientClass(ctx, {})]);
+    }
+    getClientClass(ctx, args) {
+        return kt.class(this.getApiClientName(ctx, {}), {
+            extends: ctx.refs.apiClient(),
+            primaryConstructor: kt.constructor([
+                kt.parameter('basePath', kt.refs.string(), { default: 'defaultBasePath' }),
+                kt.parameter('client', kt.refs.okhttp3.okHttpClient(), { default: kt.call(['ApiClient', 'defaultClient']) }),
+            ], null, {
+                delegateTarget: 'super',
+                delegateArguments: ['basePath', 'client'],
+            }),
+            companionObject: this.getClientCompanionObject(ctx, {}),
+            members: [
+                ...ctx.service.endpoints.flatMap((endpoint) => this.getEndpointClientMembers(ctx, { endpoint, parameters: this.getAllParameters(ctx, { endpoint }) })),
+                ...this.getAdditionalClientMembers(ctx, {}),
+            ],
         });
     }
-    generateApiClientMethodDocumentation(ctx, builder, endpoint) {
-        builder
-            .appendLine('/**')
-            .appendWithLinePrefix(' * ', (builder) => {
-            var _a;
-            return builder
-                .appendLine(`${(_a = endpoint.summary) !== null && _a !== void 0 ? _a : 'TODO: Provide summary'}`)
-                .append((builder) => this.generateParamDocEntries(ctx, builder, endpoint))
-                .append('@return ')
-                .append((builder) => this.generateApiClientMethodReturnType(ctx, builder, endpoint))
-                .appendLine()
-                .appendLine('@throws IllegalStateException If the request is not correctly configured')
-                .appendLine('@throws IOException Rethrows the OkHttp execute method exception')
-                .appendLine('@throws UnsupportedOperationException If the API returns an informational or redirection response')
-                .appendLine('@throws ClientException If the API returns a client error response')
-                .appendLine('@throws ServerException If the API returns a server error response');
-        })
-            .appendLine(' */');
-    }
-    generateApiClientMethodAnnotations(ctx, builder, endpoint) {
-        builder
-            .appendAnnotation('Throws', undefined, [
-            'IllegalStateException::class',
-            'IOException::class',
-            'UnsupportedOperationException::class',
-            'ClientException::class',
-            'ServerException::class',
-        ])
-            .addImport('IOException', 'java.io')
-            .addImport('ClientException', ctx.infrastructurePackageName)
-            .addImport('ServerException', ctx.infrastructurePackageName);
-    }
-    generateApiClientMethodSignature(ctx, builder, endpoint) {
-        builder
-            .append('fun ')
-            .append(toCasing(endpoint.name, 'camel'))
-            .parenthesize('()', (builder) => this.generateApiClientMethodParameters(ctx, builder, endpoint))
-            .append(': ')
-            .append((builder) => this.generateApiClientMethodReturnType(ctx, builder, endpoint));
-    }
-    generateApiClientMethodParameters(ctx, builder, endpoint) {
-        this.generateParams(ctx, builder, endpoint, true);
-    }
-    generateApiClientMethodReturnType(ctx, builder, endpoint) {
-        this.generateTypeUsage(ctx, builder, this.getResponseSchema(ctx, endpoint), 'Unit');
-    }
-    generateApiClientMethodContent(ctx, builder, endpoint) {
-        const responseSchema = this.getResponseSchema(ctx, endpoint);
-        builder
-            .append(`val localVarResponse = ${toCasing(endpoint.name, 'camel')}WithHttpInfo`)
-            .parenthesize('()', (builder) => this.generateParams(ctx, builder, endpoint, false))
-            .appendLine()
-            .appendLine()
-            .append('return when (localVarResponse.responseType) ')
-            .parenthesize('{}', (builder) => builder
-            .append('ResponseType.Success -> ')
-            .if(responseSchema === undefined, (builder) => builder.append('Unit'), (builder) => builder
-            .append('(localVarResponse as Success<*>).data as ')
-            .addImport('Success', ctx.infrastructurePackageName)
-            .append((builder) => this.generateTypeUsage(ctx, builder, responseSchema)))
-            .ensureCurrentLineEmpty()
-            .appendLine(responseErrorHandlingCode)
-            .addImport('ClientError', ctx.infrastructurePackageName)
-            .addImport('ServerError', ctx.infrastructurePackageName)
-            .addImport('ResponseType', ctx.infrastructurePackageName), { multiline: true });
-    }
-    generateApiClientHttpInfoMethod(ctx, builder, endpoint) {
-        builder
-            .append((builder) => this.generateApiClientHttpInfoMethodDocumentation(ctx, builder, endpoint))
-            .ensureCurrentLineEmpty()
-            .append((builder) => this.generateApiClientHttpInfoMethodAnnotations(ctx, builder, endpoint))
-            .ensureCurrentLineEmpty()
-            .append((builder) => this.generateApiClientHttpInfoMethodSignature(ctx, builder, endpoint))
-            .append(' ')
-            .parenthesize('{}', (builder) => this.generateApiClientHttpInfoMethodContent(ctx, builder, endpoint), {
-            multiline: true,
+    getClientCompanionObject(ctx, args) {
+        const result = kt.object();
+        result.members.push(kt.property('defaultBasePath', {
+            annotations: [kt.annotation(kt.refs.jvmStatic())],
+            type: kt.refs.string(),
+            delegate: kt.refs.lazyFun.infer(),
+            delegateArguments: [
+                kt.lambda([], kt.call([kt.call([kt.refs.java.system(), 'getProperties'], []), 'getProperty'], [kt.call([ctx.refs.apiClient(), 'baseUrlKey']), kt.string(this.getBasePath(ctx, {}))])),
+            ],
+        }));
+        return result;
+    }
+    getEndpointClientMembers(ctx, args) {
+        const { endpoint, parameters } = args;
+        const responseSchema = this.getResponseSchema(ctx, { endpoint });
+        return [
+            this.getEndpointClientMethod(ctx, { endpoint, parameters, responseSchema }),
+            this.getEndpointClientHttpInfoMethod(ctx, { endpoint, parameters, responseSchema }),
+            this.getEndpointClientRequestConfigMethod(ctx, { endpoint, parameters }),
+        ];
+    }
+    getEndpointClientMethod(ctx, args) {
+        const { endpoint, parameters, responseSchema } = args;
+        return kt.function(toCasing(endpoint.name, ctx.config.functionNameCasing), {
+            doc: kt.doc(endpoint.summary, [
+                kt.docTag('throws', 'IllegalStateException', 'If the request is not correctly configured'),
+                kt.docTag('throws', 'IOException', 'Rethrows the OkHttp execute method exception'),
+                kt.docTag('throws', 'UnsupportedOperationException', 'If the API returns an informational or redirection response'),
+                kt.docTag('throws', 'ClientException', 'If the API returns a client error response'),
+                kt.docTag('throws', 'ServerException', 'If the API returns a server error response'),
+            ]),
+            annotations: [
+                kt.annotation(kt.refs.throws(), [
+                    kt.refs.java.illegalStateException({ classReference: true }),
+                    kt.refs.java.ioException({ classReference: true }),
+                    kt.refs.java.unsupportedOperationException({ classReference: true }),
+                    ctx.refs.clientException({ classReference: true }),
+                    ctx.refs.serverException({ classReference: true }),
+                ]),
+            ],
+            parameters: parameters.map((p) => {
+                var _a;
+                return kt.parameter(toCasing(p.name, ctx.config.parameterNameCasing), this.getTypeUsage(ctx, { schema: p.schema, nullable: !p.required }), {
+                    description: p.description,
+                    default: !p.required ? kt.toNode((_a = p.schema) === null || _a === void 0 ? void 0 : _a.default) : null,
+                });
+            }),
+            returnType: this.getTypeUsage(ctx, { schema: responseSchema, fallback: kt.refs.unit() }),
+            body: this.getEndpointClientMethodBody(ctx, { endpoint, parameters, responseSchema }),
         });
     }
-    generateApiClientHttpInfoMethodDocumentation(ctx, builder, endpoint) {
-        builder
-            .appendLine('/**')
-            .appendWithLinePrefix(' * ', (builder) => {
-            var _a;
-            return builder
-                .appendLine(`${(_a = endpoint.summary) !== null && _a !== void 0 ? _a : 'TODO: Provide summary'}`)
-                .append((builder) => this.generateParamDocEntries(ctx, builder, endpoint))
-                .append('@return ')
-                .append((builder) => this.generateApiClientHttpInfoMethodReturnType(ctx, builder, endpoint))
-                .appendLine()
-                .appendLine('@throws IllegalStateException If the request is not correctly configured')
-                .appendLine('@throws IOException Rethrows the OkHttp execute method exception')
-                .appendLine('@throws UnsupportedOperationException If the API returns an informational or redirection response')
-                .appendLine('@throws ClientException If the API returns a client error response')
-                .appendLine('@throws ServerException If the API returns a server error response');
-        })
-            .appendLine(' */');
-    }
-    generateApiClientHttpInfoMethodAnnotations(ctx, builder, endpoint) {
-        builder
-            .appendAnnotation('Throws', undefined, ['IllegalStateException::class', 'IOException::class'])
-            .addImport('IOException', 'java.io');
-    }
-    generateApiClientHttpInfoMethodSignature(ctx, builder, endpoint) {
-        builder
-            .append('fun ')
-            .append(toCasing(endpoint.name, 'camel'), 'WithHttpInfo')
-            .parenthesize('()', (builder) => this.generateApiClientHttpInfoMethodSignatureParameters(ctx, builder, endpoint))
-            .append(': ')
-            .append((builder) => this.generateApiClientHttpInfoMethodReturnType(ctx, builder, endpoint));
-    }
-    generateApiClientHttpInfoMethodSignatureParameters(ctx, builder, endpoint) {
-        this.generateParams(ctx, builder, endpoint, true);
-    }
-    generateApiClientHttpInfoMethodReturnType(ctx, builder, endpoint) {
-        builder
-            .append('ApiResponse')
-            .addImport('ApiResponse', ctx.infrastructurePackageName)
-            .parenthesize('<>', (builder) => this.generateTypeUsage(ctx, builder, this.getResponseSchema(ctx, endpoint), 'Unit', true));
-    }
-    generateApiClientHttpInfoMethodContent(ctx, builder, endpoint) {
-        builder
-            .append(`val localVariableConfig = ${toCasing(endpoint.name, 'camel')}RequestConfig`)
-            .parenthesize('()', (builder) => this.generateParams(ctx, builder, endpoint, false))
-            .appendLine()
-            .appendLine()
-            .append('return request')
-            .parenthesize('<>', (builder) => builder
-            .append((builder) => { var _a; return this.generateTypeUsage(ctx, builder, (_a = endpoint.requestBody) === null || _a === void 0 ? void 0 : _a.content[0].schema, 'Unit'); })
-            .append(', ')
-            .append((builder) => this.generateTypeUsage(ctx, builder, this.getResponseSchema(ctx, endpoint), 'Unit')))
-            .parenthesize('()', (builder) => builder.append('localVariableConfig'), { multiline: true });
-    }
-    generateApiClientRequestConfigMethod(ctx, builder, endpoint) {
-        builder
-            .append((builder) => this.generateApiClientRequestConfigMethodDocumentation(ctx, builder, endpoint))
-            .ensureCurrentLineEmpty()
-            .append((builder) => this.generateApiClientRequestConfigMethodAnnotations(ctx, builder, endpoint))
-            .ensureCurrentLineEmpty()
-            .append((builder) => this.generateApiClientRequestConfigMethodSignature(ctx, builder, endpoint))
-            .append(' ')
-            .parenthesize('{}', (builder) => this.generateApiClientRequestConfigMethodContent(ctx, builder, endpoint), {
-            multiline: true,
+    getEndpointClientMethodBody(ctx, args) {
+        const { endpoint, parameters, responseSchema } = args;
+        return appendValueGroup([
+            s `val localVarResponse = ${kt.call([toCasing(endpoint.name + '_WithHttpInfo', ctx.config.functionNameCasing)], parameters.map((x) => x.name))}`,
+            '',
+            s `return when (localVarResponse.responseType) {${s.indent `
+            ${ctx.refs.responseType()}.Success -> ${responseSchema === undefined
+                ? kt.refs.unit()
+                : s `(localVarResponse as ${ctx.refs.success(['*'])}).data as ${this.getTypeUsage(ctx, {
+                    schema: responseSchema,
+                })}`}
+            ${ctx.refs.responseType()}.Informational -> throw ${kt.refs.java.unsupportedOperationException()}("Client does not support Informational responses.")
+            ${ctx.refs.responseType()}.Redirection -> throw ${kt.refs.java.unsupportedOperationException()}("Client does not support Redirection responses.")
+            ${ctx.refs.responseType()}.ClientError -> {${s.indent `
+              val localVarError = localVarResponse as ${ctx.refs.clientError(['*'])}
+              throw ${ctx.refs.clientException()}(${s.indent `
+                "Client error : \${localVarError.statusCode} \${localVarError.message.orEmpty()}",
+                localVarError.statusCode,
+                localVarResponse`}
+              )`}
+            }
+
+            ${ctx.refs.responseType()}.ServerError -> {${s.indent `
+              val localVarError = localVarResponse as ${ctx.refs.serverError(['*'])}
+              throw ${ctx.refs.serverException()}(${s.indent `
+                "Server error : \${localVarError.statusCode} \${localVarError.message.orEmpty()}",
+                localVarError.statusCode,
+                localVarResponse`}
+              )`}
+            }`}
+          }`,
+        ], '\n');
+    }
+    getEndpointClientHttpInfoMethod(ctx, args) {
+        const { endpoint, parameters, responseSchema } = args;
+        return kt.function(toCasing(args.endpoint.name, ctx.config.functionNameCasing) + 'WithHttpInfo', {
+            doc: kt.doc(endpoint.summary, [
+                kt.docTag('throws', 'IllegalStateException', 'If the request is not correctly configured'),
+                kt.docTag('throws', 'IOException', 'Rethrows the OkHttp execute method exception'),
+            ]),
+            annotations: [
+                kt.annotation(kt.refs.throws(), [
+                    kt.refs.java.illegalStateException({ classReference: true }),
+                    kt.refs.java.ioException({ classReference: true }),
+                ]),
+            ],
+            parameters: parameters.map((p) => {
+                var _a;
+                return kt.parameter(toCasing(p.name, ctx.config.parameterNameCasing), this.getTypeUsage(ctx, { schema: p.schema, nullable: !p.required }), {
+                    description: p.description,
+                    default: !p.required ? kt.toNode((_a = p.schema) === null || _a === void 0 ? void 0 : _a.default) : null,
+                });
+            }),
+            returnType: ctx.refs.apiResponse([
+                this.getTypeUsage(ctx, { schema: responseSchema, fallback: kt.refs.unit(), nullable: true }),
+            ]),
+            body: this.getEndpointClientHttpInfoMethodBody(ctx, { endpoint, parameters, responseSchema }),
         });
     }
-    generateApiClientRequestConfigMethodDocumentation(ctx, builder, endpoint) {
-        builder
-            .appendLine('/**')
-            .appendWithLinePrefix(' * ', (builder) => builder
-            .appendLine(`To obtain the request config of the operation ${toCasing(endpoint.name, 'camel')}`)
-            .append((builder) => this.generateParamDocEntries(ctx, builder, endpoint))
-            .append('@return RequestConfig'))
-            .appendLine(' */');
-    }
-    generateApiClientRequestConfigMethodAnnotations(ctx, builder, endpoint) {
-        // No annotations needed
-    }
-    generateApiClientRequestConfigMethodSignature(ctx, builder, endpoint) {
-        builder
-            .append('private fun ')
-            .append(toCasing(endpoint.name, 'camel'), 'RequestConfig')
-            .parenthesize('()', (builder) => this.generateApiClientRequestConfigMethodSignatureParameters(ctx, builder, endpoint))
-            .append(': ')
-            .append((builder) => this.generateApiClientRequestConfigMethodReturnType(ctx, builder, endpoint));
-    }
-    generateApiClientRequestConfigMethodSignatureParameters(ctx, builder, endpoint) {
-        this.generateParams(ctx, builder, endpoint, true);
-    }
-    generateApiClientRequestConfigMethodReturnType(ctx, builder, endpoint) {
-        builder
-            .append('RequestConfig')
-            .addImport('RequestConfig', ctx.infrastructurePackageName)
-            .parenthesize('<>', (builder) => { var _a; return this.generateTypeUsage(ctx, builder, (_a = endpoint.requestBody) === null || _a === void 0 ? void 0 : _a.content[0].schema, 'Unit'); });
+    getEndpointClientHttpInfoMethodBody(ctx, args) {
+        var _a;
+        const { endpoint, parameters, responseSchema } = args;
+        return appendValueGroup([
+            s `val localVariableConfig = ${kt.call([toCasing(endpoint.name, 'camel') + 'RequestConfig'], parameters.map((x) => x.name))}`,
+            s `return ${kt.call([
+                kt.reference('request', null, {
+                    generics: [
+                        this.getTypeUsage(ctx, { schema: (_a = endpoint.requestBody) === null || _a === void 0 ? void 0 : _a.content[0].schema, fallback: kt.refs.unit() }),
+                        this.getTypeUsage(ctx, { schema: responseSchema, fallback: kt.refs.unit() }),
+                    ],
+                }),
+            ], ['localVariableConfig'])}`,
+        ], '\n');
+    }
+    getEndpointClientRequestConfigMethod(ctx, args) {
+        var _a;
+        const { endpoint, parameters } = args;
+        const operationName = toCasing(endpoint.name, ctx.config.functionNameCasing);
+        const requestSchema = (_a = endpoint.requestBody) === null || _a === void 0 ? void 0 : _a.content[0].schema;
+        return kt.function(toCasing(args.endpoint.name, ctx.config.functionNameCasing) + 'RequestConfig', {
+            accessModifier: 'private',
+            doc: kt.doc(`To obtain the request config of the operation ${operationName}`),
+            parameters: parameters.map((p) => {
+                var _a;
+                return kt.parameter(toCasing(p.name, ctx.config.parameterNameCasing), this.getTypeUsage(ctx, { schema: p.schema, nullable: !p.required }), {
+                    description: p.description,
+                    default: !p.required ? kt.toNode((_a = p.schema) === null || _a === void 0 ? void 0 : _a.default) : null,
+                });
+            }),
+            returnType: ctx.refs.requestConfig([this.getTypeUsage(ctx, { schema: requestSchema, fallback: kt.refs.unit() })]),
+            body: this.getEndpointClientRequestConfigMethodBody(ctx, { endpoint }),
+        });
     }
-    generateApiClientRequestConfigMethodContent(ctx, builder, endpoint) {
+    getEndpointClientRequestConfigMethodBody(ctx, args) {
         var _a, _b;
+        const { endpoint } = args;
         const queryParameters = endpoint.parameters.filter((x) => x.target === 'query');
-        builder
-            .appendLineIf(!!endpoint.requestBody, `val localVariableBody = ${toCasing(this.getRequestBodyParamName(ctx, endpoint), 'camel')}`)
-            .appendLine('val localVariableQuery: MultiValueMap = mutableMapOf<String, List<String>>()')
-            .addImport('MultiValueMap', ctx.infrastructurePackageName)
-            .if(queryParameters.length > 0, (builder) => builder.indent((builder) => builder.append('.apply ').parenthesize('{}', (builder) => builder.forEach(queryParameters, (builder, param) => builder
-            .appendIf(!param.required, `if (${toCasing(param.name, 'camel')} != null) `)
-            .parenthesizeIf(!param.required, '{}', (builder) => builder.appendLine(`put(${this.toStringLiteral(ctx, toCasing(param.name, 'camel'))}, listOf(${toCasing(param.name, 'camel')}.toString()))`), { multiline: true })
-            .appendLine()), { multiline: true })))
-            .ensureCurrentLineEmpty()
-            .appendLine('val localVariableHeaders: MutableMap<String, String> = mutableMapOf()')
-            .appendLineIf(((_a = endpoint.requestBody) === null || _a === void 0 ? void 0 : _a.content[0]) !== undefined, `localVariableHeaders["Content-Type"] = "${(_b = endpoint.requestBody) === null || _b === void 0 ? void 0 : _b.content[0].type}"`)
-            .appendLine()
-            .append('return RequestConfig')
-            .addImport('RequestConfig', ctx.infrastructurePackageName)
-            .parenthesize('()', (builder) => builder
-            .appendLine(`method = RequestMethod.${endpoint.method.toUpperCase()},`)
-            .addImport('RequestMethod', ctx.infrastructurePackageName)
-            .appendLine(`path = "${this.getPathWithInterpolation(ctx, endpoint)}",`)
-            .appendLine('query = localVariableQuery,')
-            .appendLine('headers = localVariableHeaders,')
-            .appendLine('requiresAuthentication = false,')
-            .appendLineIf(!!endpoint.requestBody, 'body = localVariableBody'), { multiline: true });
-    }
-    generateAdditionalMethods(ctx, builder) {
-        this.generateEncodeUriComponentMethod(ctx, builder);
-    }
-    generateEncodeUriComponentMethod(ctx, builder) {
-        builder
-            .appendLine('private fun encodeURIComponent(uriComponent: String): String =')
-            .indent('HttpUrl.Builder().scheme("http").host("localhost").addPathSegment(uriComponent).build().encodedPathSegments[0]')
-            .addImport('HttpUrl', 'okhttp3');
-    }
-    generateParamDocEntries(ctx, builder, endpoint) {
-        const parameters = this.getAllParameters(ctx, endpoint);
-        builder.forEach(parameters, (builder, parameter) => { var _a; return builder.appendLine(`@param ${parameter.name} ${(_a = parameter.description) !== null && _a !== void 0 ? _a : 'TODO: Provide description'}`); });
-    }
-    generateParams(ctx, builder, endpoint, includeTypeDefinition) {
-        const parameters = this.getAllParameters(ctx, endpoint);
-        builder.forEach(parameters, (builder, parameter) => builder.append(toCasing(parameter.name, 'camel')).if(includeTypeDefinition, (builder) => builder
-            .append(': ')
-            .append((builder) => this.generateTypeUsage(ctx, builder, parameter.schema))
-            .appendIf(!parameter.required, '? = ', this.getDefaultValue(ctx, parameter.schema))), { separator: ', ' });
-    }
-    generateTypeUsage(ctx, builder, schema, fallback, nullable) {
-        if (schema && schema.kind === 'array') {
-            const schemaInfo = this.getSchemaInfo(ctx, schema.items);
-            builder.append(this.getTypeNameWithNullability(`List<${schemaInfo.typeName}>`, nullable));
-            builder.imports.addImports([schemaInfo, ...schemaInfo.additionalImports]);
-        }
-        else if (schema || !fallback) {
-            const schemaInfo = this.getSchemaInfo(ctx, schema);
-            builder.append(this.getTypeNameWithNullability(schemaInfo.typeName, nullable));
-            builder.imports.addImports([schemaInfo, ...schemaInfo.additionalImports]);
+        const result = appendValueGroup([], '\n');
+        if (endpoint.requestBody) {
+            const bodyParamName = toCasing(this.getRequestBodyParamName(ctx, { endpoint }), ctx.config.parameterNameCasing);
+            result.values.push(`val localVariableBody = ${bodyParamName}`);
         }
-        else {
-            builder.append(this.getTypeNameWithNullability(fallback, nullable));
+        result.values.push(s `val localVariableQuery: ${ctx.refs.multiValueMap()} = ${kt.call([kt.refs.mutableMapOf([kt.refs.string(), kt.refs.list([kt.refs.string()])])], [])}${queryParameters.length === 0
+            ? ''
+            : s.indent `
+            .apply {${s.indent `
+              ${appendValueGroup(queryParameters.map((param) => {
+                const paramName = toCasing(param.name, ctx.config.parameterNameCasing);
+                const put = s `put(${kt.string(paramName)}, listOf(${paramName}.toString()))`;
+                return param.required
+                    ? put
+                    : s `if (${paramName} != null) {${s.indent `
+                        ${put}`}
+                      }`;
+            }), '\n')}`}
+            }`}`);
+        result.values.push('val localVariableHeaders: MutableMap<String, String> = mutableMapOf()');
+        if (((_a = endpoint.requestBody) === null || _a === void 0 ? void 0 : _a.content[0]) !== undefined) {
+            result.values.push(`localVariableHeaders["Content-Type"] = "${(_b = endpoint.requestBody) === null || _b === void 0 ? void 0 : _b.content[0].type}"`);
         }
-    }
-    getPackageName(ctx, service) {
-        const packageSuffix = typeof ctx.config.packageSuffix === 'string' ? ctx.config.packageSuffix : ctx.config.packageSuffix(service);
+        result.values.push(s `return ${kt.call([ctx.refs.requestConfig.infer()], [
+            kt.argument.named('method', kt.call([ctx.refs.requestMethod(), endpoint.method.toUpperCase()])),
+            kt.argument.named('path', kt.string(this.getPathWithInterpolation(ctx, { endpoint }), { template: true })),
+            kt.argument.named('query', 'localVariableQuery'),
+            kt.argument.named('headers', 'localVariableHeaders'),
+            kt.argument.named('requiresAuthentication', 'false'),
+            endpoint.requestBody ? kt.argument.named('body', 'localVariableBody') : null,
+        ])}`);
+        return result;
+    }
+    getAdditionalClientMembers(ctx, args) {
+        return [
+            kt.function('encodeURIComponent', {
+                accessModifier: 'private',
+                parameters: [kt.parameter('uriComponent', kt.refs.string())],
+                returnType: kt.refs.string(),
+                singleExpression: true,
+                body: s `${kt.refs.okhttp3.httpUrl()}.Builder().scheme("http").host("localhost").addPathSegment(uriComponent).build().encodedPathSegments[0]`,
+            }),
+        ];
+    }
+    getTypeUsage(ctx, args) {
+        const { schema, nullable, fallback } = args;
+        const type = this.getSchemaType(ctx, { schema });
+        return type
+            ? createOverwriteProxy(type, { nullable: nullable !== null && nullable !== void 0 ? nullable : type.nullable })
+            : fallback !== null && fallback !== void 0 ? fallback : kt.refs.any({ nullable });
+    }
+    getPackageName(ctx, args) {
+        const packageSuffix = typeof ctx.config.packageSuffix === 'string' ? ctx.config.packageSuffix : ctx.config.packageSuffix(ctx.service);
         return ctx.config.packageName + packageSuffix;
     }
-    getTypeNameWithNullability(typeName, nullable) {
-        if (nullable === undefined)
-            return typeName;
-        return nullable ? `${typeName}?` : typeName.match(/^(.*?)\??$/)[1];
-    }
-    getDefaultValue(ctx, schema) {
-        if (!(schema === null || schema === void 0 ? void 0 : schema.default)) {
-            return 'null';
-        }
-        if (typeof schema.default === 'string') {
-            return toKotlinStringLiteral(schema.default);
-        }
-        else if (typeof schema.default === 'number' || typeof schema.default === 'boolean') {
-            return schema.default.toString();
-        }
-        else {
-            return 'null';
-        }
-    }
-    getPathWithInterpolation(ctx, endpoint) {
-        let path = this.getEndpointPath(ctx, endpoint);
+    getPathWithInterpolation(ctx, args) {
+        const { endpoint } = args;
+        let path = this.getEndpointPath(ctx, { endpoint });
         endpoint.parameters
             .filter((x) => x.target === 'path')
             .forEach((parameter) => {
@@ -347,23 +252,26 @@ export class DefaultKotlinOkHttp3Generator extends KotlinFileGenerator {
         });
         return path;
     }
-    getResponseSchema(ctx, endpoint) {
+    getResponseSchema(ctx, args) {
         var _a, _b;
+        const { endpoint } = args;
         return (_b = (_a = endpoint.responses.find((x) => !x.statusCode || (x.statusCode >= 200 && x.statusCode < 300))) === null || _a === void 0 ? void 0 : _a.contentOptions[0]) === null || _b === void 0 ? void 0 : _b.schema;
     }
-    getSchemaInfo(ctx, schema) {
-        var _a;
-        return ((_a = (schema && ctx.input.models[schema.id])) !== null && _a !== void 0 ? _a : { typeName: 'Any?', packageName: undefined, additionalImports: [] });
+    getSchemaType(ctx, args) {
+        const { schema } = args;
+        return schema && ctx.input.models[schema.id].type;
     }
-    getAllParameters(ctx, endpoint) {
+    getAllParameters(ctx, args) {
+        const { endpoint } = args;
         const parameters = endpoint.parameters.filter((parameter) => parameter.target === 'query' || parameter.target === 'path');
         if (endpoint.requestBody) {
             const schema = endpoint.requestBody.content[0].schema;
             parameters.push({
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
                 $src: undefined,
                 $ref: undefined,
                 id: 'body',
-                name: this.getRequestBodyParamName(ctx, endpoint),
+                name: this.getRequestBodyParamName(ctx, { endpoint }),
                 target: 'body',
                 schema,
                 required: endpoint.requestBody.required,
@@ -377,42 +285,26 @@ export class DefaultKotlinOkHttp3Generator extends KotlinFileGenerator {
         }
         return parameters.sort((a, b) => (a.required === b.required ? 0 : a.required ? -1 : 1));
     }
-    getRequestBodyParamName(ctx, endpoint) {
+    getRequestBodyParamName(ctx, args) {
         var _a;
+        const { endpoint } = args;
         const schema = (_a = endpoint.requestBody) === null || _a === void 0 ? void 0 : _a.content[0].schema;
-        const schemaInfo = this.getSchemaInfo(ctx, schema);
-        return /^Any\??$/.test(schemaInfo.typeName) ? 'body' : schemaInfo.typeName;
+        const schemaInfo = this.getSchemaType(ctx, { schema });
+        return toCasing(schemaInfo && schemaInfo.name !== 'Any' ? SourceBuilder.build((b) => kt.reference.write(b, schemaInfo)) : 'body', ctx.config.parameterNameCasing);
     }
-    getBasePath(ctx) {
+    getBasePath(ctx, args) {
         var _a, _b, _c, _d, _e, _f;
         return modifyString((_f = (_e = (_d = (_c = ((_a = ctx.service.$src) !== null && _a !== void 0 ? _a : (_b = ctx.service.endpoints[0]) === null || _b === void 0 ? void 0 : _b.$src)) === null || _c === void 0 ? void 0 : _c.document.servers) === null || _d === void 0 ? void 0 : _d[0]) === null || _e === void 0 ? void 0 : _e.url) !== null && _f !== void 0 ? _f : '/', ctx.config.basePath, ctx.service);
     }
-    getEndpointPath(ctx, endpoint) {
+    getEndpointPath(ctx, args) {
+        const { endpoint } = args;
         return modifyString(endpoint.path, ctx.config.pathModifier, endpoint);
     }
-    getFilePath(ctx, packageName) {
-        return `${ctx.config.outputDir}/${packageName.replace(/\./g, '/')}/${this.getApiClientName(ctx)}.kt`;
+    getFilePath(ctx, args) {
+        const { packageName } = args;
+        return `${ctx.config.outputDir}/${packageName.replace(/\./g, '/')}/${this.getApiClientName(ctx, {})}.kt`;
     }
-    getApiClientName(ctx) {
-        return toCasing(ctx.service.name, 'pascal') + 'ApiClient';
+    getApiClientName(ctx, args) {
+        return toCasing(ctx.service.name, ctx.config.typeNameCasing) + 'ApiClient';
     }
 }
-const responseErrorHandlingCode = `ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
-ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
-ResponseType.ClientError -> {
-    val localVarError = localVarResponse as ClientError<*>
-    throw ClientException(
-        "Client error : \${localVarError.statusCode} \${localVarError.message.orEmpty()}",
-        localVarError.statusCode,
-        localVarResponse
-    )
-}
-
-ResponseType.ServerError -> {
-    val localVarError = localVarResponse as ServerError<*>
-    throw ServerException(
-        "Server error : \${localVarError.statusCode} \${localVarError.message.orEmpty()}",
-        localVarError.statusCode,
-        localVarResponse
-    )
-}`;