@arrirpc/codegen-kotlin 0.45.0

package/dist/index.cjs

@@ -0,0 +1,1932 @@
+'use strict';
+
+const fs = require('node:fs');
+const codegenUtils = require('@arrirpc/codegen-utils');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+const fs__default = /*#__PURE__*/_interopDefaultCompat(fs);
+
+const reservedIdentifierKeywords = [
+  "as",
+  "as?",
+  "break",
+  "class",
+  "continue",
+  "do",
+  "else",
+  "false",
+  "for",
+  "fun",
+  "if",
+  "in",
+  "!in",
+  "interface",
+  "is",
+  "!is",
+  "null",
+  "object",
+  "package",
+  "return",
+  "super",
+  "this",
+  "throw",
+  "true",
+  "try",
+  "typealias",
+  "typeof",
+  "val",
+  "var",
+  "when",
+  "while"
+];
+const illegalCharacters = "+-*/%=&|!<>[]?:.@$;";
+function kotlinIdentifier(input) {
+  const name = codegenUtils.removeDisallowedChars(codegenUtils.camelCase(input), illegalCharacters);
+  if (codegenUtils.stringStartsWithNumber(name) || reservedIdentifierKeywords.includes(name)) {
+    return `\`${name}\``;
+  }
+  return name;
+}
+function kotlinClassName(input) {
+  const name = codegenUtils.removeDisallowedChars(
+    codegenUtils.pascalCase(input, { normalize: true }),
+    illegalCharacters
+  );
+  if (codegenUtils.stringStartsWithNumber(name) || reservedIdentifierKeywords.includes(name)) {
+    return `_${name}`;
+  }
+  return name;
+}
+function getClassName(schema, context) {
+  if (schema.metadata?.id) {
+    const className2 = kotlinClassName(
+      codegenUtils.pascalCase(schema.metadata.id, {
+        normalize: true
+      })
+    );
+    return `${context.modelPrefix}${className2}`;
+  }
+  const depth = instanceDepth(context);
+  if (depth === 1 && !context.discriminatorKey) {
+    const className2 = kotlinClassName(
+      codegenUtils.pascalCase(context.instancePath.replace("/", ""), {
+        normalize: true
+      })
+    );
+    return `${context.modelPrefix}${className2}`;
+  }
+  if (context.discriminatorParentId && context.discriminatorKey && context.discriminatorValue) {
+    const className2 = kotlinClassName(
+      codegenUtils.pascalCase(
+        `${context.discriminatorParentId}_${context.discriminatorValue}`,
+        { normalize: true }
+      )
+    );
+    return `${context.modelPrefix}${className2}`;
+  }
+  const className = kotlinClassName(
+    codegenUtils.pascalCase(
+      context.instancePath.split("/").join("_").split("[").join("_").split("]").join("_"),
+      {
+        normalize: true
+      }
+    )
+  );
+  return `${context.modelPrefix}${className}`;
+}
+function instanceDepth(context) {
+  const parts = context.instancePath.split("/");
+  return parts.length - 1;
+}
+function isNullable(schema, context) {
+  return schema.nullable === true || context.isOptional === true;
+}
+
+function kotlinAnyFromSchema(schema, context) {
+  const nullable = isNullable(schema, context);
+  const defaultValue = nullable ? "null" : "JsonNull";
+  return {
+    typeName: "JsonElement",
+    isNullable: nullable,
+    defaultValue,
+    fromJson(input) {
+      if (context.isOptional) {
+        return `when (${input}) {
+                    null -> null
+                    else -> ${input} 
+                }`;
+      }
+      if (schema.nullable) {
+        return `when (${input}) {
+                    JsonNull -> null
+                    null -> null
+                    else -> ${input}
+                }`;
+      }
+      return `when (${input}) {
+                is JsonElement -> ${input}!!
+                else -> JsonNull
+            }`;
+    },
+    toJson(input, target) {
+      if (schema.nullable) {
+        return `${target} += when (${input}) {
+                    null -> "null"
+                    else -> JsonInstance.encodeToString(${input})
+                }`;
+      }
+      return `${target} += JsonInstance.encodeToString(${input})`;
+    },
+    toQueryString() {
+      return `__logError("[WARNING] any's cannot be serialized to query params. Skipping field at ${context.instancePath}.")`;
+    },
+    content: ""
+  };
+}
+
+function kotlinArrayFromSchema(schema, context) {
+  const nullable = isNullable(schema, context);
+  const defaultValue = nullable ? "null" : "mutableListOf()";
+  const subType = kotlinTypeFromSchema(schema.elements, {
+    modelPrefix: context.modelPrefix,
+    clientName: context.clientName,
+    clientVersion: context.clientVersion,
+    instancePath: `${context.instancePath}/[element]`,
+    schemaPath: `${context.schemaPath}/elements`,
+    existingTypeIds: context.existingTypeIds
+  });
+  const typeName = `MutableList<${subType.typeName}${subType.isNullable ? "?" : ""}>`;
+  return {
+    typeName,
+    isNullable: nullable,
+    defaultValue,
+    fromJson(input) {
+      if (nullable) {
+        return `when (${input}) {
+                    is JsonArray -> {
+                        val __value: ${typeName} = mutableListOf()
+                        for (__element in ${input}!!.jsonArray) {
+                            __value.add(
+                                ${subType.fromJson("__element")}
+                            )
+                        }
+                        __value
+                    }
+
+                    else -> null
+                }`;
+      }
+      return `when (${input}) {
+                is JsonArray -> {
+                    val __value: ${typeName} = mutableListOf()
+                    for (__element in ${input}!!.jsonArray) {
+                        __value.add(
+                            ${subType.fromJson("__element")}
+                        )
+                    }
+                    __value
+                }
+
+                else -> mutableListOf()
+            }`;
+    },
+    toJson(input, target) {
+      if (schema.nullable) {
+        return `if (${input} == null) {
+                    ${target} += "null"
+                } else {
+                    ${target} += "["
+                    for ((__index, __element) in ${input}.withIndex()) {
+                        if (__index != 0) {
+                            ${target} += ","
+                        }
+                        ${subType.toJson("__element", target)}
+                    }
+                    ${target} += "]"
+                }`;
+      }
+      return `${target} += "["
+                for ((__index, __element) in ${input}.withIndex()) {
+                    if (__index != 0) {
+                        ${target} += ","
+                    }
+                    ${subType.toJson("__element", target)}
+                }
+                ${target} += "]"`;
+    },
+    toQueryString() {
+      return `__logError("[WARNING] arrays cannot be serialized to query params. Skipping field at ${context.instancePath}.")`;
+    },
+    content: subType.content
+  };
+}
+
+function kotlinObjectFromSchema(schema, context) {
+  const className = getClassName(schema, context);
+  const nullable = isNullable(schema, context);
+  const defaultValue = nullable ? "null" : `${className}.new()`;
+  const result = {
+    typeName: className,
+    isNullable: nullable,
+    defaultValue,
+    fromJson(input, key) {
+      if (nullable) {
+        return `when (${input}) {
+                    is JsonObject -> ${className}.fromJsonElement(
+                        ${input}!!,
+                        "$instancePath/${key}",
+                    )
+                    
+                    else -> null
+                }`;
+      }
+      return `when (${input}) {
+                is JsonObject -> ${className}.fromJsonElement(
+                    ${input}!!,
+                    "$instancePath/${key}",
+                )
+
+                else -> ${className}.new()
+            }`;
+    },
+    toJson(input, target) {
+      if (schema.nullable) {
+        return `${target} += ${input}?.toJson()`;
+      }
+      return `${target} += ${input}.toJson()`;
+    },
+    toQueryString() {
+      return `__logError("[WARNING] nested objects cannot be serialized to query params. Skipping field at ${context.instancePath}.")`;
+    },
+    content: ""
+  };
+  if (context.existingTypeIds.includes(className)) {
+    return result;
+  }
+  const subContent = [];
+  const kotlinKeys = [];
+  const fieldParts = [];
+  const defaultParts = [];
+  const toJsonParts = [`var output = "{"`];
+  const toQueryParts = ["val queryParts = mutableListOf<String>()"];
+  const fromJsonParts = [];
+  const requiredKeys = Object.keys(schema.properties);
+  const optionalKeys = Object.keys(schema.optionalProperties ?? {});
+  const hasKnownKeys = requiredKeys.length > 0 || context.discriminatorKey && context.discriminatorValue;
+  if (!hasKnownKeys) {
+    toJsonParts.push("var hasProperties = false");
+  }
+  if (context.discriminatorKey && context.discriminatorValue) {
+    toJsonParts.push(
+      `output += "\\"${context.discriminatorKey}\\":\\"${context.discriminatorValue}\\""`
+    );
+    toQueryParts.push(
+      `queryParts.add("${context.discriminatorKey}=${context.discriminatorValue}")`
+    );
+  }
+  for (let i = 0; i < requiredKeys.length; i++) {
+    const key = requiredKeys[i];
+    const kotlinKey = kotlinIdentifier(key);
+    kotlinKeys.push(kotlinKey);
+    const prop = schema.properties[key];
+    const type = kotlinTypeFromSchema(prop, {
+      modelPrefix: context.modelPrefix,
+      clientName: context.clientName,
+      clientVersion: context.clientVersion,
+      instancePath: `/${className}/${key}`,
+      schemaPath: `${context.schemaPath}/properties/${key}`,
+      existingTypeIds: context.existingTypeIds
+    });
+    if (type.content) {
+      subContent.push(type.content);
+    }
+    fieldParts.push(
+      `    val ${kotlinKey}: ${type.typeName}${type.isNullable ? "?" : ""},`
+    );
+    if (i === 0 && !context.discriminatorKey) {
+      toJsonParts.push(`output += "\\"${key}\\":"`);
+    } else {
+      toJsonParts.push(`output += ",\\"${key}\\":"`);
+    }
+    toJsonParts.push(type.toJson(kotlinKey, "output"));
+    toQueryParts.push(type.toQueryString(kotlinKey, "queryParts", key));
+    fromJsonParts.push(
+      `val ${kotlinKey}: ${type.typeName}${type.isNullable ? "?" : ""} = ${type.fromJson(`__input.jsonObject["${key}"]`, key)}`
+    );
+    defaultParts.push(
+      `                ${kotlinKey} = ${type.defaultValue},`
+    );
+  }
+  for (let i = 0; i < optionalKeys.length; i++) {
+    const isFirst = i === 0 && requiredKeys.length === 0 && !context.discriminatorKey;
+    const isLast = i === optionalKeys.length - 1;
+    const key = optionalKeys[i];
+    const kotlinKey = kotlinIdentifier(key);
+    kotlinKeys.push(kotlinKey);
+    const type = kotlinTypeFromSchema(schema.optionalProperties[key], {
+      modelPrefix: context.modelPrefix,
+      clientName: context.clientName,
+      clientVersion: context.clientVersion,
+      instancePath: `/${className}/${key}`,
+      schemaPath: `${context.schemaPath}/optionalProperties/${key}`,
+      existingTypeIds: context.existingTypeIds,
+      isOptional: true
+    });
+    if (type.content) {
+      subContent.push(type.content);
+    }
+    const addCommaPart = isFirst ? "" : `
+        if (hasProperties) output += ","
+`;
+    fieldParts.push(`    val ${kotlinKey}: ${type.typeName}? = null,`);
+    if (hasKnownKeys) {
+      toJsonParts.push(`if (${kotlinKey} != null) {
+                output += ",\\"${key}\\":"
+                ${type.toJson(kotlinKey, "output")}
+            }`);
+    } else {
+      toJsonParts.push(`if (${kotlinKey} != null) {${addCommaPart}
+    output += "\\"${key}\\":"
+    ${type.toJson(kotlinKey, "output")}
+${isLast ? "" : "    hasProperties = true"}
+}`);
+    }
+    toQueryParts.push(type.toQueryString(kotlinKey, "queryParts", key));
+    fromJsonParts.push(
+      `val ${kotlinKey}: ${type.typeName}? = ${type.fromJson(`__input.jsonObject["${key}"]`, key)}`
+    );
+  }
+  toJsonParts.push('output += "}"');
+  toJsonParts.push("return output");
+  toQueryParts.push('return queryParts.joinToString("&")');
+  const implementedClass = context.discriminatorParentId ?? `${context.clientName}Model`;
+  let discriminatorField = "";
+  if (context.discriminatorKey && context.discriminatorValue) {
+    discriminatorField = `
+    override val ${kotlinIdentifier(context.discriminatorKey)} get() = "${context.discriminatorValue}"
+`;
+  }
+  const content = `data class ${className}(
+${fieldParts.join("\n")}
+) : ${implementedClass} {${discriminatorField}
+    override fun toJson(): String {
+${toJsonParts.join("\n")}    
+    }
+
+    override fun toUrlQueryParams(): String {
+${toQueryParts.join("\n")}
+    }
+
+    companion object Factory : ${context.clientName}ModelFactory<${className}> {
+        @JvmStatic
+        override fun new(): ${className} {
+            return ${className}(
+${defaultParts.join("\n")}
+            )
+        }
+
+        @JvmStatic
+        override fun fromJson(input: String): ${className} {
+            return fromJsonElement(JsonInstance.parseToJsonElement(input))
+        }
+
+        @JvmStatic
+        override fun fromJsonElement(__input: JsonElement, instancePath: String): ${className} {
+            if (__input !is JsonObject) {
+                __logError("[WARNING] ${className}.fromJsonElement() expected kotlinx.serialization.json.JsonObject at $instancePath. Got \${__input.javaClass}. Initializing empty ${className}.")
+                return new()
+            }
+${fromJsonParts.join("\n")}
+            return ${className}(
+                ${kotlinKeys.join(",\n                ")},
+            )
+        }
+    }
+}
+
+${subContent.join("\n\n")}`;
+  context.existingTypeIds.push(className);
+  return {
+    ...result,
+    content
+  };
+}
+
+function kotlinDiscriminatorFromSchema(schema, context) {
+  const kotlinDiscriminatorKey = kotlinIdentifier(schema.discriminator);
+  const className = getClassName(schema, context);
+  const nullable = isNullable(schema, context);
+  const subTypes = [];
+  const subContent = [];
+  for (const key of Object.keys(schema.mapping)) {
+    const subSchema = schema.mapping[key];
+    const subType = kotlinObjectFromSchema(subSchema, {
+      modelPrefix: context.modelPrefix,
+      clientName: context.clientName,
+      clientVersion: context.clientVersion,
+      instancePath: context.instancePath,
+      schemaPath: `${context.schemaPath}/mapping/${key}`,
+      existingTypeIds: context.existingTypeIds,
+      discriminatorKey: schema.discriminator,
+      discriminatorValue: key,
+      discriminatorParentId: className
+    });
+    subTypes.push({
+      typeName: subType.typeName,
+      discriminatorValue: key
+    });
+    if (subType.content) {
+      subContent.push(subType.content);
+    }
+  }
+  if (subTypes.length === 0) {
+    throw new Error("Discriminator schemas must have at least one mapping");
+  }
+  const defaultValue = nullable ? "null" : `${className}.new()`;
+  const result = {
+    typeName: className,
+    isNullable: nullable,
+    defaultValue,
+    fromJson(input, key) {
+      return `when (${input}) {
+                is JsonObject -> ${className}.fromJsonElement(
+                    ${input}!!,
+                    "$instancePath/${key}",
+                )
+                else -> ${defaultValue}
+            }`;
+    },
+    toJson(input, target) {
+      if (schema.nullable) {
+        return `${target} += ${input}?.toJson()`;
+      }
+      return `${target} += ${input}.toJson()`;
+    },
+    toQueryString() {
+      return `__logError("[WARNING] nested objects cannot be serialized to query params. Skipping field at ${context.instancePath}.")`;
+    },
+    content: ""
+  };
+  if (context.existingTypeIds.includes(className)) {
+    return result;
+  }
+  const content = `sealed interface ${className} : ${context.clientName}Model {
+    val ${kotlinDiscriminatorKey}: String
+
+    companion object Factory : ${context.clientName}ModelFactory<${className}> {
+        @JvmStatic
+        override fun new(): ${className} {
+            return ${subTypes[0].typeName}.new()
+        }
+
+        @JvmStatic
+        override fun fromJson(input: String): ${className} {
+            return fromJsonElement(JsonInstance.parseToJsonElement(input))
+        }
+
+        @JvmStatic
+        override fun fromJsonElement(__input: JsonElement, instancePath: String): ${className} {
+            if (__input !is JsonObject) {
+                __logError("[WARNING] Discriminator.fromJsonElement() expected kotlinx.serialization.json.JsonObject at $instancePath. Got \${__input.javaClass}. Initializing empty ${className}.")
+                return new()
+            }
+            return when (__input.jsonObject["${schema.discriminator}"]) {
+                is JsonPrimitive -> when (__input.jsonObject["${schema.discriminator}"]!!.jsonPrimitive.contentOrNull) {
+                    ${subTypes.map((type) => `"${type.discriminatorValue}" -> ${type.typeName}.fromJsonElement(__input, instancePath)`).join("\n")}
+                    else -> new()
+                }
+
+                else -> new()
+            }
+        }
+    }
+}
+
+${subContent.join("\n\n")}`;
+  context.existingTypeIds.push(className);
+  return {
+    ...result,
+    content
+  };
+}
+
+function kotlinEnumFromSchema(schema, context) {
+  const nullable = isNullable(schema, context);
+  const className = getClassName(schema, context);
+  const enumItems = schema.enum.map((val) => {
+    return {
+      name: codegenUtils.pascalCase(val, { normalize: true }),
+      value: val
+    };
+  });
+  if (!enumItems.length) {
+    throw new Error(
+      `Enum schemas must have at least one enum value. At ${context.schemaPath}.`
+    );
+  }
+  const defaultValue = nullable ? "null" : `${className}.new()`;
+  let content = "";
+  if (!context.existingTypeIds.includes(className)) {
+    content = `enum class ${className} {
+    ${enumItems.map((item) => item.name).join(",\n    ")};
+    val serialValue: String
+        get() = when (this) {
+            ${enumItems.map((item) => `${item.name} -> "${item.value}"`).join("\n            ")}
+        }
+    
+    companion object Factory : ${context.clientName}ModelFactory<${className}> {
+        @JvmStatic
+        override fun new(): ${className} {
+            return ${enumItems[0].name}
+        }
+
+        @JvmStatic
+        override fun fromJson(input: String): ${className} {
+            return when (input) {
+                ${enumItems.map((item) => `${item.name}.serialValue -> ${item.name}`).join("\n                ")}
+                else -> ${enumItems[0].name}
+            }
+        }
+
+        @JvmStatic
+        override fun fromJsonElement(__input: JsonElement, instancePath: String): ${className} {
+            if (__input !is JsonPrimitive) {
+                __logError("[WARNING] ${className}.fromJsonElement() expected kotlinx.serialization.json.JsonPrimitive at $instancePath. Got \${__input.javaClass}. Initializing empty ${className}.")
+                return new()
+            }
+            return when (__input.jsonPrimitive.contentOrNull) {
+                ${enumItems.map((item) => `"${item.value}" -> ${item.name}`).join("\n                ")}
+                else -> new()
+            }
+        }
+    }
+}`;
+    context.existingTypeIds.push(className);
+  }
+  return {
+    typeName: className,
+    isNullable: nullable,
+    defaultValue,
+    fromJson(input, key) {
+      if (nullable) {
+        return `when (${input}) {
+                    is JsonNull -> null
+                    is JsonPrimitive -> ${className}.fromJsonElement(${input}!!, "$instancePath/${key ?? ""}")
+                    else -> null
+                }`;
+      }
+      return `when (${input}) {
+                is JsonNull -> ${defaultValue}
+                is JsonPrimitive -> ${className}.fromJsonElement(${input}!!, "$instancePath/${key}")
+                else -> ${defaultValue}
+            }`;
+    },
+    toJson(input, target) {
+      if (schema.nullable) {
+        return `${target} += when (${input}) {
+                    is ${className} -> "\\"\${${input}.serialValue}\\""
+                    else -> "null"
+                }`;
+      }
+      return `${target} += "\\"\${${input}.serialValue}\\""`;
+    },
+    toQueryString(input, target, key) {
+      if (context.isOptional) {
+        return `if (${input} != null) {
+                    ${target}.add("${key}=\${${input}.serialValue}")
+                }`;
+      }
+      if (schema.nullable) {
+        return `${target}.add("${key}=\${${input}?.serialValue}")`;
+      }
+      return `${target}.add("${key}=\${${input}.serialValue}")`;
+    },
+    content
+  };
+}
+
+function kotlinMapFromSchema(schema, context) {
+  const nullable = isNullable(schema, context);
+  const subType = kotlinTypeFromSchema(schema.values, {
+    modelPrefix: context.modelPrefix,
+    clientName: context.clientName,
+    clientVersion: context.clientVersion,
+    instancePath: `${context.instancePath}/[value]`,
+    schemaPath: `${context.schemaPath}/values`,
+    existingTypeIds: context.existingTypeIds
+  });
+  const typeName = `MutableMap<String, ${subType.typeName}${subType.isNullable ? "?" : ""}>`;
+  const defaultValue = nullable ? "null" : "mutableMapOf()";
+  return {
+    typeName,
+    isNullable: nullable,
+    defaultValue,
+    fromJson(input, key) {
+      return `when (${input}) {
+                is JsonObject -> {
+                    val __value: ${typeName} = mutableMapOf()
+                    for (__entry in ${input}!!.jsonObject.entries) {
+                        __value[__entry.key] = ${subType.fromJson("__entry.value", key)}
+                    }
+                    __value
+                }
+
+                else -> ${defaultValue}
+            }`;
+    },
+    toJson(input, target) {
+      if (schema.nullable) {
+        return `if (${input} == null) {
+                    ${target} += "null"
+                } else {
+                    ${target} += "{"
+                    for ((__index, __entry) in ${input}.entries.withIndex()) {
+                        if (__index != 0) {
+                            ${target} += ","
+                        }
+                        ${target} += "\\"\${__entry.key}\\":"
+                        ${subType.toJson("__entry.value", target)}
+                    }
+                    ${target} += "}"
+                }`;
+      }
+      return `${target} += "{"
+            for ((__index, __entry) in ${input}.entries.withIndex()) {
+                if (__index != 0) {
+                    ${target} += ","
+                }
+                ${target} += "\\"\${__entry.key}\\":"
+                ${subType.toJson("__entry.value", target)}
+            }
+            ${target} += "}"`;
+    },
+    toQueryString() {
+      return `__logError("[WARNING] nested objects cannot be serialized to query params. Skipping field at ${context.instancePath}.")`;
+    },
+    content: subType.content
+  };
+}
+
+function defaultToQueryString(context, input, target, key) {
+  if (context.isOptional) {
+    return `if (${input} != null) {
+            ${target}.add("${key}=$${input}")
+        }`;
+  }
+  return `${target}.add("${key}=$${input}")`;
+}
+function defaultToJsonString(context, input, target) {
+  return `${target} += ${input}`;
+}
+function kotlinStringFromSchema(schema, context) {
+  const nullable = isNullable(schema, context);
+  const defaultValue = nullable ? "null" : '""';
+  return {
+    typeName: "String",
+    isNullable: nullable,
+    defaultValue,
+    fromJson(input) {
+      if (nullable) {
+        return `when (${input}) {
+                    is JsonPrimitive -> ${input}!!.jsonPrimitive.contentOrNull
+                    else -> null
+                }`;
+      }
+      return `when (${input}) {
+                is JsonPrimitive -> ${input}!!.jsonPrimitive.contentOrNull ?: ${defaultValue}
+                else -> ${defaultValue}
+            }`;
+    },
+    toJson(input, target) {
+      if (schema.nullable) {
+        return `${target} += when (${input}) {
+                    is String -> buildString { printQuoted(${input}) }
+                    else -> "null"
+                }`;
+      }
+      return `${target} += buildString { printQuoted(${input}) }`;
+    },
+    toQueryString(input, target, key) {
+      return defaultToQueryString(context, input, target, key);
+    },
+    content: ""
+  };
+}
+function kotlinBooleanFromSchema(schema, context) {
+  const nullable = isNullable(schema, context);
+  const defaultValue = nullable ? "null" : "false";
+  return {
+    typeName: "Boolean",
+    isNullable: nullable,
+    defaultValue,
+    fromJson(input) {
+      if (nullable) {
+        return `when (${input}) {
+                    is JsonPrimitive -> ${input}!!.jsonPrimitive.booleanOrNull
+                    else -> null
+                }`;
+      }
+      return `when (${input}) {
+                is JsonPrimitive -> ${input}!!.jsonPrimitive.booleanOrNull ?: ${defaultValue}
+                else -> ${defaultValue}
+            }`;
+    },
+    toJson(input, target) {
+      return defaultToJsonString(context, input, target);
+    },
+    toQueryString(input, target, key) {
+      return defaultToQueryString(context, input, target, key);
+    },
+    content: ""
+  };
+}
+function kotlinTimestampFromSchema(schema, context) {
+  const nullable = isNullable(schema, context);
+  const defaultValue = nullable ? "null" : "Instant.now()";
+  return {
+    typeName: "Instant",
+    isNullable: nullable,
+    defaultValue,
+    fromJson(input) {
+      return `when (${input}) {
+                is JsonPrimitive ->
+                    if (${input}!!.jsonPrimitive.isString)
+                        Instant.parse(${input}!!.jsonPrimitive.content)
+                    else
+                        ${defaultValue}
+                else -> ${defaultValue}
+            }`;
+    },
+    toJson(input, target) {
+      if (schema.nullable) {
+        return `${target} += when (${input}) {
+                    is Instant -> "\\"\${timestampFormatter.format(${input})}\\""
+                    else -> "null"
+                }`;
+      }
+      return `${target} += "\\"\${timestampFormatter.format(${input})}\\""`;
+    },
+    toQueryString(input, target, key) {
+      if (context.isOptional) {
+        return `if (${input} != null) {
+                    ${target}.add(
+                        "${key}=\${
+                            timestampFormatter.format(${input})
+                        }"
+                )
+            }`;
+      }
+      if (schema.nullable) {
+        return `${target}.add(
+                    "${key}=\${
+                        when (${input}) {
+                            is Instant -> timestampFormatter.format(${input})
+                            else -> "null"
+                        }
+                    }"
+        )`;
+      }
+      return `${target}.add(
+                "${key}=\${
+                    timestampFormatter.format(${input})
+                }"
+        )`;
+    },
+    content: ""
+  };
+}
+function kotlinFloat32FromSchema(schema, context) {
+  const nullable = isNullable(schema, context);
+  const defaultValue = nullable ? "null" : "0.0F";
+  return {
+    typeName: "Float",
+    isNullable: nullable,
+    defaultValue,
+    fromJson(input) {
+      if (nullable) {
+        return `when (${input}) {
+                    is JsonPrimitive -> ${input}!!.jsonPrimitive.floatOrNull
+                    else -> null
+                }`;
+      }
+      return `when (${input}) {
+                is JsonPrimitive -> ${input}!!.jsonPrimitive.floatOrNull ?: ${defaultValue}
+                else -> ${defaultValue}
+            }`;
+    },
+    toJson(input, target) {
+      return defaultToJsonString(context, input, target);
+    },
+    toQueryString(input, target, key) {
+      return defaultToQueryString(context, input, target, key);
+    },
+    content: ""
+  };
+}
+function kotlinFloat64FromSchema(schema, context) {
+  const nullable = isNullable(schema, context);
+  const defaultValue = nullable ? "null" : "0.0";
+  return {
+    typeName: "Double",
+    isNullable: nullable,
+    defaultValue,
+    fromJson(input) {
+      if (nullable) {
+        return `when (${input}) {
+                    is JsonPrimitive -> ${input}!!.jsonPrimitive.doubleOrNull
+                    else -> null
+                }`;
+      }
+      return `when (${input}) {
+                is JsonPrimitive -> ${input}!!.jsonPrimitive.doubleOrNull ?: 0.0
+                else -> 0.0
+            }`;
+    },
+    toJson(input, target) {
+      return defaultToJsonString(context, input, target);
+    },
+    toQueryString(input, target, key) {
+      return defaultToQueryString(context, input, target, key);
+    },
+    content: ""
+  };
+}
+function kotlinInt8FromSchema(schema, context) {
+  const nullable = isNullable(schema, context);
+  const defaultValue = nullable ? "null" : "0";
+  return {
+    typeName: "Byte",
+    isNullable: nullable,
+    defaultValue,
+    fromJson(input) {
+      if (nullable) {
+        return `when (${input}) {
+                    is JsonPrimitive -> ${input}!!.jsonPrimitive.contentOrNull?.toByteOrNull()
+                    else -> null
+                }`;
+      }
+      return `when (${input}) {
+                is JsonPrimitive -> ${input}!!.jsonPrimitive.contentOrNull?.toByteOrNull() ?: 0
+                else -> 0
+            }`;
+    },
+    toJson(input, target) {
+      return defaultToJsonString(context, input, target);
+    },
+    toQueryString(input, target, key) {
+      return defaultToQueryString(context, input, target, key);
+    },
+    content: ""
+  };
+}
+function kotlinInt16FromSchema(schema, context) {
+  const nullable = isNullable(schema, context);
+  const defaultValue = nullable ? "null" : "0";
+  return {
+    typeName: "Short",
+    isNullable: nullable,
+    defaultValue,
+    fromJson(input) {
+      if (nullable) {
+        return `when (${input}) {
+                    is JsonPrimitive -> ${input}!!.jsonPrimitive.contentOrNull?.toShortOrNull()
+                    else -> null
+                }`;
+      }
+      return `when (${input}) {
+                is JsonPrimitive -> ${input}!!.jsonPrimitive.contentOrNull?.toShortOrNull() ?: 0
+                else -> 0
+            }`;
+    },
+    toJson(input, target) {
+      return defaultToJsonString(context, input, target);
+    },
+    toQueryString(input, target, key) {
+      return defaultToQueryString(context, input, target, key);
+    },
+    content: ""
+  };
+}
+function kotlinInt32FromSchema(schema, context) {
+  const nullable = isNullable(schema, context);
+  const defaultValue = nullable ? "null" : "0";
+  return {
+    typeName: "Int",
+    isNullable: nullable,
+    defaultValue,
+    fromJson(input) {
+      if (nullable) {
+        return `when (${input}) {
+                    is JsonPrimitive -> ${input}!!.jsonPrimitive.intOrNull
+                    else -> null
+                }`;
+      }
+      return `when (${input}) {
+                is JsonPrimitive -> ${input}!!.jsonPrimitive.intOrNull ?: 0
+                else -> 0
+            }`;
+    },
+    toJson(input, target) {
+      return defaultToJsonString(context, input, target);
+    },
+    toQueryString(input, target, key) {
+      return defaultToQueryString(context, input, target, key);
+    },
+    content: ""
+  };
+}
+function kotlinInt64FromSchema(schema, context) {
+  const nullable = isNullable(schema, context);
+  const defaultValue = nullable ? "null" : "0L";
+  return {
+    typeName: "Long",
+    isNullable: nullable,
+    defaultValue,
+    fromJson(input) {
+      if (nullable) {
+        return `when (${input}) {
+                    is JsonPrimitive -> ${input}!!.jsonPrimitive.longOrNull
+                    else -> null
+                }`;
+      }
+      return `when (${input}) {
+                is JsonPrimitive -> ${input}!!.jsonPrimitive.longOrNull ?: 0L
+                else -> 0L
+            }`;
+    },
+    toJson(input, target) {
+      if (schema.nullable) {
+        return `${target} += when (${input}) {
+                    is Long -> "\\"$${input}\\""
+                    else -> "null"
+                }`;
+      }
+      return `${target} += "\\"$${input}\\""`;
+    },
+    toQueryString(input, target, key) {
+      return defaultToQueryString(context, input, target, key);
+    },
+    content: ""
+  };
+}
+function kotlinUint8FromSchema(schema, context) {
+  const nullable = isNullable(schema, context);
+  const defaultValue = nullable ? "null" : "0u";
+  return {
+    typeName: "UByte",
+    isNullable: nullable,
+    defaultValue,
+    fromJson(input) {
+      if (nullable) {
+        return `when (${input}) {
+                    is JsonPrimitive -> ${input}!!.jsonPrimitive.contentOrNull?.toUByteOrNull()
+                    else -> null
+                }`;
+      }
+      return `when (${input}) {
+                is JsonPrimitive -> ${input}!!.jsonPrimitive.contentOrNull?.toUByteOrNull() ?: 0u
+                else -> 0u
+            }`;
+    },
+    toJson(input, target) {
+      return defaultToJsonString(context, input, target);
+    },
+    toQueryString(input, target, key) {
+      return defaultToQueryString(context, input, target, key);
+    },
+    content: ""
+  };
+}
+function kotlinUint16FromSchema(schema, context) {
+  const nullable = isNullable(schema, context);
+  const defaultValue = nullable ? "null" : "0u";
+  return {
+    typeName: "UShort",
+    isNullable: nullable,
+    defaultValue,
+    fromJson(input) {
+      if (nullable) {
+        return `when (${input}) {
+                    is JsonPrimitive -> ${input}!!.jsonPrimitive.contentOrNull?.toUShortOrNull()
+                    else -> null
+                }`;
+      }
+      return `when (${input}) {
+                is JsonPrimitive -> ${input}!!.jsonPrimitive.contentOrNull?.toUShortOrNull() ?: 0u
+                else -> 0u
+            }`;
+    },
+    toJson(input, target) {
+      return defaultToJsonString(context, input, target);
+    },
+    toQueryString(input, target, key) {
+      return defaultToQueryString(context, input, target, key);
+    },
+    content: ""
+  };
+}
+function kotlinUint32FromSchema(schema, context) {
+  const nullable = isNullable(schema, context);
+  const defaultValue = nullable ? "null" : "0u";
+  return {
+    typeName: "UInt",
+    isNullable: nullable,
+    defaultValue,
+    fromJson(input) {
+      if (nullable) {
+        return `when (${input}) {
+                    is JsonPrimitive -> ${input}!!.jsonPrimitive.contentOrNull?.toUIntOrNull()
+                    else -> null
+                }`;
+      }
+      return `when (${input}) {
+                is JsonPrimitive -> ${input}!!.jsonPrimitive.contentOrNull?.toUIntOrNull() ?: 0u
+                else -> 0u
+            }`;
+    },
+    toJson(input, target) {
+      return defaultToJsonString(context, input, target);
+    },
+    toQueryString(input, target, key) {
+      return defaultToQueryString(context, input, target, key);
+    },
+    content: ""
+  };
+}
+function kotlinUint64FromSchema(schema, context) {
+  const nullable = isNullable(schema, context);
+  const defaultValue = nullable ? "null" : "0UL";
+  return {
+    typeName: "ULong",
+    isNullable: nullable,
+    defaultValue,
+    fromJson(input) {
+      if (nullable) {
+        return `when (${input}) {
+                    is JsonPrimitive -> ${input}!!.jsonPrimitive.contentOrNull?.toULongOrNull()
+                    else -> null
+                }`;
+      }
+      return `when (${input}) {
+                is JsonPrimitive -> ${input}!!.jsonPrimitive.contentOrNull?.toULongOrNull() ?: 0UL
+                else -> 0UL
+            }`;
+    },
+    toJson(input, target) {
+      if (schema.nullable) {
+        return `${target} += when (${input}) {
+                    is ULong -> "\\"$${input}\\""
+                    else -> "null"
+                }`;
+      }
+      return `${target} += "\\"$${input}\\""`;
+    },
+    toQueryString(input, target, key) {
+      return defaultToQueryString(context, input, target, key);
+    },
+    content: ""
+  };
+}
+
+function kotlinProcedureFromSchema(schema, context) {
+  switch (schema.transport) {
+    case "http":
+      return kotlinHttpRpcFromSchema(schema, context);
+    case "ws":
+      return kotlinWsRpcFromSchema();
+    default:
+      console.warn(
+        `[codegen-kotlin] Unknown transport type "${schema.transport}". Skipping "${context.instancePath}".`
+      );
+      return "";
+  }
+}
+function kotlinHttpRpcFromSchema(schema, context) {
+  const name = getProcedureName(context);
+  const params = schema.params ? kotlinClassName(`${context.modelPrefix}_${schema.params}`) : void 0;
+  const response = schema.response ? kotlinClassName(`${context.modelPrefix}_${schema.response}`) : void 0;
+  if (schema.isEventStream) {
+    return `fun ${name}(
+            scope: CoroutineScope,
+            ${params ? `params: ${params},` : ""}
+            lastEventId: String? = null,
+            bufferCapacity: Int = 1024,
+            onOpen: ((response: HttpResponse) -> Unit) = {},
+            onClose: (() -> Unit) = {},
+            onError: ((error: ${context.clientName}Error) -> Unit) = {},
+            onConnectionError: ((error: ${context.clientName}Error) -> Unit) = {},
+            onData: ((${response ? `data: ${response}` : ""}) -> Unit) = {},
+        ): Job {
+            val job = scope.launch {
+                __handleSseRequest(
+                    scope = scope,
+                    httpClient = httpClient,
+                    url = "$baseUrl${schema.path}",
+                    method = HttpMethod.${codegenUtils.pascalCase(schema.method, { normalize: true })},
+                    params = ${params ? "params" : "null"},
+                    headers = headers,
+                    backoffTime = 0,
+                    maxBackoffTime = 30000L,
+                    lastEventId = lastEventId,
+                    bufferCapacity = bufferCapacity,
+                    onOpen = onOpen,
+                    onClose = onClose,
+                    onError = onError,
+                    onConnectionError = onConnectionError,
+                    onData = { str ->
+                        ${response ? `val data = ${response}.fromJson(str)` : ""}
+                        onData(${response ? "data" : ""})
+                    }
+                )
+            }
+            return job
+        }`;
+  }
+  const headingCheck = `if (response.headers["Content-Type"] != "application/json") {
+            throw ${context.clientName}Error(
+                code = 0,
+                errorMessage = "Expected server to return Content-Type \\"application/json\\". Got \\"\${response.headers["Content-Type"]}\\"",
+                data = JsonPrimitive(response.bodyAsText()),
+                stack = null,
+            )
+        }`;
+  return `suspend fun ${name}(${params ? `params: ${params}` : ""}): ${response ?? "Unit"} {
+        val response = __prepareRequest(
+            client = httpClient,
+            url = "$baseUrl${schema.path}",
+            method = HttpMethod.${codegenUtils.pascalCase(schema.method, { normalize: true })},
+            params = ${params ? "params" : null},
+            headers = headers?.invoke(),
+        ).execute()
+        ${response ? headingCheck : ""}
+        if (response.status.value in 200..299) {
+            return ${response ? `${response}.fromJson(response.bodyAsText())` : ""}
+        }
+        throw ${context.clientName}Error.fromJson(response.bodyAsText())
+    }`;
+}
+function kotlinWsRpcFromSchema(schema, context) {
+  return "";
+}
+function kotlinServiceFromSchema(schema, context) {
+  const name = getServiceName(context);
+  const procedureParts = [];
+  const subServiceParts = [];
+  for (const key of Object.keys(schema)) {
+    const kotlinKey = kotlinIdentifier(key);
+    const subSchema = schema[key];
+    if (codegenUtils.isServiceDefinition(subSchema)) {
+      const subService = kotlinServiceFromSchema(subSchema, {
+        ...context,
+        instancePath: `${context.instancePath}.${key}`
+      });
+      procedureParts.push(`val ${kotlinKey}: ${subService.name} = ${subService.name}(
+                httpClient = httpClient,
+                baseUrl = baseUrl,
+                headers = headers,
+            )`);
+      if (subService.content) {
+        subServiceParts.push(subService.content);
+      }
+      continue;
+    }
+    if (codegenUtils.isRpcDefinition(subSchema)) {
+      const procedure = kotlinProcedureFromSchema(subSchema, {
+        ...context,
+        instancePath: `${context.instancePath}.${key}`
+      });
+      if (procedure.length > 0) {
+        procedureParts.push(procedure);
+      }
+      continue;
+    }
+  }
+  return {
+    name,
+    content: `class ${name}(
+    private val httpClient: HttpClient,
+    private val baseUrl: String,
+    private val headers: headersFn,
+) {
+    ${procedureParts.join("\n\n    ")}
+}
+
+${subServiceParts.join("\n\n")}`
+  };
+}
+function getProcedureName(context) {
+  const name = context.instancePath.split(".").pop() ?? "";
+  return kotlinIdentifier(name);
+}
+function getServiceName(context) {
+  const name = codegenUtils.pascalCase(context.instancePath.split(".").join("_"));
+  return `${context.clientName}${name}Service`;
+}
+
+function kotlinRefFromSchema(schema, context) {
+  const typeName = kotlinClassName(schema.ref);
+  const nullable = isNullable(schema, context);
+  const defaultValue = nullable ? "null" : `${typeName}.new()`;
+  return {
+    typeName,
+    isNullable: nullable,
+    defaultValue,
+    fromJson(input, key) {
+      return `when (${input}) {
+                is JsonObject -> ${typeName}.fromJsonElement(
+                    ${input}!!,
+                    "$instancePath/${key}",
+                )
+                else -> ${defaultValue}
+            }`;
+    },
+    toJson(input, target) {
+      if (schema.nullable) {
+        return `${target} += ${input}?.toJson()`;
+      }
+      return `${target} += ${input}.toJson()`;
+    },
+    toQueryString() {
+      return `__logError("[WARNING] nested objects cannot be serialized to query params. Skipping field at ${context.instancePath}.")`;
+    },
+    content: ""
+  };
+}
+
+const kotlinClientGenerator = codegenUtils.defineClientGeneratorPlugin(
+  (options) => {
+    return {
+      generator(def) {
+        const client = kotlinClientFromAppDefinition(def, options);
+        fs__default.writeFileSync(options.outputFile, client);
+      },
+      options
+    };
+  }
+);
+function kotlinClientFromAppDefinition(def, options) {
+  const clientName = kotlinClassName(options.clientName ?? "Client");
+  const context = {
+    modelPrefix: options.modelPrefix ?? "",
+    clientName,
+    clientVersion: def.info?.version ?? "",
+    instancePath: "",
+    schemaPath: "",
+    existingTypeIds: []
+  };
+  const modelParts = [];
+  for (const key of Object.keys(def.definitions)) {
+    const subSchema = def.definitions[key];
+    const model = kotlinTypeFromSchema(subSchema, {
+      modelPrefix: context.modelPrefix,
+      clientName: context.clientName,
+      clientVersion: context.clientVersion,
+      instancePath: `/${key}`,
+      schemaPath: `/definitions`,
+      existingTypeIds: context.existingTypeIds
+    });
+    if (model.content) {
+      modelParts.push(model.content);
+    }
+  }
+  const procedureParts = [];
+  const subServiceParts = [];
+  const services = codegenUtils.unflattenProcedures(def.procedures);
+  for (const key of Object.keys(services)) {
+    const subSchema = services[key];
+    if (codegenUtils.isServiceDefinition(subSchema)) {
+      const kotlinKey = kotlinIdentifier(key);
+      const subService = kotlinServiceFromSchema(subSchema, {
+        ...context,
+        instancePath: `${key}`
+      });
+      procedureParts.push(`val ${kotlinKey}: ${subService.name} = ${subService.name}(
+                httpClient = httpClient,
+                baseUrl = baseUrl,
+                headers = headers,
+            )`);
+      if (subService.content) {
+        subServiceParts.push(subService.content);
+      }
+      continue;
+    }
+    if (codegenUtils.isRpcDefinition(subSchema)) {
+      const procedure = kotlinProcedureFromSchema(subSchema, {
+        ...context,
+        instancePath: key
+      });
+      if (procedure.length) {
+        procedureParts.push(procedure);
+      }
+      continue;
+    }
+  }
+  if (procedureParts.length === 0) {
+    return `${getHeader({ clientName, clientVersion: context.clientVersion, packageName: "" })}
+${getUtilityClasses(clientName)}
+
+${modelParts.join("\n\n")}
+
+${getUtilityFunctions(clientName)}`;
+  }
+  return `${getHeader({ clientName, clientVersion: context.clientVersion, packageName: "" })}
+
+class ${clientName}(
+    private val httpClient: HttpClient,
+    private val baseUrl: String,
+    private val headers: headersFn,
+) {
+    ${procedureParts.join("\n\n    ")}
+}
+
+${subServiceParts.join("\n\n")}
+
+${getUtilityClasses(clientName)}
+
+${modelParts.join("\n\n")}
+
+${getUtilityFunctions(clientName)}`;
+}
+function kotlinTypeFromSchema(schema, context) {
+  if (codegenUtils.isSchemaFormType(schema)) {
+    switch (schema.type) {
+      case "string":
+        return kotlinStringFromSchema(schema, context);
+      case "boolean":
+        return kotlinBooleanFromSchema(schema, context);
+      case "timestamp":
+        return kotlinTimestampFromSchema(schema, context);
+      case "float32":
+        return kotlinFloat32FromSchema(schema, context);
+      case "float64":
+        return kotlinFloat64FromSchema(schema, context);
+      case "int8":
+        return kotlinInt8FromSchema(schema, context);
+      case "int16":
+        return kotlinInt16FromSchema(schema, context);
+      case "int32":
+        return kotlinInt32FromSchema(schema, context);
+      case "int64":
+        return kotlinInt64FromSchema(schema, context);
+      case "uint8":
+        return kotlinUint8FromSchema(schema, context);
+      case "uint16":
+        return kotlinUint16FromSchema(schema, context);
+      case "uint32":
+        return kotlinUint32FromSchema(schema, context);
+      case "uint64":
+        return kotlinUint64FromSchema(schema, context);
+      default:
+        schema.type;
+        throw new Error(`Unhandled schema.type case`);
+    }
+  }
+  if (codegenUtils.isSchemaFormEnum(schema)) {
+    return kotlinEnumFromSchema(schema, context);
+  }
+  if (codegenUtils.isSchemaFormProperties(schema)) {
+    return kotlinObjectFromSchema(schema, context);
+  }
+  if (codegenUtils.isSchemaFormElements(schema)) {
+    return kotlinArrayFromSchema(schema, context);
+  }
+  if (codegenUtils.isSchemaFormValues(schema)) {
+    return kotlinMapFromSchema(schema, context);
+  }
+  if (codegenUtils.isSchemaFormDiscriminator(schema)) {
+    return kotlinDiscriminatorFromSchema(schema, context);
+  }
+  if (codegenUtils.isSchemaFormRef(schema)) {
+    return kotlinRefFromSchema(schema, context);
+  }
+  return kotlinAnyFromSchema(schema, context);
+}
+function getUtilityClasses(clientName) {
+  return `interface ${clientName}Model {
+    fun toJson(): String
+    fun toUrlQueryParams(): String
+}
+
+interface ${clientName}ModelFactory<T> {
+    fun new(): T
+    fun fromJson(input: String): T
+    fun fromJsonElement(
+        __input: JsonElement,
+        instancePath: String = "",
+    ): T
+}
+
+data class ${clientName}Error(
+    val code: Int,
+    val errorMessage: String,
+    val data: JsonElement?,
+    val stack: List<String>?,
+) : Exception(errorMessage), ${clientName}Model {
+    override fun toJson(): String {
+        var output = "{"
+        output += "\\"code\\":"
+        output += "$code"
+        output += ",\\"message\\":"
+        output += buildString { printQuoted(errorMessage) }
+        if (data != null) {
+            output += ",\\"data\\":"
+            output += JsonInstance.encodeToString(data)
+        }
+        if (stack != null) {
+            output += ",\\"stack\\":"
+            output += "["
+            for ((__index, __element) in stack.withIndex()) {
+                if (__index > 0) {
+                    output += ","
+                }
+                output += buildString { printQuoted(__element) }
+            }
+            output += "]"
+        }
+        output += "}"
+        return output
+    }
+
+    override fun toUrlQueryParams(): String {
+        val queryParts = mutableListOf<String>()
+        queryParts.add("code=\${code}")
+        queryParts.add("message=\${errorMessage}")
+        return queryParts.joinToString("&")
+    }
+
+    companion object Factory : ${clientName}ModelFactory<${clientName}Error> {
+        override fun new(): ${clientName}Error {
+            return ${clientName}Error(
+                code = 0,
+                errorMessage = "",
+                data = null,
+                stack = null
+            )
+        }
+
+        override fun fromJson(input: String): ${clientName}Error {
+            return fromJsonElement(JsonInstance.parseToJsonElement(input))
+        }
+
+        override fun fromJsonElement(__input: JsonElement, instancePath: String): ${clientName}Error {
+            if (__input !is JsonObject) {
+                __logError("[WARNING] ${clientName}Error.fromJsonElement() expected JsonObject at $instancePath. Got \${__input.javaClass}. Initializing empty ${clientName}Error.")
+            }
+            val code = when (__input.jsonObject["code"]) {
+                is JsonPrimitive -> __input.jsonObject["code"]!!.jsonPrimitive.intOrNull ?: 0
+                else -> 0
+            }
+            val errorMessage = when (__input.jsonObject["message"]) {
+                is JsonPrimitive -> __input.jsonObject["message"]!!.jsonPrimitive.contentOrNull ?: ""
+                else -> ""
+            }
+            val data = when (__input.jsonObject["data"]) {
+                is JsonNull -> null
+                is JsonElement -> __input.jsonObject["data"]!!
+                else -> null
+            }
+            val stack = when (__input.jsonObject["stack"]) {
+                is JsonArray -> {
+                    val stackVal = mutableListOf<String>()
+                    for (item in __input.jsonObject["stack"]!!.jsonArray) {
+                        stackVal.add(
+                            when (item) {
+                                is JsonPrimitive -> item.contentOrNull ?: ""
+                                else -> ""
+                            }
+                        )
+                    }
+                    stackVal
+                }
+
+                else -> null
+
+            }
+            return ${clientName}Error(
+                code,
+                errorMessage,
+                data,
+                stack,
+            )
+        }
+
+    }
+}`;
+}
+function getUtilityFunctions(clientName) {
+  return `// Implementation copied from https://github.com/Kotlin/kotlinx.serialization/blob/d0ae697b9394103879e6c7f836d0f7cf128f4b1e/formats/json/commonMain/src/kotlinx/serialization/json/internal/StringOps.kt#L45
+internal const val STRING = '"'
+
+private fun toHexChar(i: Int): Char {
+    val d = i and 0xf
+    return if (d < 10) (d + '0'.code).toChar()
+    else (d - 10 + 'a'.code).toChar()
+}
+
+internal val ESCAPE_STRINGS: Array<String?> = arrayOfNulls<String>(93).apply {
+    for (c in 0..0x1f) {
+        val c1 = toHexChar(c shr 12)
+        val c2 = toHexChar(c shr 8)
+        val c3 = toHexChar(c shr 4)
+        val c4 = toHexChar(c)
+        this[c] = "\\\\u$c1$c2$c3$c4"
+    }
+    this['"'.code] = "\\\\\\""
+    this['\\\\'.code] = "\\\\\\\\"
+    this['\\t'.code] = "\\\\t"
+    this['\\b'.code] = "\\\\b"
+    this['\\n'.code] = "\\\\n"
+    this['\\r'.code] = "\\\\r"
+    this[0x0c] = "\\\\f"
+}
+
+internal val ESCAPE_MARKERS: ByteArray = ByteArray(93).apply {
+    for (c in 0..0x1f) {
+        this[c] = 1.toByte()
+    }
+    this['"'.code] = '"'.code.toByte()
+    this['\\\\'.code] = '\\\\'.code.toByte()
+    this['\\t'.code] = 't'.code.toByte()
+    this['\\b'.code] = 'b'.code.toByte()
+    this['\\n'.code] = 'n'.code.toByte()
+    this['\\r'.code] = 'r'.code.toByte()
+    this[0x0c] = 'f'.code.toByte()
+}
+
+internal fun StringBuilder.printQuoted(value: String) {
+    append(STRING)
+    var lastPos = 0
+    for (i in value.indices) {
+        val c = value[i].code
+        if (c < ESCAPE_STRINGS.size && ESCAPE_STRINGS[c] != null) {
+            append(value, lastPos, i) // flush prev
+            append(ESCAPE_STRINGS[c])
+            lastPos = i + 1
+        }
+    }
+
+    if (lastPos != 0) append(value, lastPos, value.length)
+    else append(value)
+    append(STRING)
+}
+
+private fun __logError(string: String) {
+    System.err.println(string)
+}
+
+private suspend fun __prepareRequest(
+    client: HttpClient,
+    url: String,
+    method: HttpMethod,
+    params: ${clientName}Model?,
+    headers: MutableMap<String, String>?,
+): HttpStatement {
+    var finalUrl = url
+    var finalBody = ""
+    when (method) {
+        HttpMethod.Get, HttpMethod.Head -> {
+            finalUrl = "$finalUrl?\${params?.toUrlQueryParams() ?: ""}"
+        }
+
+        HttpMethod.Post, HttpMethod.Put, HttpMethod.Patch, HttpMethod.Delete -> {
+            finalBody = params?.toJson() ?: ""
+        }
+    }
+    val builder = HttpRequestBuilder()
+    builder.method = method
+    builder.url(finalUrl)
+    builder.timeout {
+        requestTimeoutMillis = 10 * 60 * 1000
+    }
+    if (headers != null) {
+        for (entry in headers.entries) {
+            builder.headers[entry.key] = entry.value
+        }
+    }
+    builder.headers["client-version"] = generatedClientVersion
+    if (method != HttpMethod.Get && method != HttpMethod.Head) {
+        builder.setBody(finalBody)
+    }
+    return client.prepareRequest(builder)
+}
+
+private fun __parseSseEvent(input: String): __SseEvent {
+    val lines = input.split("\\n")
+    var id: String? = null
+    var event: String? = null
+    var data: String = ""
+    for (line in lines) {
+        if (line.startsWith("id: ")) {
+            id = line.substring(3).trim()
+            continue
+        }
+        if (line.startsWith("event: ")) {
+            event = line.substring(6).trim()
+            continue
+        }
+        if (line.startsWith("data: ")) {
+            data = line.substring(5).trim()
+            continue
+        }
+    }
+    return __SseEvent(id, event, data)
+}
+
+private class __SseEvent(val id: String? = null, val event: String? = null, val data: String)
+
+private class __SseEventParsingResult(val events: List<__SseEvent>, val leftover: String)
+
+private fun __parseSseEvents(input: String): __SseEventParsingResult {
+    val inputs = input.split("\\n\\n").toMutableList()
+    if (inputs.isEmpty()) {
+        return __SseEventParsingResult(
+            events = listOf(),
+            leftover = "",
+        )
+    }
+    if (inputs.size == 1) {
+        return __SseEventParsingResult(
+            events = listOf(),
+            leftover = inputs.last(),
+        )
+    }
+    val leftover = inputs.last()
+    inputs.removeLast()
+    val events = mutableListOf<__SseEvent>()
+    for (item in inputs) {
+        if (item.contains("data: ")) {
+            events.add(__parseSseEvent(item))
+        }
+    }
+    return __SseEventParsingResult(
+        events = events,
+        leftover = leftover,
+    )
+}
+
+private suspend fun __handleSseRequest(
+    scope: CoroutineScope,
+    httpClient: HttpClient,
+    url: String,
+    method: HttpMethod,
+    params: ${clientName}Model?,
+    headers: headersFn,
+    backoffTime: Long,
+    maxBackoffTime: Long,
+    lastEventId: String?,
+    onOpen: ((response: HttpResponse) -> Unit) = {},
+    onClose: (() -> Unit) = {},
+    onError: ((error: ${clientName}Error) -> Unit) = {},
+    onData: ((data: String) -> Unit) = {},
+    onConnectionError: ((error: ${clientName}Error) -> Unit) = {},
+    bufferCapacity: Int,
+) {
+    val finalHeaders = headers?.invoke() ?: mutableMapOf()
+    var lastId = lastEventId
+    // exponential backoff maxing out at 32 seconds
+    if (backoffTime > 0) {
+        withContext(scope.coroutineContext) {
+            Thread.sleep(backoffTime)
+        }
+    }
+    var newBackoffTime =
+        if (backoffTime == 0L) 2L else if (backoffTime * 2L >= maxBackoffTime) maxBackoffTime else backoffTime * 2L
+    if (lastId != null) {
+        finalHeaders["Last-Event-ID"] = lastId.toString()
+    }
+    val request = __prepareRequest(
+        client = httpClient,
+        url = url,
+        method = method,
+        params = params,
+        headers = finalHeaders,
+    )
+    try {
+        request.execute { httpResponse ->
+            try {
+                onOpen(httpResponse)
+            } catch (e: CancellationException) {
+                onClose()
+                return@execute
+            }
+            if (httpResponse.status.value !in 200..299) {
+                try {
+                    if (httpResponse.headers["Content-Type"] == "application/json") {
+                        onConnectionError(
+                            ${clientName}Error.fromJson(httpResponse.bodyAsText())
+                        )
+                    } else {
+                        onConnectionError(
+                            ${clientName}Error(
+                                code = httpResponse.status.value,
+                                errorMessage = httpResponse.status.description,
+                                data = JsonPrimitive(httpResponse.bodyAsText()),
+                                stack = null,
+                            )
+                        )
+                    }
+                } catch (e: CancellationException) {
+                    onClose()
+                    return@execute
+                }
+                __handleSseRequest(
+                    scope = scope,
+                    httpClient = httpClient,
+                    url = url,
+                    method = method,
+                    params = params,
+                    headers = headers,
+                    backoffTime = newBackoffTime,
+                    maxBackoffTime = maxBackoffTime,
+                    lastEventId = lastId,
+                    bufferCapacity = bufferCapacity,
+                    onOpen = onOpen,
+                    onClose = onClose,
+                    onError = onError,
+                    onData = onData,
+                    onConnectionError = onConnectionError,
+                )
+                return@execute
+            }
+            if (httpResponse.headers["Content-Type"] != "text/event-stream") {
+                try {
+                    onConnectionError(
+                        ${clientName}Error(
+                            code = 0,
+                            errorMessage = "Expected server to return Content-Type \\"text/event-stream\\". Got \\"\${httpResponse.headers["Content-Type"]}\\"",
+                            data = JsonPrimitive(httpResponse.bodyAsText()),
+                            stack = null,
+                        )
+                    )
+                } catch (e: CancellationException) {
+                    return@execute
+                }
+                __handleSseRequest(
+                    scope = scope,
+                    httpClient = httpClient,
+                    url = url,
+                    method = method,
+                    params = params,
+                    headers = headers,
+                    backoffTime = newBackoffTime,
+                    maxBackoffTime = maxBackoffTime,
+                    lastEventId = lastId,
+                    bufferCapacity = bufferCapacity,
+                    onOpen = onOpen,
+                    onClose = onClose,
+                    onError = onError,
+                    onData = onData,
+                    onConnectionError = onConnectionError,
+                )
+                return@execute
+            }
+            newBackoffTime = 0
+            val channel: ByteReadChannel = httpResponse.bodyAsChannel()
+            var pendingData = ""
+            while (!channel.isClosedForRead) {
+                val buffer = ByteBuffer.allocateDirect(bufferCapacity)
+                val read = channel.readAvailable(buffer)
+                if (read == -1) break
+                buffer.flip()
+                val input = Charsets.UTF_8.decode(buffer).toString()
+                val parsedResult = __parseSseEvents("\${pendingData}\${input}")
+                pendingData = parsedResult.leftover
+                for (event in parsedResult.events) {
+                    if (event.id != null) {
+                        lastId = event.id
+                    }
+                    when (event.event) {
+                        "message" -> {
+                            try {
+                                onData(event.data)
+                            } catch (e: CancellationException) {
+                                onClose()
+                                return@execute
+                            }
+                        }
+
+                        "done" -> {
+                            onClose()
+                            return@execute
+                        }
+
+                        "error" -> {
+                            val error = ${clientName}Error.fromJson(event.data)
+                            try {
+                                onError(error)
+                            } catch (e: CancellationException) {
+                                onClose()
+                                return@execute
+                            }
+                        }
+
+                        else -> {}
+                    }
+                }
+            }
+            __handleSseRequest(
+                scope = scope,
+                httpClient = httpClient,
+                url = url,
+                method = method,
+                params = params,
+                headers = headers,
+                backoffTime = newBackoffTime,
+                maxBackoffTime = maxBackoffTime,
+                lastEventId = lastId,
+                bufferCapacity = bufferCapacity,
+                onOpen = onOpen,
+                onClose = onClose,
+                onError = onError,
+                onData = onData,
+                onConnectionError = onConnectionError,
+            )
+        }
+    } catch (e: java.net.ConnectException) {
+        onConnectionError(
+            ${clientName}Error(
+                code = 503,
+                errorMessage = if (e.message != null) e.message!! else "Error connecting to $url",
+                data = JsonPrimitive(e.toString()),
+                stack = e.stackTraceToString().split("\\n"),
+            )
+        )
+        __handleSseRequest(
+            scope = scope,
+            httpClient = httpClient,
+            url = url,
+            method = method,
+            params = params,
+            headers = headers,
+            backoffTime = newBackoffTime,
+            maxBackoffTime = maxBackoffTime,
+            lastEventId = lastId,
+            bufferCapacity = bufferCapacity,
+            onOpen = onOpen,
+            onClose = onClose,
+            onError = onError,
+            onData = onData,
+            onConnectionError = onConnectionError,
+        )
+        return
+    } catch (e: Exception) {
+        __handleSseRequest(
+            scope = scope,
+            httpClient = httpClient,
+            url = url,
+            method = method,
+            params = params,
+            headers = headers,
+            backoffTime = newBackoffTime,
+            maxBackoffTime = maxBackoffTime,
+            lastEventId = lastId,
+            bufferCapacity = bufferCapacity,
+            onOpen = onOpen,
+            onClose = onClose,
+            onError = onError,
+            onData = onData,
+            onConnectionError = onConnectionError,
+        )
+    }
+}`;
+}
+function getHeader(options) {
+  return `@file:Suppress(
+    "FunctionName", "LocalVariableName", "UNNECESSARY_NOT_NULL_ASSERTION", "ClassName", "NAME_SHADOWING",
+    "USELESS_IS_CHECK", "unused", "RemoveRedundantQualifierName", "CanBeParameter", "RedundantUnitReturnType",
+    "RedundantExplicitType"
+)
+
+import io.ktor.client.*
+import io.ktor.client.plugins.*
+import io.ktor.client.request.*
+import io.ktor.client.statement.*
+import io.ktor.http.*
+import io.ktor.utils.io.*
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import kotlinx.serialization.encodeToString
+import kotlinx.serialization.json.*
+import java.nio.ByteBuffer
+import java.time.Instant
+import java.time.ZoneId
+import java.time.ZoneOffset
+import java.time.format.DateTimeFormatter
+
+private const val generatedClientVersion = "${options.clientVersion}"
+private val timestampFormatter =
+    DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'")
+        .withZone(ZoneId.ofOffset("GMT", ZoneOffset.UTC))
+private val JsonInstance = Json {
+    encodeDefaults = true
+    ignoreUnknownKeys = true
+}
+private typealias headersFn = (() -> MutableMap<String, String>?)?`;
+}
+
+exports.kotlinClientFromAppDefinition = kotlinClientFromAppDefinition;
+exports.kotlinClientGenerator = kotlinClientGenerator;
+exports.kotlinTypeFromSchema = kotlinTypeFromSchema;