@counterfact/generator 0.1.1

package/dist/response-type-coder.js

@@ -0,0 +1,104 @@
+import { STREAMING_CONTENT_TYPES } from "@counterfact/types/streaming-content-types";
+import { pathJoin } from "./forward-slash-path.js";
+import { printObject } from "./printers.js";
+import { SchemaTypeCoder } from "./schema-type-coder.js";
+import { TypeCoder } from "./type-coder.js";
+export class ResponseTypeCoder extends TypeCoder {
+    openApi2MediaTypes;
+    constructor(requirement, version = "", openApi2MediaTypes = []) {
+        super(requirement, version);
+        this.openApi2MediaTypes = openApi2MediaTypes;
+    }
+    names() {
+        return super.names(this.requirement.refUrl.split("/").at(-1));
+    }
+    buildContentObjectType(script, response) {
+        if (response.has("content")) {
+            return response
+                .get("content")
+                .map((content, mediaType) => {
+                let schemaType;
+                if (content.has("itemSchema") &&
+                    STREAMING_CONTENT_TYPES.has(mediaType)) {
+                    schemaType = `AsyncIterable<${new SchemaTypeCoder(content.get("itemSchema"), this.version).write(script)}>`;
+                }
+                else {
+                    schemaType = content.has("schema")
+                        ? new SchemaTypeCoder(content.get("schema"), this.version).write(script)
+                        : "unknown";
+                }
+                return [
+                    mediaType,
+                    `{ 
+            schema:  ${schemaType}
+         }`,
+                ];
+            });
+        }
+        return this.openApi2MediaTypes.map((mediaType) => [
+            mediaType,
+            `{
+            schema: ${new SchemaTypeCoder(response.get("schema"), this.version).write(script)}
+         }`,
+        ]);
+    }
+    printContentObjectType(script, response) {
+        if (response.has("content") || response.has("schema")) {
+            return printObject(this.buildContentObjectType(script, response));
+        }
+        return "never";
+    }
+    buildHeaders(script, response) {
+        return response
+            .get("headers")
+            .map((value, name) => [
+            name,
+            `{ schema: ${new SchemaTypeCoder(value.get("schema") ?? value, this.version).write(script)}}`,
+        ]);
+    }
+    printHeaders(script, response) {
+        if (!response.has("headers")) {
+            return "never";
+        }
+        return printObject(this.buildHeaders(script, response));
+    }
+    printRequiredHeaders(response) {
+        const requiredHeaders = (response.get("headers")?.map((value, name) => ({
+            name,
+            required: value.data.required,
+        })) ?? [])
+            .filter(({ required }) => required)
+            .map(({ name }) => `"${name}"`);
+        return requiredHeaders.length === 0 ? "never" : requiredHeaders.join(" | ");
+    }
+    buildExamplesObjectType(response) {
+        if (!response.has("content")) {
+            return "{}";
+        }
+        const exampleNames = [];
+        response.get("content").forEach((content) => {
+            if (content.has("examples")) {
+                content.get("examples").forEach((_, name) => {
+                    if (!exampleNames.includes(name)) {
+                        exampleNames.push(name);
+                    }
+                });
+            }
+        });
+        if (exampleNames.length === 0) {
+            return "{}";
+        }
+        return printObject(exampleNames.map((name) => [name, "unknown"]));
+    }
+    modulePath() {
+        return pathJoin("types", this.version, this.requirement.refUrl + ".ts");
+    }
+    writeCode(script) {
+        return `{
+          headers: ${this.printHeaders(script, this.requirement)};
+          requiredHeaders: ${this.printRequiredHeaders(this.requirement)};
+          content: ${this.printContentObjectType(script, this.requirement)};
+          examples: ${this.buildExamplesObjectType(this.requirement)};
+        }`;
+    }
+}

package/dist/responses-type-coder.d.ts

@@ -0,0 +1,11 @@
+import { TypeCoder } from "./type-coder.js";
+import type { Requirement } from "./requirement.js";
+import type { Script } from "./script.js";
+export declare class ResponsesTypeCoder extends TypeCoder {
+    openApi2MediaTypes: string[];
+    constructor(requirement: Requirement, version?: string, openApi2MediaTypes?: string[]);
+    typeForDefaultStatusCode(listedStatusCodes: string[]): string;
+    normalizeStatusCode(statusCode: string): string;
+    buildResponseObjectType(script: Script): string;
+    writeCode(script: Script): string;
+}

package/dist/responses-type-coder.js

@@ -0,0 +1,43 @@
+import { printObjectWithoutQuotes } from "./printers.js";
+import { ResponseTypeCoder } from "./response-type-coder.js";
+import { TypeCoder } from "./type-coder.js";
+export class ResponsesTypeCoder extends TypeCoder {
+    openApi2MediaTypes;
+    constructor(requirement, version = "", openApi2MediaTypes = []) {
+        super(requirement, version);
+        this.openApi2MediaTypes = openApi2MediaTypes;
+    }
+    typeForDefaultStatusCode(listedStatusCodes) {
+        const definedStatusCodes = listedStatusCodes.filter((key) => key !== "default");
+        if (definedStatusCodes.length === 0) {
+            return "[statusCode in HttpStatusCode]";
+        }
+        return `[statusCode in Exclude<HttpStatusCode, ${definedStatusCodes.join(" | ")}>]`;
+    }
+    normalizeStatusCode(statusCode) {
+        if (statusCode === "default") {
+            return this.typeForDefaultStatusCode(Object.keys(this.requirement.data));
+        }
+        return statusCode;
+    }
+    buildResponseObjectType(script) {
+        const entries = this.requirement.map((response, responseCode) => [
+            this.normalizeStatusCode(responseCode),
+            new ResponseTypeCoder(response, this.version, this.openApi2MediaTypes).write(script),
+        ]);
+        const explicitEntries = entries.filter(([key]) => !key.startsWith("["));
+        const mappedEntries = entries.filter(([key]) => key.startsWith("["));
+        if (explicitEntries.length > 0 && mappedEntries.length > 0) {
+            return `${printObjectWithoutQuotes(explicitEntries)} & ${printObjectWithoutQuotes(mappedEntries)}`;
+        }
+        return printObjectWithoutQuotes(entries);
+    }
+    writeCode(script) {
+        script.importSharedType("ResponseBuilderFactory");
+        const text = `ResponseBuilderFactory<${this.buildResponseObjectType(script)}>`;
+        if (text.includes("HttpStatusCode")) {
+            script.importSharedType("HttpStatusCode");
+        }
+        return text;
+    }
+}

package/dist/scenario-file-generator.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Encapsulates the generation of scenario-related files:
+ * - `types/_.context.ts` — the typed `Scenario$` interface derived from all
+ *   `_.context.ts` files found under `routes/`.
+ * - `scenarios/index.ts` — the default scenarios entry-point (created only if
+ *   it does not already exist).
+ *
+ * When {@link watch} is called, file-system watchers monitor the `routes/`
+ * directory for changes to `_.context.ts` files and the application root's
+ * optional `_.store.ts`, automatically regenerating `types/_.context.ts` and
+ * the mirrored `_.middleware.ts` files under `types/`.
+ */
+export declare class ScenarioFileGenerator {
+    private readonly destination;
+    private readonly rootDestination;
+    private watcher;
+    private storeWatcher;
+    constructor(destination: string, rootDestination?: string);
+    /** Generates both scenario-related files once and resolves when complete. */
+    generate(): Promise<void>;
+    /**
+     * Starts watching route context files and the exact application-root store
+     * path, regenerating `types/_.context.ts` and the mirrored `_.middleware.ts`
+     * files under `types/` on every relevant change.
+     *
+     * Resolves once the watcher is ready.
+     */
+    watch(): Promise<void>;
+    /** Closes the file-system watcher. */
+    stopWatching(): Promise<void>;
+}

package/dist/scenario-file-generator.js

@@ -0,0 +1,368 @@
+import { existsSync } from "node:fs";
+import fs from "node:fs/promises";
+import nodePath from "node:path";
+/* eslint-disable security/detect-non-literal-fs-filename -- scenario files are discovered and generated under the configured destination tree. */
+import { watch } from "chokidar";
+import { pathRelative } from "./forward-slash-path.js";
+import { waitForEvent } from "./wait-for-event.js";
+import { CHOKIDAR_OPTIONS } from "./watch-options.js";
+const GENERATED_FILE_COMMENT = "// This file is generated by Counterfact. Do not edit manually.";
+async function collectContextFiles(destination) {
+    const routesDir = nodePath.join(destination, "routes");
+    const results = [];
+    if (!existsSync(routesDir)) {
+        return results;
+    }
+    await walkForContextFiles(routesDir, routesDir, results);
+    results.sort((a, b) => b.depth - a.depth);
+    return results;
+}
+async function walkForContextFiles(routesDir, currentDir, results) {
+    let entries;
+    try {
+        entries = await fs.readdir(currentDir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        if (entry.isDirectory()) {
+            await walkForContextFiles(routesDir, nodePath.join(currentDir, entry.name), results);
+        }
+        else if (entry.name === "_.context.ts") {
+            const relDir = pathRelative(routesDir, currentDir);
+            const routePath = relDir === "" ? "/" : `/${relDir}`;
+            const depth = relDir === "" ? 0 : relDir.split("/").length;
+            const importPath = relDir === "" ? "../routes/_.context" : `../routes/${relDir}/_.context`;
+            const alias = routePathToAlias(routePath);
+            results.push({ importPath, alias, routePath, depth });
+        }
+    }
+}
+async function collectRouteDirectories(destination) {
+    const routesDir = nodePath.join(destination, "routes");
+    if (!existsSync(routesDir)) {
+        return [];
+    }
+    const results = [];
+    await walkRouteDirectories(routesDir, routesDir, undefined, results);
+    return results;
+}
+async function walkRouteDirectories(routesDir, currentDir, inheritedContextFile, results) {
+    let entries;
+    try {
+        entries = await fs.readdir(currentDir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    const localContextFile = entries.some((entry) => entry.isFile() && entry.name === "_.context.ts")
+        ? nodePath.join(currentDir, "_.context.ts")
+        : inheritedContextFile;
+    results.push({
+        contextFile: localContextFile,
+        relativePath: pathRelative(routesDir, currentDir),
+    });
+    for (const entry of entries) {
+        if (entry.isDirectory()) {
+            await walkRouteDirectories(routesDir, nodePath.join(currentDir, entry.name), localContextFile, results);
+        }
+    }
+}
+function routePathToAlias(routePath) {
+    if (routePath === "/") {
+        return "Context";
+    }
+    return (routePath
+        .split("/")
+        .filter(Boolean)
+        .map((seg) => seg
+        .replace(/\{(.+?)\}/g, (_match, name) => name.replace(/[^a-z0-9]/gi, " "))
+        .replace(/[-_\s]([a-z])/g, (_match, c) => c.toUpperCase())
+        .replace(/^[a-z]/, (c) => c.toUpperCase())
+        .replace(/[^a-z0-9]/gi, ""))
+        .join("") + "Context");
+}
+const PARAM_SEGMENT_REGEX = /^\{.+\}$/u;
+function buildLoadContextOverload(routePath, alias) {
+    if (routePath === "/") {
+        return '  loadContext(path: "/" | `/${string}`): ' + alias + ";";
+    }
+    const segments = routePath.split("/").filter(Boolean);
+    const hasParam = segments.some((seg) => PARAM_SEGMENT_REGEX.test(seg));
+    if (!hasParam) {
+        return `  loadContext(path: "${routePath}" | \`${routePath}/\${string}\`): ${alias};`;
+    }
+    const templatePath = `/${segments
+        .map((seg) => (PARAM_SEGMENT_REGEX.test(seg) ? "${string}" : seg))
+        .join("/")}`;
+    return `  loadContext(path: \`${templatePath}\`): ${alias};`;
+}
+function buildScenarioContextContent(contextFiles, storeImportPath) {
+    const rootContext = contextFiles.find((f) => f.routePath === "/");
+    const contextType = rootContext
+        ? rootContext.alias
+        : "Record<string, unknown>";
+    const importLines = contextFiles.map(({ importPath, alias }) => alias === "Context"
+        ? `import type { Context } from "${importPath}";`
+        : `import type { Context as ${alias} } from "${importPath}";`);
+    if (storeImportPath !== undefined) {
+        importLines.push(`import type { Store } from "${storeImportPath}";`);
+    }
+    const overloadLines = contextFiles.map(({ alias, routePath }) => buildLoadContextOverload(routePath, alias));
+    const parts = [
+        GENERATED_FILE_COMMENT,
+        ...importLines,
+        "",
+        "interface LoadContextDefinitions {",
+        "  /* code generator adds additional signatures here */",
+        ...overloadLines,
+        "  loadContext(path: string): Record<string, unknown>;",
+        "}",
+        "",
+        "export interface Scenario$ {",
+        '  /** Root context, same as loadContext("/") */',
+        `  readonly context: ${contextType};`,
+        '  readonly loadContext: LoadContextDefinitions["loadContext"];',
+        "  /** Named route builders stored in the REPL execution context */",
+        "  readonly routes: Record<string, unknown>;",
+        "  /** Create a new route builder for a given path */",
+        "  readonly route: (path: string) => unknown;",
+        "}",
+        "",
+        "/** A scenario function that receives the live REPL environment */",
+        "export type Scenario = ($: Scenario$) => Promise<void> | void;",
+        "",
+        "/** Interface for Context objects defined in _.context.ts files */",
+        "export interface Context$ {",
+        ...(storeImportPath === undefined
+            ? []
+            : [
+                "  /** Application-level store shared by every API group */",
+                "  readonly store: Store;",
+            ]),
+        "  /** Load a context object for a specific path */",
+        '  readonly loadContext: LoadContextDefinitions["loadContext"];',
+        "  /** Load a JSON file relative to this file's path */",
+        "  readonly readJson: (relativePath: string) => Promise<unknown>;",
+        "}",
+        "",
+    ];
+    return parts.join("\n");
+}
+function ensureRelativeImportPath(path) {
+    return path.startsWith(".") ? path : `./${path}`;
+}
+function buildMiddlewareTypeContent(destination, routeDirectory) {
+    const typesDirectory = nodePath.join(destination, "types", routeDirectory.relativePath);
+    const sharedTypePath = ensureRelativeImportPath(pathRelative(typesDirectory, nodePath.join(destination, "counterfact-types", "index.js")));
+    const lines = [
+        GENERATED_FILE_COMMENT,
+        `import type { Middleware as MiddlewareFunction } from "${sharedTypePath}";`,
+    ];
+    if (routeDirectory.contextFile === undefined) {
+        lines.push("", "export type Middleware = MiddlewareFunction;");
+    }
+    else {
+        const contextImportPath = ensureRelativeImportPath(pathRelative(typesDirectory, routeDirectory.contextFile).replace(/\.ts$/u, ".js"));
+        lines.push(`import type { Context } from "${contextImportPath}";`, "", "export type Middleware = MiddlewareFunction<Context>;");
+    }
+    return `${lines.join("\n")}\n`;
+}
+async function collectGeneratedMiddlewareTypeFiles(directory) {
+    let entries;
+    try {
+        entries = await fs.readdir(directory, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const files = [];
+    for (const entry of entries) {
+        const path = nodePath.join(directory, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...(await collectGeneratedMiddlewareTypeFiles(path)));
+        }
+        else if (entry.name === "_.middleware.ts") {
+            const content = await fs.readFile(path, "utf8");
+            if (content.startsWith(GENERATED_FILE_COMMENT)) {
+                files.push(path);
+            }
+        }
+    }
+    return files;
+}
+async function writeMiddlewareTypes(destination) {
+    const routeDirectories = await collectRouteDirectories(destination);
+    const expectedFiles = new Set();
+    for (const routeDirectory of routeDirectories) {
+        const filePath = nodePath.join(destination, "types", routeDirectory.relativePath, "_.middleware.ts");
+        expectedFiles.add(nodePath.resolve(filePath));
+        await fs.mkdir(nodePath.dirname(filePath), { recursive: true });
+        await fs.writeFile(filePath, buildMiddlewareTypeContent(destination, routeDirectory), "utf8");
+    }
+    const generatedFiles = await collectGeneratedMiddlewareTypeFiles(nodePath.join(destination, "types"));
+    await Promise.all(generatedFiles
+        .filter((file) => !expectedFiles.has(nodePath.resolve(file)))
+        .map((file) => fs.rm(file)));
+}
+/**
+ * Writes the `types/_.context.ts` file, which exports the
+ * `Scenario$` interface used to type scenario functions.
+ *
+ * The interface is generated from all `_.context.ts` files found under the
+ * `routes/` directory, providing strongly typed `loadContext()` overloads for
+ * every route path that has a context file.
+ *
+ * @param destination - Root output directory.
+ * @param rootDestination - Application root containing the optional store.
+ */
+async function writeScenarioContextType(destination, rootDestination) {
+    const typesDir = nodePath.join(destination, "types");
+    const filePath = nodePath.join(typesDir, "_.context.ts");
+    const storePath = nodePath.join(rootDestination, "_.store.ts");
+    const contextFiles = await collectContextFiles(destination);
+    const relativeStorePath = pathRelative(typesDir, storePath);
+    const storeImportPath = existsSync(storePath)
+        ? `${relativeStorePath.startsWith(".") ? "" : "./"}${relativeStorePath.replace(/\.ts$/u, ".js")}`
+        : undefined;
+    const content = buildScenarioContextContent(contextFiles, storeImportPath);
+    await fs.mkdir(typesDir, { recursive: true });
+    await fs.writeFile(filePath, content, "utf8");
+}
+const DEFAULT_SCENARIOS_INDEX = `import type { Scenario } from "../types/_.context.js";
+
+/**
+ * Scenario scripts are plain TypeScript functions that receive the live REPL
+ * environment and can read or mutate server state. Run them from the REPL with:
+ *   .scenario <functionName>
+ */
+
+/**
+ * Read or mutate the root context (same object routes see as $.context):
+ *   $.context.<property> = <value>;
+ *
+ * Load a context for a specific path:
+ *   const petsCtx = $.loadContext("/pets");
+ *
+ * Store a pre-configured route builder for later use in the REPL:
+ *   $.routes.myRequest = $.route("/pets").method("get");
+ */
+
+/**
+ * startup() runs automatically when the server initializes, right before the
+ * REPL starts. Use it to seed dummy data so the server is ready to use
+ * immediately. It receives the same $ argument as all other scenario functions.
+ *
+ * Tip: delegate to other scenario functions and pass $ along so each function
+ * stays focused on a single concern. You can also pass additional arguments to
+ * configure them, e.g. addPets($, 20, "dog").
+ *
+ * If you don't need a startup scenario, delete this function or leave it empty.
+ */
+export const startup: Scenario = ($) => {
+  void $;
+};
+
+/**
+ * An example scenario. To use it in the REPL, type:
+ *   .scenario help
+ */
+export const help: Scenario = ($) => {
+  void $;
+
+  console.log(
+    [
+      "Scenarios are functions that populate the context object",
+      "and / or the REPL environment. They are intended to",
+      "populate your environment with specific data and",
+      "configurations for testing purposes.",
+    ].join("\\n"),
+  );
+
+  console.log(
+    "\\nScenarios (including this one) are defined in the ./scenarios directory.",
+  );
+};
+`;
+async function writeDefaultScenariosIndex(destination) {
+    const scenariosDir = nodePath.join(destination, "scenarios");
+    const filePath = nodePath.join(scenariosDir, "index.ts");
+    if (existsSync(filePath)) {
+        return;
+    }
+    await fs.mkdir(scenariosDir, { recursive: true });
+    await fs.writeFile(filePath, DEFAULT_SCENARIOS_INDEX, "utf8");
+}
+/**
+ * Encapsulates the generation of scenario-related files:
+ * - `types/_.context.ts` — the typed `Scenario$` interface derived from all
+ *   `_.context.ts` files found under `routes/`.
+ * - `scenarios/index.ts` — the default scenarios entry-point (created only if
+ *   it does not already exist).
+ *
+ * When {@link watch} is called, file-system watchers monitor the `routes/`
+ * directory for changes to `_.context.ts` files and the application root's
+ * optional `_.store.ts`, automatically regenerating `types/_.context.ts` and
+ * the mirrored `_.middleware.ts` files under `types/`.
+ */
+export class ScenarioFileGenerator {
+    destination;
+    rootDestination;
+    watcher;
+    storeWatcher;
+    constructor(destination, rootDestination = destination) {
+        this.destination = destination;
+        this.rootDestination = rootDestination;
+    }
+    /** Generates both scenario-related files once and resolves when complete. */
+    async generate() {
+        await writeScenarioContextType(this.destination, this.rootDestination);
+        await writeMiddlewareTypes(this.destination);
+        await writeDefaultScenariosIndex(this.destination);
+    }
+    /**
+     * Starts watching route context files and the exact application-root store
+     * path, regenerating `types/_.context.ts` and the mirrored `_.middleware.ts`
+     * files under `types/` on every relevant change.
+     *
+     * Resolves once the watcher is ready.
+     */
+    async watch() {
+        const routesDir = nodePath.join(this.destination, "routes");
+        const storePath = nodePath.join(this.rootDestination, "_.store.ts");
+        const regenerate = () => {
+            void Promise.all([
+                writeScenarioContextType(this.destination, this.rootDestination),
+                writeMiddlewareTypes(this.destination),
+            ]).catch((error) => {
+                console.error("Failed to regenerate scenario files:", error);
+            });
+        };
+        this.watcher = watch(routesDir, CHOKIDAR_OPTIONS).on("all", (event, filePath) => {
+            if (filePath.endsWith("_.context.ts") ||
+                event === "addDir" ||
+                event === "unlinkDir") {
+                regenerate();
+            }
+        });
+        // Polling lets chokidar observe creation of the exact conventional store
+        // path even when the file is absent when the watcher starts.
+        this.storeWatcher = watch(storePath, {
+            ...CHOKIDAR_OPTIONS,
+            usePolling: true,
+        }).on("all", (_event, filePath) => {
+            if (nodePath.resolve(filePath) === nodePath.resolve(storePath)) {
+                regenerate();
+            }
+        });
+        await Promise.all([
+            waitForEvent(this.watcher, "ready"),
+            waitForEvent(this.storeWatcher, "ready"),
+        ]);
+    }
+    /** Closes the file-system watcher. */
+    async stopWatching() {
+        await Promise.all([this.watcher?.close(), this.storeWatcher?.close()]);
+    }
+}

package/dist/schema-coder.d.ts

@@ -0,0 +1,10 @@
+import { Coder } from "./coder.js";
+import type { Script } from "./script.js";
+export declare class SchemaCoder extends Coder {
+    names(): Generator<string>;
+    objectSchema(script: Script): string;
+    arraySchema(script: Script): string;
+    typeDeclaration(_namespace: Map<string, unknown> | undefined, script: Script): string;
+    modulePath(): string;
+    writeCode(script: Script): string;
+}

package/dist/schema-coder.js

@@ -0,0 +1,49 @@
+import { Coder } from "./coder.js";
+function scrubSchema(schema) {
+    // remove properties that are not valid in JSON Schema 6 and not useful anyway
+    const cleaned = { ...schema };
+    delete cleaned["example"];
+    delete cleaned["xml"];
+    return cleaned;
+}
+export class SchemaCoder extends Coder {
+    names() {
+        return super.names(`${this.requirement.refUrl.split("/").at(-1)}Schema`);
+    }
+    objectSchema(script) {
+        const { properties, required } = this.requirement.data;
+        const propertyLines = Object.keys(properties ?? {}).map((name) => {
+            const schemaCoder = new SchemaCoder(this.requirement.select(`properties/${name}`), this.version);
+            return `"${name}": ${schemaCoder.write(script)}`;
+        });
+        return `
+      {
+        type: "object",
+        required: ${JSON.stringify(required ?? [])},
+        properties: { ${propertyLines.join(", ")} }
+      }
+    `;
+    }
+    arraySchema(script) {
+        return `{
+        type: "array",     
+        items: ${new SchemaCoder(this.requirement.get("items"), this.version).write(script)}
+      }`;
+    }
+    typeDeclaration(_namespace, script) {
+        return script.importExternalType("JSONSchema6", "json-schema");
+    }
+    modulePath() {
+        return `types/${this.requirement.refUrl}.ts`;
+    }
+    writeCode(script) {
+        const { type } = this.requirement.data;
+        if (type === "object") {
+            return this.objectSchema(script);
+        }
+        if (type === "array") {
+            return this.arraySchema(script);
+        }
+        return JSON.stringify(scrubSchema(this.requirement.data));
+    }
+}

package/dist/schema-type-coder.d.ts

@@ -0,0 +1,20 @@
+import { TypeCoder } from "./type-coder.js";
+import { Requirement } from "./requirement.js";
+import type { Script } from "./script.js";
+export declare class SchemaTypeCoder extends TypeCoder {
+    names(): Generator<string>;
+    jsdoc(): string;
+    additionalPropertiesType(script: Script): string;
+    objectSchema(script: Script): string;
+    arraySchema(script: Script): string;
+    writePrimitive(value: unknown): string;
+    writeType(script: Script, type: unknown): string;
+    writeGroup(script: Script, { allOf, anyOf, oneOf, }: {
+        allOf?: unknown[];
+        anyOf?: unknown[];
+        oneOf?: unknown[];
+    }): string;
+    writeEnum(_script: Script, requirement: Requirement): string;
+    modulePath(): string;
+    writeCode(script: Script): string;
+}