@azure-tools/typespec-ts 0.17.0-alpha.20231010.1 → 0.17.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@azure-tools/typespec-ts",
-  "version": "0.17.0-alpha.20231010.1",
+  "version": "0.17.1",
   "description": "An experimental TypeSpec emitter for TypeScript RLC",
   "main": "dist/src/index.js",
   "type": "module",
@@ -33,7 +33,8 @@
     "@azure/core-lro": "^2.5.4",
     "@azure/core-rest-pipeline": "^1.12.0",
     "@azure/logger": "^1.0.4",
-    "@azure/core-util": "^1.4.0"
+    "@azure/core-util": "^1.4.0",
+    "eslint-plugin-require-extensions": "0.1.3"
   },
   "peerDependencies": {
     "@azure-tools/typespec-azure-core": ">=0.34.0 <1.0.0",
@@ -46,7 +47,7 @@
   "dependencies": {
     "prettier": "^2.6.1",
     "tslib": "^2.3.1",
-    "@azure-tools/rlc-common": "^0.17.0",
+    "@azure-tools/rlc-common": "^0.17.1",
     "ts-morph": "^15.1.0",
     "fs-extra": "^11.1.0"
   },
@@ -90,8 +91,8 @@
     "generate-tsp-only:rlc": "ts-node ./test/commands/gen-cadl-ranch.ts --tag=rlc",
     "generate-tsp-only:modular": "ts-node ./test/commands/gen-cadl-ranch.ts --tag=modular",
     "integration-test:alone": "npm run integration-test:alone:rlc && npm run integration-test:alone:modular",
-    "integration-test:alone:rlc": "cross-env TS_NODE_PROJECT=tsconfig.test.json mocha -r ts-node/register --experimental-specifier-resolution=node --timeout 4000 ./test/integration/*.spec.ts",
-    "integration-test:alone:modular": "cross-env TS_NODE_PROJECT=tsconfig.test.json mocha -r ts-node/register --experimental-specifier-resolution=node --timeout 4000 ./test/modularIntegration/*.spec.ts",
+    "integration-test:alone:rlc": "cross-env TS_NODE_PROJECT=tsconfig.integration.json mocha -r ts-node/register --experimental-specifier-resolution=node --timeout 4000 ./test/integration/*.spec.ts",
+    "integration-test:alone:modular": "cross-env TS_NODE_PROJECT=tsconfig.integration.json mocha -r ts-node/register --experimental-specifier-resolution=node --timeout 4000 ./test/modularIntegration/*.spec.ts",
     "stop-test-server": "npx cadl-ranch server stop",
     "unit-test": "npm run unit-test:rlc && npm run unit-test:modular",
     "unit-test:rlc": "cross-env TS_NODE_PROJECT=tsconfig.json mocha -r ts-node/register --experimental-specifier-resolution=node --experimental-modules=true  --timeout 4000 './test/unit/**/*.spec.ts'",

package/src/index.ts

@@ -29,7 +29,8 @@ import {
   buildLogger,
   RLCOptions,
   hasUnexpectedHelper,
-  RLCModel
+  RLCModel,
+  buildSamples
 } from "@azure-tools/rlc-common";
 import { transformRLCModel } from "./transform/transform.js";
 import { emitContentByBuilder, emitModels } from "./utils/emitUtil.js";
@@ -137,6 +138,12 @@ export async function $onEmit(context: EmitContext) {
       await emitContentByBuilder(program, buildPaginateHelper, rlcModels);
       await emitContentByBuilder(program, buildPollingHelper, rlcModels);
       await emitContentByBuilder(program, buildSerializeHelper, rlcModels);
+      await emitContentByBuilder(
+        program,
+        buildSamples,
+        rlcModels,
+        dpgContext.generationPathDetail?.metadataDir
+      );
     }
   }
 

package/src/modular/buildClassicalClient.ts

@@ -62,6 +62,15 @@ export function buildClassicalClient(
     });
   }
 
+  // Add the pipeline member. This will be the pipeline from /api
+  clientClass.addProperty({
+    name: "pipeline",
+    type: "Pipeline",
+    scope: Scope.Public,
+    isReadonly: true,
+    docs: ["The pipeline used by this client to make requests"]
+  });
+
   // TODO: We may need to generate constructor overloads at some point. Here we'd do that.
   const constructor = clientClass.addConstructor({
     docs: getDocsFromDescription(description),
@@ -72,7 +81,9 @@ export function buildClassicalClient(
       .map((p) => p.name)
       .join(",")})`
   ]);
+  constructor.addStatements(`this.pipeline = this._client.pipeline`);
   importCredential(clientFile);
+  importPipeline(clientFile);
   importAllModels(clientFile, srcPath, subfolder);
   buildClientOperationGroups(client, clientClass, subfolder);
   importAllApis(clientFile, srcPath, subfolder);
@@ -143,6 +154,12 @@ function importAllModels(
   });
 }
 
+function importPipeline(clientSourceFile: SourceFile): void {
+  clientSourceFile.addImportDeclaration({
+    moduleSpecifier: "@azure/core-rest-pipeline",
+    namedImports: ["Pipeline"]
+  });
+}
 function buildClientOperationGroups(
   client: Client,
   clientClass: ClassDeclaration,

package/src/modular/buildCodeModel.ts

@@ -1052,6 +1052,14 @@ function emitCredential(auth: HttpAuth): Record<string, any> {
         key: auth.name
       }
     };
+  } else if (auth.type === "http") {
+    credential_type = {
+      type: "Key",
+      policy: {
+        type: "AzureKeyCredentialPolicy",
+        key: "Authorization"
+      }
+    };
   }
   return credential_type;
 }

package/src/modular/buildProjectFiles.ts

@@ -206,10 +206,10 @@ export function emitPackage(
   if (generateTest) {
     packageInfo.module = `./dist-esm/src/index.js`;
     packageInfo.devDependencies["@azure-tools/test-credential"] = "^1.0.0";
-    packageInfo.devDependencies["@azure/identity"] = "^2.0.1";
+    packageInfo.devDependencies["@azure/identity"] = "^3.3.0";
     packageInfo.devDependencies["@azure-tools/test-recorder"] = "^3.0.0";
-    packageInfo.devDependencies["mocha"] = "^7.1.1";
-    packageInfo.devDependencies["@types/mocha"] = "^7.0.2";
+    packageInfo.devDependencies["mocha"] = "^10.0.0";
+    packageInfo.devDependencies["@types/mocha"] = "^10.0.0";
     packageInfo.devDependencies["mocha-junit-reporter"] = "^1.18.0";
     packageInfo.devDependencies["cross-env"] = "^7.0.2";
     packageInfo.devDependencies["@types/chai"] = "^4.2.8";
@@ -242,12 +242,12 @@ export function emitPackage(
     packageInfo.scripts["unit-test"] =
       "npm run unit-test:node && npm run unit-test:browser";
     packageInfo.scripts["unit-test:node"] =
-      'mocha -r esm --require ts-node/register --reporter ../../../common/tools/mocha-multi-reporter.js --timeout 1200000 --full-trace "test/{,!(browser)/**/}*.spec.ts"';
+      'mocha --full-trace "test/{,!(browser)/**/}*.spec.ts"';
     packageInfo.scripts["unit-test:browser"] = "karma start --single-run";
     packageInfo.scripts["integration-test:browser"] =
       "karma start --single-run";
     packageInfo.scripts["integration-test:node"] =
-      'nyc mocha -r esm --require source-map-support/register --reporter ../../../common/tools/mocha-multi-reporter.js --timeout 5000000 --full-trace "dist-esm/test/{,!(browser)/**/}*.spec.js"';
+      'nyc mocha --require source-map-support/register.js --timeout 5000000 --full-trace "dist-esm/test/{,!(browser)/**/}*.spec.js"';
     packageInfo.scripts["integration-test"] =
       "npm run integration-test:node && npm run integration-test:browser";
     if (azureSdkForJs) {
@@ -265,6 +265,12 @@ export function emitPackage(
       "./dist-esm/test/public/utils/env.js":
         "./dist-esm/test/public/utils/env.browser.js"
     };
+
+    packageInfo["mocha"] = {
+      extension: ["ts"],
+      timeout: "1200000",
+      loader: "ts-node/esm"
+    };
   }
 
   if (generateSample) {

package/src/modular/emitModels.ts

@@ -139,7 +139,11 @@ export function buildModelsOptions(
   client: Client
 ) {
   const modelOptionsFile = codeModel.project.createSourceFile(
-    `${codeModel.modularOptions.sourceRoot}/${client.subfolder}/models/options.ts`,
+    path.join(
+      codeModel.modularOptions.sourceRoot,
+      client.subfolder ?? "",
+      `models/options.ts`
+    ),
     undefined,
     {
       overwrite: true

package/src/modular/helpers/typeHelpers.ts

@@ -38,7 +38,7 @@ export function getType(type: Type, format?: string): TypeMetadata {
     case "boolean":
       return { name: getNullableType(type.type, type) };
     case "constant": {
-      let typeName: string = type.value ?? "undefined";
+      let typeName: string = type.value?.toString() ?? "undefined";
       if (type.valueType?.type === "string") {
         typeName = type.value ? `"${type.value}"` : "undefined";
       }

package/src/transform/transform.ts

@@ -35,6 +35,7 @@ import { transformApiVersionInfo } from "./transformApiVersionInfo.js";
 import { getClientLroOverload } from "../utils/operationUtil.js";
 import { transformTelemetryInfo } from "./transformTelemetryInfo.js";
 import { SdkContext } from "../utils/interfaces.js";
+import { transformSampleGroups } from "@azure-tools/rlc-common";
 
 export async function transformRLCModel(
   client: SdkClient,
@@ -60,7 +61,6 @@ export async function transformRLCModel(
   const importSet = new Map<ImportKind, Set<string>>();
   const paths: Paths = transformPaths(program, client, dpgContext);
   const schemas: Schema[] = transformSchemas(program, client, dpgContext);
-
   const responses: OperationResponse[] = transformToResponseTypes(
     importSet,
     client,
@@ -77,7 +77,7 @@ export async function transformRLCModel(
   const urlInfo = transformUrlInfo(dpgContext);
   const apiVersionInfo = transformApiVersionInfo(client, dpgContext, urlInfo);
   const telemetryOptions = transformTelemetryInfo(dpgContext, client);
-  return {
+  const model: RLCModel = {
     srcPath,
     libraryName,
     paths,
@@ -91,6 +91,12 @@ export async function transformRLCModel(
     urlInfo,
     telemetryOptions
   };
+  model.sampleGroups = transformSampleGroups(
+    model,
+    options?.generateSample ===
+      true /* Enable mock sample content if generateSample === true */
+  );
+  return model;
 }
 
 export function transformUrlInfo(dpgContext: SdkContext): UrlInfo | undefined {

package/src/transform/transformParameters.ts

@@ -304,7 +304,8 @@ function transformNormalBody(
         name: "body",
         type: overrideType ?? type,
         required: parameters?.bodyParameter?.optional === false,
-        description: descriptions.join("\n\n")
+        description: descriptions.join("\n\n"),
+        oriSchema: schema
       }
     ]
   };

package/src/transform/transformSchemas.ts

@@ -122,8 +122,12 @@ export function transformSchemas(
 
       setModelMap(model, context);
       const indexer = (model as Model).indexer;
-      if (indexer?.value && !program.stateMap(modelKey).get(indexer?.value)) {
-        setModelMap(indexer.value, context);
+      if (
+        indexer?.value &&
+        (!program.stateMap(modelKey).get(indexer?.value) ||
+          !program.stateMap(modelKey).get(indexer?.value)?.includes(context))
+      ) {
+        getGeneratedModels(indexer.value, context);
       }
       for (const prop of model.properties) {
         if (
@@ -131,7 +135,7 @@ export function transformSchemas(
           (!program.stateMap(modelKey).get(prop[1].type) ||
             !program.stateMap(modelKey).get(prop[1].type)?.includes(context))
         ) {
-          if (prop[1].type.name === "Error") {
+          if (isAzureCoreErrorType(prop[1].type)) {
             continue;
           }
           getGeneratedModels(prop[1].type, context);

package/src/utils/emitUtil.ts

@@ -29,9 +29,15 @@ export async function emitContentByBuilder(
     builderFnOrList = [builderFnOrList];
   }
   for (const builderFn of builderFnOrList) {
-    const contentFile = builderFn(rlcModels);
-    if (contentFile) {
-      await emitFile(contentFile, program, emitterOutputDir);
+    let contentFiles: File[] | File | undefined = builderFn(rlcModels);
+    if (!contentFiles) {
+      continue;
+    }
+    if (!Array.isArray(contentFiles)) {
+      contentFiles = [contentFiles];
+    }
+    for (const file of contentFiles) {
+      await emitFile(file, program, emitterOutputDir);
     }
   }
 }

package/src/utils/modelUtils.ts

@@ -41,7 +41,9 @@ import {
   listServices,
   Program,
   getEncode,
-  EncodeData
+  EncodeData,
+  isRecordModelType,
+  isArrayModelType
 } from "@typespec/compiler";
 import { reportDiagnostic } from "../lib.js";
 import {
@@ -134,7 +136,7 @@ export function getSchemaForType(
   const program = dpgContext.program;
   const type = getEffectiveModelFromType(program, typeInput);
 
-  const builtinType = mapTypeSpecTypeToTypeScript(dpgContext, type, usage);
+  const builtinType = getSchemaForLiteral(type);
   if (builtinType !== undefined) {
     // add in description elements for types derived from primitive types (SecureString, etc.)
     const doc = getDoc(program, type);
@@ -145,17 +147,19 @@ export function getSchemaForType(
   }
   if (type.kind === "Model") {
     const schema = getSchemaForModel(dpgContext, type, usage, needRef) as any;
-    if (usage && usage.includes(SchemaContext.Output)) {
-      if (!schema.name || schema.name === "") {
-        //TODO: HANDLE ANONYMOUS
-        schema.outputTypeName =
-          schema.type === "object" ? "Record<string, any>" : "any";
-        schema.typeName =
-          schema.type === "object" ? "Record<string, unknown>" : "unknown";
-        schema.type = "unknown";
-      } else {
-        schema.outputTypeName = `${schema.name}Output`;
-        schema.typeName = `${schema.name}`;
+    if (!isArrayModelType(program, type) && !isRecordModelType(program, type)) {
+      if (usage && usage.includes(SchemaContext.Output)) {
+        if (!schema.name || schema.name === "") {
+          //TODO: HANDLE ANONYMOUS
+          schema.outputTypeName =
+            schema.type === "object" ? "Record<string, any>" : "any";
+          schema.typeName =
+            schema.type === "object" ? "Record<string, unknown>" : "unknown";
+          schema.type = "unknown";
+        } else {
+          schema.outputTypeName = `${schema.name}Output`;
+          schema.typeName = `${schema.name}`;
+        }
       }
     }
     schema.usage = usage;
@@ -418,6 +422,10 @@ function getSchemaForModel(
   usage?: SchemaContext[],
   needRef?: boolean
 ) {
+  if (isArrayModelType(dpgContext.program, model)) {
+    return getSchemaForArrayModel(dpgContext, model, usage!);
+  }
+
   const program = dpgContext.program;
   const overridedModelName =
     getFriendlyName(program, model) ?? getProjectedName(program, model, "json");
@@ -443,7 +451,8 @@ function getSchemaForModel(
         })
         .join("") + "List";
   }
-  let modelSchema: ObjectSchema = {
+
+  const modelSchema: ObjectSchema = {
     name: overridedModelName ?? name,
     type: "object",
     description: getDoc(program, model) ?? ""
@@ -455,7 +464,13 @@ function getSchemaForModel(
     true /** shouldGuard */
   );
 
+  if (modelSchema.name === "Record" && isRecordModelType(program, model)) {
+    return getSchemaForRecordModel(dpgContext, model, usage!);
+  }
   modelSchema.typeName = modelSchema.name;
+  if (usage && usage.includes(SchemaContext.Output)) {
+    modelSchema.outputTypeName = modelSchema.name + "Output";
+  }
 
   if (isAzureCoreErrorType(model)) {
     modelSchema.fromCore = true;
@@ -489,6 +504,7 @@ function getSchemaForModel(
     }
   }
   modelSchema.properties = {};
+
   const derivedModels = model.derivedModels.filter(includeDerivedModel);
 
   // getSchemaOrRef on all children to push them into components.schemas
@@ -545,6 +561,12 @@ function getSchemaForModel(
   if (needRef) {
     return modelSchema;
   }
+  if (isRecordModelType(program, model)) {
+    modelSchema.parents = {
+      all: [getSchemaForRecordModel(dpgContext, model, usage!)],
+      immediate: [getSchemaForRecordModel(dpgContext, model, usage!)]
+    };
+  }
   for (const [propName, prop] of model.properties) {
     const restApiName = getProjectedName(program, prop, "json");
     const name = `"${restApiName ?? propName}"`;
@@ -617,27 +639,7 @@ function getSchemaForModel(
     modelSchema.properties[name] = newPropSchema;
   }
 
-  // Special case: if a model type extends a single *templated* base type and
-  // has no properties of its own, absorb the definition of the base model
-  // into this schema definition.  The assumption here is that any model type
-  // defined like this is just meant to rename the underlying instance of a
-  // templated type.
-  if (
-    model.baseModel &&
-    model.baseModel.templateMapper &&
-    model.baseModel.templateMapper.args &&
-    model.baseModel.templateMapper.args.length > 0 &&
-    modelSchema.properties &&
-    Object.keys(modelSchema.properties).length === 0
-  ) {
-    // Take the base model schema but carry across the documentation property
-    // that we set before
-    const baseSchema = getSchemaForType(dpgContext, model.baseModel, usage);
-    modelSchema = {
-      ...baseSchema,
-      description: modelSchema.description
-    };
-  } else if (model.baseModel) {
+  if (model.baseModel) {
     modelSchema.parents = {
       all: [getSchemaForType(dpgContext, model.baseModel, usage, true)],
       immediate: [getSchemaForType(dpgContext, model.baseModel, usage, true)]
@@ -647,20 +649,14 @@ function getSchemaForModel(
 }
 // Map an typespec type to an OA schema. Returns undefined when the resulting
 // OA schema is just a regular object schema.
-function mapTypeSpecTypeToTypeScript(
-  dpgContext: SdkContext,
-  type: Type,
-  usage?: SchemaContext[]
-): any {
+function getSchemaForLiteral(type: Type): any {
   switch (type.kind) {
     case "Number":
-      return { type: `${type.value}` };
+      return { type: `${type.value}`, isConstant: true };
     case "String":
-      return { type: `"${type.value}"` };
+      return { type: `"${type.value}"`, isConstant: true };
     case "Boolean":
-      return { type: `${type.value}` };
-    case "Model":
-      return mapTypeSpecStdTypeToTypeScript(dpgContext, type, usage);
+      return { type: `${type.value}`, isConstant: true };
   }
   if (type.kind === undefined) {
     if (typeof type === "string") {
@@ -669,6 +665,7 @@ function mapTypeSpecTypeToTypeScript(
       return { type: `${type}` };
     }
   }
+  return undefined;
 }
 function applyIntrinsicDecorators(
   program: Program,
@@ -735,7 +732,7 @@ function applyIntrinsicDecorators(
 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) };
+  return { type, description: getDoc(program, e), isConstant: true };
 }
 
 function getSchemaForEnum(program: Program, e: Enum) {
@@ -774,111 +771,119 @@ function enumMemberType(member: EnumMember) {
 /**
  * Map TypeSpec intrinsic models to open api definitions
  */
-function mapTypeSpecStdTypeToTypeScript(
+function getSchemaForArrayModel(
   dpgContext: SdkContext,
   type: Model,
-  usage?: SchemaContext[]
-): any | undefined {
-  const program = dpgContext.program;
-  const indexer = (type as Model).indexer;
-  if (indexer !== undefined) {
-    if (!isNeverType(indexer.key)) {
-      const name = indexer.key.name;
-      let schema: any = {};
-      if (name === "string") {
-        const valueType = getSchemaForType(
-          dpgContext,
-          indexer.value!,
-          usage,
-          true
-        );
-        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
-          ])}>`;
-        }
-      } else if (name === "integer") {
-        schema = {
-          type: "array",
-          items: getSchemaForType(dpgContext, indexer.value!, usage, true),
-          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>`;
-          }
+  usage: SchemaContext[]
+) {
+  const { program } = dpgContext;
+  const { indexer } = type;
+  let schema: any = {};
+  if (!indexer) {
+    return schema;
+  }
+  if (isArrayModelType(program, type)) {
+    schema = {
+      type: "array",
+      items: getSchemaForType(dpgContext, indexer.value!, usage, true),
+      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}[]`;
+        } else if (schema.items.type === "union") {
+          schema.typeName = `(${schema.items.typeName})[]`;
         } else {
-          if (schema.items.typeName) {
-            if (schema.items.type === "dictionary") {
-              schema.typeName = `${schema.items.typeName}[]`;
-            } else if (schema.items.type === "union") {
-              schema.typeName = `(${schema.items.typeName})[]`;
-            } 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.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;
+  }
+}
 
-      schema.usage = usage;
-      return schema;
+function getSchemaForRecordModel(
+  dpgContext: SdkContext,
+  type: Model,
+  usage: SchemaContext[]
+) {
+  const { program } = dpgContext;
+  const { indexer } = type;
+  let schema: any = {};
+  if (!indexer) {
+    return schema;
+  }
+  if (isRecordModelType(program, type)) {
+    const valueType = getSchemaForType(dpgContext, indexer?.value, usage, true);
+    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;
   }
 }