@arrirpc/codegen-swift 0.60.0

package/dist/index.cjs

@@ -0,0 +1,1536 @@
+'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);
+
+function isNullableType(schema, context) {
+  return schema.nullable === true || context.isOptional === true;
+}
+function validTypeName(input) {
+  const formatted = codegenUtils.removeDisallowedChars(
+    codegenUtils.pascalCase(input.split("[").join("_").split("]").join("_"), {
+      normalize: true
+    }),
+    illegalPropertyChars
+  );
+  if (reservedKeywords[formatted]) {
+    return `_${formatted}`;
+  }
+  if (codegenUtils.stringStartsWithNumber(formatted)) {
+    return `_${formatted}`;
+  }
+  return formatted;
+}
+function getTypeName(schema, context) {
+  if (schema.metadata?.id) {
+    const typeName2 = validTypeName(schema.metadata.id);
+    return typeName2;
+  }
+  if (context.discriminatorParent && context.discriminatorValue) {
+    const typeName2 = validTypeName(
+      `${context.discriminatorParent}_${context.discriminatorValue}`
+    );
+    return typeName2;
+  }
+  const typeName = validTypeName(context.instancePath.split("/").join("_"));
+  return typeName;
+}
+const reservedKeywords = {
+  associatedType: true,
+  class: true,
+  deinit: true,
+  enum: true,
+  extension: true,
+  fileprivate: true,
+  func: true,
+  import: true,
+  init: true,
+  inout: true,
+  internal: true,
+  let: true,
+  open: true,
+  operator: true,
+  private: true,
+  precedencegroup: true,
+  protocol: true,
+  public: true,
+  rethrows: true,
+  static: true,
+  subscript: true,
+  typealias: true,
+  var: true,
+  break: true,
+  case: true,
+  catch: true,
+  continue: true,
+  default: true,
+  defer: true,
+  do: true,
+  else: true,
+  fallthrough: true,
+  for: true,
+  guard: true,
+  if: true,
+  in: true,
+  repeat: true,
+  return: true,
+  throw: true,
+  switch: true,
+  where: true,
+  while: true,
+  Any: true,
+  as: true,
+  false: true,
+  is: true,
+  nil: true,
+  self: true,
+  Self: true,
+  super: true,
+  true: true,
+  try: true
+};
+const illegalPropertyChars = "!@#$%^&*()+=[]{}\\|;:'\",./?><`~";
+function validSwiftKey(input) {
+  const key = codegenUtils.removeDisallowedChars(
+    codegenUtils.camelCase(input, { normalize: true }),
+    illegalPropertyChars
+  );
+  if (reservedKeywords[key]) {
+    return `\`${key}\``;
+  }
+  if (codegenUtils.stringStartsWithNumber(key)) {
+    return `_${key}`;
+  }
+  return key;
+}
+function codeComments(schema, leading = "") {
+  const description = schema.metadata?.description?.split("\n").map((line) => `${leading}/// ${line}`).join("\n");
+  if (description && schema.metadata?.isDeprecated) {
+    return `${description}
+${leading}@available(*, deprecated)
+`;
+  }
+  if (description) {
+    return `${description}
+`;
+  }
+  if (schema.metadata?.isDeprecated) {
+    return `${leading}@available(*, deprecated)
+`;
+  }
+  return "";
+}
+
+function swiftAnyFromSchema(schema, context) {
+  const isNullable = isNullableType(schema, context);
+  let defaultValue = "JSON()";
+  if (schema.nullable) {
+    defaultValue = 'JSON(parseJSON: "null")';
+  } else if (context.isOptional) {
+    defaultValue = "";
+  }
+  return {
+    typeName: context.isOptional ? "JSON?" : "JSON",
+    defaultValue,
+    isNullable,
+    canBeQueryString: false,
+    hasRequiredRef: false,
+    fromJsonTemplate(input, target) {
+      if (isNullable) {
+        return `        if ${input}.exists() {
+            ${target} = ${input}
+        }`;
+      }
+      return `        ${target} = ${input}`;
+    },
+    toJsonTemplate(input, target) {
+      if (context.isOptional) {
+        return `        ${target} += serializeAny(input: ${input}!)`;
+      }
+      return `        ${target} += serializeAny(input: ${input})`;
+    },
+    toQueryPartTemplate(_, __, ___) {
+      return `        print("[WARNING] any's cannot be serialized to query params. Skipping field at ${context.instancePath}.")`;
+    },
+    content: ""
+  };
+}
+
+function swiftArrayFromSchema(schema, context) {
+  const subType = swiftTypeFromSchema(schema.elements, {
+    clientVersion: context.clientVersion,
+    clientName: context.clientName,
+    typePrefix: context.typePrefix,
+    instancePath: `${context.instancePath}/[element]`,
+    schemaPath: `${context.schemaPath}/elements`,
+    generatedTypes: context.generatedTypes,
+    containsRequiredRef: context.containsRequiredRef
+  });
+  const isNullable = isNullableType(schema, context);
+  const typeName = isNullable ? `[${subType.typeName}]?` : `[${subType.typeName}]`;
+  const defaultValue = isNullable ? "" : "[]";
+  return {
+    typeName,
+    isNullable,
+    defaultValue,
+    canBeQueryString: false,
+    hasRequiredRef: false,
+    fromJsonTemplate(input, target, key) {
+      const innerKey = validSwiftKey(key);
+      const mainContent = `        ${target} = []
+            for __${innerKey}JsonElement in ${input}.array ?? [] {
+                var __${innerKey}JsonElementValue: ${subType.typeName}
+                ${subType.fromJsonTemplate(`__${innerKey}JsonElement`, `__${innerKey}JsonElementValue`, `element`)}
+                ${target}${isNullable ? "!" : ""}.append(__${innerKey}JsonElementValue)
+            }`;
+      if (context.isOptional) {
+        return `        if ${input}.exists() {
+${mainContent}
+                }`;
+      }
+      if (schema.nullable) {
+        return `        if ${input}.array != nil {
+${mainContent}
+                }`;
+      }
+      return mainContent;
+    },
+    toJsonTemplate(input, target) {
+      const mainContent = `       ${target} += "["
+            for (__index, __element) in ${input}${isNullable ? "!" : ""}.enumerated() {
+                if __index > 0 {
+                    ${target} += ","
+                }
+                ${subType.toJsonTemplate(`__element`, target)}
+            }
+            ${target} += "]"`;
+      if (schema.nullable) {
+        return `        if ${input} != nil {
+                    ${mainContent}
+                } else {
+                    ${target} += "null" 
+                }`;
+      }
+      return mainContent;
+    },
+    toQueryPartTemplate(_, __, ___) {
+      return `        print("[WARNING] arrays cannot be serialized to query params. Skipping field at ${context.instancePath}.")`;
+    },
+    cloneTemplate(input, key) {
+      const innerKey = validSwiftKey(key);
+      const subTypeClonedResult = subType.cloneTemplate?.(
+        `__${innerKey}Element`,
+        `__${innerKey}Element`
+      );
+      if (isNullable) {
+        return {
+          bodyContent: `var __${innerKey}Cloned: ${typeName}
+                if ${input} != nil {
+                    __${innerKey}Cloned = []
+                    for __${innerKey}Element in ${input}! {
+                        ${subTypeClonedResult?.bodyContent ?? ""}
+                        __${innerKey}Cloned!.append(${subTypeClonedResult?.fieldContent || `__${innerKey}Element`})
+                    }
+                }`,
+          fieldContent: `__${innerKey}Cloned`
+        };
+      }
+      return {
+        bodyContent: `var __${innerKey}Cloned: ${typeName} = []
+                for __${innerKey}Element in ${input} {
+                    ${subTypeClonedResult?.bodyContent ?? ""}
+                    __${innerKey}Cloned.append(${subTypeClonedResult?.fieldContent || `__${innerKey}Element`})
+                }`,
+        fieldContent: `__${innerKey}Cloned`
+      };
+    },
+    content: subType.content
+  };
+}
+
+function swiftObjectFromSchema(schema, context) {
+  const typeName = getTypeName(schema, context);
+  const prefixedTypeName = `${context.typePrefix}${typeName}`;
+  const isNullable = isNullableType(schema, context);
+  const defaultValue = isNullable ? "" : `${prefixedTypeName}()`;
+  const result = {
+    typeName: isNullable ? `${prefixedTypeName}?` : prefixedTypeName,
+    defaultValue,
+    isNullable,
+    canBeQueryString: false,
+    hasRequiredRef: context.containsRequiredRef[typeName] ?? false,
+    fromJsonTemplate(input, target) {
+      if (context.isOptional) {
+        return `         if ${input}.exists() {
+                    ${target} = ${prefixedTypeName}(json: ${input})
+                }`;
+      }
+      if (schema.nullable) {
+        return `        if ${input}.dictionary != nil {
+                    ${target} = ${prefixedTypeName}(json: ${input})
+                }`;
+      }
+      return `        ${target} = ${prefixedTypeName}(json: ${input})`;
+    },
+    toJsonTemplate(input, target) {
+      if (context.isOptional) {
+        return `        ${target} += ${input}!.toJSONString()`;
+      }
+      if (schema.nullable) {
+        return `        if ${input} != nil {
+                    ${target} += ${input}!.toJSONString()
+                } else {
+                    ${target} += "null" 
+                }`;
+      }
+      return `        ${target} += ${input}.toJSONString()`;
+    },
+    toQueryPartTemplate(_, __, ___) {
+      return `        print("[WARNING] nested objects cannot be serialized to query params. Skipping field at ${context.instancePath}.")`;
+    },
+    cloneTemplate(input, _key) {
+      let fieldContent = `${input}.clone()`;
+      if (isNullable) {
+        fieldContent = `${input}?.clone()`;
+      }
+      return {
+        tempKey: "",
+        bodyContent: "",
+        fieldContent
+      };
+    },
+    content: ""
+  };
+  if (context.generatedTypes.includes(typeName)) {
+    return result;
+  }
+  const fieldNames = [];
+  const fieldNameParts = [];
+  const initArgParts = [];
+  const initBodyParts = [];
+  const initFromJsonParts = [];
+  const toJsonParts = [];
+  const toQueryStringParts = [];
+  const cloneBodyParts = [];
+  const cloneFieldParts = [];
+  const subContent = [];
+  let numKeys = 0;
+  let canBeQueryString = false;
+  let hasRecursiveSubType = false;
+  if (context.discriminatorKey && context.discriminatorValue) {
+    numKeys++;
+    canBeQueryString = true;
+    const discriminatorKey = validSwiftKey(context.discriminatorKey);
+    fieldNames.push(discriminatorKey);
+    fieldNameParts.push(
+      `    let ${discriminatorKey}: String = "${context.discriminatorValue}"`
+    );
+    toJsonParts.push(
+      `        __json += "\\"${context.discriminatorKey}\\":\\"${context.discriminatorValue}\\""`
+    );
+    toQueryStringParts.push(
+      `        __queryParts.append(URLQueryItem(name: "${context.discriminatorKey}", value: "${context.discriminatorValue}"))`
+    );
+  }
+  for (const key of Object.keys(schema.properties)) {
+    const subSchema = schema.properties[key];
+    const subType = swiftTypeFromSchema(subSchema, {
+      clientVersion: context.clientVersion,
+      clientName: context.clientName,
+      typePrefix: context.typePrefix,
+      instancePath: `/${typeName}/${key}`,
+      schemaPath: `${context.schemaPath}/properties/${key}`,
+      generatedTypes: context.generatedTypes,
+      containsRequiredRef: context.containsRequiredRef
+    });
+    if (subType.content)
+      subContent.push(subType.content);
+    if (subType.hasRequiredRef && !subType.isNullable) {
+      context.containsRequiredRef[typeName] = true;
+      result.hasRequiredRef = true;
+    }
+    if (codegenUtils.isSchemaFormRef(subSchema)) {
+      hasRecursiveSubType = true;
+    }
+    if (subType.canBeQueryString)
+      canBeQueryString = true;
+    const fieldName = validSwiftKey(key);
+    fieldNames.push(fieldName);
+    if (subType.defaultValue) {
+      fieldNameParts.push(
+        `${codeComments(subSchema, "    ")}    public var ${fieldName}: ${subType.typeName} = ${subType.defaultValue}`
+      );
+    } else {
+      fieldNameParts.push(
+        `${codeComments(subSchema, "    ")}    public var ${fieldName}: ${subType.typeName}`
+      );
+    }
+    initArgParts.push(`        ${fieldName}: ${subType.typeName}`);
+    initBodyParts.push(`            self.${fieldName} = ${fieldName}`);
+    initFromJsonParts.push(
+      subType.fromJsonTemplate(
+        `json["${key}"]`,
+        `self.${fieldName}`,
+        key
+      )
+    );
+    if (numKeys > 0) {
+      toJsonParts.push(`        __json += ",\\"${key}\\":"`);
+    } else {
+      toJsonParts.push(`        __json += "\\"${key}\\":"`);
+    }
+    toJsonParts.push(subType.toJsonTemplate(`self.${fieldName}`, `__json`));
+    if (subType.canBeQueryString)
+      canBeQueryString = true;
+    toQueryStringParts.push(
+      subType.toQueryPartTemplate(
+        `self.${fieldName}`,
+        `__queryParts`,
+        key
+      )
+    );
+    const cloneResult = subType.cloneTemplate?.(
+      `self.${fieldName}`,
+      fieldName
+    );
+    if (cloneResult) {
+      cloneBodyParts.push(cloneResult.bodyContent);
+      cloneFieldParts.push(
+        `            ${fieldName}: ${cloneResult.fieldContent}`
+      );
+    } else {
+      cloneFieldParts.push(
+        `            ${fieldName.split("`").join("")}: self.${fieldName}`
+      );
+    }
+    numKeys++;
+  }
+  let numOptionalKeys = 0;
+  for (const key of Object.keys(schema.optionalProperties ?? {})) {
+    const subSchema = schema.optionalProperties[key];
+    const subType = swiftTypeFromSchema(subSchema, {
+      clientVersion: context.clientVersion,
+      clientName: context.clientName,
+      typePrefix: context.typePrefix,
+      instancePath: `/${typeName}/${key}`,
+      schemaPath: `${context.schemaPath}/optionalProperties/${key}`,
+      generatedTypes: context.generatedTypes,
+      isOptional: true,
+      containsRequiredRef: context.containsRequiredRef
+    });
+    if (subType.content)
+      subContent.push(subType.content);
+    if (codegenUtils.isSchemaFormRef(subSchema)) {
+      hasRecursiveSubType = true;
+    }
+    if (subType.canBeQueryString)
+      canBeQueryString = true;
+    const fieldName = validSwiftKey(key);
+    fieldNames.push(fieldName);
+    fieldNameParts.push(
+      `${codeComments(subSchema, "    ")}    public var ${fieldName}: ${subType.typeName}`
+    );
+    initArgParts.push(`        ${fieldName}: ${subType.typeName}`);
+    initBodyParts.push(`            self.${fieldName} = ${fieldName}`);
+    initFromJsonParts.push(
+      subType.fromJsonTemplate(
+        `json["${key}"]`,
+        `self.${fieldName}`,
+        key
+      )
+    );
+    let toJsonContent = ``;
+    if (numKeys > 0) {
+      toJsonContent += `        __json += ",\\"${key}\\":"
+`;
+    } else {
+      if (numOptionalKeys > 0) {
+        toJsonContent += `            if __numKeys > 0 {
+                    __json += ","
+                }
+`;
+      }
+      toJsonContent += `            __json += "\\"${key}\\":"
+`;
+    }
+    toJsonContent += subType.toJsonTemplate(`self.${fieldName}`, `__json`);
+    if (numKeys === 0) {
+      toJsonContent += `            
+__numKeys += 1`;
+    }
+    toJsonParts.push(`        if self.${fieldName} != nil {
+            ${toJsonContent}
+        }`);
+    if (subType.canBeQueryString)
+      canBeQueryString = true;
+    toQueryStringParts.push(
+      subType.toQueryPartTemplate(
+        `self.${fieldName}`,
+        `__queryParts`,
+        key
+      )
+    );
+    const cloneResult = subType.cloneTemplate?.(
+      `self.${fieldName}`,
+      fieldName
+    );
+    if (cloneResult) {
+      cloneBodyParts.push(cloneResult.bodyContent);
+      cloneFieldParts.push(
+        `            ${fieldName}: ${cloneResult.fieldContent}`
+      );
+    } else {
+      cloneFieldParts.push(
+        `            ${fieldName.split("`").join("")}: self.${fieldName}`
+      );
+    }
+    numOptionalKeys++;
+  }
+  const declaration = hasRecursiveSubType ? `final class` : "struct";
+  const initPrefix = hasRecursiveSubType ? `public required` : `public`;
+  const initJsonStringPrefix = hasRecursiveSubType ? `public required convenience` : `public`;
+  let equalsPart = "";
+  if (hasRecursiveSubType) {
+    equalsPart = `public static func == (lhs: ${prefixedTypeName}, rhs: ${prefixedTypeName}) -> Bool {
+            return
+${fieldNames.map((field) => `               lhs.${field} == rhs.${field}`).join(" &&\n")}
+        }`;
+  }
+  result.content = `${codeComments(schema)}public ${declaration} ${prefixedTypeName}: ArriClientModel {
+${fieldNameParts.join("\n")}
+    ${initPrefix} init(
+${initArgParts.join(",\n")}
+    ) {
+${initBodyParts.join("\n")}
+    }
+    ${initPrefix} init() {}
+    ${initPrefix} init(json: JSON) {
+${initFromJsonParts.join("\n")}
+    }
+    ${initJsonStringPrefix} init(JSONData: Data) {
+        do {
+            let json = try JSON(data: JSONData)
+            self.init(json: json)
+        } catch {
+            print("[WARNING] Error parsing JSON: \\(error)")
+            self.init()
+        }
+    }
+    ${initJsonStringPrefix} init(JSONString: String) {
+        do {
+            let json = try JSON(data: JSONString.data(using: .utf8) ?? Data())
+            self.init(json: json) 
+        } catch {
+            print("[WARNING] Error parsing JSON: \\(error)")
+            self.init()
+        }
+    }
+    public func toJSONString() -> String {
+        var __json = "{"
+${numKeys === 0 ? `      var __numKeys = 0` : ""}
+${toJsonParts.join("\n")}
+        __json += "}"
+        return __json
+    }
+    public func toURLQueryParts() -> [URLQueryItem] {
+        ${canBeQueryString ? `var __queryParts: [URLQueryItem] = []` : ""}
+${toQueryStringParts.join("\n")}
+        ${canBeQueryString ? `return __queryParts` : `return []`}
+    }
+    public func clone() -> ${prefixedTypeName} {
+${cloneBodyParts.join("\n")}
+        return ${prefixedTypeName}(
+${cloneFieldParts.join(",\n")}
+        )
+    }
+    ${equalsPart}
+}
+    
+${subContent.join("\n")}`;
+  context.generatedTypes.push(typeName);
+  return result;
+}
+
+function swiftTaggedUnionFromSchema(schema, context) {
+  const typeName = getTypeName(schema, context);
+  const prefixedTypeName = `${context.typePrefix}${typeName}`;
+  const isNullable = isNullableType(schema, context);
+  const defaultValue = isNullable ? `` : `${prefixedTypeName}()`;
+  const result = {
+    typeName: isNullable ? `${prefixedTypeName}?` : prefixedTypeName,
+    isNullable,
+    defaultValue,
+    canBeQueryString: false,
+    hasRequiredRef: context.containsRequiredRef[typeName] ?? false,
+    fromJsonTemplate(input, target, _) {
+      if (context.isOptional) {
+        return `        if ${input}.exists() {
+                    ${target} = ${prefixedTypeName}(json: ${input})
+                }`;
+      }
+      if (schema.nullable) {
+        return `        if ${input}.dictionary != nil {
+                    ${target} = ${prefixedTypeName}(json: ${input})
+                }`;
+      }
+      return `        ${target} = ${prefixedTypeName}(json: ${input})`;
+    },
+    toJsonTemplate(input, target) {
+      if (context.isOptional) {
+        return `        ${target} += ${input}!.toJSONString()`;
+      }
+      if (schema.nullable) {
+        return `        if ${input} != nil {
+                    ${target} += ${input}!.toJSONString()
+                } else {
+                    ${target} += "null" 
+                }`;
+      }
+      return `        ${target} += ${input}.toJSONString()`;
+    },
+    toQueryPartTemplate(_, __, ___) {
+      return `        print("[WARNING] nested objects cannot be serialized to query params. Skipping field at ${context.instancePath}.")`;
+    },
+    cloneTemplate(input, _) {
+      return {
+        fieldContent: `${input}${isNullable ? "?" : ""}.clone()`,
+        bodyContent: ""
+      };
+    },
+    content: ""
+  };
+  if (context.generatedTypes.includes(typeName)) {
+    return result;
+  }
+  const discriminatorParts = [];
+  const discriminatorKey = schema.discriminator;
+  for (const key of Object.keys(schema.mapping)) {
+    const discriminatorValue = key;
+    const subSchema = schema.mapping[key];
+    const subType = swiftObjectFromSchema(subSchema, {
+      clientVersion: context.clientVersion,
+      clientName: context.clientName,
+      typePrefix: context.typePrefix,
+      instancePath: context.instancePath,
+      schemaPath: `${context.schemaPath}/mapping/${key}`,
+      generatedTypes: context.generatedTypes,
+      discriminatorKey,
+      discriminatorParent: typeName,
+      discriminatorValue: key,
+      containsRequiredRef: context.containsRequiredRef
+    });
+    const discriminatorCase = validSwiftKey(key);
+    const discriminatorPart = {
+      discriminatorValue,
+      discriminatorCase,
+      hasRequiredRef: subType.hasRequiredRef,
+      typeName: subType.typeName.replace("?", ""),
+      content: subType.content
+    };
+    discriminatorParts.push(discriminatorPart);
+  }
+  if (!discriminatorParts.length) {
+    throw new Error(
+      `Invalid schema at ${context.schemaPath}. Discriminators must have at least one mapping.`
+    );
+  }
+  let defaultPart;
+  for (const part of discriminatorParts) {
+    if (part.hasRequiredRef)
+      continue;
+    defaultPart = part;
+    break;
+  }
+  if (!defaultPart) {
+    throw new Error(
+      `Invalid schema a ${context.schemaPath}. All subtypes have a required recursive reference. This creates an infinite loop.`
+    );
+  }
+  result.content = `${codeComments(schema)}public enum ${prefixedTypeName}: ArriClientModel {
+${discriminatorParts.map((part) => `    case ${part.discriminatorCase}(${part.typeName})`).join("\n")}
+    public init() {
+        self = .${defaultPart.discriminatorCase}(${defaultPart.typeName}())
+    }
+    public init(json: JSON) {
+        let discriminator = json["${discriminatorKey}"].string ?? ""
+        switch (discriminator) {
+${discriminatorParts.map(
+    (part) => `            case "${part.discriminatorValue}":
+                self = .${part.discriminatorCase}(${part.typeName}(json: json))
+                break`
+  ).join("\n")}
+            default:
+                self = .${defaultPart.discriminatorCase}(${defaultPart.typeName}())
+                break
+        }
+    }
+    public init(JSONData: Data) {
+        do {
+            let json = try JSON(data: JSONData)
+            self.init(json: json)
+        } catch {
+            print("[WARNING] Error parsing JSON: \\(error)")
+            self.init()
+        }
+    }
+    public init(JSONString: String) {
+        do {
+            let json = try JSON(data: JSONString.data(using: .utf8) ?? Data())
+            self.init(json: json)
+        } catch {
+            print("[WARNING] Error parsing JSON: \\(error)")
+            self.init()
+        }
+    }
+    public func toJSONString() -> String {
+        switch(self) {
+${discriminatorParts.map(
+    (part) => `            case .${part.discriminatorCase}(let __innerVal):
+                return __innerVal.toJSONString()`
+  ).join("\n")}
+        }
+    }
+    public func toURLQueryParts() -> [URLQueryItem] {
+        switch(self) {
+${discriminatorParts.map(
+    (part) => `            case .${part.discriminatorCase}(let __innerVal):
+                return __innerVal.toURLQueryParts()`
+  ).join("\n")}
+        }
+    }
+    public func clone() -> ${prefixedTypeName} {
+        switch(self) {
+${discriminatorParts.map(
+    (part) => `            case .${part.discriminatorCase}(let __innerVal):
+                return .${part.discriminatorCase}(__innerVal.clone())`
+  ).join("\n")}
+        }
+    }
+}
+    
+${discriminatorParts.map((part) => part.content).join("\n")}`;
+  context.generatedTypes.push(typeName);
+  return result;
+}
+
+function swiftEnumFromSchema(schema, context) {
+  if (!schema.enum[0]) {
+    throw new Error(
+      `Error at ${context.instancePath}. Must have at least one enum value.`
+    );
+  }
+  const typeName = getTypeName(schema, context);
+  const isNullable = isNullableType(schema, context);
+  const defaultEnumValue = codegenUtils.camelCase(schema.enum[0], { normalize: true });
+  const prefixedTypeName = `${context.typePrefix}${typeName}`;
+  const defaultValue = isNullable ? "" : `${prefixedTypeName}.${defaultEnumValue}`;
+  const result = {
+    typeName: isNullable ? `${typeName}?` : typeName,
+    isNullable,
+    defaultValue,
+    canBeQueryString: true,
+    hasRequiredRef: false,
+    fromJsonTemplate(input, target) {
+      if (context.isOptional) {
+        return `        if ${input}.exists() {
+                    ${target} = ${prefixedTypeName}(serialValue: ${input}.string ?? "")
+                }`;
+      }
+      if (schema.nullable) {
+        return `        if ${input}.string != nil {
+                    ${target} = ${prefixedTypeName}(serialValue: ${input}.string ?? "")
+                }`;
+      }
+      return `        ${target} = ${prefixedTypeName}(serialValue: ${input}.string ?? "")`;
+    },
+    toJsonTemplate(input, target) {
+      if (context.isOptional) {
+        return `        ${target} += "\\"\\(${input}!.serialValue())\\""`;
+      }
+      if (schema.nullable) {
+        return `        if ${input} != nil {
+                    ${target} += "\\"\\(${input}!.serialValue())\\""
+                } else {
+                    ${target} += "null" 
+                }`;
+      }
+      return `        ${target} += "\\"\\(${input}.serialValue())\\""`;
+    },
+    toQueryPartTemplate(input, target, key) {
+      if (context.isOptional) {
+        return `        if ${input} != nil {
+                    ${target}.append(URLQueryItem(name: "${key}", value: ${input}!.serialValue()))
+                }`;
+      }
+      if (schema.nullable) {
+        return `        if ${input} != nil {
+                    ${target}.append(URLQueryItem(name: "${key}", value: ${input}!.serialValue()))
+                } else {
+                    ${target}.append(URLQueryItem(name: "${key}", value: "null")) 
+                }`;
+      }
+      return `        ${target}.append(URLQueryItem(name: "${key}", value: ${input}.serialValue()))`;
+    },
+    content: ""
+  };
+  if (context.generatedTypes.includes(typeName)) {
+    return result;
+  }
+  result.content = `public enum ${prefixedTypeName}: ArriClientEnum {
+${schema.enum.map((val) => `    case ${codegenUtils.camelCase(val, { normalize: true })}`).join("\n")}
+    public init() {
+        self = .${defaultEnumValue}
+    }
+    public init(serialValue: String) {
+        switch(serialValue) {
+${schema.enum.map(
+    (val) => `            case "${val}":
+                self = .${codegenUtils.camelCase(val, { normalize: true })}
+                break;`
+  ).join("\n")}
+            default:
+                self = .${defaultEnumValue}
+        }
+    }
+    public func serialValue() -> String {
+        switch (self) {
+${schema.enum.map(
+    (val) => `            case .${codegenUtils.camelCase(val, { normalize: true })}:
+                return "${val}"`
+  ).join("\n")}
+        }
+    }
+}`;
+  context.generatedTypes.push(typeName);
+  return result;
+}
+
+function swiftStringFromSchema(schema, context) {
+  const isNullable = isNullableType(schema, context);
+  const typeName = isNullable ? "String?" : "String";
+  const defaultValue = isNullable ? "" : '""';
+  return {
+    typeName,
+    isNullable,
+    defaultValue,
+    canBeQueryString: true,
+    hasRequiredRef: false,
+    fromJsonTemplate(input, target) {
+      if (context.isOptional) {
+        return `        if ${input}.exists() {
+            ${target} = ${input}.string    
+        }`;
+      }
+      if (schema.nullable) {
+        return `        if ${input}.string != nil {
+            ${target} = ${input}.string
+        }`;
+      }
+      return `        ${target} = ${input}.string ?? ""`;
+    },
+    toJsonTemplate(input, target) {
+      if (context.isOptional) {
+        return `        ${target} += serializeString(input: ${input}!)`;
+      }
+      if (schema.nullable) {
+        return `        if ${input} != nil {
+                    ${target} += serializeString(input: ${input}!)
+                } else {
+                    ${target} += "null" 
+                }`;
+      }
+      return `        ${target} += serializeString(input: ${input})`;
+    },
+    toQueryPartTemplate(input, target, key) {
+      if (context.isOptional) {
+        return `        if ${input} != nil {
+                    ${target}.append(URLQueryItem(name: "${key}", value: ${input}!))
+                }`;
+      }
+      if (schema.nullable) {
+        return `        if ${input} != nil {
+                    ${target}.append(URLQueryItem(name: "${key}", value: ${input}!))
+                } else {
+                    ${target}.append(URLQueryItem(name: "${key}", value: "null")) 
+                }`;
+      }
+      return `        ${target}.append(URLQueryItem(name: "${key}", value: ${input}))`;
+    },
+    content: ""
+  };
+}
+function swiftBooleanFromSchema(schema, context) {
+  const isNullable = isNullableType(schema, context);
+  const typeName = isNullable ? "Bool?" : "Bool";
+  const defaultValue = isNullable ? "" : "false";
+  return {
+    typeName,
+    isNullable,
+    defaultValue,
+    canBeQueryString: true,
+    hasRequiredRef: false,
+    fromJsonTemplate(input, target) {
+      if (context.isOptional) {
+        return `        if ${input}.exists() {
+                    ${target} = ${input}.bool
+                }`;
+      }
+      if (schema.nullable) {
+        return `        if ${input}.bool != nil {
+                    ${target} = ${input}.bool
+                }`;
+      }
+      return `        ${target} = ${input}.bool ?? false`;
+    },
+    toJsonTemplate(input, target) {
+      if (context.isOptional) {
+        return `${target} += "\\(${input}!)"`;
+      }
+      if (schema.nullable) {
+        return `        if ${input} != nil {
+                    ${target} += "\\(${input}!)"
+                } else {
+                    ${target} += "null" 
+                }`;
+      }
+      return `        ${target} += "\\(${input})"`;
+    },
+    toQueryPartTemplate(input, target, key) {
+      if (context.isOptional) {
+        return `        if ${input} != nil {
+                    ${target}.append(URLQueryItem(name: "${key}", value: "\\(${input}!)"))
+                }`;
+      }
+      if (schema.nullable) {
+        return `        if ${input} != nil {
+                    ${target}.append(URLQueryItem(name: "${key}", value: "\\(${input}!)"))
+                } else {
+                    ${target}.append(URLQueryItem(name: "${key}", value: "null")) 
+                }`;
+      }
+      return `        ${target}.append(URLQueryItem(name: "${key}", value: "\\(${input})"))`;
+    },
+    content: ""
+  };
+}
+function swiftTimestampFromSchema(schema, context) {
+  const isNullable = isNullableType(schema, context);
+  const typeName = isNullable ? "Date?" : "Date";
+  const defaultValue = isNullable ? "" : "Date()";
+  return {
+    typeName,
+    defaultValue,
+    isNullable,
+    canBeQueryString: true,
+    hasRequiredRef: false,
+    fromJsonTemplate(input, target) {
+      if (context.isOptional) {
+        return `        if ${input}.exists() {
+                    ${target} = parseDate(${input}.string ?? "") ?? Date()
+                }`;
+      }
+      if (schema.nullable) {
+        return `        if ${input}.string != nil {
+                    ${target} = parseDate(${input}.string ?? "") ?? Date()
+                }`;
+      }
+      return `        ${target} = parseDate(${input}.string ?? "") ?? Date()`;
+    },
+    toJsonTemplate(input, target) {
+      if (context.isOptional) {
+        return `        ${target} += serializeDate(${input}!)`;
+      }
+      if (schema.nullable) {
+        return `        if ${input} != nil {
+                    ${target} += serializeDate(${input}!)
+                } else {
+                    ${target} += "null" 
+                }`;
+      }
+      return `        ${target} += serializeDate(${input})`;
+    },
+    toQueryPartTemplate(input, target, key) {
+      if (context.isOptional) {
+        return `        if ${input} != nil {
+                    ${target}.append(URLQueryItem(name: "${key}", value: serializeDate(${input}!, withQuotes: false)))
+                }`;
+      }
+      if (schema.nullable) {
+        return `        if ${input} != nil {
+                    ${target}.append(URLQueryItem(name: "${key}", value: serializeDate(${input}!, withQuotes: false)))
+                } else {
+                    ${target}.append(URLQueryItem(name: "${key}", value: "null")) 
+                }`;
+      }
+      return `        ${target}.append(URLQueryItem(name: "${key}", value: serializeDate(${input}, withQuotes: false)))`;
+    },
+    content: ""
+  };
+}
+function swiftNumberFromSchema(schema, context, typeName, jsonAccessor, defaultValue) {
+  const isNullable = isNullableType(schema, context);
+  return {
+    typeName: isNullable ? `${typeName}?` : typeName,
+    defaultValue: isNullable ? "" : defaultValue,
+    isNullable,
+    canBeQueryString: true,
+    hasRequiredRef: false,
+    fromJsonTemplate(input, target) {
+      if (context.isOptional) {
+        return `        if ${input}.exists() {
+                    ${target} = ${input}.${jsonAccessor}
+                }`;
+      }
+      if (schema.nullable) {
+        return `        if ${input}.${jsonAccessor} != nil {
+                    ${target} = ${input}.${jsonAccessor}
+                }`;
+      }
+      return `        ${target} = ${input}.${jsonAccessor} ?? ${defaultValue}`;
+    },
+    toJsonTemplate(input, target) {
+      if (context.isOptional) {
+        return `        ${target} += "\\(${input}!)"`;
+      }
+      if (schema.nullable) {
+        return `        if ${input} != nil {
+                    ${target} += "\\(${input}!)"
+                } else {
+                    ${target} += "null"
+                }`;
+      }
+      return `        ${target} += "\\(${input})"`;
+    },
+    toQueryPartTemplate(input, target, key) {
+      if (context.isOptional) {
+        return `        if ${input} != nil {
+                    ${target}.append(URLQueryItem(name: "${key}", value: "\\(${input}!)"))
+                }`;
+      }
+      if (schema.nullable) {
+        return `        if ${input} != nil {
+                    ${target}.append(URLQueryItem(name: "${key}", value: "\\(${input}!)"))
+                } else {
+                    ${target}.append(URLQueryItem(name: "${key}", value: "null")) 
+                }`;
+      }
+      return `        ${target}.append(URLQueryItem(name: "${key}", value: "\\(${input})"))`;
+    },
+    content: ""
+  };
+}
+function swiftLargeIntFromSchema(schema, context, typeName) {
+  const isNullable = isNullableType(schema, context);
+  return {
+    typeName: isNullable ? `${typeName}?` : typeName,
+    defaultValue: isNullable ? "" : "0",
+    isNullable,
+    canBeQueryString: true,
+    hasRequiredRef: false,
+    fromJsonTemplate(input, target) {
+      if (context.isOptional) {
+        return `        if ${input}.exists() {
+                    ${target} = ${typeName}(${input}.string ?? "0")
+                }`;
+      }
+      if (schema.nullable) {
+        return `        if ${input}.string != nil {
+                    ${target} = ${typeName}(${input}.string ?? "0")
+                }`;
+      }
+      return `        ${target} = ${typeName}(${input}.string ?? "0") ?? 0`;
+    },
+    toJsonTemplate(input, target) {
+      if (context.isOptional) {
+        return `        ${target} += "\\"\\(${input}!)\\""`;
+      }
+      if (schema.nullable) {
+        return `        if ${input} != nil {
+                    ${target} += "\\"\\(${input}!)\\""
+                } else {
+                    ${target} += "null" 
+                }`;
+      }
+      return `        ${target} += "\\"\\(${input})\\""`;
+    },
+    toQueryPartTemplate(input, target, key) {
+      if (context.isOptional) {
+        return `        if ${input} != nil {
+                    ${target}.append(URLQueryItem(name: "${key}", value: "\\(${input}!)"))
+                }`;
+      }
+      if (schema.nullable) {
+        return `        if ${input} != nil {
+                    ${target}.append(URLQueryItem(name: "${key}", value: "\\(${input}!)"))
+                } else {
+                    ${target}.append(URLQueryItem(name: "${key}", value: "null")) 
+                }`;
+      }
+      return `        ${target}.append(URLQueryItem(name: "${key}", value: "\\(${input})"))`;
+    },
+    content: ""
+  };
+}
+
+function swiftProcedureFromSchema(schema, context) {
+  switch (schema.transport) {
+    case "http":
+      return swiftHttpProcedureFromSchema(schema, context);
+    case "ws":
+      return swiftWsProcedureFromSchema(schema, context);
+    default:
+      console.warn(
+        `[swift-codegen] Unsupported transport type at ${context.instancePath}`
+      );
+      return "";
+  }
+}
+function swiftHttpProcedureFromSchema(schema, context) {
+  const rpcName = getRpcName(context.instancePath);
+  const comments = codeComments(
+    {
+      metadata: {
+        description: schema.description,
+        isDeprecated: schema.isDeprecated
+      }
+    },
+    "    "
+  );
+  const params = schema.params ? `${context.typePrefix}${validTypeName(schema.params)}` : void 0;
+  const response = schema.response ? `${context.typePrefix}${validTypeName(schema.response)}` : void 0;
+  if (schema.isEventStream) {
+    return `${comments}    public func ${rpcName}(${params ? `_ params: ${params}, ` : ""}options: EventSourceOptions<${response ?? "EmptyArriModel"}>) -> Task<(), Never> {
+        let task = Task {
+            var eventSource = EventSource<${response ?? "EmptyArriModel"}>(
+                url: "\\(self.baseURL)${schema.path}",
+                method: "${schema.method.toUpperCase()}",
+                headers: self.headers,
+                params: ${params ? "params" : "nil"},
+                delegate: self.delegate,
+                clientVersion: "${context.clientVersion}",
+                options: options
+            )
+            await eventSource.sendRequest()
+        }
+        return task
+    }`;
+  }
+  return `${comments}    public func ${rpcName}(${params ? `_ params: ${params}` : ""}) async throws -> ${response ?? "()"} {
+        ${response ? `let result: ${response} = ` : "let _: EmptyArriModel = "}try await parsedArriHttpRequest(
+            delegate: self.delegate,
+            url: "\\(self.baseURL)${schema.path}",
+            method: "${schema.method.toUpperCase()}",
+            headers: self.headers,
+            clientVersion: "${context.clientVersion}",
+            ${params ? `params: params` : "params: EmptyArriModel()"}
+        )
+        ${response ? `return result` : ""}
+    }`;
+}
+function getRpcName(instancePath) {
+  const part = instancePath.split(".").pop();
+  if (!part) {
+    throw new Error(`Error determining procedure name at ${instancePath}`);
+  }
+  return validSwiftKey(part);
+}
+function swiftWsProcedureFromSchema(schema, context) {
+  console.warn(
+    "[swift-codegen] Websocket procedures are not supported at this time."
+  );
+  const name = getRpcName(context.instancePath);
+  const params = schema.params ? `${context.typePrefix}${validTypeName(schema.params)}` : void 0;
+  const response = schema.response ? `${context.typePrefix}${validTypeName(schema.response)}` : void 0;
+  const comments = codeComments(
+    {
+      metadata: {
+        description: schema.description,
+        isDeprecated: schema.isDeprecated
+      }
+    },
+    `    `
+  );
+  return `${comments}    public func ${name}(${params ? `_ params: ${params}` : ""}) async throws -> ${response ?? "()"} {
+        throw ArriRequestError.notImplemented
+    }`;
+}
+function swiftServiceFromSchema(schema, context) {
+  const serviceName = getServiceName(
+    context.instancePath,
+    context.clientName
+  );
+  const services = [];
+  const procedureParts = [];
+  const subContent = [];
+  for (const key of Object.keys(schema)) {
+    const subSchema = schema[key];
+    if (codegenUtils.isServiceDefinition(subSchema)) {
+      const subService = swiftServiceFromSchema(subSchema, {
+        clientVersion: context.clientVersion,
+        clientName: context.clientName,
+        typePrefix: context.typePrefix,
+        instancePath: `${context.instancePath}.${key}`,
+        schemaPath: `${context.schemaPath}.${key}`,
+        generatedTypes: context.generatedTypes,
+        containsRequiredRef: context.containsRequiredRef
+      });
+      if (subService) {
+        const subServiceKey = validSwiftKey(key);
+        const subServiceName = getServiceName(
+          `${context.instancePath}.${key}`,
+          context.clientName
+        );
+        services.push({
+          key: subServiceKey,
+          typeName: subServiceName
+        });
+        subContent.push(subService);
+      }
+      continue;
+    }
+    if (codegenUtils.isRpcDefinition(subSchema)) {
+      const rpc = swiftProcedureFromSchema(subSchema, {
+        clientVersion: context.clientVersion,
+        clientName: context.clientName,
+        typePrefix: context.typePrefix,
+        instancePath: `${context.instancePath}.${key}`,
+        schemaPath: `${context.schemaPath}.${key}`,
+        generatedTypes: context.generatedTypes,
+        containsRequiredRef: context.containsRequiredRef
+      });
+      if (rpc) {
+        procedureParts.push(rpc);
+      }
+      continue;
+    }
+  }
+  return `public class ${serviceName} {
+    let baseURL: String
+    let delegate: ArriRequestDelegate
+    let headers: () -> Dictionary<String, String>
+${services.map((service) => `    public let ${service.key}: ${service.typeName}`).join("\n")}
+    public init(
+        baseURL: String,
+        delegate: ArriRequestDelegate,
+        headers: @escaping () -> Dictionary<String, String>
+    ) {
+        self.baseURL = baseURL
+        self.delegate = delegate
+        self.headers = headers
+${services.map(
+    (service) => `        self.${service.key} = ${service.typeName}(
+            baseURL: baseURL,
+            delegate: delegate,
+            headers: headers
+        )`
+  ).join("\n")}    
+    }
+${procedureParts.join("\n")}
+        
+}
+
+${subContent.join("\n")}`;
+}
+function getServiceName(instancePath, clientName) {
+  if (instancePath.length === 0) {
+    return clientName;
+  }
+  const name = `${clientName}${validTypeName(instancePath.split(".").join("_"))}Service`;
+  return name;
+}
+
+function swiftDictionaryFromSchema(schema, context) {
+  const subType = swiftTypeFromSchema(schema.values, {
+    clientVersion: context.clientVersion,
+    clientName: context.clientName,
+    typePrefix: context.typePrefix,
+    instancePath: `${context.instancePath}/[value]`,
+    schemaPath: `${context.schemaPath}/values`,
+    generatedTypes: context.generatedTypes,
+    containsRequiredRef: context.containsRequiredRef
+  });
+  const isNullable = isNullableType(schema, context);
+  const typeName = isNullable ? `Dictionary<String, ${subType.typeName}>?` : `Dictionary<String, ${subType.typeName}>`;
+  const defaultValue = isNullable ? `` : `Dictionary()`;
+  return {
+    typeName,
+    isNullable,
+    defaultValue,
+    canBeQueryString: false,
+    hasRequiredRef: false,
+    fromJsonTemplate(input, target, _) {
+      const mainContent = `        ${target} = Dictionary()
+            for (__key, __value) in ${input}.dictionary ?? Dictionary() {
+                var __parsedValue: ${subType.typeName}
+                ${subType.fromJsonTemplate(`__value`, `__parsedValue`, `__parsedValue`)}
+                ${target}${isNullable ? "!" : ""}[__key] = __parsedValue            
+            }`;
+      if (context.isOptional) {
+        return `        if ${input}.exists() {
+${mainContent}
+                }`;
+      }
+      if (schema.nullable) {
+        return `        if ${input}.dictionary != nil {
+${mainContent}
+                }`;
+      }
+      return mainContent;
+    },
+    toJsonTemplate(input, target) {
+      const mainContent = `        ${target} += "{"
+            for (__index, (__key, __value)) in ${input}${isNullable ? "!" : ""}.enumerated() {
+                if __index > 0 {
+                    ${target} += ","
+                }
+                ${target} += "\\"\\(__key)\\":"
+                ${subType.toJsonTemplate("__value", target)}
+            }
+            ${target} += "}"`;
+      if (schema.nullable) {
+        return `if ${input} != nil {
+                    ${mainContent}
+                } else {
+                    ${target} += "null" 
+                }`;
+      }
+      return mainContent;
+    },
+    toQueryPartTemplate(_, __, ___) {
+      return `        print("[WARNING] nested objects cannot be serialized to query params. Skipping field at ${context.instancePath}.")`;
+    },
+    cloneTemplate(input, key) {
+      const innerKey = validSwiftKey(key);
+      const subTypeClonedResult = subType.cloneTemplate?.(
+        `__${innerKey}Value`,
+        `__${innerKey}Value`
+      );
+      if (isNullable) {
+        return {
+          bodyContent: `var __${innerKey}Cloned: ${typeName}
+                    if ${input} != nil {
+                        __${innerKey}Cloned = Dictionary()
+                        for (__${innerKey}Key, __${innerKey}Value) in ${input}! {
+                            ${subTypeClonedResult?.bodyContent ?? ""}
+                            __${innerKey}Cloned![__${innerKey}Key] = ${subTypeClonedResult?.fieldContent ?? `__${innerKey}Value`}
+                        }          
+                    }`,
+          fieldContent: `__${innerKey}Cloned`
+        };
+      }
+      return {
+        bodyContent: `var __${innerKey}Cloned: ${typeName} = Dictionary()
+                    for (__${innerKey}Key, __${innerKey}Value) in ${input} {
+                        ${subTypeClonedResult?.bodyContent ?? ""}
+                        __${innerKey}Cloned[__${innerKey}Key] = ${subTypeClonedResult?.fieldContent ?? `__${innerKey}Value`}
+                    }`,
+        fieldContent: `__${innerKey}Cloned`
+      };
+    },
+    content: subType.content
+  };
+}
+
+function swiftRefFromSchema(schema, context) {
+  const typeName = validTypeName(schema.ref);
+  const prefixedTypeName = `${context.typePrefix}${typeName}`;
+  const isNullable = isNullableType(schema, context);
+  const defaultValue = isNullable ? `` : `${prefixedTypeName}()`;
+  return {
+    typeName: isNullable ? `${prefixedTypeName}?` : prefixedTypeName,
+    isNullable,
+    defaultValue,
+    canBeQueryString: false,
+    hasRequiredRef: !isNullable,
+    fromJsonTemplate(input, target, _key) {
+      if (context.isOptional) {
+        return `if ${input}.exists() {
+                    ${target} = ${prefixedTypeName}(json: ${input})
+                }`;
+      }
+      if (schema.nullable) {
+        return `if ${input}.dictionary != nil {
+                    ${target} = ${prefixedTypeName}(json: ${input})
+                }`;
+      }
+      return `${target} = ${prefixedTypeName}(json: ${input})`;
+    },
+    toJsonTemplate(input, target) {
+      const mainContent = `${target} += ${input}${isNullable ? "!" : ""}.toJSONString()`;
+      if (schema.nullable) {
+        return `if ${input} != nil {
+                    ${mainContent}
+                } else {
+                    ${target} += "null"
+                }`;
+      }
+      return mainContent;
+    },
+    toQueryPartTemplate(_, __, ___) {
+      return `print("[WARNING] nested objects cannot be serialized to query params. Skipping field at ${context.instancePath}.")`;
+    },
+    cloneTemplate(input, _) {
+      return {
+        bodyContent: "",
+        fieldContent: `${input}${isNullable ? "?" : ""}.clone()`
+      };
+    },
+    content: ""
+  };
+}
+
+const swiftClientGenerator = codegenUtils.defineGeneratorPlugin(
+  (options) => {
+    return {
+      async generator(def, _isDevServer) {
+        const content = createSwiftClient(def, options);
+        fs__default.writeFileSync(options.outputFile, content, "utf8");
+      },
+      options
+    };
+  }
+);
+function createSwiftClient(def, options) {
+  const context = {
+    clientVersion: def.info?.version ?? "",
+    clientName: options.clientName,
+    typePrefix: options.typePrefix ?? "",
+    instancePath: "",
+    schemaPath: "",
+    generatedTypes: [],
+    containsRequiredRef: {}
+  };
+  const services = codegenUtils.unflattenProcedures(def.procedures);
+  const mainService = swiftServiceFromSchema(services, context);
+  const typeContent = [];
+  for (const key of Object.keys(def.definitions)) {
+    const subSchema = def.definitions[key];
+    const subType = swiftTypeFromSchema(subSchema, {
+      clientVersion: context.clientVersion,
+      clientName: context.clientName,
+      typePrefix: context.typePrefix,
+      instancePath: `/${key}`,
+      schemaPath: `/${key}`,
+      generatedTypes: context.generatedTypes,
+      containsRequiredRef: context.containsRequiredRef
+    });
+    if (subType.content) {
+      typeContent.push(subType.content);
+    }
+  }
+  return `import Foundation
+import ArriClient
+
+${mainService}
+${typeContent.join("\n")}`;
+}
+function swiftTypeFromSchema(schema, context) {
+  if (codegenUtils.isSchemaFormType(schema)) {
+    switch (schema.type) {
+      case "string":
+        return swiftStringFromSchema(schema, context);
+      case "boolean":
+        return swiftBooleanFromSchema(schema, context);
+      case "timestamp":
+        return swiftTimestampFromSchema(schema, context);
+      case "float32":
+        return swiftNumberFromSchema(
+          schema,
+          context,
+          "Float32",
+          "float",
+          "0.0"
+        );
+      case "float64":
+        return swiftNumberFromSchema(
+          schema,
+          context,
+          "Float64",
+          "double",
+          "0.0"
+        );
+      case "int8":
+        return swiftNumberFromSchema(
+          schema,
+          context,
+          "Int8",
+          "int8",
+          "0"
+        );
+      case "uint8":
+        return swiftNumberFromSchema(
+          schema,
+          context,
+          "UInt8",
+          "uInt8",
+          "0"
+        );
+      case "int16":
+        return swiftNumberFromSchema(
+          schema,
+          context,
+          "Int16",
+          "int16",
+          "0"
+        );
+      case "uint16":
+        return swiftNumberFromSchema(
+          schema,
+          context,
+          "UInt16",
+          "uInt16",
+          "0"
+        );
+      case "int32":
+        return swiftNumberFromSchema(
+          schema,
+          context,
+          "Int32",
+          "int32",
+          "0"
+        );
+      case "uint32":
+        return swiftNumberFromSchema(
+          schema,
+          context,
+          "UInt32",
+          "uInt32",
+          "0"
+        );
+      case "int64":
+        return swiftLargeIntFromSchema(schema, context, "Int64");
+      case "uint64":
+        return swiftLargeIntFromSchema(schema, context, "UInt64");
+      default:
+        schema.type;
+        break;
+    }
+  }
+  if (codegenUtils.isSchemaFormEnum(schema)) {
+    return swiftEnumFromSchema(schema, context);
+  }
+  if (codegenUtils.isSchemaFormProperties(schema)) {
+    return swiftObjectFromSchema(schema, context);
+  }
+  if (codegenUtils.isSchemaFormElements(schema)) {
+    return swiftArrayFromSchema(schema, context);
+  }
+  if (codegenUtils.isSchemaFormValues(schema)) {
+    return swiftDictionaryFromSchema(schema, context);
+  }
+  if (codegenUtils.isSchemaFormDiscriminator(schema)) {
+    return swiftTaggedUnionFromSchema(schema, context);
+  }
+  if (codegenUtils.isSchemaFormRef(schema)) {
+    return swiftRefFromSchema(schema, context);
+  }
+  return swiftAnyFromSchema(schema, context);
+}
+
+exports.createSwiftClient = createSwiftClient;
+exports.swiftClientGenerator = swiftClientGenerator;
+exports.swiftTypeFromSchema = swiftTypeFromSchema;