@groton/canvas-api.swagger-renderer 0.1.0

package/README.md

@@ -0,0 +1,117 @@
+# @groton/canvas-api.swagger-renderer
+
+Render Canvas LMS Swagger 1.0 API documentation as TypeScript client
+
+[![npm version](https://badge.fury.io/js/@groton%2Fcanvas-api.swagger-renderer.svg)](https://www.npmjs.com/package/@groton/canvas-api.swagger-renderer)
+
+## Install
+
+```sh
+npm install @groton/canvas-api.swagger-renderer
+```
+
+## Usage
+
+See all options:
+
+```sh
+swagger-renderer --help
+```
+
+Download API documentation (to `./spec/` by default):
+
+```sh
+swagger-renderer download --instanceUrl "https://example.instructure.com"
+```
+
+Render downloaded spec (from `./spec/` and to `./src/Resources/` and `./src/Endpoints/` by default):
+
+```sh
+swagger-renderer render
+```
+
+See [@groton/canvas-api's scripts](https://github.com/groton-school/canvas-cli/blob/main/packages/api/canvas-api/package.json) for an example use.
+
+## Annotation
+
+`swagger-renderer` analyzes the provided Swagger specification and annotates it before using those annotations to render the actual TypeScript source code. The annotations can be output to `./src/map.json` as part of the rendering process.
+
+```sh
+swagger-renderer render --map
+```
+
+The annotation types are defined in [./src/Render/Annotation.ts](https://github.com/groton-school/canvas-cli/blob/main/packages/api/swagger-renderer/src/Render/Annotation.ts) and [./src/Render/TSAnnotation.ts](https://github.com/groton-school/canvas-cli/blob/main/packages/api/swagger-renderer/src/Render/TSAnnotation.ts). These annotation types are useful to understand when defining overrides.
+
+## Overrides
+
+Due to eccentricities in the documentation of the Canvas LMS API, it is desireable to override the automated specification in a number of respects. See [@groton/canvas-api's known issues](https://github.com/groton-school/canvas-cli/tree/main/packages/api/canvas-api#known-issues) for discussion of a real-world example.
+
+Overrides for `swagger-renderer` are defined in a JSON file. The object has three main properties.
+
+### `tsReferences`
+
+These provide specific reference information for otherwise ambiguous types. Usually the reference information follows the pattern:
+
+```json
+{
+  "tsReferences": [
+    {
+      "type": "Account",
+      "filePath": "Resources/Accounts.ts"
+    }
+  ]
+}
+```
+
+### `tsTypes`
+
+The `tsTypes` property is a hash of type values provided in the Swagger specification to TypeScript type definitions (defined using the [annotation](#annotation) syntax).
+
+```json
+{
+  "tsTypes": {
+    "Positive Integer": {
+      "type": "number"
+    },
+    "Integer": {
+      "type": "number"
+    },
+    "DateTime": {
+      "type": "string",
+      "description": "format: date-time"
+    },
+    "object": {
+      "type": "JSONObject",
+      "tsReferences": [
+        {
+          "type": "JSONObject",
+          "packagePath": "@battis/typescript-tricks"
+        }
+      ]
+    }
+  }
+}
+```
+
+### `operations`
+
+The `operations` property is a hash of Swagger specification operation nicknames and [`Partial<AnnotatedOperation>`](https://github.com/groton-school/canvas-cli/blob/main/packages/api/swagger-renderer/src/Render/Annotation.ts) definitions to supplement or replace missing or deficient documentation.
+
+```json
+{
+  "operations": {
+    "edit_assignment": {
+      "tsFormParameters": [
+        {
+          "tsName": "\"assignment[submission_types]\"",
+          "description": "Only applies if the assignment doesn't have student submissions.\n\nList of supported submission types for the assignment.\nUnless the assignment is allowing online submissions, the array should\nonly have one element.\n\nIf not allowing online submissions, your options are:\n  \"online_quiz\"\n  \"none\"\n  \"on_paper\"\n  \"discussion_topic\"\n  \"external_tool\"\n\nIf you are allowing online submissions, you can have one or many\nallowed submission types:\n\n  \"online_upload\"\n  \"online_text_entry\"\n  \"online_url\"\n  \"media_recording\" (Only valid when the Kaltura plugin is enabled)\n  \"student_annotation\"",
+          "tsOptional": "?",
+          "tsType": {
+            "type": "('online_quiz'|'none'|'on_paper'|'discussion_topic'|'external_tool'|'online_upload'|'online_text_entry'|'online_url'|'media_recording'|'student_annotation')[]"
+          }
+        }
+      ]
+    }
+  }
+}
+```

package/bin/swagger-renderer

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import '../dist/index.js';

package/dist/Download.d.ts

@@ -0,0 +1,13 @@
+import { PathString, URLString } from '@battis/descriptive-types';
+import * as Plugin from '@battis/qui-cli.plugin';
+type Configuration = Plugin.Configuration & {
+    instanceUrl?: URLString;
+    specPath?: PathString;
+};
+export declare const name = "download";
+export declare const src: string;
+export declare function configure(config?: Configuration): void;
+export declare function options(): Plugin.Options;
+export declare function init(args: Plugin.ExpectedArguments<typeof options>): void;
+export declare function run(): Promise<string[]>;
+export {};

package/dist/Download.js

@@ -0,0 +1,78 @@
+import { Colors } from '@battis/qui-cli.colors';
+import { Log } from '@battis/qui-cli.log';
+import * as Plugin from '@battis/qui-cli.plugin';
+import { Root } from '@battis/qui-cli.root';
+import fetch from 'node-fetch';
+import fs from 'node:fs';
+import path from 'node:path';
+import ora from 'ora';
+import PQueue from 'p-queue';
+Root.configure({ root: process.cwd() });
+export const name = 'download';
+export const src = import.meta.dirname;
+let instanceUrl = 'https://canvas.instructure.com';
+let specPath = './spec';
+export function configure(config = {}) {
+    instanceUrl = Plugin.hydrate(config.instanceUrl, instanceUrl);
+    specPath = Plugin.hydrate(config.specPath, specPath);
+}
+export function options() {
+    return {
+        opt: {
+            instanceUrl: {
+                description: `URL of the Canvas instance from which to download the Swagger API spec (default: ${Colors.url(instanceUrl)})`,
+                default: instanceUrl
+            },
+            specPath: {
+                description: `Path to store the downloaded spec files (default: ${Colors.url(specPath)})`,
+                default: specPath
+            }
+        }
+    };
+}
+export function init(args) {
+    configure(args.values);
+}
+export async function run() {
+    const spinner = ora(`Downloading Swagger API definition`).start();
+    const queue = new PQueue({ interval: 1000 });
+    instanceUrl = path.join(instanceUrl, 'doc/api');
+    specPath = path.resolve(Root.path(), specPath);
+    if (!fs.existsSync(specPath)) {
+        fs.mkdirSync(specPath, { recursive: true });
+    }
+    const paths = ['/api-docs.json'];
+    const result = [];
+    do {
+        await queue.add(async () => {
+            const url = new URL(instanceUrl + paths.pop());
+            spinner.text = Colors.url(url);
+            const response = await fetch(url);
+            if (response.ok) {
+                const text = await response.text();
+                try {
+                    const swagger = JSON.parse(text);
+                    const filePath = path.join(specPath, path.basename(url.toString()));
+                    fs.writeFileSync(filePath, text);
+                    result.push(filePath);
+                    if (swagger.apis) {
+                        swagger.apis.map((api) => {
+                            if (api.path.endsWith('.json')) {
+                                paths.push(api.path);
+                            }
+                        });
+                    }
+                    spinner.succeed(url.toString());
+                }
+                catch (error) {
+                    spinner.fail(`${Colors.url(url)}: ${Colors.error(error)}`);
+                }
+            }
+            else {
+                spinner.fail(`${Colors.url(url)}: ${Colors.error(`${response.status} ${response.statusText}`)}`);
+            }
+        });
+    } while (paths.length);
+    Log.info(`Spec files written to ${Colors.url(specPath)}`);
+    return result;
+}

package/dist/Render/Annotation.d.ts

@@ -0,0 +1,46 @@
+import { PathString } from '@battis/descriptive-types';
+import * as Swagger from '@groton/swagger-spec-ts';
+import { TSDeprecation, TSExport, TSName, TSReference, TSType } from './TSAnnotation.js';
+export type AnnotatedApiObject = Swagger.v1p2.ApiObject & {
+    operations: AnnotatedOperation[];
+};
+export type AnnotatedOperation = Swagger.v1p2.OperationObject & {
+    specPath: PathString;
+    tsFilePath: PathString;
+    tsImports?: TSReference[];
+    tsEndpoint?: PathString;
+    tsName: TSName;
+    tsType: TSType;
+    tsPathParameters?: (AnnotatedParameter & {
+        paramType: 'path';
+    })[];
+    tsQueryParameters?: (AnnotatedParameter & {
+        paramType: 'query';
+    })[];
+    tsBodyParameters?: (AnnotatedParameter & {
+        paramType: 'body';
+    })[];
+    tsFormParameters?: (AnnotatedParameter & {
+        paramType: 'form';
+    })[];
+    tsPaginated?: boolean;
+    tsUpload?: boolean;
+};
+export type AnnotatedParameter = Swagger.v1p2.ParameterObject & {
+    tsDeprecation?: TSDeprecation;
+    tsName: TSName;
+    tsType: TSType;
+};
+export type AnnotatedModel = Omit<Swagger.v1p2.ModelsObject, 'properties'> & {
+    specPath: PathString;
+    tsImports?: TSReference[];
+    tsDeprecation?: TSDeprecation;
+    tsExport?: TSExport;
+    tsName: TSName;
+    properties: AnnotatedProperty[];
+};
+export type AnnotatedProperty = Swagger.v1p2.DataTypeBase & {
+    tsDeprecation?: TSDeprecation;
+    tsName: TSName;
+    tsType: TSType;
+};

package/dist/Render/Annotation.js

@@ -0,0 +1 @@
+export {};

package/dist/Render/Models.d.ts

@@ -0,0 +1,14 @@
+import { PathString } from '@battis/descriptive-types';
+import * as Swagger from '@groton/swagger-spec-ts';
+import { AnnotatedModel } from './Annotation.js';
+type GenerateOptions = {
+    specPaths: PathString[];
+    templatePath: PathString;
+    outputPath: PathString;
+};
+export type Annotation = {
+    spec: Record<PathString, Swagger.v1p2.ApiDeclaration[]>;
+    models: Record<PathString, AnnotatedModel[]>;
+};
+export declare function generate(options: GenerateOptions): Promise<Annotation>;
+export {};

package/dist/Render/Models.js

@@ -0,0 +1,135 @@
+import Handlebars from 'handlebars';
+import fs from 'node:fs';
+import path from 'node:path';
+import { importPath } from './importPath.js';
+import * as Overrides from './Overrides.js';
+import { toTSDeprecation, toTSExport, toTSNamespace, toTSPropertyName, toTSType, toTSTypeName } from './TypeScript.js';
+import { writePrettier } from './writePrettier.js';
+export async function generate(options) {
+    const annotations = annotateFileList(options);
+    annotateImports(annotations);
+    const outputOptions = {
+        ...options,
+        ...annotations
+    };
+    await outputModels(outputOptions);
+    await outputModelIndex(outputOptions);
+    return annotations;
+}
+function annotateFileList({ outputPath, specPaths }) {
+    const annotation = { spec: {}, models: {} };
+    for (const specPath of specPaths) {
+        const annotatedSpec = annotateJSONFile({ specPath, outputPath });
+        annotation.spec = { ...annotation.spec, ...annotatedSpec.spec };
+        annotation.models = { ...annotation.models, ...annotatedSpec.models };
+    }
+    return annotation;
+}
+function annotateJSONFile({ specPath, outputPath }) {
+    const spec = JSON.parse(fs.readFileSync(specPath).toString());
+    return {
+        spec: { [specPath]: [spec] },
+        models: {
+            [toFilePath(outputPath, specPath)]: annotateModels(spec, specPath)
+        }
+    };
+}
+function annotateModels(api, specPath) {
+    const models = [];
+    for (const modelId in api.models) {
+        const model = api.models[modelId];
+        const properties = [];
+        const tsImports = [];
+        for (const propertyId in model.properties) {
+            const property = model.properties[propertyId];
+            const annotatedProperty = {
+                ...property,
+                tsDeprecation: toTSDeprecation(property),
+                tsName: toTSPropertyName(propertyId),
+                tsType: toTSType(property)
+            };
+            properties.push(annotatedProperty);
+            if (annotatedProperty.tsType.tsReferences) {
+                tsImports.push(...annotatedProperty.tsType.tsReferences);
+            }
+        }
+        const annotatedModel = {
+            specPath,
+            ...model,
+            tsImports,
+            tsDeprecation: toTSDeprecation(model),
+            tsName: toTSTypeName(modelId),
+            properties
+        };
+        annotatedModel.tsExport = toTSExport(annotatedModel);
+        /*
+         * TODO force IDs to strings
+         *   https://developerdocs.instructure.com/services/canvas#schema
+         */
+        models.push(annotatedModel);
+    }
+    return models.map((model) => {
+        model.tsImports = model.tsImports?.filter((tsType) => !models.find((model) => model.tsName === tsType.type));
+        return model;
+    });
+}
+function annotateImports(annotation) {
+    for (const filePath in annotation.models) {
+        for (const model of annotation.models[filePath]) {
+            for (const tsImport of model.tsImports || []) {
+                tsImport.filePath =
+                    Overrides.tsReference(tsImport.type)?.filePath ||
+                        Object.keys(annotation.models).find((filePath) => annotation.models[filePath]
+                            .map((model) => model.tsName)
+                            .includes(tsImport.type));
+            }
+        }
+    }
+}
+async function outputModels({ templatePath, outputPath, models }) {
+    const template = Handlebars.compile(fs.readFileSync(path.join(templatePath, 'Model.handlebars')).toString());
+    fs.mkdirSync(outputPath, { recursive: true });
+    for (const filePath in models) {
+        if (models[filePath].length) {
+            await writePrettier(filePath, template({
+                models: models[filePath],
+                tsImports: models[filePath]
+                    .reduce((tsImports, model) => {
+                    for (const tsImport of model.tsImports || []) {
+                        if (!tsImports.find((t) => t.type === tsImport.type)) {
+                            tsImports.push(tsImport);
+                        }
+                    }
+                    return tsImports;
+                }, [])
+                    .map((tsImport) => {
+                    if (tsImport.filePath) {
+                        return {
+                            ...tsImport,
+                            filePath: importPath(filePath, tsImport.filePath)
+                        };
+                    }
+                    return tsImport;
+                })
+            }));
+        }
+    }
+}
+async function outputModelIndex({ templatePath, outputPath, models }) {
+    const template = Handlebars.compile(fs.readFileSync(path.join(templatePath, 'ModelIndex.handlebars')).toString());
+    await writePrettier(path.join(outputPath, 'index.ts'), template({
+        index: Object.keys(models)
+            .filter((filePath) => models[filePath].length)
+            .map((filePath) => ({
+            tsNamespace: toTSNamespace(filePath),
+            filePath: importPath(path.join(outputPath, 'index.ts'), filePath)
+        }))
+    }));
+}
+function toFilePath(outputPath, specPath) {
+    return path.join(outputPath, path
+        .basename(specPath, '.json')
+        .split('_')
+        .map((token) => token[0].toUpperCase() + token.slice(1))
+        .join('') + '.ts');
+}

package/dist/Render/Operations.d.ts

@@ -0,0 +1,16 @@
+import { PathString } from '@battis/descriptive-types';
+import { AnnotatedOperation } from './Annotation.js';
+import * as Models from './Models.js';
+type GenerateOptions = Models.Annotation & {
+    outputPath: PathString;
+    templatePath: PathString;
+};
+type AnnotateOptions = Models.Annotation & {
+    outputPath: PathString;
+};
+type Annotation = Models.Annotation & {
+    operations: Record<PathString, AnnotatedOperation>;
+};
+export declare function generate({ spec, models, outputPath, templatePath }: GenerateOptions): Promise<Annotation>;
+export declare function annotateOperations({ outputPath, ...annotation }: AnnotateOptions): Annotation;
+export {};

package/dist/Render/Operations.js

@@ -0,0 +1,234 @@
+import Handlebars from 'handlebars';
+import fs from 'node:fs';
+import path from 'node:path';
+import { importPath } from './importPath.js';
+import * as Overrides from './Overrides.js';
+import { toTSDeprecation, toTSNamespace, toTSPropertyName, toTSType } from './TypeScript.js';
+import { writePrettier } from './writePrettier.js';
+export async function generate({ spec, models, outputPath, templatePath }) {
+    const annotation = annotateOperations({ spec, models, outputPath });
+    annotateImports(annotation);
+    await outputOperations({ ...annotation, outputPath, templatePath });
+    await outputOperationIndices(outputPath, templatePath);
+    return annotation;
+}
+export function annotateOperations({ outputPath, ...annotation }) {
+    const clientReference = {
+        type: 'client',
+        filePath: path.join(outputPath, '../Client.ts')
+    };
+    const operations = {};
+    for (const specPath in annotation.spec) {
+        for (const spec of annotation.spec[specPath]) {
+            for (const endpoint of spec.apis) {
+                for (const operation of endpoint.operations || []) {
+                    const tsImports = [{ ...clientReference }];
+                    const tsName = toTSMethodName(operation);
+                    let tsType = toTSType(operation);
+                    if (tsType.type === 'unknown' && operation.type) {
+                        tsType = {
+                            type: operation.type,
+                            tsReferences: [{ type: operation.type }]
+                        };
+                    }
+                    if (tsType.tsReferences) {
+                        tsImports.push(...tsType.tsReferences);
+                    }
+                    let tsPaginated = undefined;
+                    if (tsType.type.endsWith('[]')) {
+                        tsPaginated = true;
+                        tsImports.push({
+                            type: 'Paginated',
+                            packagePath: '@groton/canvas-api.client.base'
+                        });
+                    }
+                    const tsUpload = tsName === 'upload';
+                    if (tsUpload) {
+                        tsImports.push({
+                            type: 'FileLocation',
+                            packagePath: '@groton/canvas-api.client.base'
+                        });
+                    }
+                    // @ts-expect-error 2322 TODO $ref typing
+                    const annotatedOperation = {
+                        ...operation,
+                        specPath,
+                        tsImports,
+                        tsType,
+                        tsEndpoint: decodeURIComponent(new URL(spec.basePath + endpoint.path).pathname),
+                        tsName,
+                        tsUpload,
+                        tsPaginated
+                    };
+                    annotatedOperation.tsFilePath = path.join(outputPath, toOperationPath(endpoint.path, annotatedOperation), tsName + '.ts');
+                    for (const parameter of operation.parameters) {
+                        const annotatedParameter = {
+                            ...parameter,
+                            tsDeprecation: toTSDeprecation(parameter),
+                            tsName: toTSPropertyName(parameter.name),
+                            tsType: toTSType(parameter)
+                        };
+                        if (annotatedParameter.tsType.type === 'unknown') {
+                            annotatedParameter.tsType = {
+                                type: parameter.type,
+                                tsReferences: [{ type: parameter.type }]
+                            };
+                        }
+                        if (annotatedParameter.tsType.tsReferences) {
+                            annotatedOperation.tsImports.push(...annotatedParameter.tsType.tsReferences);
+                        }
+                        const paramType = ('ts' +
+                            annotatedParameter.paramType[0].toUpperCase() +
+                            annotatedParameter.paramType.slice(1) +
+                            'Parameters');
+                        if (!(paramType in annotatedOperation)) {
+                            annotatedOperation[paramType] = [];
+                        }
+                        if (Array.isArray(annotatedOperation[paramType])) {
+                            // @ts-expect-error 2345 TODO fix wonky annotation typing
+                            annotatedOperation[paramType].push(annotatedParameter);
+                        }
+                        // force path params to accept numbers too
+                        for (const param of annotatedOperation['tsPathParameters'] || []) {
+                            if ((param.name === 'id' || /_id$/.test(param.name)) &&
+                                param.tsType.type === 'string') {
+                                param.tsType.description = `type: ${param.tsType.type} ${param.tsType.description || ''}`;
+                                param.tsType.type = `${param.tsType.type} | number`;
+                            }
+                        }
+                    }
+                    operations[annotatedOperation.tsFilePath] =
+                        Overrides.operation(annotatedOperation);
+                }
+            }
+        }
+    }
+    return { ...annotation, operations };
+}
+function annotateImports({ operations, models }) {
+    for (const filePath in operations) {
+        operations[filePath].tsImports = operations[filePath].tsImports?.reduce((tsImports, tsReference) => {
+            const match = tsImports.find((t) => t.type === tsReference.type);
+            if (!match) {
+                tsImports.push(tsReference);
+            }
+            else {
+                if ((match.filePath && match.filePath !== tsReference.filePath) ||
+                    (match.packagePath && match.packagePath !== tsReference.packagePath)) {
+                    throw new TypeError(`Importing two identically named objects from different files: ${JSON.stringify({ tsReference, match })}.`);
+                }
+            }
+            return tsImports;
+        }, []);
+        for (const tsImport of operations[filePath].tsImports || []) {
+            tsImport.filePath =
+                tsImport.filePath ||
+                    // look first for definitions local to the same spec file
+                    Object.keys(models).find((filePath) => models[filePath].find((model) => model.specPath === operations[filePath]?.specPath &&
+                        model.tsName == tsImport.type)) ||
+                    // check for overrides
+                    Overrides.tsReference(tsImport.type)?.filePath ||
+                    // find what's available
+                    Object.keys(models).find((filePath) => models[filePath].map((model) => model.tsName).includes(tsImport.type));
+        }
+    }
+}
+function toOperationPath(endpointPath, operation) {
+    return operation.parameters
+        .reduce((tsFilePath, parameter) => {
+        if (parameter.paramType === 'path') {
+            return tsFilePath.replace(new RegExp(`{${parameter.name}}/?`), '');
+        }
+        return tsFilePath;
+    }, endpointPath)
+        .split('/')
+        .map((token) => token.length
+        ? token
+            .split('_')
+            .map((t) => t[0].toUpperCase() + t.slice(1))
+            .join('')
+        : undefined)
+        .join('/');
+}
+function toTSMethodName(operation) {
+    switch (operation.method) {
+        case 'GET':
+            if (operation.nickname.startsWith('list_')) {
+                return 'list';
+            }
+            if (operation.nickname.startsWith('get_')) {
+                return 'get';
+            }
+        // eslint-disable-next-line no-fallthrough
+        case 'POST':
+            if (operation.nickname.startsWith('create_')) {
+                return 'create';
+            }
+            else if (operation.nickname.startsWith('upload_file')) {
+                return 'upload';
+            }
+        // eslint-disable-next-line no-fallthrough
+        case 'PUT':
+            if (operation.nickname.startsWith('update_') ||
+                operation.nickname.startsWith('edit_')) {
+                return 'update';
+            }
+        // eslint-disable-next-line no-fallthrough
+        case 'PATCH':
+            if (operation.nickname.startsWith('batch_update_')) {
+                return 'batchUpdate';
+            }
+        // eslint-disable-next-line no-fallthrough
+        default:
+            return operation.nickname;
+    }
+}
+async function outputOperations({ operations, templatePath }) {
+    const template = Handlebars.compile(fs.readFileSync(path.join(templatePath, 'Operation.handlebars')).toString());
+    for (const filePath in operations) {
+        await writePrettier(filePath, template({
+            ...operations[filePath],
+            tsImports: operations[filePath].tsImports?.map((tsImport) => {
+                if (tsImport.filePath) {
+                    return {
+                        ...tsImport,
+                        filePath: importPath(filePath, tsImport.filePath)
+                    };
+                }
+                return tsImport;
+            })
+        }));
+    }
+}
+async function outputOperationIndices(outputPath, templatePath) {
+    const template = Handlebars.compile(fs
+        .readFileSync(path.join(templatePath, 'OperationIndex.handlebars'))
+        .toString());
+    async function recursiveIndex(outputPath) {
+        const modules = await Promise.all(fs
+            .readdirSync(outputPath)
+            .filter((fileName) => !fileName.startsWith('.'))
+            .map((fileName) => ({
+            tsNamespace: `as ${toTSNamespace(fileName)}`,
+            filePath: path.join(outputPath, fileName)
+        }))
+            .map(async (module) => {
+            if (fs.lstatSync(module.filePath).isDirectory()) {
+                await recursiveIndex(module.filePath);
+                module.filePath = path.join(module.filePath, 'index.ts');
+            }
+            else {
+                module.tsNamespace = '';
+            }
+            return module;
+        }));
+        const filePath = path.join(outputPath, 'index.ts');
+        await writePrettier(filePath, template({
+            modules: modules.map((module) => ({
+                ...module,
+                filePath: importPath(filePath, module.filePath)
+            }))
+        }));
+    }
+    await recursiveIndex(outputPath);
+}

package/dist/Render/Overrides.d.ts

@@ -0,0 +1,16 @@
+import { PathString } from '@battis/descriptive-types';
+import { AnnotatedOperation } from './Annotation.js';
+import { TSName, TSReference, TSType } from './TSAnnotation.js';
+export type Collection = {
+    /** Import paths for ambiguously specified types */
+    tsReferences?: TSReference[];
+    /** Hash of non-standard type values to TSType definitions */
+    tsTypes?: Record<string, TSType>;
+    /** Hash of OperationObject.nickname to partial OperationObject definitions */
+    operations?: Record<string, Partial<AnnotatedOperation>>;
+};
+export declare function setOverrides(overrides: Collection): void;
+export declare function setOutputPath(outputPath: PathString): void;
+export declare function tsReference(type: TSName): TSReference | undefined;
+export declare function tsType(type: string): TSType | undefined;
+export declare function operation(operation: AnnotatedOperation): AnnotatedOperation;