@azure-tools/typespec-ts 0.47.1 → 0.48.0-alpha.20260108.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@azure-tools/typespec-ts",
-  "version": "0.47.1",
+  "version": "0.48.0-alpha.20260108.1",
   "description": "An experimental TypeSpec emitter for TypeScript RLC",
   "main": "dist/src/index.js",
   "type": "module",
@@ -26,7 +26,7 @@
     "@azure-tools/typespec-autorest": "^0.63.0",
     "@azure-tools/typespec-azure-core": "^0.63.0",
     "@azure-tools/typespec-azure-resource-manager": "^0.63.0",
-    "@azure-tools/typespec-client-generator-core": "^0.63.0",
+    "@azure-tools/typespec-client-generator-core": "^0.63.3",
     "@azure/abort-controller": "^2.1.2",
     "@azure/core-auth": "^1.6.0",
     "@azure/core-lro": "^3.1.0",
@@ -65,7 +65,7 @@
   },
   "peerDependencies": {
     "@azure-tools/typespec-azure-core": "^0.63.0",
-    "@azure-tools/typespec-client-generator-core": "^0.63.0",
+    "@azure-tools/typespec-client-generator-core": "^0.63.3",
     "@typespec/compiler": "^1.7.0",
     "@typespec/http": "^1.7.0",
     "@typespec/rest": "^0.77.0",
@@ -73,7 +73,7 @@
     "@typespec/xml": "^0.77.0"
   },
   "dependencies": {
-    "@azure-tools/rlc-common": "^0.47.1",
+    "@azure-tools/rlc-common": "0.48.0-alpha.20260108.1",
     "fs-extra": "^11.1.0",
     "lodash": "^4.17.21",
     "prettier": "^3.3.3",

package/src/index.ts

@@ -258,7 +258,10 @@ export async function $onEmit(context: EmitContext) {
     for (const client of clients) {
       const rlcModels = await transformRLCModel(client, dpgContext);
       rlcCodeModels.push(rlcModels);
-      serviceNameToRlcModelsMap.set(client.service.name, rlcModels);
+      const serviceName = Array.isArray(client.service)
+        ? (client.service[0]?.name ?? "Unknown")
+        : client.service.name;
+      serviceNameToRlcModelsMap.set(serviceName, rlcModels);
       needUnexpectedHelper.set(
         getClientName(rlcModels),
         hasUnexpectedHelper(rlcModels)

package/src/lib.ts

@@ -54,7 +54,7 @@ export interface EmitterOptions {
   "azure-arm"?: boolean;
   "source-from"?: "TypeSpec" | "Swagger";
   "is-modular-library"?: boolean;
-  "module-kind"?: "esm" | "cjs";
+  "module-kind"?: "esm";
   "enable-operation-group"?: boolean;
   flavor?: PackageFlavor;
   "enable-model-namespace"?: boolean;
@@ -272,7 +272,7 @@ export const RLCOptionsSchema: JSONSchemaType<EmitterOptions> = {
     "module-kind": {
       type: "string",
       nullable: true,
-      enum: ["esm", "cjs"],
+      enum: ["esm"],
       default: "esm",
       description: "Internal option for test."
     },
@@ -608,6 +608,12 @@ const libDef = {
       messages: {
         default: paramMessage`Model name conflict detected: "${"modelName"}" exists in multiple namespaces: ${"namespaces"}. Please use @clientName to rename them.`
       }
+    },
+    "un-supported-array-encoding": {
+      severity: "warning",
+      messages: {
+        default: paramMessage`The array property "${"arrayName"}" of ${"arrayType"} type is not supported for encoding and will be ignored.`
+      }
     }
   },
   emitter: {

package/src/modular/emitModels.ts

@@ -670,7 +670,7 @@ export function normalizeModelName(
     : "";
   const internalModelPrefix =
     isPagedResultModel(context, type) || type.isGeneratedName ? "_" : "";
-  return `${internalModelPrefix}${normalizeName(namespacePrefix + type.name + unionSuffix, nameType, true)}`;
+  return `${internalModelPrefix}${normalizeName(namespacePrefix + type.name, nameType, true)}${unionSuffix}`;
 }
 
 function buildModelPolymorphicType(context: SdkContext, type: SdkModelType) {

package/src/modular/emitSamples.ts

@@ -571,12 +571,19 @@ function getParameterValue(
         }
         let propRetValue;
 
-        if (property?.flatten && property.type.kind === "model") {
+        if (
+          property?.flatten &&
+          property.type.kind === "model" &&
+          options?.overrides?.enableFlatten !== false
+        ) {
+          // For flatten property, we need to recursively get its properties
+          // but disable further flattening to match the TypeScript interface structure
           const paramValue = getParameterValue(context, propValue, {
             overrides: {
               propertyRenames:
                 useContext("sdkTypes").flattenProperties.get(property)
-                  ?.conflictMap
+                  ?.conflictMap,
+              enableFlatten: false
             }
           });
           propRetValue =
@@ -584,7 +591,7 @@ function getParameterValue(
         } else {
           propRetValue =
             `"${mapper.get(propName) ?? propName}": ` +
-            getParameterValue(context, propValue);
+            getParameterValue(context, propValue, options);
         }
         if (propRetValue) values.push(propRetValue);
       }

package/src/modular/helpers/operationHelpers.ts

@@ -21,7 +21,10 @@ import {
   getCollectionFormatHelper,
   hasCollectionFormatInfo,
   isBinaryPayload,
-  ServiceOperation
+  ServiceOperation,
+  getCollectionFormatParseHelper,
+  getCollectionFormatFromArrayEncoding,
+  KnownCollectionFormat
 } from "../../utils/operationUtil.js";
 import {
   getPropertyWithOverrides,
@@ -245,6 +248,7 @@ export function getDeserializePrivateFunction(
           context,
           deserializedType,
           deserializedRoot,
+          true,
           isBinaryPayload(context, response.type!.__raw!, contentTypes!)
             ? "binary"
             : getEncodeForType(deserializedType)
@@ -856,6 +860,7 @@ function buildBodyParameter(
     isBinaryPayload(context, bodyParameter.__raw!, bodyParameter.contentTypes)
       ? "binary"
       : getEncodeForType(bodyParameter.type),
+    undefined,
     true
   );
   return `\nbody: ${serializedBody.startsWith(nullOrUndefinedPrefix) ? "" : nullOrUndefinedPrefix}${serializedBody},`;
@@ -884,7 +889,7 @@ export function getParameterMap(
   }
 
   if (hasCollectionFormatInfo(param.kind, (param as any).collectionFormat)) {
-    return getCollectionFormat(context, param, optionalParamName);
+    return getCollectionFormatForParam(context, param, optionalParamName);
   }
 
   // if the parameter or property is optional, we don't need to handle the default value
@@ -909,39 +914,22 @@ export function getParameterMap(
   return `"${param.name}": undefined`;
 }
 
-function getCollectionFormat(
+function getCollectionFormatForParam(
   context: SdkContext,
   param: SdkHttpParameter,
   optionalParamName: string = "options"
 ) {
   const serializedName = getPropertySerializedName(param);
   const format = (param as any).collectionFormat;
-  const collectionInfo = getCollectionFormatHelper(param.kind, format ?? "");
-  if (!collectionInfo) {
-    throw "Has collection format info but without helper function detected";
-  }
-  const isMulti = format.toLowerCase() === "multi";
-  const additionalParam = isMulti ? `, "${serializedName}"` : "";
-  if (!param.optional) {
-    return `"${serializedName}": ${collectionInfo}(${serializeRequestValue(
-      context,
-      param.type,
-      param.name,
-      true,
-      getEncodeForType(param.type),
-      true
-    )}${additionalParam})`;
-  }
-  return `"${serializedName}": ${optionalParamName}?.${
-    param.name
-  } !== undefined ? ${collectionInfo}(${serializeRequestValue(
+  return `"${serializedName}": ${serializeRequestValue(
     context,
     param.type,
-    `${optionalParamName}?.${param.name}`,
-    false,
-    getEncodeForType(param.type),
+    param.optional ? `${optionalParamName}?.${param.name}` : param.name,
+    !param.optional,
+    format,
+    serializedName,
     true
-  )}${additionalParam}): undefined`;
+  )}`;
 }
 
 function isContentType(param: SdkHttpParameter): boolean {
@@ -992,6 +980,7 @@ function getRequired(context: SdkContext, param: SdkHttpParameter) {
     clientValue,
     true,
     getEncodeForType(param.type),
+    serializedName,
     true
   )}`;
 }
@@ -1033,6 +1022,7 @@ function getOptional(
     paramName,
     false,
     getEncodeForType(param.type),
+    serializedName,
     true
   )}`;
 }
@@ -1172,6 +1162,41 @@ function getNullableCheck(name: string, type: SdkType) {
   return `${name} === null ? null :`;
 }
 
+/**
+ * Determines the appropriate encoding format for a model property, especially for arrays with collection format encoding.
+ * For example, returns "csv" for comma-delimited arrays or the property's type encoding for regular properties.
+ */
+function getEncodeForModelProperty(
+  context: SdkContext,
+  property: SdkModelPropertyType
+): string | undefined {
+  if (property.encode && property.type.kind === "array") {
+    // Only arrays of string type can have collectionFormat encoding
+    if (property.type.valueType.kind !== "string") {
+      reportDiagnostic(context.program, {
+        code: "un-supported-array-encoding",
+        format: {
+          arrayName: property.name,
+          arrayType: property.type.valueType.kind
+        },
+        target: NoTarget
+      });
+      return getEncodeForType(property.type);
+    }
+
+    const collectionFormat = getCollectionFormatFromArrayEncoding(
+      property.encode
+    );
+    if (
+      collectionFormat &&
+      hasCollectionFormatInfo(property.kind, collectionFormat)
+    ) {
+      return collectionFormat;
+    }
+  }
+  return getEncodeForType(property.type);
+}
+
 function getSerializationExpressionForFlatten(
   context: SdkContext,
   property: SdkModelPropertyType,
@@ -1194,9 +1219,6 @@ function getSerializationExpressionForFlatten(
       !isReadOnly(p) &&
       !isMetadata(context.program, p.__raw!)
   );
-  if (validProps.length === 0) {
-    return `undefined`;
-  }
   const optionalPrefix = property.optional
     ? `${resolveReference(SerializationHelpers.areAllPropsUndefined)}(${propertyPath}, [${validProps
         .map((p) => `"${p.name}"`)
@@ -1245,7 +1267,8 @@ export function getSerializationExpression(
       property.type,
       propertyFullName,
       !property.optional,
-      getEncodeForType(property.type),
+      getEncodeForModelProperty(context, property),
+      getPropertySerializedName(property),
       propertyPath === "" ? true : false
     );
   }
@@ -1373,20 +1396,17 @@ export function getResponseMapping(
         context,
         property.type,
         `${propertyPath}${dot}["${serializedName}"]`,
-        getEncodeForType(property.type)
-      );
-      props.push(
-        `${propertyName}: ${deserializeValue === `${propertyPath}${dot}["${serializedName}"]` ? "" : nullOrUndefinedPrefix}${deserializeValue}`
+        !property.optional,
+        getEncodeForModelProperty(context, property)
       );
+      props.push(`${propertyName}: ${deserializeValue}`);
     }
   }
   return props;
 }
 
 /**
- * This function helps converting strings into JS complex types recursively.
- * We need to drill down into Array elements to make sure that the element type is
- * deserialized correctly
+ * Converts JavaScript values to their serialized wire format for HTTP requests.
  */
 export function serializeRequestValue(
   context: SdkContext,
@@ -1394,6 +1414,7 @@ export function serializeRequestValue(
   clientValue: string,
   required: boolean,
   format?: string,
+  serializedName?: string,
   isTopLevel: boolean = false
 ): string {
   const getSdkType = useSdkTypes();
@@ -1414,8 +1435,8 @@ export function serializeRequestValue(
           return `${nullOrUndefinedPrefix}${clientValue}.toISOString()`;
       }
     case "array": {
-      const prefix = nullOrUndefinedPrefix + clientValue;
       if (type.valueType) {
+        const prefix = nullOrUndefinedPrefix + clientValue;
         const elementNullOrUndefinedPrefix =
           isTypeNullable(type.valueType) || getOptionalForType(type.valueType)
             ? "!p ? p : "
@@ -1435,7 +1456,17 @@ export function serializeRequestValue(
         ) {
           return `${prefix}.map((p: any) => { return ${elementNullOrUndefinedPrefix}p})`;
         } else {
-          return `${prefix}.map((p: any) => { return ${elementNullOrUndefinedPrefix}${serializeRequestValue(context, type.valueType, "p", true, getEncodeForType(type.valueType))}})`;
+          const serializedValue = `${clientValue}.map((p: any) => { return ${elementNullOrUndefinedPrefix}${serializeRequestValue(context, type.valueType, "p", true, getEncodeForType(type.valueType))}})`;
+          if (format) {
+            const formatHelper = getCollectionFormatHelper(format);
+            if (formatHelper) {
+              if (format?.toLowerCase() === KnownCollectionFormat.Multi) {
+                return `${nullOrUndefinedPrefix}${formatHelper}(${serializedValue}, "${serializedName}")`;
+              }
+              return `${nullOrUndefinedPrefix}${formatHelper}(${serializedValue})`;
+            }
+          }
+          return `${nullOrUndefinedPrefix}${serializedValue}`;
         }
       }
       return clientValue;
@@ -1507,14 +1538,16 @@ export function deserializeResponseValue(
   context: SdkContext,
   type: SdkType,
   restValue: string,
-  format?: string
+  required: boolean,
+  format?: string,
+  recursionDepth: number = 0
 ): string {
   const dependencies = useDependencies();
   const stringToUint8ArrayReference = resolveReference(
     dependencies.stringToUint8Array
   );
   const nullOrUndefinedPrefix =
-    isTypeNullable(type) || getOptionalForType(type)
+    isTypeNullable(type) || getOptionalForType(type) || !required
       ? `!${restValue}? ${restValue}: `
       : "";
   switch (type.kind) {
@@ -1522,12 +1555,13 @@ export function deserializeResponseValue(
       return `${nullOrUndefinedPrefix} new Date(${type.encode === "unixTimestamp" ? `${restValue} * 1000` : restValue})`;
     case "array": {
       const prefix = nullOrUndefinedPrefix + restValue;
+      const varName = recursionDepth > 0 ? `p${recursionDepth}` : "p";
       let elementNullOrUndefinedPrefix = "";
       if (
         type.valueType &&
         (isTypeNullable(type.valueType) || getOptionalForType(type.valueType))
       ) {
-        elementNullOrUndefinedPrefix = "!p ? p :";
+        elementNullOrUndefinedPrefix = `!${varName} ? ${varName} :`;
       }
       const deserializeFunctionName = type.valueType
         ? buildModelDeserializer(
@@ -1540,26 +1574,38 @@ export function deserializeResponseValue(
           )
         : undefined;
       if (deserializeFunctionName) {
-        return `${prefix}.map((p: any) => { return ${elementNullOrUndefinedPrefix}${deserializeFunctionName}(p)})`;
+        return `${prefix}.map((${varName}: any) => { return ${elementNullOrUndefinedPrefix}${deserializeFunctionName}(${varName})})`;
       } else if (
         type.valueType &&
         isAzureCoreErrorType(context.program, type.valueType.__raw)
       ) {
-        return `${prefix}.map((p: any) => { return ${elementNullOrUndefinedPrefix}p})`;
+        return `${prefix}.map((${varName}: any) => { return ${elementNullOrUndefinedPrefix}${varName}})`;
       } else if (type.valueType) {
-        return `${prefix}.map((p: any) => { return ${elementNullOrUndefinedPrefix}${deserializeResponseValue(context, type.valueType, "p", getEncodeForType(type.valueType))}})`;
+        if (format) {
+          const parseHelper = getCollectionFormatParseHelper(format);
+          if (parseHelper) {
+            // We shouldn't check for an empty string here since an empty string should be parsed as an empty array
+            const optionalPrefixForString =
+              isTypeNullable(type) || getOptionalForType(type) || !required
+                ? `${restValue} === null || ${restValue} === undefined ? ${restValue}: `
+                : "";
+            return `${optionalPrefixForString}${parseHelper}(${restValue})`;
+          }
+        }
+        return `${prefix}.map((${varName}: any) => { return ${elementNullOrUndefinedPrefix}${deserializeResponseValue(context, type.valueType, varName, true, getEncodeForType(type.valueType), recursionDepth + 1)}})`;
       } else {
         return restValue;
       }
     }
     case "dict": {
-      const prefix = nullOrUndefinedPrefix + restValue;
+      const keyVar = recursionDepth > 0 ? `k${recursionDepth}` : "k";
+      const valueVar = recursionDepth > 0 ? `p${recursionDepth}` : "p";
       let elementNullOrUndefinedPrefix = "";
       if (
         type.valueType &&
         (isTypeNullable(type.valueType) || getOptionalForType(type.valueType))
       ) {
-        elementNullOrUndefinedPrefix = "!p ? p :";
+        elementNullOrUndefinedPrefix = `!${valueVar} ? ${valueVar} :`;
       }
       const deserializeFunctionName = type.valueType
         ? buildModelDeserializer(
@@ -1572,21 +1618,21 @@ export function deserializeResponseValue(
           )
         : undefined;
       if (deserializeFunctionName) {
-        return `Object.fromEntries(Object.entries(${prefix}).map(([k, p]: [string, any]) => [k, ${elementNullOrUndefinedPrefix}${deserializeFunctionName}(p)]))`;
+        return `${nullOrUndefinedPrefix}Object.fromEntries(Object.entries(${restValue}).map(([${keyVar}, ${valueVar}]: [string, any]) => [${keyVar}, ${elementNullOrUndefinedPrefix}${deserializeFunctionName}(${valueVar})]))`;
       } else if (
         type.valueType &&
         isAzureCoreErrorType(context.program, type.valueType.__raw)
       ) {
-        return `Object.fromEntries(Object.entries(${prefix}).map(([k, p]: [string, any]) => [k, ${elementNullOrUndefinedPrefix}p]))`;
+        return `${nullOrUndefinedPrefix}Object.fromEntries(Object.entries(${restValue}).map(([${keyVar}, ${valueVar}]: [string, any]) => [${keyVar}, ${elementNullOrUndefinedPrefix}${valueVar}]))`;
       } else if (type.valueType) {
-        return `Object.fromEntries(Object.entries(${prefix}).map(([k, p]: [string, any]) => [k, ${elementNullOrUndefinedPrefix}${deserializeResponseValue(context, type.valueType, "p", getEncodeForType(type.valueType))}]))`;
+        return `${nullOrUndefinedPrefix}Object.fromEntries(Object.entries(${restValue}).map(([${keyVar}, ${valueVar}]: [string, any]) => [${keyVar}, ${elementNullOrUndefinedPrefix}${deserializeResponseValue(context, type.valueType, valueVar, true, getEncodeForType(type.valueType), recursionDepth + 1)}]))`;
       } else {
         return restValue;
       }
     }
     case "bytes":
       if (format !== "binary" && format !== "bytes") {
-        return `typeof ${restValue} === 'string'
+        return `${nullOrUndefinedPrefix}typeof ${restValue} === 'string'
         ? ${stringToUint8ArrayReference}(${restValue}, "${format ?? "base64"}")
         : ${restValue}`;
       }
@@ -1616,7 +1662,9 @@ export function deserializeResponseValue(
         context,
         type.type,
         restValue,
-        getEncodeForType(type.type)
+        false,
+        getEncodeForType(type.type),
+        recursionDepth + 1
       );
     default:
       return restValue;

package/src/modular/serialization/serializeUtils.ts

@@ -201,6 +201,10 @@ export interface ModelOverrideOptions {
   // The <Property, Client_Name> map for any renamed properties.
   // Mainly because the original client name has collision with other property names during flattening.
   propertyRenames?: Map<SdkModelPropertyType, string>;
+
+  // If true (default), enable flattening for nested flatten properties when generating samples.
+  // When false, nested flatten properties are not further flattened to match the TypeScript interface structure.
+  enableFlatten?: boolean;
 }
 
 export function getPropertyWithOverrides(

package/src/modular/static-helpers-metadata.ts

@@ -24,6 +24,31 @@ export const SerializationHelpers = {
     name: "buildTsvCollection",
     location: "serialization/build-tsv-collection.ts"
   },
+  buildNewlineCollection: {
+    kind: "function",
+    name: "buildNewlineCollection",
+    location: "serialization/build-newline-collection.ts"
+  },
+  parseCsvCollection: {
+    kind: "function",
+    name: "parseCsvCollection",
+    location: "serialization/parse-csv-collection.ts"
+  },
+  parsePipeCollection: {
+    kind: "function",
+    name: "parsePipeCollection",
+    location: "serialization/parse-pipe-collection.ts"
+  },
+  parseSsvCollection: {
+    kind: "function",
+    name: "parseSsvCollection",
+    location: "serialization/parse-ssv-collection.ts"
+  },
+  parseNewlineCollection: {
+    kind: "function",
+    name: "parseNewlineCollection",
+    location: "serialization/parse-newline-collection.ts"
+  },
   serializeRecord: {
     kind: "function",
     name: "serializeRecord",

package/src/utils/clientUtils.ts

@@ -20,7 +20,14 @@ import { NameType, normalizeName } from "@azure-tools/rlc-common";
 
 export function getRLCClients(dpgContext: SdkContext): SdkClient[] {
   const services = new Set<Namespace>();
-  listClients(dpgContext).forEach((c) => services.add(c.service));
+  listClients(dpgContext).forEach((c) => {
+    const clientService = c.service;
+    if (Array.isArray(clientService)) {
+      clientService.forEach((ns) => services.add(ns));
+    } else {
+      services.add(clientService);
+    }
+  });
   const rawServiceNamespaces = listAllServiceNamespaces(dpgContext);
   if (services.size === 0 && rawServiceNamespaces.length > 0) {
     // If no clients are found, fall back to raw service namespaces
@@ -45,7 +52,10 @@ export function getRLCClients(dpgContext: SdkContext): SdkClient[] {
 
 export function listOperationsUnderRLCClient(client: SdkClient): Operation[] {
   const operations = [];
-  const queue: (Namespace | Interface)[] = [client.service];
+  const serviceArray = Array.isArray(client.service)
+    ? client.service
+    : [client.service];
+  const queue: (Namespace | Interface)[] = [...serviceArray];
   while (queue.length > 0) {
     const current = queue.shift()!;
     if (
@@ -55,7 +65,7 @@ export function listOperationsUnderRLCClient(client: SdkClient): Operation[] {
           getNamespaceFullName(d.definition?.namespace) ===
             "Azure.ClientGenerator.Core"
       ) &&
-      current !== client.service
+      !serviceArray.includes(current as Namespace)
     ) {
       continue;
     }

package/src/utils/operationUtil.ts

@@ -461,7 +461,8 @@ export function hasCollectionFormatInfo(
     getHasSsvCollection(paramType, paramFormat) ||
     getHasTsvCollection(paramType, paramFormat) ||
     getHasCsvCollection(paramType, paramFormat) ||
-    getHasPipeCollection(paramType, paramFormat)
+    getHasPipeCollection(paramType, paramFormat) ||
+    getHasNewlineCollection(paramType, paramFormat)
   );
 }
 
@@ -503,50 +504,96 @@ function getHasMultiCollection(
 ) {
   return (
     ((includeQuery && paramType === "query") || paramType === "header") &&
-    paramFormat === "multi"
+    paramFormat === KnownCollectionFormat.Multi
   );
 }
 function getHasSsvCollection(paramType: string, paramFormat: string) {
-  return paramType === "query" && paramFormat === "ssv";
+  return (
+    (paramType === "query" || paramType === "property") &&
+    paramFormat === KnownCollectionFormat.Ssv
+  );
 }
 
 function getHasTsvCollection(paramType: string, paramFormat: string) {
-  return paramType === "query" && paramFormat === "tsv";
+  return paramType === "query" && paramFormat === KnownCollectionFormat.Tsv;
 }
 
 function getHasCsvCollection(paramType: string, paramFormat: string) {
-  return paramType === "header" && paramFormat === "csv";
+  return (
+    (paramType === "header" || paramType === "property") &&
+    paramFormat === KnownCollectionFormat.Csv
+  );
 }
 
 function getHasPipeCollection(paramType: string, paramFormat: string) {
-  return paramType === "query" && paramFormat === "pipes";
+  return (
+    (paramType === "query" || paramType === "property") &&
+    paramFormat === KnownCollectionFormat.Pipes
+  );
 }
 
-export function getCollectionFormatHelper(
-  paramType: string,
-  paramFormat: string
-) {
-  if (getHasMultiCollection(paramType, paramFormat, false)) {
-    return resolveReference(SerializationHelpers.buildMultiCollection);
-  }
-
-  if (getHasPipeCollection(paramType, paramFormat)) {
-    return resolveReference(SerializationHelpers.buildPipeCollection);
-  }
+function getHasNewlineCollection(paramType: string, paramFormat: string) {
+  return (
+    paramType === "property" && paramFormat === KnownCollectionFormat.Newline
+  );
+}
 
-  if (getHasSsvCollection(paramType, paramFormat)) {
-    return resolveReference(SerializationHelpers.buildSsvCollection);
+export function getCollectionFormatHelper(format: string) {
+  switch (format) {
+    case KnownCollectionFormat.Multi:
+      return resolveReference(SerializationHelpers.buildMultiCollection);
+    case KnownCollectionFormat.Pipes:
+      return resolveReference(SerializationHelpers.buildPipeCollection);
+    case KnownCollectionFormat.Ssv:
+      return resolveReference(SerializationHelpers.buildSsvCollection);
+    case KnownCollectionFormat.Tsv:
+      return resolveReference(SerializationHelpers.buildTsvCollection);
+    case KnownCollectionFormat.Csv:
+      return resolveReference(SerializationHelpers.buildCsvCollection);
+    case KnownCollectionFormat.Newline:
+      return resolveReference(SerializationHelpers.buildNewlineCollection);
+    default:
+      return undefined;
   }
+}
 
-  if (getHasTsvCollection(paramType, paramFormat)) {
-    return resolveReference(SerializationHelpers.buildTsvCollection);
+export function getCollectionFormatParseHelper(format: string) {
+  switch (format) {
+    case KnownCollectionFormat.Pipes:
+      return resolveReference(SerializationHelpers.parsePipeCollection);
+    case KnownCollectionFormat.Ssv:
+      return resolveReference(SerializationHelpers.parseSsvCollection);
+    case KnownCollectionFormat.Csv:
+      return resolveReference(SerializationHelpers.parseCsvCollection);
+    case KnownCollectionFormat.Newline:
+      return resolveReference(SerializationHelpers.parseNewlineCollection);
+    default:
+      return undefined;
   }
+}
 
-  if (getHasCsvCollection(paramType, paramFormat)) {
-    return resolveReference(SerializationHelpers.buildCsvCollection);
+export function getCollectionFormatFromArrayEncoding(encoding: string) {
+  switch (encoding) {
+    case "pipeDelimited":
+      return KnownCollectionFormat.Pipes;
+    case "spaceDelimited":
+      return KnownCollectionFormat.Ssv;
+    case "commaDelimited":
+      return KnownCollectionFormat.Csv;
+    case "newlineDelimited":
+      return KnownCollectionFormat.Newline;
+    default:
+      return undefined;
   }
+}
 
-  return undefined;
+export enum KnownCollectionFormat {
+  Csv = "csv",
+  Ssv = "ssv",
+  Tsv = "tsv",
+  Pipes = "pipes",
+  Newline = "newline",
+  Multi = "multi"
 }
 
 export function getCustomRequestHeaderNameForOperation(

package/static/static-helpers/serialization/build-newline-collection.ts

@@ -0,0 +1,3 @@
+export function buildNewlineCollection(items: string[] | number[]): string {
+  return items.join("\n");
+}