@skmtc/core 0.0.791 → 0.0.793

package/esm/dsl/GeneratedValueList.d.ts

@@ -1,9 +1,167 @@
 import type { GeneratedValue } from '../types/GeneratedValue.js';
+/**
+ * A utility class for managing lists of generated values with customizable separators.
+ *
+ * `GeneratedValueList` provides a way to collect multiple generated values and combine
+ * them into a single string with a specified separator. It automatically filters out
+ * empty values to prevent generating unnecessary whitespace or malformed output.
+ *
+ * This class is useful for building lists of code elements like function parameters,
+ * import statements, or any other comma-separated (or otherwise separated) constructs
+ * where individual items might sometimes be empty.
+ *
+ * ## Key Features
+ *
+ * - **Custom Separators**: Support for any string separator (commas, newlines, spaces, etc.)
+ * - **Empty Filtering**: Automatically removes empty values from output
+ * - **Type Safety**: Works with any GeneratedValue type
+ * - **Incremental Building**: Values can be added one at a time
+ *
+ * @example Basic usage with comma separation
+ * ```typescript
+ * import { GeneratedValueList } from '@skmtc/core';
+ *
+ * const parameterList = new GeneratedValueList(', ');
+ * parameterList.add({ toString: () => 'id: string' });
+ * parameterList.add({ toString: () => 'name: string' });
+ * parameterList.add({ toString: () => 'email?: string' });
+ *
+ * console.log(parameterList.toString());
+ * // 'id: string, name: string, email?: string'
+ * ```
+ *
+ * @example With newline separation for code blocks
+ * ```typescript
+ * const codeLines = new GeneratedValueList('\n');
+ * codeLines.add({ toString: () => 'import { User } from "./types";' });
+ * codeLines.add({ toString: () => 'import { validate } from "./utils";' });
+ * codeLines.add({ toString: () => '' }); // Empty line will be filtered
+ * codeLines.add({ toString: () => 'export class UserService {' });
+ * codeLines.add({ toString: () => '  // Implementation' });
+ * codeLines.add({ toString: () => '}' });
+ *
+ * console.log(codeLines.toString());
+ * // import { User } from "./types";
+ * // import { validate } from "./utils";
+ * // export class UserService {
+ * //   // Implementation
+ * // }
+ * ```
+ *
+ * @example Empty value filtering
+ * ```typescript
+ * const mixedList = new GeneratedValueList(' | ');
+ * mixedList.add({ toString: () => "'active'" });
+ * mixedList.add({ toString: () => '' }); // This will be filtered out
+ * mixedList.add({ toString: () => "'inactive'" });
+ * mixedList.add({ toString: () => "'pending'" });
+ *
+ * console.log(mixedList.toString());
+ * // "'active' | 'inactive' | 'pending'"
+ * ```
+ *
+ * @example Using in code generation
+ * ```typescript
+ * class InterfaceGenerator {
+ *   generateInterface(name: string, properties: Array<{name: string, type: string}>) {
+ *     const propertyList = new GeneratedValueList(';\n  ');
+ *
+ *     properties.forEach(prop => {
+ *       if (prop.type) { // Only add properties that have types
+ *         propertyList.add({
+ *           toString: () => `${prop.name}: ${prop.type}`
+ *         });
+ *       }
+ *     });
+ *
+ *     return `interface ${name} {\n  ${propertyList.toString()};\n}`;
+ *   }
+ * }
+ *
+ * const generator = new InterfaceGenerator();
+ * const userInterface = generator.generateInterface('User', [
+ *   { name: 'id', type: 'string' },
+ *   { name: 'name', type: 'string' },
+ *   { name: 'invalid', type: '' }, // Will be filtered out
+ *   { name: 'email', type: 'string | null' }
+ * ]);
+ *
+ * console.log(userInterface);
+ * // interface User {
+ * //   id: string;
+ * //   name: string;
+ * //   email: string | null;
+ * // }
+ * ```
+ */
 export declare class GeneratedValueList {
+    /** The separator string used to join values */
     separator: string;
+    /** Internal array of generated values */
     private items;
+    /**
+     * Creates a new GeneratedValueList with the specified separator.
+     *
+     * @param separator - The string to use when joining values (e.g., ', ', '\n', ' | ')
+     *
+     * @example
+     * ```typescript
+     * // For comma-separated lists
+     * const commaList = new GeneratedValueList(', ');
+     *
+     * // For line-separated content
+     * const lineList = new GeneratedValueList('\n');
+     *
+     * // For union types
+     * const unionList = new GeneratedValueList(' | ');
+     * ```
+     */
     constructor(separator: string);
+    /**
+     * Adds a generated value to the list.
+     *
+     * The value will be included in the output string when `toString()` is called,
+     * unless the value's `toString()` method returns an empty string, in which case
+     * it will be automatically filtered out.
+     *
+     * @param str - The generated value to add to the list
+     *
+     * @example
+     * ```typescript
+     * const list = new GeneratedValueList(', ');
+     *
+     * // Add simple values
+     * list.add({ toString: () => 'value1' });
+     * list.add({ toString: () => 'value2' });
+     *
+     * // Add conditional values
+     * const conditionalValue = shouldInclude ? 'conditional' : '';
+     * list.add({ toString: () => conditionalValue });
+     *
+     * console.log(list.toString()); // 'value1, value2' (conditional filtered if empty)
+     * ```
+     */
     add(str: GeneratedValue): void;
+    /**
+     * Converts the list to a string representation with values joined by the separator.
+     *
+     * This method processes all added values by calling their `toString()` methods,
+     * filters out any empty strings (matching the {@link EMPTY} constant), and joins
+     * the remaining values with the configured separator.
+     *
+     * @returns The joined string representation of all non-empty values
+     *
+     * @example
+     * ```typescript
+     * const list = new GeneratedValueList(' -> ');
+     * list.add({ toString: () => 'start' });
+     * list.add({ toString: () => '' }); // Will be filtered out
+     * list.add({ toString: () => 'middle' });
+     * list.add({ toString: () => 'end' });
+     *
+     * console.log(list.toString()); // 'start -> middle -> end'
+     * ```
+     */
     toString(): string;
 }
 //# sourceMappingURL=GeneratedValueList.d.ts.map

package/esm/dsl/GeneratedValueList.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GeneratedValueList.d.ts","sourceRoot":"","sources":["../../src/dsl/GeneratedValueList.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAA;AAGhE,qBAAa,kBAAkB;IAC7B,SAAS,EAAE,MAAM,CAAA;IACjB,OAAO,CAAC,KAAK,CAAuB;gBAExB,SAAS,EAAE,MAAM;IAI7B,GAAG,CAAC,GAAG,EAAE,cAAc,GAAG,IAAI;IAI9B,QAAQ,IAAI,MAAM;CAMnB"}
+{"version":3,"file":"GeneratedValueList.d.ts","sourceRoot":"","sources":["../../src/dsl/GeneratedValueList.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAA;AAGhE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8FG;AACH,qBAAa,kBAAkB;IAC7B,+CAA+C;IAC/C,SAAS,EAAE,MAAM,CAAA;IAEjB,yCAAyC;IACzC,OAAO,CAAC,KAAK,CAAuB;IAEpC;;;;;;;;;;;;;;;;OAgBG;gBACS,SAAS,EAAE,MAAM;IAI7B;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,GAAG,CAAC,GAAG,EAAE,cAAc,GAAG,IAAI;IAI9B;;;;;;;;;;;;;;;;;;;OAmBG;IACH,QAAQ,IAAI,MAAM;CAMnB"}

package/esm/dsl/GeneratedValueList.js

@@ -1,12 +1,126 @@
 import { EMPTY } from './constants.js';
+/**
+ * A utility class for managing lists of generated values with customizable separators.
+ *
+ * `GeneratedValueList` provides a way to collect multiple generated values and combine
+ * them into a single string with a specified separator. It automatically filters out
+ * empty values to prevent generating unnecessary whitespace or malformed output.
+ *
+ * This class is useful for building lists of code elements like function parameters,
+ * import statements, or any other comma-separated (or otherwise separated) constructs
+ * where individual items might sometimes be empty.
+ *
+ * ## Key Features
+ *
+ * - **Custom Separators**: Support for any string separator (commas, newlines, spaces, etc.)
+ * - **Empty Filtering**: Automatically removes empty values from output
+ * - **Type Safety**: Works with any GeneratedValue type
+ * - **Incremental Building**: Values can be added one at a time
+ *
+ * @example Basic usage with comma separation
+ * ```typescript
+ * import { GeneratedValueList } from '@skmtc/core';
+ *
+ * const parameterList = new GeneratedValueList(', ');
+ * parameterList.add({ toString: () => 'id: string' });
+ * parameterList.add({ toString: () => 'name: string' });
+ * parameterList.add({ toString: () => 'email?: string' });
+ *
+ * console.log(parameterList.toString());
+ * // 'id: string, name: string, email?: string'
+ * ```
+ *
+ * @example With newline separation for code blocks
+ * ```typescript
+ * const codeLines = new GeneratedValueList('\n');
+ * codeLines.add({ toString: () => 'import { User } from "./types";' });
+ * codeLines.add({ toString: () => 'import { validate } from "./utils";' });
+ * codeLines.add({ toString: () => '' }); // Empty line will be filtered
+ * codeLines.add({ toString: () => 'export class UserService {' });
+ * codeLines.add({ toString: () => '  // Implementation' });
+ * codeLines.add({ toString: () => '}' });
+ *
+ * console.log(codeLines.toString());
+ * // import { User } from "./types";
+ * // import { validate } from "./utils";
+ * // export class UserService {
+ * //   // Implementation
+ * // }
+ * ```
+ *
+ * @example Empty value filtering
+ * ```typescript
+ * const mixedList = new GeneratedValueList(' | ');
+ * mixedList.add({ toString: () => "'active'" });
+ * mixedList.add({ toString: () => '' }); // This will be filtered out
+ * mixedList.add({ toString: () => "'inactive'" });
+ * mixedList.add({ toString: () => "'pending'" });
+ *
+ * console.log(mixedList.toString());
+ * // "'active' | 'inactive' | 'pending'"
+ * ```
+ *
+ * @example Using in code generation
+ * ```typescript
+ * class InterfaceGenerator {
+ *   generateInterface(name: string, properties: Array<{name: string, type: string}>) {
+ *     const propertyList = new GeneratedValueList(';\n  ');
+ *
+ *     properties.forEach(prop => {
+ *       if (prop.type) { // Only add properties that have types
+ *         propertyList.add({
+ *           toString: () => `${prop.name}: ${prop.type}`
+ *         });
+ *       }
+ *     });
+ *
+ *     return `interface ${name} {\n  ${propertyList.toString()};\n}`;
+ *   }
+ * }
+ *
+ * const generator = new InterfaceGenerator();
+ * const userInterface = generator.generateInterface('User', [
+ *   { name: 'id', type: 'string' },
+ *   { name: 'name', type: 'string' },
+ *   { name: 'invalid', type: '' }, // Will be filtered out
+ *   { name: 'email', type: 'string | null' }
+ * ]);
+ *
+ * console.log(userInterface);
+ * // interface User {
+ * //   id: string;
+ * //   name: string;
+ * //   email: string | null;
+ * // }
+ * ```
+ */
 export class GeneratedValueList {
+    /**
+     * Creates a new GeneratedValueList with the specified separator.
+     *
+     * @param separator - The string to use when joining values (e.g., ', ', '\n', ' | ')
+     *
+     * @example
+     * ```typescript
+     * // For comma-separated lists
+     * const commaList = new GeneratedValueList(', ');
+     *
+     * // For line-separated content
+     * const lineList = new GeneratedValueList('\n');
+     *
+     * // For union types
+     * const unionList = new GeneratedValueList(' | ');
+     * ```
+     */
     constructor(separator) {
+        /** The separator string used to join values */
         Object.defineProperty(this, "separator", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
+        /** Internal array of generated values */
         Object.defineProperty(this, "items", {
             enumerable: true,
             configurable: true,
@@ -15,9 +129,53 @@ export class GeneratedValueList {
         });
         this.separator = separator;
     }
+    /**
+     * Adds a generated value to the list.
+     *
+     * The value will be included in the output string when `toString()` is called,
+     * unless the value's `toString()` method returns an empty string, in which case
+     * it will be automatically filtered out.
+     *
+     * @param str - The generated value to add to the list
+     *
+     * @example
+     * ```typescript
+     * const list = new GeneratedValueList(', ');
+     *
+     * // Add simple values
+     * list.add({ toString: () => 'value1' });
+     * list.add({ toString: () => 'value2' });
+     *
+     * // Add conditional values
+     * const conditionalValue = shouldInclude ? 'conditional' : '';
+     * list.add({ toString: () => conditionalValue });
+     *
+     * console.log(list.toString()); // 'value1, value2' (conditional filtered if empty)
+     * ```
+     */
     add(str) {
         this.items.push(str);
     }
+    /**
+     * Converts the list to a string representation with values joined by the separator.
+     *
+     * This method processes all added values by calling their `toString()` methods,
+     * filters out any empty strings (matching the {@link EMPTY} constant), and joins
+     * the remaining values with the configured separator.
+     *
+     * @returns The joined string representation of all non-empty values
+     *
+     * @example
+     * ```typescript
+     * const list = new GeneratedValueList(' -> ');
+     * list.add({ toString: () => 'start' });
+     * list.add({ toString: () => '' }); // Will be filtered out
+     * list.add({ toString: () => 'middle' });
+     * list.add({ toString: () => 'end' });
+     *
+     * console.log(list.toString()); // 'start -> middle -> end'
+     * ```
+     */
     toString() {
         return this.items
             .map(item => item.toString())

package/esm/dsl/Stringable.d.ts

@@ -1,5 +1,81 @@
+/**
+ * Represents any object that can be converted to a string representation.
+ *
+ * The `Stringable` interface is a fundamental type used throughout the SKMTC DSL
+ * system to ensure that objects can be converted to strings for code generation.
+ * This interface matches JavaScript's built-in `toString()` contract and is used
+ * extensively by the {@link List} class and other string-building utilities.
+ *
+ * ## Usage in SKMTC
+ *
+ * This type is used as a constraint in generic classes and functions that need
+ * to output string representations. It allows for type-safe string building
+ * while accommodating both primitive types and custom objects.
+ *
+ * @example Built-in types are stringable
+ * ```typescript
+ * import type { Stringable } from '@skmtc/core';
+ *
+ * // All these types implement Stringable
+ * const str: Stringable = 'hello';        // string
+ * const num: Stringable = 42;             // number
+ * const bool: Stringable = true;          // boolean
+ * const obj: Stringable = { toString: () => 'custom' }; // custom object
+ * ```
+ *
+ * @example Custom classes implementing Stringable
+ * ```typescript
+ * class CodeBlock implements Stringable {
+ *   constructor(private code: string) {}
+ *
+ *   toString(): string {
+ *     return `{\n  ${this.code}\n}`;
+ *   }
+ * }
+ *
+ * const block = new CodeBlock('console.log("hello");');
+ * console.log(block.toString());
+ * // {
+ * //   console.log("hello");
+ * // }
+ * ```
+ *
+ * @example Using with List class
+ * ```typescript
+ * import { List } from '@skmtc/core';
+ *
+ * // List accepts any Stringable items
+ * const stringables: Stringable[] = [
+ *   'string literal',
+ *   42,
+ *   true,
+ *   { toString: () => 'custom object' },
+ *   new CodeBlock('return value;')
+ * ];
+ *
+ * const list = new List(stringables);
+ * console.log(list.toString());
+ * // string literal, 42, true, custom object, {
+ * //   return value;
+ * // }
+ * ```
+ *
+ * @example Type constraints in generics
+ * ```typescript
+ * function joinWithCommas<T extends Stringable>(items: T[]): string {
+ *   return items.map(item => item.toString()).join(', ');
+ * }
+ *
+ * const result = joinWithCommas([1, 2, 3]); // "1, 2, 3"
+ * const identifiers = joinWithCommas([
+ *   Identifier.createVariable('user'),
+ *   Identifier.createType('User')
+ * ]); // "user, User"
+ * ```
+ */
 import "../_dnt.polyfills.js";
 export type Stringable = {
+    /** Converts the object to its string representation */
     toString: () => string;
 };
 //# sourceMappingURL=Stringable.d.ts.map

package/esm/dsl/Stringable.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Stringable.d.ts","sourceRoot":"","sources":["../../src/dsl/Stringable.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAC9B,MAAM,MAAM,UAAU,GAAG;IACvB,QAAQ,EAAE,MAAM,MAAM,CAAA;CACvB,CAAA"}
+{"version":3,"file":"Stringable.d.ts","sourceRoot":"","sources":["../../src/dsl/Stringable.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0EG;AACH,OAAO,sBAAsB,CAAC;AAE9B,MAAM,MAAM,UAAU,GAAG;IACvB,uDAAuD;IACvD,QAAQ,EAAE,MAAM,MAAM,CAAA;CACvB,CAAA"}

package/esm/dsl/Stringable.js

@@ -1 +1,76 @@
+/**
+ * Represents any object that can be converted to a string representation.
+ *
+ * The `Stringable` interface is a fundamental type used throughout the SKMTC DSL
+ * system to ensure that objects can be converted to strings for code generation.
+ * This interface matches JavaScript's built-in `toString()` contract and is used
+ * extensively by the {@link List} class and other string-building utilities.
+ *
+ * ## Usage in SKMTC
+ *
+ * This type is used as a constraint in generic classes and functions that need
+ * to output string representations. It allows for type-safe string building
+ * while accommodating both primitive types and custom objects.
+ *
+ * @example Built-in types are stringable
+ * ```typescript
+ * import type { Stringable } from '@skmtc/core';
+ *
+ * // All these types implement Stringable
+ * const str: Stringable = 'hello';        // string
+ * const num: Stringable = 42;             // number
+ * const bool: Stringable = true;          // boolean
+ * const obj: Stringable = { toString: () => 'custom' }; // custom object
+ * ```
+ *
+ * @example Custom classes implementing Stringable
+ * ```typescript
+ * class CodeBlock implements Stringable {
+ *   constructor(private code: string) {}
+ *
+ *   toString(): string {
+ *     return `{\n  ${this.code}\n}`;
+ *   }
+ * }
+ *
+ * const block = new CodeBlock('console.log("hello");');
+ * console.log(block.toString());
+ * // {
+ * //   console.log("hello");
+ * // }
+ * ```
+ *
+ * @example Using with List class
+ * ```typescript
+ * import { List } from '@skmtc/core';
+ *
+ * // List accepts any Stringable items
+ * const stringables: Stringable[] = [
+ *   'string literal',
+ *   42,
+ *   true,
+ *   { toString: () => 'custom object' },
+ *   new CodeBlock('return value;')
+ * ];
+ *
+ * const list = new List(stringables);
+ * console.log(list.toString());
+ * // string literal, 42, true, custom object, {
+ * //   return value;
+ * // }
+ * ```
+ *
+ * @example Type constraints in generics
+ * ```typescript
+ * function joinWithCommas<T extends Stringable>(items: T[]): string {
+ *   return items.map(item => item.toString()).join(', ');
+ * }
+ *
+ * const result = joinWithCommas([1, 2, 3]); // "1, 2, 3"
+ * const identifiers = joinWithCommas([
+ *   Identifier.createVariable('user'),
+ *   Identifier.createType('User')
+ * ]); // "user, User"
+ * ```
+ */
 import "../_dnt.polyfills.js";

package/esm/helpers/collateExamples.d.ts

@@ -1,10 +1,160 @@
 import "../_dnt.polyfills.js";
 import type { OasRef } from '../oas/ref/Ref.js';
 import type { OasSchema } from '../oas/schema/Schema.js';
+/**
+ * Arguments for collating examples from OpenAPI schemas.
+ */
 type CollatedExampleArgs = {
+    /** The OpenAPI schema or reference to extract examples from */
     objectSchema: OasSchema | OasRef<'schema'> | undefined;
+    /** Current recursion depth (used to prevent infinite loops) */
     depth: number;
 };
+/**
+ * Recursively collates and builds example values from OpenAPI schemas.
+ *
+ * This function traverses OpenAPI schema structures and generates comprehensive
+ * example values based on the schema definitions and any explicit examples provided.
+ * It handles complex nested structures including objects, arrays, unions, and
+ * references while preventing infinite recursion through depth limiting.
+ *
+ * The function prioritizes explicit examples when available and falls back to
+ * generating examples from nested schemas. It's particularly useful for creating
+ * realistic test data, API documentation examples, and mock responses.
+ *
+ * @param args - Configuration for example collation
+ * @param args.objectSchema - The schema to extract examples from
+ * @param args.depth - Current recursion depth (prevents infinite loops)
+ * @returns Collated example value matching the schema structure, or undefined if no examples
+ *
+ * @throws {Error} When recursion depth exceeds 15 levels (prevents stack overflow)
+ *
+ * @example Basic schema examples
+ * ```typescript
+ * import { collateExamples } from '@skmtc/core';
+ *
+ * // String schema with example
+ * const stringSchema = new OasString({ example: 'john.doe@example.com' });
+ * const example = collateExamples({ objectSchema: stringSchema, depth: 0 });
+ * console.log(example); // 'john.doe@example.com'
+ *
+ * // Number schema with example
+ * const numberSchema = new OasNumber({ example: 42 });
+ * const numExample = collateExamples({ objectSchema: numberSchema, depth: 0 });
+ * console.log(numExample); // 42
+ * ```
+ *
+ * @example Object schema examples
+ * ```typescript
+ * // Object schema with nested properties
+ * const userSchema = new OasObject({
+ *   properties: {
+ *     id: new OasInteger({ example: 123 }),
+ *     name: new OasString({ example: 'John Doe' }),
+ *     email: new OasString({ example: 'john@example.com' }),
+ *     age: new OasInteger({ example: 30 })
+ *   }
+ * });
+ *
+ * const userExample = collateExamples({ objectSchema: userSchema, depth: 0 });
+ * console.log(userExample);
+ * // {
+ * //   id: 123,
+ * //   name: 'John Doe',
+ * //   email: 'john@example.com',
+ * //   age: 30
+ * // }
+ * ```
+ *
+ * @example Array schema examples
+ * ```typescript
+ * // Array of objects
+ * const usersArraySchema = new OasArray({
+ *   items: new OasObject({
+ *     properties: {
+ *       id: new OasInteger({ example: 1 }),
+ *       name: new OasString({ example: 'Jane Smith' })
+ *     }
+ *   })
+ * });
+ *
+ * const arrayExample = collateExamples({ objectSchema: usersArraySchema, depth: 0 });
+ * console.log(arrayExample);
+ * // [
+ * //   {
+ * //     id: 1,
+ * //     name: 'Jane Smith'
+ * //   }
+ * // ]
+ * ```
+ *
+ * @example Union schema examples
+ * ```typescript
+ * // Union of string and number
+ * const unionSchema = new OasUnion({
+ *   members: [
+ *     new OasString({ example: 'text-value' }),
+ *     new OasNumber({ example: 99 })
+ *   ]
+ * });
+ *
+ * const unionExample = collateExamples({ objectSchema: unionSchema, depth: 0 });
+ * console.log(unionExample); // 'text-value' (first member with example)
+ * ```
+ *
+ * @example Reference resolution
+ * ```typescript
+ * // Schema with reference to another schema
+ * const addressRef = new OasRef({
+ *   $ref: '#/components/schemas/Address',
+ *   resolve: () => new OasObject({
+ *     properties: {
+ *       street: new OasString({ example: '123 Main St' }),
+ *       city: new OasString({ example: 'Springfield' })
+ *     }
+ *   })
+ * });
+ *
+ * const refExample = collateExamples({ objectSchema: addressRef, depth: 0 });
+ * console.log(refExample);
+ * // {
+ * //   street: '123 Main St',
+ * //   city: 'Springfield'
+ * // }
+ * ```
+ *
+ * @example Depth limiting and error handling
+ * ```typescript
+ * // Deep nesting detection
+ * try {
+ *   const deepExample = collateExamples({ objectSchema: someSchema, depth: 16 });
+ * } catch (error) {
+ *   console.error('Depth limit exceeded:', error.message); // 'Depth limit reached'
+ * }
+ *
+ * // Handling missing schemas
+ * const emptyExample = collateExamples({ objectSchema: undefined, depth: 0 });
+ * console.log(emptyExample); // undefined
+ * ```
+ *
+ * @example Using in API documentation generation
+ * ```typescript
+ * class ApiDocGenerator {
+ *   generateExampleResponse(responseSchema: OasSchema) {
+ *     const example = collateExamples({ objectSchema: responseSchema, depth: 0 });
+ *
+ *     if (example) {
+ *       return {
+ *         description: 'Example response',
+ *         value: example
+ *       };
+ *     }
+ *
+ *     return { description: 'No example available' };
+ *   }
+ * }
+ * ```
+ */
 export declare const collateExamples: ({ objectSchema, depth }: CollatedExampleArgs) => unknown;
 export {};
 //# sourceMappingURL=collateExamples.d.ts.map

package/esm/helpers/collateExamples.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"collateExamples.d.ts","sourceRoot":"","sources":["../../src/helpers/collateExamples.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAA;AAC/C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AAIxD,KAAK,mBAAmB,GAAG;IACzB,YAAY,EAAE,SAAS,GAAG,MAAM,CAAC,QAAQ,CAAC,GAAG,SAAS,CAAA;IACtD,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AAED,eAAO,MAAM,eAAe,GAAI,yBAAyB,mBAAmB,KAAG,OAwE9E,CAAA"}
+{"version":3,"file":"collateExamples.d.ts","sourceRoot":"","sources":["../../src/helpers/collateExamples.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAA;AAC/C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AAIxD;;GAEG;AACH,KAAK,mBAAmB,GAAG;IACzB,+DAA+D;IAC/D,YAAY,EAAE,SAAS,GAAG,MAAM,CAAC,QAAQ,CAAC,GAAG,SAAS,CAAA;IACtD,+DAA+D;IAC/D,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgJG;AACH,eAAO,MAAM,eAAe,GAAI,yBAAyB,mBAAmB,KAAG,OAwE9E,CAAA"}