@azure-tools/typespec-ts 0.55.0-dev.1 → 0.55.0-dev.10

package/src/utils/modelUtils.ts

@@ -1,1737 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-
-import { getUnionAsEnum } from "@azure-tools/typespec-azure-core";
-import {
-  getDefaultApiVersion,
-  getWireName,
-  isApiVersion,
-} from "@azure-tools/typespec-client-generator-core";
-import {
-  Discriminator,
-  EncodeData,
-  Enum,
-  EnumMember,
-  Model,
-  ModelProperty,
-  NoTarget,
-  Program,
-  Scalar,
-  Service,
-  Type,
-  Union,
-  UnionVariant,
-  Value,
-  getDiscriminator,
-  getDoc,
-  getEffectiveModelType,
-  getEncode,
-  getFormat,
-  getFriendlyName,
-  getLifecycleVisibilityEnum,
-  getMaxLength,
-  getMaxValue,
-  getMinLength,
-  getMinValue,
-  getPattern,
-  getProperty,
-  getPropertyType,
-  getSummary,
-  getVisibilityForClass,
-  isArrayModelType,
-  isNeverType,
-  isNullType,
-  isNumericType,
-  isRecordModelType,
-  isSecret,
-  isStringType,
-  isTemplateDeclaration,
-  isUnknownType,
-  listServices,
-} from "@typespec/compiler";
-import {
-  HttpOperation,
-  HttpOperationHeaderParameter,
-  HttpOperationParameters,
-  HttpOperationPathParameter,
-  HttpOperationQueryParameter,
-  Visibility,
-  getHeaderFieldName,
-  getHttpFileModel,
-  getHttpPart,
-  getPathParamName,
-  getQueryParamName,
-  isBody,
-  isStatusCode,
-} from "@typespec/http";
-import {
-  ArraySchema,
-  DictionarySchema,
-  NameType,
-  ObjectSchema,
-  Schema,
-  SchemaContext,
-  isArraySchema,
-  normalizeName,
-} from "../rlc-common/index.js";
-import { GetSchemaOptions, SdkContext } from "./interfaces.js";
-import { KnownMediaType, hasMediaType, isMediaTypeMultipartFormData } from "./mediaTypes.js";
-
-import { reportDiagnostic } from "../lib.js";
-import { getModelNamespaceName } from "./namespaceUtils.js";
-
-export const BINARY_TYPE_UNION =
-  "string | Uint8Array | ReadableStream<Uint8Array> | NodeReadableStream";
-
-export const BINARY_AND_FILE_TYPE_UNION = `${BINARY_TYPE_UNION} | File`;
-
-export function getBinaryType(usage: SchemaContext[]) {
-  return usage.includes(SchemaContext.Output) ? "Uint8Array" : BINARY_TYPE_UNION;
-}
-
-export function isByteOrByteUnion(dpgContext: SdkContext, type: Type) {
-  const schema = getSchemaForType(dpgContext, type);
-  return isBytesType(schema) || isBytesUnion(schema);
-}
-
-function isBytesType(schema: any) {
-  return schema.type === "string" && (schema.format === "bytes" || schema.format === "binary");
-}
-
-function isBytesUnion(schema: any) {
-  if (!Array.isArray(schema.enum)) {
-    return false;
-  }
-  for (const ele of schema.enum) {
-    if (isBytesType(ele)) {
-      return true;
-    }
-  }
-  return false;
-}
-
-function refineByteType(schema: any) {
-  schema.typeName = getBinaryType([SchemaContext.Input, SchemaContext.Exception]);
-  schema.outputTypeName = getBinaryType([SchemaContext.Output]);
-  return schema;
-}
-
-export function enrichBinaryTypeInBody(schema: any) {
-  if (isBytesType(schema)) {
-    refineByteType(schema);
-  } else if (isBytesUnion(schema)) {
-    const inputType: string[] = [];
-    for (const item of schema.enum) {
-      if (isBytesType(item)) {
-        refineByteType(item);
-      }
-      // ignore the string type for input because we already have it in bytes union
-      if (getTypeName(item, [SchemaContext.Input]) !== "string") {
-        inputType.push(getTypeName(item, [SchemaContext.Input]));
-      }
-    }
-    // refine the input type
-    schema.typeName = inputType.join(" | ");
-  }
-  return schema;
-}
-
-export function getSchemaForType(
-  dpgContext: SdkContext,
-  typeInput: Type,
-  options?: GetSchemaOptions,
-): any {
-  const program = dpgContext.program;
-  const { usage } = options ?? {};
-  const type = getEffectiveModelFromType(dpgContext, typeInput);
-
-  const builtinType = getSchemaForLiteral(type);
-  if (builtinType !== undefined) {
-    // add in description elements for types derived from primitive types (SecureString, etc.)
-    const doc = getDoc(program, type);
-    if (doc) {
-      builtinType.description = doc;
-    }
-    return builtinType;
-  }
-
-  if (type.kind === "ModelProperty") {
-    return getSchemaForType(dpgContext, type.type, options);
-  }
-
-  if (type.kind === "Model") {
-    const httpPart = getHttpPart(program, type);
-    if (httpPart) {
-      const fileModel = getHttpFileModel(program, httpPart.type);
-      if (fileModel) {
-        const schema: any = getSchemaForType(dpgContext, fileModel.contents, options);
-        return {
-          ...schema,
-          multipartOptions: {
-            filenameSchema: {
-              required: !fileModel.filename.optional,
-              ...getSchemaForType(dpgContext, fileModel.filename, options),
-            },
-            contentTypeSchema: {
-              required: !fileModel.contentType.optional,
-              ...getSchemaForType(dpgContext, fileModel.contentType, options),
-            },
-          },
-        };
-      } else {
-        // extract body if required
-        const body =
-          (httpPart.type.kind === "Model" &&
-            [...httpPart.type.properties.values()].find((x) => isBody(program, x))) ||
-          httpPart.type;
-        return getSchemaForType(dpgContext, body, options);
-      }
-    }
-
-    const schema = getSchemaForModel(dpgContext, type, options) as any;
-    if (isAnonymousObjectSchema(schema)) {
-      if (Object.keys(schema.properties ?? {}).length === 0) {
-        // Handle empty anonymous model as Record
-        schema.typeName = schema.type === "object" ? "Record<string, unknown>" : "unknown";
-        if (usage && usage.includes(SchemaContext.Output)) {
-          schema.outputTypeName = schema.type === "object" ? "Record<string, any>" : "any";
-        }
-        schema.type = "unknown";
-      } else {
-        // Handle non-empty anonymous model as inline model
-        if (usage && usage.includes(SchemaContext.Output)) {
-          schema.outputTypeName = getModelInlineSigniture(schema, {
-            usage: [SchemaContext.Output],
-          });
-        }
-        schema.typeName = getModelInlineSigniture(schema, {
-          usage: [SchemaContext.Input],
-          multipart:
-            options?.isRequestBody && isMediaTypeMultipartFormData(options?.mediaTypes ?? []),
-        });
-        schema.type = "object";
-      }
-    } else if (!isArrayModelType(type) && !isRecordModelType(type)) {
-      if (usage && usage.includes(SchemaContext.Output)) {
-        schema.outputTypeName = `${schema.name}Output`;
-      }
-      schema.typeName = `${schema.name}`;
-    }
-    schema.usage = usage;
-    return schema;
-  } else if (type.kind === "Union") {
-    return getSchemaForUnion(dpgContext, type, options);
-  } else if (type.kind === "UnionVariant") {
-    return getSchemaForUnionVariant(dpgContext, type, options);
-  } else if (type.kind === "Enum") {
-    return getSchemaForEnum(dpgContext, type);
-  } else if (type.kind === "Scalar") {
-    return getSchemaForScalar(dpgContext, type, options);
-  } else if (type.kind === "EnumMember") {
-    return getSchemaForEnumMember(program, type);
-  }
-  if (isUnknownType(type)) {
-    const returnType: any = { name: "unknown", type: "unknown" };
-    if (usage && usage.includes(SchemaContext.Output)) {
-      returnType.outputTypeName = "any";
-      returnType.typeName = "unknown";
-    }
-    return returnType;
-  }
-  if (isNeverType(type)) {
-    return { name: "never", type: "never" };
-  }
-  if (isNullType(type)) {
-    return { name: "null", type: "null" };
-  }
-  if (type.kind === "Intrinsic" && type.name === "void") {
-    return { name: "void", type: "void" };
-  }
-  reportDiagnostic(program, {
-    code: "invalid-schema",
-    format: {
-      type: type.kind,
-      property: options?.relevantProperty?.name ?? "",
-    },
-    target: type,
-  });
-  return undefined;
-}
-export function getEffectiveModelFromType(context: SdkContext, type: Type): Type {
-  /**
-   * If type is an anonymous model, tries to find a named model that has the same
-   * set of properties when non-schema properties are excluded.
-   */
-  if (type.kind === "Model" && type.name === "") {
-    const effective = getEffectiveModelType(context.program, type, (property) =>
-      isSchemaProperty(context.program, property),
-    );
-    if (effective.name) {
-      return effective;
-    }
-  }
-  return type;
-}
-export function includeDerivedModel(model: Model, needRef: boolean = false): boolean {
-  return (
-    !needRef &&
-    !isTemplateDeclaration(model) &&
-    (!model.templateMapper ||
-      !model.templateMapper.args ||
-      model.templateMapper.args?.length === 0 ||
-      model.derivedModels.length > 0)
-  );
-}
-
-function applyEncoding(
-  dpgContext: SdkContext,
-  typespecType: Scalar | ModelProperty,
-  target: any = {},
-) {
-  const encodeData = getEncode(dpgContext.program, typespecType);
-  if (encodeData) {
-    const newTarget = { ...target };
-    const newType = getSchemaForScalar(dpgContext, encodeData.type);
-    newTarget["type"] = newType["type"];
-    newTarget["typeName"] = newType["typeName"];
-    newTarget["outputTypeName"] = newType["outputTypeName"];
-    // If the target already has a format it takes priority. (e.g. int32)
-    newTarget["format"] = mergeFormatAndEncoding(
-      newTarget.format,
-      encodeData.encoding,
-      newType["format"],
-    );
-    return newTarget;
-  }
-  return target;
-}
-
-function mergeFormatAndEncoding(
-  format: string | undefined,
-  encoding: string | undefined,
-  encodeAsFormat: string | undefined,
-): string | undefined {
-  switch (format) {
-    case undefined:
-      return encodeAsFormat ?? encoding ?? format;
-    case "date-time":
-      return encoding;
-    case "duration":
-    default:
-      return encodeAsFormat ?? encoding ?? format;
-  }
-}
-
-function getSchemaForScalar(dpgContext: SdkContext, scalar: Scalar, options?: GetSchemaOptions) {
-  let result = {} as any;
-  const isStd = dpgContext.program.checker.isStdType(scalar);
-  const {
-    relevantProperty,
-    isRequestBody,
-    isParentRequestBody,
-    mediaTypes: contentTypes,
-  } = options ?? {};
-  if (isStd) {
-    result = getSchemaForStdScalar(dpgContext.program, scalar, {
-      relevantProperty,
-    });
-  } else if (scalar.baseScalar) {
-    result = getSchemaForScalar(dpgContext, scalar.baseScalar);
-  }
-
-  if (isBinaryAsRequestBody()) {
-    // bytes in the body of application/octet-stream is the raw binary payload/file
-    result.typeName = BINARY_TYPE_UNION;
-    result.outputTypeName = "Uint8Array";
-    return result;
-  } else if (isFormDataBytesInRequestBody()) {
-    // bytes inside a multipart part (for now) is assumed to be file
-    result.typeName = BINARY_AND_FILE_TYPE_UNION;
-    result.outputTypeName = "Uint8Array";
-    return result;
-  } else {
-    // for other cases we would trust the @encode decorator if not present we would treat it as string
-    const withDecorators = applyEncoding(
-      dpgContext,
-      scalar,
-      result ? applyIntrinsicDecorators(dpgContext.program, scalar, result) : undefined,
-    );
-    if (withDecorators.type === "string" && withDecorators.format === "binary") {
-      withDecorators.typeName = BINARY_TYPE_UNION;
-      withDecorators.outputTypeName = "Uint8Array";
-    }
-    return withDecorators;
-  }
-
-  function isBinaryAsRequestBody() {
-    return (
-      hasMediaType(KnownMediaType.Binary, contentTypes) && isRequestBody && isBytesType(result)
-    );
-  }
-
-  function isFormDataBytesInRequestBody() {
-    return (
-      hasMediaType(KnownMediaType.MultipartFormData, contentTypes) &&
-      isParentRequestBody &&
-      isBytesType(result)
-    );
-  }
-}
-
-function getSchemaForUnion(dpgContext: SdkContext, union: Union, options?: GetSchemaOptions) {
-  const [asEnum, _] = getUnionAsEnum(union);
-  const variants = Array.from(union.variants.values());
-
-  const values = [];
-  let namedUnionMember = false;
-
-  if (!(options?.needRef && union.name && !asEnum)) {
-    if (asEnum?.open && asEnum.members.size > 0) {
-      for (const [_, member] of asEnum.members.entries()) {
-        const memberType = getSchemaForType(dpgContext, member.type, {
-          ...options,
-          needRef: options?.needRef ?? false,
-        });
-        values.push(memberType);
-        if (memberType.name) {
-          namedUnionMember = true;
-        }
-      }
-    } else {
-      for (const variant of variants) {
-        // We already know it's not a model type
-        const variantType = getSchemaForType(dpgContext, variant.type, {
-          ...options,
-          needRef: isAnonymousModelType(variant.type) ? false : true,
-        });
-        values.push(variantType);
-        if (variantType.typeName) {
-          namedUnionMember = true;
-        }
-      }
-    }
-  }
-
-  const schema: any = {};
-  if (values.length > 0) {
-    schema.enum = values;
-    const unionAlias =
-      asEnum?.open && asEnum?.kind && !namedUnionMember
-        ? asEnum.kind + (asEnum.nullable ? " | null" : "")
-        : values.map((item) => `${getTypeName(item, [SchemaContext.Input]) ?? item}`).join(" | ");
-    const outputUnionAlias =
-      asEnum?.open && asEnum?.kind && !namedUnionMember
-        ? asEnum.kind + (asEnum.nullable ? " | null" : "")
-        : values.map((item) => `${getTypeName(item, [SchemaContext.Output]) ?? item}`).join(" | ");
-    schema.alias = unionAlias;
-    schema.outputAlias = outputUnionAlias;
-  }
-  if (!union.expression) {
-    const unionName = union.name ? normalizeName(union.name, NameType.Interface) : undefined;
-    schema.name = unionName;
-    schema.type = "object";
-    schema.typeName = unionName;
-    schema.outputTypeName = unionName + "Output";
-  } else if (union.expression && !union.name) {
-    schema.type = "union";
-    schema.typeName = schema.alias;
-    schema.outputTypeName = schema.outputAlias;
-    delete schema.alias;
-    delete schema.outputAlias;
-  } else {
-    schema.type = "union";
-    schema.typeName = union.name ?? schema.alias;
-    schema.outputTypeName = union.name ? union.name + "Output" : schema.outputAlias;
-    delete schema.alias;
-    delete schema.outputAlias;
-  }
-
-  return schema;
-}
-
-function getSchemaForUnionVariant(
-  dpgContext: SdkContext,
-  variant: UnionVariant,
-  options?: GetSchemaOptions,
-): Schema {
-  return getSchemaForType(dpgContext, variant.type, options);
-}
-
-// An openapi "string" can be defined in several different ways in typespec
-function isOasString(type: Type): boolean {
-  if (type.kind === "String") {
-    // A string literal
-    return true;
-  } else if (type.kind === "Scalar" && type.name === "string") {
-    // string type
-    return true;
-  } else if (type.kind === "Union") {
-    // A union where all variants are an OasString
-    for (const variant of type.variants) {
-      if (!isOasString(variant[1].type)) {
-        return false;
-      }
-    }
-    return true;
-  } else if (type.kind === "UnionVariant") {
-    // A union variant where the type is an OasString
-    return isOasString(type.type);
-  }
-  return false;
-}
-
-function isStringLiteral(type: Type): boolean {
-  if (type.kind === "Union") {
-    // A union where all variants are an OasString
-    for (const variant of type.variants) {
-      if (!isStringLiteral(variant[1].type)) {
-        return false;
-      }
-    }
-    return true;
-  }
-  return (
-    type.kind === "String" ||
-    (type.kind === "EnumMember" && typeof (type.value ?? type.name) === "string") ||
-    (type.kind === "UnionVariant" && type.type.kind === "String")
-  );
-}
-
-// Return any string literal values for type
-function getStringValues(type: Type): string[] {
-  switch (type.kind) {
-    case "String":
-      return [type.value];
-    case "Union":
-      return [...type.variants.values()]
-        .flatMap((x) => getStringValues(x.type))
-        .filter((x) => x !== undefined);
-    case "EnumMember":
-      return typeof type.value !== "number" ? [type.value ?? type.name] : [];
-    case "UnionVariant":
-      return getStringValues(type.type);
-    default:
-      return [];
-  }
-}
-function validateDiscriminator(
-  program: Program,
-  discriminator: Discriminator,
-  derivedModels: readonly Model[],
-): boolean {
-  const { propertyName } = discriminator;
-  const retVals = derivedModels.map((t) => {
-    const prop = getProperty(t, propertyName);
-    if (!prop) {
-      reportDiagnostic(program, {
-        code: "discriminator",
-        messageId: "missing",
-        target: t,
-      });
-      return false;
-    }
-    let retval = true;
-    if (!isOasString(prop.type) && prop.type.kind !== "EnumMember" && prop.type.kind !== "Enum") {
-      reportDiagnostic(program, {
-        code: "discriminator",
-        messageId: "type",
-        target: prop,
-      });
-      retval = false;
-    }
-    if (prop.optional) {
-      reportDiagnostic(program, {
-        code: "discriminator",
-        messageId: "required",
-        target: prop,
-      });
-      retval = false;
-    }
-    return retval;
-  });
-  // Map of discriminator value to the model in which it is declared
-  const discriminatorValues = new Map<string, string>();
-  for (const t of derivedModels) {
-    // Get the discriminator property directly in the child model
-    const prop = t.properties?.get(propertyName);
-    // Issue warning diagnostic if discriminator property missing or is not a string literal
-    if (!prop || !isStringLiteral(prop.type)) {
-      reportDiagnostic(program, {
-        code: "discriminator-value",
-        messageId: "literal",
-        target: prop || t,
-      });
-    }
-    if (prop) {
-      const vals = getStringValues(prop.type);
-      vals.forEach((val) => {
-        if (discriminatorValues.has(val)) {
-          reportDiagnostic(program, {
-            code: "discriminator",
-            messageId: "duplicate",
-            format: {
-              val: val,
-              model1: discriminatorValues.get(val)!,
-              model2: t.name,
-            },
-            target: prop,
-          });
-          retVals.push(false);
-        } else {
-          discriminatorValues.set(val, t.name);
-        }
-      });
-    }
-  }
-  return retVals.every((v) => v);
-}
-
-function getSchemaForModel(dpgContext: SdkContext, model: Model, options?: GetSchemaOptions) {
-  const { usage, needRef, isRequestBody, mediaTypes: contentTypes } = options ?? {};
-  if (isArrayModelType(model)) {
-    return getSchemaForArrayModel(dpgContext, model, options);
-  }
-
-  const program = dpgContext.program;
-  const isMultipartBody = isMediaTypeMultipartFormData(contentTypes ?? []);
-  const isCoreModel = isAzureCoreErrorType(program, model);
-  const modelSchema: ObjectSchema = {
-    name: getModelName(dpgContext, model),
-    type: "object",
-    isMultipartBody,
-    description: getDoc(program, model) ?? "",
-    fromCore: isCoreModel,
-  };
-  // normalized the output name
-  modelSchema.name = normalizeName(modelSchema.name, NameType.Interface, true /** shouldGuard */);
-
-  if (model.name === "Record" && isRecordModelType(model)) {
-    return getSchemaForRecordModel(dpgContext, model, { usage });
-  }
-  modelSchema.typeName = modelSchema.name;
-  if (usage && usage.includes(SchemaContext.Output)) {
-    modelSchema.outputTypeName = modelSchema.name + "Output";
-  }
-
-  modelSchema.properties = {};
-
-  // getSchemaOrRef on all children to push them into components.schemas
-  const discriminator = getDiscriminator(program, model);
-  // should respect needRef for derived models unless there's a discriminator in base model
-  const derivedModels = model.derivedModels.filter((dm) => {
-    return includeDerivedModel(dm, discriminator ? false : needRef);
-  });
-  if (derivedModels.length > 0) {
-    modelSchema.children = {
-      all: [],
-      immediate: [],
-    };
-  }
-  for (const child of derivedModels) {
-    const childSchema = getSchemaForType(dpgContext, child, {
-      usage,
-      needRef: true,
-    });
-    for (const [name, prop] of child.properties) {
-      if (name === discriminator?.propertyName) {
-        const propSchema = getSchemaForType(dpgContext, prop.type, {
-          usage,
-          needRef: !isAnonymousModelType(prop.type),
-          relevantProperty: prop,
-        });
-        childSchema.discriminatorValue = propSchema.type.replace(/"/g, "");
-        break;
-      }
-    }
-    modelSchema.children?.all?.push(childSchema);
-    modelSchema.children?.immediate?.push(childSchema);
-  }
-
-  // Enable option `isPolyParent` and discriminator only when it has valid children
-  if (
-    discriminator &&
-    modelSchema?.children?.all?.length &&
-    modelSchema?.children?.all?.length > 0
-  ) {
-    if (!validateDiscriminator(program, discriminator, derivedModels)) {
-      // appropriate diagnostic is generated in the validate function
-      return {};
-    }
-
-    const { propertyName } = discriminator;
-
-    modelSchema.discriminator = {
-      name: propertyName,
-      type: "string",
-      description: `Discriminator property for ${model.name}.`,
-    };
-    modelSchema.discriminatorValue = propertyName;
-    modelSchema.isPolyParent = true;
-  }
-
-  // applyExternalDocs(model, modelSchema);
-  if (needRef) {
-    return modelSchema;
-  }
-  if (isRecordModelType(model)) {
-    modelSchema.parents = {
-      all: [getSchemaForRecordModel(dpgContext, model, { usage })],
-      immediate: [getSchemaForRecordModel(dpgContext, model, { usage })],
-    };
-  }
-  for (const [propName, prop] of model.properties) {
-    const restApiName = getWireName(dpgContext, prop);
-    const name = `"${restApiName ?? propName}"`;
-    if (!isSchemaProperty(program, prop)) {
-      continue;
-    }
-
-    const propSchema = getSchemaForType(dpgContext, prop.type, {
-      usage,
-      needRef: isAnonymousModelType(prop.type) ? false : true,
-      relevantProperty: prop,
-      isParentRequestBody: isRequestBody,
-      isRequestBody: false,
-      mediaTypes: contentTypes,
-    });
-
-    if (propSchema === undefined) {
-      continue;
-    }
-    if (!prop.optional) {
-      propSchema.required = true;
-    }
-    const propertyDescription = getFormattedPropertyDoc(program, prop, propSchema);
-    propSchema.usage = usage;
-    // Use the description from ModelProperty not derived from Model Type
-    propSchema.description = propertyDescription;
-    modelSchema.properties[name] = propSchema;
-    // if this property is a discriminator property, remove it to keep autorest validation happy
-    const { propertyName } = getDiscriminator(program, model) || {};
-    if (propertyName && name === `"${propertyName}"` && modelSchema.discriminator) {
-      modelSchema.discriminator = {
-        ...modelSchema.discriminator,
-        ...{
-          type: propSchema.typeName ?? propSchema.type,
-          typeName: propSchema.typeName,
-          outputTypeName: propSchema.outputTypeName,
-        },
-      };
-      continue;
-    }
-
-    // Apply decorators on the property to the type's schema
-    const newPropSchema = applyIntrinsicDecorators(program, prop, propSchema);
-    if (newPropSchema === undefined) {
-      continue;
-    }
-    // Use the description from ModelProperty not devired from Model Type
-    newPropSchema.description = propertyDescription;
-
-    // Should the property be marked as readOnly?
-    const vis = getSdkVisibility(program, prop);
-    if (vis && vis.includes(Visibility.Read)) {
-      const mutability = [];
-      if (vis.includes(Visibility.Read)) {
-        if (vis.length > 1) {
-          mutability.push(SchemaContext.Output);
-        } else {
-          newPropSchema["readOnly"] = true;
-        }
-      }
-      if (vis.includes(Visibility.Create) || vis.includes(Visibility.Update)) {
-        mutability.push(SchemaContext.Input);
-      }
-
-      if (mutability.length > 0) {
-        newPropSchema["usage"] = mutability;
-      }
-    }
-    modelSchema.properties[name] = newPropSchema;
-  }
-
-  if (model.baseModel) {
-    if (modelSchema.parents === undefined) {
-      modelSchema.parents = {
-        all: [],
-        immediate: [],
-      };
-    }
-    modelSchema.parents.all?.push(
-      getSchemaForType(dpgContext, model.baseModel, {
-        usage,
-        needRef: true,
-      }),
-    );
-    modelSchema.parents.immediate?.push(
-      getSchemaForType(dpgContext, model.baseModel, {
-        usage,
-        needRef: true,
-      }),
-    );
-  }
-  return modelSchema;
-}
-
-function getSdkVisibility(program: Program, type: ModelProperty): Visibility[] | undefined {
-  const lifecycle = getLifecycleVisibilityEnum(program);
-  const visibility = getVisibilityForClass(program, type, lifecycle);
-  if (visibility) {
-    const result: Visibility[] = [];
-    if (lifecycle.members.get("Read") && visibility.has(lifecycle.members.get("Read")!)) {
-      result.push(Visibility.Read);
-    }
-    if (lifecycle.members.get("Create") && visibility.has(lifecycle.members.get("Create")!)) {
-      result.push(Visibility.Create);
-    }
-    if (lifecycle.members.get("Update") && visibility.has(lifecycle.members.get("Update")!)) {
-      result.push(Visibility.Update);
-    }
-    if (lifecycle.members.get("Delete") && visibility.has(lifecycle.members.get("Delete")!)) {
-      result.push(Visibility.Delete);
-    }
-    if (lifecycle.members.get("Query") && visibility.has(lifecycle.members.get("Query")!)) {
-      result.push(Visibility.Query);
-    }
-    return result;
-  }
-  return undefined;
-}
-/**
- * Return the model name for a given model
- */
-function getModelName(dpgContext: SdkContext, model: Model) {
-  const { program } = dpgContext;
-
-  // 1. check if this is an anonymous model
-  if (model.name === "") {
-    return "";
-  }
-
-  // 2. check if there's a friendly name
-  const friendlyName = getFriendlyName(program, model);
-  if (friendlyName) {
-    return friendlyName;
-  }
-
-  // 3. check if this is an Azure Core error model
-  const isCoreModel = isAzureCoreErrorType(program, model);
-  if (isCoreModel) {
-    return model.name;
-  }
-
-  // 4. check if this is a model with template arguments
-  let name = model.name;
-  if (model.templateMapper?.args) {
-    // const isPage = getPagedResult(program, model);
-    const templateTypeNames = model.templateMapper.args
-      .map((arg) => (arg.entityKind === "Indeterminate" ? arg.type : arg))
-      .map((arg: any) => {
-        switch (arg.kind) {
-          case "Model":
-          case "Enum":
-          case "Union":
-          case "Scalar":
-            return arg.name ?? "";
-          case "String":
-          case "Boolean":
-          case "Number":
-            return arg.value ?? "";
-          default:
-            return "";
-        }
-      })
-      .filter((arg) => arg !== "")
-      .join(" ");
-    name = normalizeName(`${name} ${templateTypeNames}`, NameType.Interface);
-  }
-  let fullNamespacePrefix = getModelNamespaceName(dpgContext, model.namespace!)
-    .map((nsName) => {
-      return normalizeName(nsName, NameType.Interface);
-    })
-    .join("");
-  if (
-    fullNamespacePrefix.startsWith("AzureResourceManager") ||
-    fullNamespacePrefix.startsWith("AzureCore") ||
-    fullNamespacePrefix.startsWith("TypeSpecRest") ||
-    fullNamespacePrefix.startsWith("TypeSpecHttp")
-  ) {
-    fullNamespacePrefix = "";
-  }
-  // 5. check if this model should be namespaced
-  return dpgContext.rlcOptions?.enableModelNamespace ? `${fullNamespacePrefix}${name}` : name;
-}
-
-// Map an typespec type to an OA schema. Returns undefined when the resulting
-// OA schema is just a regular object schema.
-function getSchemaForLiteral(type: Type): any {
-  switch (type.kind) {
-    case "Number":
-      return { type: `${type.value}`, isConstant: true };
-    case "String":
-      return { type: `"${type.value}"`, isConstant: true };
-    case "Boolean":
-      return { type: `${type.value}`, isConstant: true };
-  }
-  if (type.kind === undefined) {
-    if (typeof type === "string") {
-      return { type: `"${type}"` };
-    } else if (typeof type === "number" || typeof type === "boolean") {
-      return { type: `${type}` };
-    }
-  }
-  return undefined;
-}
-function applyIntrinsicDecorators(
-  program: Program,
-  type: Scalar | ModelProperty,
-  target: any,
-): any {
-  const newTarget = { ...target };
-  const docStr = getDoc(program, type);
-  const isString = isStringType(program, getPropertyType(type));
-  const isNumeric = isNumericType(program, getPropertyType(type));
-
-  if (isString && !target?.documentation && docStr) {
-    newTarget.description = docStr;
-  }
-
-  const summaryStr = getSummary(program, type);
-  if (isString && !target.summary && summaryStr) {
-    newTarget.summary = summaryStr;
-  }
-
-  const formatStr = getFormat(program, type);
-  if (isString && !target.format && formatStr) {
-    newTarget.format = formatStr;
-  }
-
-  const pattern = getPattern(program, type);
-  if (isString && !target.pattern && pattern) {
-    newTarget.pattern = pattern;
-  }
-
-  const minLength = getMinLength(program, type);
-  if (isString && !target.minLength && minLength !== undefined) {
-    newTarget.minLength = minLength;
-  }
-
-  const maxLength = getMaxLength(program, type);
-  if (isString && !target.maxLength && maxLength !== undefined) {
-    newTarget.maxLength = maxLength;
-  }
-
-  const minValue = getMinValue(program, type);
-  if (isNumeric && !target.minimum && minValue !== undefined) {
-    newTarget.minimum = minValue;
-  }
-
-  const maxValue = getMaxValue(program, type);
-  if (isNumeric && !target.maximum && maxValue !== undefined) {
-    newTarget.maximum = maxValue;
-  }
-
-  if (isSecret(program, type)) {
-    newTarget.format = "password";
-    newTarget["x-ms-secret"] = true;
-  }
-
-  return newTarget;
-}
-
-function getSchemaForEnumMember(program: Program, e: EnumMember) {
-  const value = e.value ?? e.name;
-  const type = enumMemberType(e) === "string" ? `"${value}"` : `${value}`;
-  return { type, description: getDoc(program, e), isConstant: true };
-}
-
-function getSchemaForEnum(dpgContext: SdkContext, e: Enum) {
-  const values = [];
-  const memberValues = Array.from(e.members.values());
-  if (memberValues.length === 0) {
-    return {};
-  }
-  const type = enumMemberType(memberValues[0]!);
-  for (const option of memberValues) {
-    if (type !== enumMemberType(option)) {
-      reportDiagnostic(dpgContext.program, {
-        code: "union-unsupported",
-        target: e,
-      });
-      continue;
-    }
-
-    values.push(getSchemaForType(dpgContext, option));
-  }
-
-  const schema: any = {
-    type: "object",
-    name: e.name,
-    typeName: normalizeName(e.name, NameType.Interface),
-    outputTypeName: normalizeName(e.name, NameType.Interface) + "Output",
-    description: getDoc(dpgContext.program, e),
-    memberType: type,
-  };
-
-  if (values.length > 0) {
-    schema.enum = values;
-    const unionAlias = values
-      .map((item) => `${getTypeName(item, [SchemaContext.Input]) ?? item}`)
-      .join(" | ");
-    schema.alias = unionAlias;
-    schema.outputAlias = unionAlias;
-  }
-  return schema;
-}
-
-function enumMemberType(member: EnumMember) {
-  const memberValue = member.value;
-  if (typeof memberValue === "number") {
-    return "number";
-  }
-  return "string";
-}
-/**
- * Map TypeSpec intrinsic models to open api definitions
- */
-function getSchemaForArrayModel(dpgContext: SdkContext, type: Model, options?: GetSchemaOptions) {
-  const { program } = dpgContext;
-  const { indexer } = type;
-  const { usage, isParentRequestBody, mediaTypes: contentTypes } = options ?? {};
-  let schema: any = {};
-  if (!indexer) {
-    return schema;
-  }
-  if (isArrayModelType(type)) {
-    schema = {
-      type: "array",
-      items: getSchemaForType(dpgContext, indexer.value!, {
-        usage,
-        isRequestBody: false,
-        mediaTypes: contentTypes,
-        // special handling for array in formdata
-        isParentRequestBody: hasMediaType(KnownMediaType.MultipartFormData, contentTypes)
-          ? isParentRequestBody
-          : false,
-        needRef: !isAnonymousModelType(indexer.value!),
-      }),
-      description: getDoc(program, type),
-    };
-    if (
-      !program.checker.isStdType(indexer.value) &&
-      !isUnknownType(indexer.value!) &&
-      indexer.value?.kind &&
-      schema.items.name &&
-      !schema.items.enum
-    ) {
-      schema.typeName = `Array<${schema.items.name}>`;
-      if (usage && usage.includes(SchemaContext.Output)) {
-        schema.outputTypeName = `Array<${schema.items.name}Output>`;
-      }
-    } else {
-      if (schema.items.typeName) {
-        if (schema.items.type === "dictionary") {
-          schema.typeName = `${schema.items.typeName}[]`;
-          if (usage && usage.includes(SchemaContext.Output)) {
-            schema.outputTypeName = `(${schema.items.outputTypeName})[]`;
-          }
-        } else if (schema.items.type === "union") {
-          schema.typeName = `(${schema.items.typeName})[]`;
-          if (usage && usage.includes(SchemaContext.Output)) {
-            schema.outputTypeName = `(${schema.items.outputTypeName})[]`;
-          }
-        } else if (
-          schema.items.typeName.includes(BINARY_TYPE_UNION) &&
-          schema.items.type === "string"
-        ) {
-          schema.typeName = `(${schema.items.typeName})[]`;
-          if (usage && usage.includes(SchemaContext.Output)) {
-            schema.outputTypeName = `(${schema.items.outputTypeName})[]`;
-          }
-        } else if (isAnonymousObjectSchema(schema.items)) {
-          schema.typeName = `${schema.items.typeName}[]`;
-          if (usage && usage.includes(SchemaContext.Output)) {
-            schema.outputTypeName = `${schema.items.outputTypeName}[]`;
-          }
-        } else {
-          schema.typeName = schema.items.typeName
-            .split("|")
-            .map((typeName: string) => {
-              return `${typeName}[]`;
-            })
-            .join(" | ");
-          if (schema.items.outputTypeName && usage && usage.includes(SchemaContext.Output)) {
-            schema.outputTypeName = schema.items.outputTypeName
-              .split("|")
-              .map((typeName: string) => {
-                return `${typeName}[]`;
-              })
-              .join(" | ");
-          }
-        }
-      } else if (schema.items?.type?.includes("|")) {
-        schema.typeName = `(${schema.items.type})[]`;
-      } else {
-        schema.typeName = `${schema.items.type}[]`;
-      }
-    }
-    schema.usage = usage;
-    return schema;
-  }
-}
-
-function getSchemaForRecordModel(dpgContext: SdkContext, type: Model, options?: GetSchemaOptions) {
-  const { program } = dpgContext;
-  const { indexer } = type;
-  const { usage } = options ?? {};
-  let schema: any = {};
-  if (!indexer) {
-    return schema;
-  }
-  if (isRecordModelType(type)) {
-    const valueType = getSchemaForType(dpgContext, indexer?.value, {
-      usage,
-      needRef: !isAnonymousModelType(indexer.value),
-    });
-    schema = {
-      type: "dictionary",
-      additionalProperties: valueType,
-      description: getDoc(program, type),
-    };
-    if (
-      !program.checker.isStdType(indexer.value) &&
-      !isUnknownType(indexer.value!) &&
-      !isUnionType(indexer.value!)
-    ) {
-      schema.typeName = `Record<string, ${valueType.typeName}>`;
-      schema.valueTypeName = valueType.name;
-      if (usage && usage.includes(SchemaContext.Output)) {
-        schema.outputTypeName = `Record<string, ${valueType.outputTypeName}>`;
-        schema.outputValueTypeName = `${valueType.outputTypeName}`;
-      }
-    } else if (isUnknownType(indexer.value!)) {
-      schema.typeName = `Record<string, ${valueType.typeName ?? valueType.type}>`;
-      if (usage && usage.includes(SchemaContext.Output)) {
-        schema.outputTypeName = `Record<string, ${valueType.outputTypeName ?? valueType.type}>`;
-      }
-    } else {
-      schema.typeName = `Record<string, ${getTypeName(valueType, [SchemaContext.Input])}>`;
-      schema.outputTypeName = `Record<string, ${getTypeName(valueType, [SchemaContext.Output])}>`;
-    }
-    schema.usage = usage;
-    return schema;
-  }
-}
-
-function isUnionType(type: Type) {
-  return type.kind === "Union";
-}
-
-export function isObjectOrDictType(schema: Schema) {
-  return (
-    (schema.type === "object" && (schema as ObjectSchema).properties !== undefined) ||
-    schema.type === "dictionary"
-  );
-}
-
-export function isArrayType(schema: Schema) {
-  return schema.type === "array";
-}
-
-function getSchemaForStdScalar(program: Program, type: Scalar, options?: GetSchemaOptions) {
-  const { relevantProperty } = options ?? {};
-  if (!program.checker.isStdType(type)) {
-    return undefined;
-  }
-
-  /**
-   * lookup for @encode decorator
-   *  if absent use typespec type (or default way of serializing that type)
-   *  if present respect type provided in @encode
-   */
-  let format = undefined;
-  if (relevantProperty) {
-    const encodeData = getEncode(program, relevantProperty);
-    if (encodeData && isEncodeTypeEffective(type, encodeData)) {
-      type = encodeData.type;
-      format = encodeData.encoding;
-    }
-  }
-  const name = type.name;
-  const description = getSummary(program, type);
-  switch (name) {
-    case "bytes":
-      return { type: "string", format: "bytes", description };
-    case "integer":
-      return applyIntrinsicDecorators(program, type, {
-        type: "number",
-      });
-    case "int8":
-      return applyIntrinsicDecorators(program, type, {
-        type: "number",
-        format: "int8",
-      });
-    case "int16":
-      return applyIntrinsicDecorators(program, type, {
-        type: "number",
-        format: "int16",
-      });
-    case "int32":
-      return applyIntrinsicDecorators(program, type, {
-        type: "number",
-        format: "int32",
-      });
-    case "int64":
-      return applyIntrinsicDecorators(program, type, {
-        type: "number",
-        format: "int64",
-      });
-    case "safeint":
-      return applyIntrinsicDecorators(program, type, {
-        type: "number",
-        format: "safeint",
-      });
-    case "numeric":
-      return applyIntrinsicDecorators(program, type, {
-        type: "number",
-      });
-    case "uint8":
-      return applyIntrinsicDecorators(program, type, {
-        type: "number",
-        format: "uint8",
-      });
-    case "uint16":
-      return applyIntrinsicDecorators(program, type, {
-        type: "number",
-        format: "uint16",
-      });
-    case "uint32":
-      return applyIntrinsicDecorators(program, type, {
-        type: "number",
-        format: "uint32",
-      });
-    case "uint64":
-      return applyIntrinsicDecorators(program, type, {
-        type: "number",
-        format: "uint64",
-      });
-    case "float64":
-      return applyIntrinsicDecorators(program, type, {
-        type: "number",
-        format: "float64",
-      });
-    case "float32":
-      return applyIntrinsicDecorators(program, type, {
-        type: "number",
-        format: "float32",
-      });
-    case "float":
-      return applyIntrinsicDecorators(program, type, {
-        type: "number",
-        format: "float",
-      });
-    case "decimal":
-      reportDiagnostic(program, {
-        code: "decimal-to-number",
-        format: {
-          propertyName: relevantProperty?.name ?? "",
-        },
-        target: relevantProperty ?? NoTarget,
-      });
-      return applyIntrinsicDecorators(program, type, {
-        type: "number",
-        format: "decimal",
-        description: "decimal",
-      });
-    case "decimal128":
-      reportDiagnostic(program, {
-        code: "decimal-to-number",
-        format: {
-          propertyName: relevantProperty?.name ?? "",
-        },
-        target: relevantProperty ?? NoTarget,
-      });
-      return applyIntrinsicDecorators(program, type, {
-        type: "number",
-        format: "decimal128",
-        description: "decimal128",
-      });
-    case "string":
-      if (format === "binary") {
-        return {
-          type: "string",
-          format: "binary",
-          description,
-          typeName: BINARY_TYPE_UNION,
-          outputTypeName: "Uint8Array",
-        };
-      }
-      return applyIntrinsicDecorators(program, type, {
-        type: "string",
-      });
-    case "boolean":
-      return { type: "boolean", description };
-    case "plainDate":
-      return {
-        type: "string",
-        format,
-        description,
-        typeName: "string",
-        outputTypeName: "string",
-      };
-    case "utcDateTime":
-      return {
-        type: "string",
-        format,
-        description,
-        typeName: "Date | string",
-        outputTypeName: "string",
-      };
-    case "offsetDateTime":
-      return {
-        type: "string",
-        format: "date-time",
-        description,
-        typeName: "string",
-        outputTypeName: "string",
-      };
-    case "plainTime":
-      return {
-        type: "string",
-        format: "time",
-        description,
-        typeName: "string",
-        outputTypeName: "string",
-      };
-    case "duration":
-      return { type: "string", format, description };
-    case "url":
-      return { type: "string", format: "uri" };
-  }
-}
-
-function isEncodeTypeEffective(type: Scalar, encodeData: EncodeData | undefined) {
-  if (!encodeData) {
-    return false;
-  }
-  const datetimeTypes = ["plaindate", "utcdatetime", "offsetdatetime", "plaintime"];
-  if (datetimeTypes.includes(type.name.toLowerCase()) && encodeData.type.name === "string") {
-    return false;
-  }
-  return true;
-}
-
-export function getTypeName(schema: Schema, usage?: SchemaContext[]): string {
-  // TODO: Handle more cases
-  return getPriorityName(schema, usage) ?? schema.type ?? "any";
-}
-
-export function getImportedModelName(schema: Schema, usage?: SchemaContext[]): string[] {
-  switch (schema.type) {
-    case "array": {
-      const ret = new Set<string>();
-      [(schema as ArraySchema).items]
-        .filter((i?: Schema) => !!i)
-        .forEach((i?: Schema) => getImportedModelName(i!, usage).forEach((it) => ret.add(it)));
-      return [...ret];
-    }
-    case "object": {
-      if (isAnonymousObjectSchema(schema)) {
-        const ret = new Set<string>();
-        const properties = (schema as ObjectSchema).properties ?? {};
-        for (const name in properties) {
-          if (!properties[name]) {
-            continue;
-          }
-          getImportedModelName(properties[name]!, usage).forEach((it) => ret.add(it));
-        }
-        return [...ret];
-      }
-      return getPriorityName(schema, usage) ? [getPriorityName(schema, usage)] : [];
-    }
-    case "dictionary": {
-      const ret = new Set<string>();
-      [(schema as DictionarySchema).additionalProperties]
-        .filter((i?: Schema) => !!i)
-        .forEach((i?: Schema) => getImportedModelName(i!, usage).forEach((it) => ret.add(it)));
-
-      return [...ret];
-    }
-    case "union": {
-      const ret = new Set<string>();
-      ((schema as Schema).enum ?? [])
-        .filter((i?: Schema) => !!i)
-        .forEach((i?: Schema) => getImportedModelName(i!, usage).forEach((it) => ret.add(it)));
-
-      return [...ret];
-    }
-    default:
-      return [];
-  }
-}
-
-function getPriorityName(schema: Schema, usage?: SchemaContext[]): string {
-  return usage && usage.includes(SchemaContext.Input) && !usage.includes(SchemaContext.Output)
-    ? (schema.typeName ?? schema.name)
-    : (schema.outputTypeName ?? schema.typeName ?? schema.name);
-}
-
-function getEnumStringDescription(type: any) {
-  if (
-    (type.name === "string" ||
-      type.alias === "string" ||
-      type.name === "number" ||
-      type.alias === "number" ||
-      type.name === "boolean" ||
-      type.alias === "boolean") &&
-    type.enum &&
-    type.enum.length > 0
-  ) {
-    return `Possible values: ${type.enum
-      .map((e: Schema) => {
-        return e.type;
-      })
-      .join(", ")}`;
-  }
-  return undefined;
-}
-
-function getBinaryDescription(type: any) {
-  if (type?.typeName?.includes(BINARY_TYPE_UNION)) {
-    return `Value may contain any sequence of octets`;
-  }
-  return undefined;
-}
-
-function getDecimalDescription(type: any) {
-  if ((type.format === "decimal" || type.format === "decimal128") && type.type === "number") {
-    return `NOTE: This property is represented as a 'number' in JavaScript, but it corresponds to a 'decimal' type in other languages.
-Due to the inherent limitations of floating-point arithmetic in JavaScript, precision issues may arise when performing arithmetic operations.
-If your application requires high precision for arithmetic operations or when round-tripping data back to other languages, consider using a library like decimal.js, which provides an arbitrary-precision Decimal type.
-For simpler cases, where you need to control the number of decimal places for display purposes, you can use the 'toFixed()' method. However, be aware that 'toFixed()' returns a string and may not be suitable for all arithmetic precision requirements.
-Always be cautious with direct arithmetic operations and consider implementing appropriate rounding strategies to maintain accuracy.
-   `;
-  }
-  return undefined;
-}
-
-export function getFormattedPropertyDoc(
-  program: Program,
-  type: ModelProperty | Type,
-  schemaType: any,
-  sperator: string = "\n\n",
-) {
-  const propertyDoc = getDoc(program, type);
-  const enhancedDocFromType =
-    getEnumStringDescription(schemaType) ??
-    getDecimalDescription(schemaType) ??
-    getBinaryDescription(schemaType);
-  if (propertyDoc && enhancedDocFromType) {
-    return `${propertyDoc}${sperator}${enhancedDocFromType}`;
-  }
-  return propertyDoc ?? enhancedDocFromType;
-}
-
-export function getBodyType(route: HttpOperation): Type | undefined {
-  const bodyModel = route.parameters.body?.type;
-  return bodyModel;
-}
-
-export function getValueTypeValue(
-  value: Value,
-): string | boolean | null | number | Array<unknown> | object | undefined {
-  switch (value.valueKind) {
-    case "ArrayValue":
-      return value.values.map((x) => getValueTypeValue(x));
-    case "BooleanValue":
-    case "StringValue":
-    case "NullValue":
-      return value.value;
-    case "NumericValue":
-      return value.value.asNumber();
-    case "EnumValue":
-      return value.value.value ?? value.value.name;
-    case "ObjectValue":
-      return Object.fromEntries(
-        [...value.properties.keys()].map((x) => [
-          x,
-          getValueTypeValue(value.properties.get(x)!.value),
-        ]),
-      );
-    default:
-      // TODO: handle scalar value
-      return undefined;
-  }
-}
-
-/**
- * Predict if the default value exists in param, we would follow the rules:
- * 1. If we have specific default literal in param
- * 2. If we take the default api-version value into considerations
- * @param program
- * @param dpgContext
- * @param param The param to predict
- * @returns
- */
-export function predictDefaultValue(dpgContext: SdkContext, param?: ModelProperty) {
-  if (!param) {
-    return;
-  }
-  const program = dpgContext.program;
-  const specificDefault = param.defaultValue ? getValueTypeValue(param.defaultValue) : undefined;
-  if (specificDefault) {
-    if (typeof specificDefault === "object") {
-      reportDiagnostic(program, {
-        code: "default-value-object",
-        format: {
-          propertyName: param.name,
-        },
-        target: param,
-      });
-      return specificDefault.toString();
-    }
-    return specificDefault;
-  }
-  const serviceNamespace = getDefaultService(
-    program,
-    dpgContext.rlcOptions?.isModularLibrary,
-  )?.type;
-  if (!serviceNamespace) {
-    return;
-  }
-  const defaultApiVersion = getDefaultApiVersionString(dpgContext);
-  if (param && isApiVersion(dpgContext, param) && defaultApiVersion) {
-    return defaultApiVersion;
-  }
-  return;
-}
-
-export function getDefaultService(
-  program: Program,
-  isModularLibrary: boolean = true,
-): Service | undefined {
-  const services = listServices(program);
-  if (!services || services.length === 0) {
-    reportDiagnostic(program, {
-      code: "no-service-defined",
-      target: NoTarget,
-    });
-  }
-  if (services.length > 1 && !isModularLibrary) {
-    reportDiagnostic(program, {
-      code: "more-than-one-service",
-      target: NoTarget,
-    });
-  }
-  return services[0];
-}
-/**
- * Return the default api version from the program; undefined if no default
- */
-export function getDefaultApiVersionString(dpgContext: SdkContext): string | undefined {
-  const program = dpgContext.program;
-  const isModularLibrary = dpgContext.rlcOptions?.isModularLibrary;
-  return getDefaultService(program, isModularLibrary)
-    ? getDefaultApiVersion(dpgContext, getDefaultService(program, isModularLibrary)!.type)?.value
-    : undefined;
-}
-
-export function trimUsage(model: any) {
-  if (typeof model !== "object") {
-    return model;
-  }
-  const tmpModel = Object.assign({}, model);
-  const tmpModelKeys = Object.keys(tmpModel).filter((item) => {
-    return item !== "usage";
-  });
-  const ordered = tmpModelKeys.sort().reduce((obj, key) => {
-    (obj as any)[key] = trimUsage(tmpModel[key]);
-    return obj;
-  }, {});
-  return ordered;
-}
-
-export function isAzureCoreErrorType(program: Program, t?: Type): boolean {
-  if (!t || t.kind !== "Model") {
-    return false;
-  }
-  const effective = getEffectiveSchemaType(program, t);
-  if (!["error", "errorresponse", "innererror"].includes(effective.name.toLowerCase())) {
-    return false;
-  }
-  return isAzureCoreFoundationsNamespace(effective);
-}
-
-function isAzureCoreFoundationsNamespace(t?: Type, skipFoundation: boolean = false): boolean {
-  const namespaces = (skipFoundation ? ".Azure.Core" : ".Azure.Core.Foundations").split(".");
-  while (
-    namespaces.length > 0 &&
-    (t?.kind === "Model" || t?.kind === "Enum" || t?.kind === "Union" || t?.kind === "Namespace") &&
-    t.namespace?.name === namespaces.pop()
-  ) {
-    t = t.namespace;
-  }
-  return namespaces.length == 0;
-}
-
-// Check if the schema is an anonymous object
-export function isAnonymousObjectSchema(schema: Schema) {
-  return schema.name === "" && schema.type === "object";
-}
-
-// Check if the type is an anonymous model
-export function isAnonymousModelType(type: Type) {
-  if (type.kind === "Model") {
-    return type.name === "";
-  }
-  return false;
-}
-
-/**
- * Get the inline signiture of the model
- * @param schema object schema detail
- * @param options other optional parameters
- * @returns
- */
-export function getModelInlineSigniture(
-  schema: ObjectSchema,
-  options: {
-    importedModels?: Set<string>;
-    usage?: SchemaContext[];
-    multipart?: boolean;
-  } = {},
-) {
-  if (options.multipart) {
-    return getMultipartInlineSignature(schema, options.importedModels, options.usage);
-  }
-
-  let schemaSignature = `{`;
-  for (const propName in schema.properties) {
-    const propType = schema.properties[propName]!;
-    const propTypeName = getTypeName(propType, options.usage);
-    if (!propType || !propTypeName) {
-      continue;
-    }
-    if (options.importedModels) {
-      const importNames = getImportedModelName(propType);
-      if (importNames) {
-        importNames!.forEach(options.importedModels.add, options.importedModels);
-      }
-    }
-    const isOptional = propType.required ? "" : "?";
-    schemaSignature += `${propName}${isOptional}: ${propTypeName};`;
-  }
-
-  schemaSignature += `}`;
-  return schemaSignature;
-}
-
-function getMultipartInlineSignature(
-  schema: ObjectSchema,
-  importedModels?: Set<string>,
-  usage?: SchemaContext[],
-): string {
-  const types = Object.entries(schema.properties ?? {})
-    .map(([propertyName, property]) => {
-      let schema: Schema;
-
-      // Flatten arrays for file uploads
-      if (
-        isArraySchema(property) &&
-        property.items &&
-        getTypeName(property.items, usage).includes(BINARY_AND_FILE_TYPE_UNION)
-      ) {
-        schema = property.items;
-      } else {
-        schema = property;
-      }
-
-      const typeName = getTypeName(schema, usage);
-      if (!typeName) {
-        return undefined;
-      }
-
-      const importNames = getImportedModelName(schema);
-      if (importedModels && importNames) {
-        importNames.forEach(importedModels.add.bind(importedModels));
-      }
-
-      if (typeName.includes("File")) {
-        return `{ name: ${propertyName}, body: ${typeName}, filename?: string, contentType?: string }`;
-      } else {
-        return `{ name: ${propertyName}, body: ${typeName} }`;
-      }
-    })
-    .filter(Boolean)
-    .join(" | ");
-
-  return `FormData | Array<${types}>`;
-}
-
-/**
- * A "schema property" here is a property that is emitted to OpenAPI schema.
- *
- * Headers, parameters, status codes are not schema properties even they are
- * represented as properties in typespec.
- */
-export function isSchemaProperty(program: Program, property: ModelProperty): boolean {
-  const headerInfo = getHeaderFieldName(program, property);
-  const queryInfo = getQueryParamName(program, property);
-  const pathInfo = getPathParamName(program, property);
-  const statusCodeInfo = isStatusCode(program, property);
-  const isNonVisibility = getSdkVisibility(program, property)?.includes(Visibility.None);
-  return !(headerInfo || queryInfo || pathInfo || statusCodeInfo || isNonVisibility);
-}
-
-export function getEffectiveSchemaType(program: Program, type: Model | Union): Model {
-  // If type is an anonymous model, tries to find a named model that has the same properties
-  let effective: Model | undefined = undefined;
-  if (type.kind === "Union") {
-    const nonNullOptions = [...type.variants.values()]
-      .map((x) => x.type)
-      .filter((t) => !isNullType(t));
-    if (
-      nonNullOptions.length === 1 &&
-      nonNullOptions[0]?.kind === "Model" &&
-      nonNullOptions[0]?.name === ""
-    ) {
-      effective = getEffectiveModelType(program, nonNullOptions[0]);
-    }
-    return type as any;
-  } else if (type.name === "") {
-    effective = getEffectiveModelType(program, type, (property) =>
-      isSchemaProperty(program, property),
-    );
-  }
-
-  if (effective?.name) {
-    return effective;
-  }
-  return type as Model;
-}
-
-export function isBodyRequired(parameter: HttpOperationParameters) {
-  return parameter.body?.type && parameter.body?.property?.optional !== true ? true : false;
-}
-
-export function getCollectionFormat(
-  context: SdkContext,
-  param: HttpOperationPathParameter | HttpOperationQueryParameter | HttpOperationHeaderParameter,
-): string | undefined {
-  const type = param.param;
-  const encode = getEncode(context.program, param.param);
-  if (type.type.kind === "Model" && isArrayModelType(type.type)) {
-    if (param.explode) {
-      return "multi";
-    }
-    switch (encode?.encoding) {
-      case "ArrayEncoding.pipeDelimited":
-        return "pipes";
-      case "ArrayEncoding.spaceDelimited":
-        return "ssv";
-      default:
-        return "csv";
-    }
-  }
-  return;
-}