@skmtc/core 0.0.785 → 0.0.787

package/esm/dsl/operation/OperationBase.d.ts

@@ -199,10 +199,190 @@ export declare class OperationBase<EnrichmentType = undefined> extends ContentBa
      * ```
      */
     insertOperation<V extends GeneratedValue, EnrichmentType = undefined>(insertable: OperationInsertable<V, EnrichmentType>, operation: OasOperation, options?: Pick<InsertOperationOptions<'force'>, 'noExport'>): Inserted<V, 'force', EnrichmentType>;
+    /**
+     * Inserts a related model with forced generation.
+     *
+     * This method adds a model to the current generation context, typically used
+     * for request/response models or other types related to the operation. The model
+     * will be generated and can be referenced in the operation code.
+     *
+     * @template V - Type of generated value returned by the insertable
+     * @template EnrichmentType - Type of enrichment data for the insertable
+     * @param insertable - The model generator to insert
+     * @param refName - Reference name for the inserted model
+     * @param options - Insertion options
+     * @param options.noExport - Whether to skip exporting the inserted model
+     * @returns Inserted model reference with generated value
+     *
+     * @example Inserting request/response models
+     * ```typescript
+     * class ApiOperation extends OperationBase {
+     *   toDefinition(): Definition {
+     *     // Insert request model
+     *     const requestModel = this.insertModel(
+     *       new RequestModel({ ... }),
+     *       'CreateUserRequest'
+     *     );
+     *
+     *     // Insert response model
+     *     const responseModel = this.insertModel(
+     *       new ResponseModel({ ... }),
+     *       'CreateUserResponse'
+     *     );
+     *
+     *     return new Definition({
+     *       name: this.operation.operationId,
+     *       content: `async ${this.operation.operationId}(data: ${requestModel.value}): Promise<${responseModel.value}> {
+     *         return this.request('${this.operation.method}', '${this.operation.path}', data);
+     *       }`
+     *     });
+     *   }
+     * }
+     * ```
+     */
     insertModel<V extends GeneratedValue, EnrichmentType = undefined>(insertable: ModelInsertable<V, EnrichmentType>, refName: RefName, options?: Pick<InsertModelOptions<'force'>, 'noExport'>): Inserted<V, 'force', EnrichmentType>;
+    /**
+     * Inserts a related model with automatic schema normalization and reference resolution.
+     *
+     * This method intelligently handles schema references from operation request/response
+     * bodies, automatically resolving schema references to appropriate model names.
+     * This is particularly useful for operations with complex request/response schemas.
+     *
+     * @template V - Type of generated value returned by the insertable
+     * @template Schema - Type of OpenAPI schema (schema object, reference, or void)
+     * @template EnrichmentType - Type of enrichment data for the insertable
+     * @param insertable - The model generator to insert
+     * @param args - Schema normalization arguments
+     * @param args.schema - The OpenAPI schema to normalize (from request/response)
+     * @param args.fallbackName - Name to use if schema is not a reference
+     * @param options - Insertion options
+     * @param options.noExport - Whether to skip exporting the inserted model
+     * @returns Inserted model reference with normalized name and generated value
+     *
+     * @example Handling operation request/response schemas
+     * ```typescript
+     * class RestApiOperation extends OperationBase {
+     *   toDefinition(): Definition {
+     *     const operation = this.operation;
+     *
+     *     // Handle request body schema
+     *     let requestType = 'void';
+     *     const requestSchema = operation.requestBody?.content?.['application/json']?.schema;
+     *     if (requestSchema) {
+     *       const requestModel = this.insertNormalizedModel(
+     *         new TypeScriptInterface({ ... }),
+     *         {
+     *           schema: requestSchema,
+     *           fallbackName: `${operation.operationId}Request`
+     *         }
+     *       );
+     *       requestType = requestModel.value;
+     *     }
+     *
+     *     // Handle response schema
+     *     const responseSchema = operation.responses?.['200']?.content?.['application/json']?.schema;
+     *     const responseModel = this.insertNormalizedModel(
+     *       new TypeScriptInterface({ ... }),
+     *       {
+     *         schema: responseSchema,
+     *         fallbackName: `${operation.operationId}Response`
+     *       }
+     *     );
+     *
+     *     return new Definition({
+     *       name: operation.operationId,
+     *       content: `async ${operation.operationId}(data: ${requestType}): Promise<${responseModel.value}>`
+     *     });
+     *   }
+     * }
+     * ```
+     */
     insertNormalizedModel<V extends GeneratedValue, Schema extends OasSchema | OasRef<'schema'> | OasVoid, EnrichmentType = undefined>(insertable: ModelInsertable<V, EnrichmentType>, { schema, fallbackName }: Omit<InsertNormalisedModelArgs<Schema>, 'destinationPath'>, options?: Pick<InsertModelOptions<'force'>, 'noExport'>): InsertNormalisedModelReturn<V, Schema>;
-    /** @experimental */
+    /**
+     * Defines and registers a new definition in the generation context.
+     *
+     * This is an experimental method that allows creating and registering
+     * definitions directly without going through the standard insertion flow.
+     * Use with caution as the API may change in future versions.
+     *
+     * @experimental This method's API may change in future versions
+     * @template V - Type of generated value
+     * @param args - Definition arguments
+     * @param args.identifier - Unique identifier for the definition
+     * @param args.value - The generated value to associate with the definition
+     * @param args.noExport - Whether to skip exporting the definition
+     * @returns The created and registered definition
+     *
+     * @example Creating inline definitions
+     * ```typescript
+     * class InlineHelperOperation extends OperationBase {
+     *   toDefinition(): Definition {
+     *     // Create an inline helper function
+     *     const helper = this.defineAndRegister({
+     *       identifier: 'validateRequest',
+     *       value: 'function validateRequest(data: any) { ... }',
+     *       noExport: true
+     *     });
+     *
+     *     return new Definition({
+     *       name: this.operation.operationId,
+     *       content: `async ${this.operation.operationId}(data: any) {
+     *         ${helper.value}(data);
+     *         return this.request('${this.operation.method}', '${this.operation.path}', data);
+     *       }`
+     *     });
+     *   }
+     * }
+     * ```
+     */
     defineAndRegister<V extends GeneratedValue>({ identifier, value, noExport }: Omit<DefineAndRegisterArgs<V>, 'destinationPath'>): Definition<V>;
+    /**
+     * Registers a file-level artifact with the generation context.
+     *
+     * This method allows the operation generator to register additional content
+     * (like imports, exports, or file-level definitions) that should be included
+     * in the generated file. The registration is automatically scoped to this
+     * operation's export path.
+     *
+     * @param args - Registration arguments
+     * @param args.content - The content to register (import, export, etc.)
+     * @param args.phase - When to register the content ('pre' or 'post')
+     *
+     * @example Registering API client imports
+     * ```typescript
+     * class HttpOperation extends OperationBase {
+     *   toDefinition(): Definition {
+     *     // Register imports needed for HTTP operations
+     *     this.register({
+     *       content: "import { ApiClient } from './client';",
+     *       phase: 'pre'
+     *     });
+     *
+     *     this.register({
+     *       content: "import { RequestOptions } from './types';",
+     *       phase: 'pre'
+     *     });
+     *
+     *     return new Definition({ ... });
+     *   }
+     * }
+     * ```
+     *
+     * @example Registering utility exports
+     * ```typescript
+     * class ApiOperationGroup extends OperationBase {
+     *   toDefinition(): Definition {
+     *     // Register a utility export after all operations
+     *     this.register({
+     *       content: "export const API_VERSION = '1.0';",
+     *       phase: 'post'
+     *     });
+     *
+     *     return new Definition({ ... });
+     *   }
+     * }
+     * ```
+     */
     register(args: BaseRegisterArgs): void;
 }
 //# sourceMappingURL=OperationBase.d.ts.map

package/esm/dsl/operation/OperationBase.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"OperationBase.d.ts","sourceRoot":"","sources":["../../../src/dsl/operation/OperationBase.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"OperationBase.d.ts","sourceRoot":"","sources":["../../../src/dsl/operation/OperationBase.ts"],"names":[],"mappings":"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"}

package/esm/dsl/operation/OperationBase.js

@@ -197,6 +197,47 @@ export class OperationBase extends ContentBase {
             noExport: options.noExport
         });
     }
+    /**
+     * Inserts a related model with forced generation.
+     *
+     * This method adds a model to the current generation context, typically used
+     * for request/response models or other types related to the operation. The model
+     * will be generated and can be referenced in the operation code.
+     *
+     * @template V - Type of generated value returned by the insertable
+     * @template EnrichmentType - Type of enrichment data for the insertable
+     * @param insertable - The model generator to insert
+     * @param refName - Reference name for the inserted model
+     * @param options - Insertion options
+     * @param options.noExport - Whether to skip exporting the inserted model
+     * @returns Inserted model reference with generated value
+     *
+     * @example Inserting request/response models
+     * ```typescript
+     * class ApiOperation extends OperationBase {
+     *   toDefinition(): Definition {
+     *     // Insert request model
+     *     const requestModel = this.insertModel(
+     *       new RequestModel({ ... }),
+     *       'CreateUserRequest'
+     *     );
+     *
+     *     // Insert response model
+     *     const responseModel = this.insertModel(
+     *       new ResponseModel({ ... }),
+     *       'CreateUserResponse'
+     *     );
+     *
+     *     return new Definition({
+     *       name: this.operation.operationId,
+     *       content: `async ${this.operation.operationId}(data: ${requestModel.value}): Promise<${responseModel.value}> {
+     *         return this.request('${this.operation.method}', '${this.operation.path}', data);
+     *       }`
+     *     });
+     *   }
+     * }
+     * ```
+     */
     insertModel(insertable, refName, options = {}) {
         return this.context.insertModel(insertable, refName, {
             generation: 'force',
@@ -204,6 +245,62 @@ export class OperationBase extends ContentBase {
             noExport: options.noExport
         });
     }
+    /**
+     * Inserts a related model with automatic schema normalization and reference resolution.
+     *
+     * This method intelligently handles schema references from operation request/response
+     * bodies, automatically resolving schema references to appropriate model names.
+     * This is particularly useful for operations with complex request/response schemas.
+     *
+     * @template V - Type of generated value returned by the insertable
+     * @template Schema - Type of OpenAPI schema (schema object, reference, or void)
+     * @template EnrichmentType - Type of enrichment data for the insertable
+     * @param insertable - The model generator to insert
+     * @param args - Schema normalization arguments
+     * @param args.schema - The OpenAPI schema to normalize (from request/response)
+     * @param args.fallbackName - Name to use if schema is not a reference
+     * @param options - Insertion options
+     * @param options.noExport - Whether to skip exporting the inserted model
+     * @returns Inserted model reference with normalized name and generated value
+     *
+     * @example Handling operation request/response schemas
+     * ```typescript
+     * class RestApiOperation extends OperationBase {
+     *   toDefinition(): Definition {
+     *     const operation = this.operation;
+     *
+     *     // Handle request body schema
+     *     let requestType = 'void';
+     *     const requestSchema = operation.requestBody?.content?.['application/json']?.schema;
+     *     if (requestSchema) {
+     *       const requestModel = this.insertNormalizedModel(
+     *         new TypeScriptInterface({ ... }),
+     *         {
+     *           schema: requestSchema,
+     *           fallbackName: `${operation.operationId}Request`
+     *         }
+     *       );
+     *       requestType = requestModel.value;
+     *     }
+     *
+     *     // Handle response schema
+     *     const responseSchema = operation.responses?.['200']?.content?.['application/json']?.schema;
+     *     const responseModel = this.insertNormalizedModel(
+     *       new TypeScriptInterface({ ... }),
+     *       {
+     *         schema: responseSchema,
+     *         fallbackName: `${operation.operationId}Response`
+     *       }
+     *     );
+     *
+     *     return new Definition({
+     *       name: operation.operationId,
+     *       content: `async ${operation.operationId}(data: ${requestType}): Promise<${responseModel.value}>`
+     *     });
+     *   }
+     * }
+     * ```
+     */
     insertNormalizedModel(insertable, { schema, fallbackName }, options = {}) {
         return this.context.insertNormalisedModel(insertable, {
             schema,
@@ -211,7 +308,43 @@ export class OperationBase extends ContentBase {
             destinationPath: this.settings.exportPath
         }, options);
     }
-    /** @experimental */
+    /**
+     * Defines and registers a new definition in the generation context.
+     *
+     * This is an experimental method that allows creating and registering
+     * definitions directly without going through the standard insertion flow.
+     * Use with caution as the API may change in future versions.
+     *
+     * @experimental This method's API may change in future versions
+     * @template V - Type of generated value
+     * @param args - Definition arguments
+     * @param args.identifier - Unique identifier for the definition
+     * @param args.value - The generated value to associate with the definition
+     * @param args.noExport - Whether to skip exporting the definition
+     * @returns The created and registered definition
+     *
+     * @example Creating inline definitions
+     * ```typescript
+     * class InlineHelperOperation extends OperationBase {
+     *   toDefinition(): Definition {
+     *     // Create an inline helper function
+     *     const helper = this.defineAndRegister({
+     *       identifier: 'validateRequest',
+     *       value: 'function validateRequest(data: any) { ... }',
+     *       noExport: true
+     *     });
+     *
+     *     return new Definition({
+     *       name: this.operation.operationId,
+     *       content: `async ${this.operation.operationId}(data: any) {
+     *         ${helper.value}(data);
+     *         return this.request('${this.operation.method}', '${this.operation.path}', data);
+     *       }`
+     *     });
+     *   }
+     * }
+     * ```
+     */
     defineAndRegister({ identifier, value, noExport }) {
         return this.context.defineAndRegister({
             identifier,
@@ -220,6 +353,53 @@ export class OperationBase extends ContentBase {
             noExport
         });
     }
+    /**
+     * Registers a file-level artifact with the generation context.
+     *
+     * This method allows the operation generator to register additional content
+     * (like imports, exports, or file-level definitions) that should be included
+     * in the generated file. The registration is automatically scoped to this
+     * operation's export path.
+     *
+     * @param args - Registration arguments
+     * @param args.content - The content to register (import, export, etc.)
+     * @param args.phase - When to register the content ('pre' or 'post')
+     *
+     * @example Registering API client imports
+     * ```typescript
+     * class HttpOperation extends OperationBase {
+     *   toDefinition(): Definition {
+     *     // Register imports needed for HTTP operations
+     *     this.register({
+     *       content: "import { ApiClient } from './client';",
+     *       phase: 'pre'
+     *     });
+     *
+     *     this.register({
+     *       content: "import { RequestOptions } from './types';",
+     *       phase: 'pre'
+     *     });
+     *
+     *     return new Definition({ ... });
+     *   }
+     * }
+     * ```
+     *
+     * @example Registering utility exports
+     * ```typescript
+     * class ApiOperationGroup extends OperationBase {
+     *   toDefinition(): Definition {
+     *     // Register a utility export after all operations
+     *     this.register({
+     *       content: "export const API_VERSION = '1.0';",
+     *       phase: 'post'
+     *     });
+     *
+     *     return new Definition({ ... });
+     *   }
+     * }
+     * ```
+     */
     register(args) {
         this.context.register({
             ...args,

package/esm/oas/array/Array.d.ts

@@ -2,21 +2,129 @@ import "../../_dnt.polyfills.js";
 import type { OasSchema, ToJsonSchemaOptions } from '../schema/Schema.js';
 import type { OasRef } from '../ref/Ref.js';
 import type { OpenAPIV3 } from 'openapi-types';
+/**
+ * Constructor fields for {@link OasArray}.
+ *
+ * @template Nullable - Whether the array value can be null
+ */
 export type ArrayFields<Nullable extends boolean | undefined> = {
+    /** Schema definition for array items */
     items: OasSchema | OasRef<'schema'>;
+    /** A short summary of the array schema */
     title?: string;
+    /** A description of the array schema */
     description?: string;
+    /** Whether the array value can be null */
     nullable?: Nullable;
+    /** Whether array items must be unique */
     uniqueItems?: boolean;
+    /** Custom extension fields (x-* properties) */
     extensionFields?: Record<string, unknown>;
+    /** Example array value */
     example?: Nullable extends true ? unknown[] | null | undefined : unknown[] | undefined;
+    /** Maximum number of items allowed */
     maxItems?: number;
+    /** Minimum number of items required */
     minItems?: number;
+    /** Array of allowed enum values for the entire array */
     enums?: Nullable extends true ? (unknown | null)[] | undefined : unknown[] | undefined;
+    /** Default value for the array */
     defaultValue?: Nullable extends true ? unknown[] | null | undefined : unknown[] | undefined;
 };
 /**
- * Object representing an array in the OpenAPI Specification.
+ * Represents an array schema in the OpenAPI Specification.
+ *
+ * `OasArray` handles array type definitions with comprehensive validation
+ * constraints including item count limits, uniqueness requirements, and
+ * item type specifications. It supports nested schemas and references
+ * for complex array structures.
+ *
+ * This class is used throughout the OAS processing pipeline to represent
+ * array fields in API schemas, including lists of objects, primitive arrays,
+ * and complex nested array structures.
+ *
+ * ## Key Features
+ *
+ * - **Item Type Definition**: Support for any schema type as array items
+ * - **Size Constraints**: Minimum and maximum item count validation
+ * - **Uniqueness Validation**: Ensure array items are unique (like Set behavior)
+ * - **Nested Schemas**: Support for complex nested array structures
+ * - **Reference Handling**: Seamless integration with schema references
+ * - **Nullable Support**: Type-safe nullable array handling
+ * - **JSON Schema**: Conversion to standard JSON Schema format
+ *
+ * @template Nullable - Whether the array value can be null
+ *
+ * @example String array
+ * ```typescript
+ * import { OasArray, OasString } from '@skmtc/core';
+ *
+ * const tagsArray = new OasArray({
+ *   title: 'Tags',
+ *   description: 'List of tags associated with the item',
+ *   items: new OasString({ minLength: 1 }),
+ *   minItems: 1,
+ *   uniqueItems: true,
+ *   example: ['javascript', 'typescript', 'react']
+ * });
+ * ```
+ *
+ * @example Object array with references
+ * ```typescript
+ * import { OasArray, OasRef } from '@skmtc/core';
+ *
+ * const usersArray = new OasArray({
+ *   title: 'Users',
+ *   description: 'List of user objects',
+ *   items: new OasRef({ refName: 'User' }),
+ *   maxItems: 100,
+ *   example: [
+ *     { id: 1, name: 'John' },
+ *     { id: 2, name: 'Jane' }
+ *   ]
+ * });
+ * ```
+ *
+ * @example Nested array (array of arrays)
+ * ```typescript
+ * const matrixArray = new OasArray({
+ *   title: 'Matrix',
+ *   description: '2D array of numbers',
+ *   items: new OasArray({
+ *     items: new OasInteger({ minimum: 0 })
+ *   }),
+ *   example: [
+ *     [1, 2, 3],
+ *     [4, 5, 6],
+ *     [7, 8, 9]
+ *   ]
+ * });
+ * ```
+ *
+ * @example Nullable array with constraints
+ * ```typescript
+ * const optionalIdsArray = new OasArray<true>({
+ *   title: 'Optional IDs',
+ *   description: 'Optional list of IDs',
+ *   items: new OasInteger({ format: 'int64', minimum: 1 }),
+ *   nullable: true,
+ *   minItems: 0,
+ *   maxItems: 10,
+ *   defaultValue: null
+ * });
+ * ```
+ *
+ * @example Unique items validation
+ * ```typescript
+ * const uniqueEmailsArray = new OasArray({
+ *   title: 'Email Recipients',
+ *   description: 'List of unique email addresses',
+ *   items: new OasString({ format: 'email' }),
+ *   uniqueItems: true, // Ensures no duplicate emails
+ *   minItems: 1,
+ *   example: ['user1@example.com', 'user2@example.com']
+ * });
+ * ```
  */
 export declare class OasArray<Nullable extends boolean | undefined = boolean | undefined> {
     /**

package/esm/oas/array/Array.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Array.d.ts","sourceRoot":"","sources":["../../../src/oas/array/Array.ts"],"names":[],"mappings":"AAAA,OAAO,yBAAyB,CAAC;AACjC,OAAO,KAAK,EAAE,SAAS,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAA;AACzE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,eAAe,CAAA;AAC3C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAE9C,MAAM,MAAM,WAAW,CAAC,QAAQ,SAAS,OAAO,GAAG,SAAS,IAAI;IAC9D,KAAK,EAAE,SAAS,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAA;IACnC,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,EAAE,QAAQ,CAAA;IACnB,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,eAAe,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IACzC,OAAO,CAAC,EAAE,QAAQ,SAAS,IAAI,GAAG,OAAO,EAAE,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,EAAE,GAAG,SAAS,CAAA;IACtF,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,KAAK,CAAC,EAAE,QAAQ,SAAS,IAAI,GAAG,CAAC,OAAO,GAAG,IAAI,CAAC,EAAE,GAAG,SAAS,GAAG,OAAO,EAAE,GAAG,SAAS,CAAA;IACtF,YAAY,CAAC,EAAE,QAAQ,SAAS,IAAI,GAAG,OAAO,EAAE,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,EAAE,GAAG,SAAS,CAAA;CAC5F,CAAA;AAED;;GAEG;AACH,qBAAa,QAAQ,CAAC,QAAQ,SAAS,OAAO,GAAG,SAAS,GAAG,OAAO,GAAG,SAAS;IAC9E;;;OAGG;IACH,OAAO,EAAG,QAAQ,CAAS;IAC3B;;OAEG;IACH,IAAI,EAAG,OAAO,CAAS;IACvB;;OAEG;IACH,KAAK,EAAE,SAAS,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAA;IACnC;;OAEG;IACH,KAAK,EAAE,MAAM,GAAG,SAAS,CAAA;IACzB;;OAEG;IACH,WAAW,EAAE,MAAM,GAAG,SAAS,CAAA;IAC/B;;OAEG;IACH,QAAQ,EAAE,QAAQ,GAAG,SAAS,CAAA;IAC9B;;OAEG;IACH,WAAW,EAAE,OAAO,GAAG,SAAS,CAAA;IAEhC,qCAAqC;IACrC,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAAA;IAEpD;;OAEG;IACH,OAAO,EAAE,QAAQ,SAAS,IAAI,GAAG,OAAO,EAAE,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,EAAE,GAAG,SAAS,CAAA;IACrF;;OAEG;IACH,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAA;IAC5B;;OAEG;IACH,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAA;IAE5B;;OAEG;IACH,KAAK,EAAE,QAAQ,SAAS,IAAI,GAAG,CAAC,OAAO,GAAG,IAAI,CAAC,EAAE,GAAG,SAAS,GAAG,OAAO,EAAE,GAAG,SAAS,CAAA;IAErF;;OAEG;IACH,YAAY,EAAE,QAAQ,SAAS,IAAI,GAAG,OAAO,EAAE,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,EAAE,GAAG,SAAS,CAAA;gBAE9E,MAAM,EAAE,WAAW,CAAC,QAAQ,CAAC;IAczC,KAAK,IAAI,IAAI,IAAI,MAAM,CAAC,QAAQ,CAAC;IAIjC,OAAO,IAAI,QAAQ,CAAC,QAAQ,CAAC;IAI7B,WAAW,IAAI,QAAQ,CAAC,QAAQ,CAAC;IAIjC,YAAY,CAAC,OAAO,EAAE,mBAAmB,GAAG,SAAS,CAAC,iBAAiB;CAexE"}
+{"version":3,"file":"Array.d.ts","sourceRoot":"","sources":["../../../src/oas/array/Array.ts"],"names":[],"mappings":"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"}

package/esm/oas/array/Array.js

@@ -1,6 +1,98 @@
 import "../../_dnt.polyfills.js";
 /**
- * Object representing an array in the OpenAPI Specification.
+ * Represents an array schema in the OpenAPI Specification.
+ *
+ * `OasArray` handles array type definitions with comprehensive validation
+ * constraints including item count limits, uniqueness requirements, and
+ * item type specifications. It supports nested schemas and references
+ * for complex array structures.
+ *
+ * This class is used throughout the OAS processing pipeline to represent
+ * array fields in API schemas, including lists of objects, primitive arrays,
+ * and complex nested array structures.
+ *
+ * ## Key Features
+ *
+ * - **Item Type Definition**: Support for any schema type as array items
+ * - **Size Constraints**: Minimum and maximum item count validation
+ * - **Uniqueness Validation**: Ensure array items are unique (like Set behavior)
+ * - **Nested Schemas**: Support for complex nested array structures
+ * - **Reference Handling**: Seamless integration with schema references
+ * - **Nullable Support**: Type-safe nullable array handling
+ * - **JSON Schema**: Conversion to standard JSON Schema format
+ *
+ * @template Nullable - Whether the array value can be null
+ *
+ * @example String array
+ * ```typescript
+ * import { OasArray, OasString } from '@skmtc/core';
+ *
+ * const tagsArray = new OasArray({
+ *   title: 'Tags',
+ *   description: 'List of tags associated with the item',
+ *   items: new OasString({ minLength: 1 }),
+ *   minItems: 1,
+ *   uniqueItems: true,
+ *   example: ['javascript', 'typescript', 'react']
+ * });
+ * ```
+ *
+ * @example Object array with references
+ * ```typescript
+ * import { OasArray, OasRef } from '@skmtc/core';
+ *
+ * const usersArray = new OasArray({
+ *   title: 'Users',
+ *   description: 'List of user objects',
+ *   items: new OasRef({ refName: 'User' }),
+ *   maxItems: 100,
+ *   example: [
+ *     { id: 1, name: 'John' },
+ *     { id: 2, name: 'Jane' }
+ *   ]
+ * });
+ * ```
+ *
+ * @example Nested array (array of arrays)
+ * ```typescript
+ * const matrixArray = new OasArray({
+ *   title: 'Matrix',
+ *   description: '2D array of numbers',
+ *   items: new OasArray({
+ *     items: new OasInteger({ minimum: 0 })
+ *   }),
+ *   example: [
+ *     [1, 2, 3],
+ *     [4, 5, 6],
+ *     [7, 8, 9]
+ *   ]
+ * });
+ * ```
+ *
+ * @example Nullable array with constraints
+ * ```typescript
+ * const optionalIdsArray = new OasArray<true>({
+ *   title: 'Optional IDs',
+ *   description: 'Optional list of IDs',
+ *   items: new OasInteger({ format: 'int64', minimum: 1 }),
+ *   nullable: true,
+ *   minItems: 0,
+ *   maxItems: 10,
+ *   defaultValue: null
+ * });
+ * ```
+ *
+ * @example Unique items validation
+ * ```typescript
+ * const uniqueEmailsArray = new OasArray({
+ *   title: 'Email Recipients',
+ *   description: 'List of unique email addresses',
+ *   items: new OasString({ format: 'email' }),
+ *   uniqueItems: true, // Ensures no duplicate emails
+ *   minItems: 1,
+ *   example: ['user1@example.com', 'user2@example.com']
+ * });
+ * ```
  */
 export class OasArray {
     constructor(fields) {