@skmtc/core 0.0.808 → 0.0.809

package/esm/oas/array/array-types.d.ts

@@ -4,67 +4,280 @@ import { type OasSchemaRefData } from '../ref/ref-types.js';
 /**
  * Valibot schema for validating OpenAPI array data objects.
  *
- * Validates array schemas including item type definitions, length constraints,
- * uniqueness requirements, and enumeration values. Uses lazy evaluation
- * to handle recursive schema references.
+ * This comprehensive schema validates OpenAPI array schemas according to the OpenAPI v3
+ * specification, including item type definitions, length constraints, uniqueness requirements,
+ * and enumeration values. It uses lazy evaluation to handle recursive schema references,
+ * allowing for complex nested array structures and self-referential schemas.
+ *
+ * The schema supports both direct schema definitions and reference objects for the items
+ * property, enabling flexible array type definitions that can reference other schemas
+ * in the document or define inline item types.
+ *
+ * @example Validating a simple array schema
+ * ```typescript
+ * import { oasArrayData } from '@skmtc/core/oas/array';
+ * import * as v from 'valibot';
+ *
+ * const schema = {
+ *   type: 'array',
+ *   items: {
+ *     type: 'string'
+ *   },
+ *   description: 'List of user names',
+ *   minItems: 1,
+ *   maxItems: 100
+ * };
+ *
+ * const validated = v.parse(oasArrayData, schema);
+ * console.log(validated.minItems); // 1
+ * ```
+ *
+ * @example Validating array with reference items
+ * ```typescript
+ * const refArraySchema = {
+ *   type: 'array',
+ *   items: {
+ *     $ref: '#/components/schemas/User'
+ *   },
+ *   title: 'User List',
+ *   uniqueItems: true,
+ *   default: []
+ * };
+ *
+ * const result = v.parse(oasArrayData, refArraySchema);
+ * console.log(result.uniqueItems); // true
+ * ```
+ *
+ * @example Validating constrained arrays
+ * ```typescript
+ * const constrainedArray = {
+ *   type: 'array',
+ *   items: { type: 'number' },
+ *   minItems: 2,
+ *   maxItems: 10,
+ *   uniqueItems: true,
+ *   enums: [[1, 2, 3], [4, 5, 6]]
+ * };
+ *
+ * const validated = v.parse(oasArrayData, constrainedArray);
+ * console.log(validated.maxItems); // 10
+ * ```
  */
 export declare const oasArrayData: v.GenericSchema<OasArrayData>;
 /**
  * Valibot schema for array data without the items property.
  *
- * Used for parsing array schemas when the items property is handled separately,
- * typically during schema transformation and validation processes.
+ * This specialized schema validates array schemas when the items property is processed
+ * separately from the main array constraints. It's commonly used during schema parsing
+ * and transformation processes where items need special handling, such as when resolving
+ * references or applying schema merging operations.
+ *
+ * This pattern is useful in multi-phase parsing where array constraints (like min/max
+ * items, uniqueness) are validated independently from the item type definitions,
+ * allowing for more flexible processing pipelines.
+ *
+ * @example Validating array constraints without items
+ * ```typescript
+ * import { oasArrayDataWithoutItems } from '@skmtc/core/oas/array';
+ * import * as v from 'valibot';
+ *
+ * const constraintsOnly = {
+ *   type: 'array',
+ *   title: 'Validation Rules',
+ *   minItems: 1,
+ *   maxItems: 50,
+ *   uniqueItems: true,
+ *   default: []
+ * };
+ *
+ * const validated = v.parse(oasArrayDataWithoutItems, constraintsOnly);
+ * console.log(validated.uniqueItems); // true
+ * ```
+ *
+ * @example Usage in two-phase parsing
+ * ```typescript
+ * function parseArraySchema(schema: unknown) {
+ *   // Phase 1: Validate basic array structure
+ *   const arrayConstraints = v.parse(oasArrayDataWithoutItems, schema);
+ *
+ *   // Phase 2: Process items separately (not shown)
+ *   const items = processItemsSchema((schema as any).items);
+ *
+ *   return { ...arrayConstraints, items };
+ * }
+ * ```
  */
 export declare const oasArrayDataWithoutItems: v.GenericSchema<OasArrayDataWithoutItems>;
 /**
  * Data type for OpenAPI array schema objects.
  *
- * Represents array schemas with item type specifications, length constraints,
- * and validation rules. Used throughout the SKMTC pipeline for array type
- * processing and code generation.
+ * Represents the complete structure of OpenAPI array schemas as processed by the SKMTC
+ * pipeline. This type includes all standard OpenAPI array schema properties including
+ * item type specifications, length constraints, uniqueness requirements, and metadata
+ * fields. It's used throughout the array processing pipeline for type-safe handling
+ * of array schema definitions.
+ *
+ * ## Usage in SKMTC Pipeline
+ *
+ * This type is used by:
+ * - Schema parsers to validate incoming array schema data
+ * - Array processors to transform OpenAPI schemas into OAS objects
+ * - Code generators to access array constraints and generate validation code
+ * - Type generators to create appropriate array type definitions
+ *
+ * @example Basic string array schema
+ * ```typescript
+ * import type { OasArrayData } from '@skmtc/core/oas/array';
+ *
+ * const tagListSchema: OasArrayData = {
+ *   type: 'array',
+ *   items: {
+ *     type: 'string',
+ *     minLength: 1,
+ *     maxLength: 50
+ *   },
+ *   title: 'Tag List',
+ *   description: 'Collection of tags for categorization',
+ *   minItems: 0,
+ *   maxItems: 20,
+ *   uniqueItems: true,
+ *   default: []
+ * };
+ * ```
+ *
+ * @example Array of referenced objects
+ * ```typescript
+ * const userListSchema: OasArrayData = {
+ *   type: 'array',
+ *   items: {
+ *     $ref: '#/components/schemas/User'
+ *   },
+ *   title: 'User Collection',
+ *   description: 'List of user objects',
+ *   minItems: 1,
+ *   default: []
+ * };
+ * ```
+ *
+ * @example Complex nested array schema
+ * ```typescript
+ * const matrixSchema: OasArrayData = {
+ *   type: 'array',
+ *   items: {
+ *     type: 'array',
+ *     items: {
+ *       type: 'number'
+ *     },
+ *     minItems: 3,
+ *     maxItems: 3
+ *   },
+ *   title: '3x3 Matrix',
+ *   description: 'Two-dimensional number array representing a 3x3 matrix',
+ *   minItems: 3,
+ *   maxItems: 3
+ * };
+ * ```
+ *
+ * @example Enum array with constraints
+ * ```typescript
+ * const statusListSchema: OasArrayData = {
+ *   type: 'array',
+ *   items: {
+ *     type: 'string',
+ *     enum: ['active', 'inactive', 'pending']
+ *   },
+ *   title: 'Status List',
+ *   description: 'Multiple status values',
+ *   uniqueItems: true,
+ *   enums: [
+ *     ['active'],
+ *     ['active', 'pending'],
+ *     ['inactive', 'pending']
+ *   ]
+ * };
+ * ```
  */
 export type OasArrayData = {
     /** Type identifier (always 'array') */
     type: 'array';
-    /** Schema definition for array items */
+    /** Schema definition for array items (can be direct schema or reference) */
     items: OasSchemaData | OasSchemaRefData;
-    /** Human-readable title for the array */
+    /** Human-readable title for the array schema */
     title?: string;
-    /** Detailed description of the array's purpose */
+    /** Detailed description explaining the array's purpose and contents */
     description?: string;
-    /** Default value for the array */
+    /** Default value used when no explicit array is provided */
     default?: unknown[];
-    /** Maximum number of items allowed */
+    /** Maximum number of items allowed in the array */
     maxItems?: number;
-    /** Minimum number of items required */
+    /** Minimum number of items required in the array */
     minItems?: number;
-    /** Whether all items must be unique */
+    /** Whether all items in the array must be unique */
     uniqueItems?: boolean;
-    /** Array of valid enumeration values */
+    /** Array of valid enumeration values for the entire array */
     enums?: unknown[];
 };
 /**
  * Array schema data without the items property.
  *
- * Represents an array schema with all properties except the items definition.
- * Used during parsing phases where item schemas are processed separately.
+ * Represents an array schema with all standard properties except the items definition.
+ * This type is used during parsing phases where item schemas are processed separately
+ * from array constraints, enabling more flexible processing pipelines and better
+ * separation of concerns in complex schema transformation operations.
+ *
+ * ## Common Use Cases
+ *
+ * - **Two-phase parsing**: Validate array structure first, then process items
+ * - **Schema merging**: Combine array constraints from multiple sources
+ * - **Constraint extraction**: Extract array rules for validation generation
+ * - **Reference resolution**: Process items after resolving schema references
+ *
+ * @example Array constraints for validation
+ * ```typescript
+ * import type { OasArrayDataWithoutItems } from '@skmtc/core/oas/array';
+ *
+ * const constraintsSchema: OasArrayDataWithoutItems = {
+ *   type: 'array',
+ *   title: 'Validation Rules',
+ *   description: 'Array with length and uniqueness constraints',
+ *   minItems: 1,
+ *   maxItems: 100,
+ *   uniqueItems: true,
+ *   default: []
+ * };
+ * ```
+ *
+ * @example Enum constraints without item types
+ * ```typescript
+ * const enumArrayConstraints: OasArrayDataWithoutItems = {
+ *   type: 'array',
+ *   title: 'Option Groups',
+ *   description: 'Predefined option combinations',
+ *   enums: [
+ *     ['option1', 'option2'],
+ *     ['option3', 'option4'],
+ *     ['option1', 'option3', 'option4']
+ *   ],
+ *   uniqueItems: true
+ * };
+ * ```
  */
 export type OasArrayDataWithoutItems = {
     /** Type identifier (always 'array') */
     type: 'array';
-    /** Human-readable title for the array */
+    /** Human-readable title for the array schema */
     title?: string;
-    /** Detailed description of the array's purpose */
+    /** Detailed description explaining the array's purpose and contents */
     description?: string;
-    /** Default value for the array */
+    /** Default value used when no explicit array is provided */
     default?: unknown[];
-    /** Maximum number of items allowed */
+    /** Maximum number of items allowed in the array */
     maxItems?: number;
-    /** Minimum number of items required */
+    /** Minimum number of items required in the array */
     minItems?: number;
-    /** Whether all items must be unique */
+    /** Whether all items in the array must be unique */
     uniqueItems?: boolean;
-    /** Array of valid enumeration values */
+    /** Array of valid enumeration values for the entire array */
     enums?: unknown[];
 };
 //# sourceMappingURL=array-types.d.ts.map

package/esm/oas/array/array-types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"array-types.d.ts","sourceRoot":"","sources":["../../../src/oas/array/array-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAC5B,OAAO,EAAE,KAAK,aAAa,EAAiB,MAAM,2BAA2B,CAAA;AAC7E,OAAO,EAAE,KAAK,gBAAgB,EAAoB,MAAM,qBAAqB,CAAA;AAE7E;;;;;;GAMG;AACH,eAAO,MAAM,YAAY,EAAE,CAAC,CAAC,aAAa,CAAC,YAAY,CAUrD,CAAA;AAEF;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB,EAAE,CAAC,CAAC,aAAa,CAAC,wBAAwB,CAS7E,CAAA;AAEF;;;;;;GAMG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,uCAAuC;IACvC,IAAI,EAAE,OAAO,CAAA;IACb,wCAAwC;IACxC,KAAK,EAAE,aAAa,GAAG,gBAAgB,CAAA;IACvC,yCAAyC;IACzC,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,kDAAkD;IAClD,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,kCAAkC;IAClC,OAAO,CAAC,EAAE,OAAO,EAAE,CAAA;IACnB,sCAAsC;IACtC,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,uCAAuC;IACvC,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,uCAAuC;IACvC,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,wCAAwC;IACxC,KAAK,CAAC,EAAE,OAAO,EAAE,CAAA;CAClB,CAAA;AAED;;;;;GAKG;AACH,MAAM,MAAM,wBAAwB,GAAG;IACrC,uCAAuC;IACvC,IAAI,EAAE,OAAO,CAAA;IACb,yCAAyC;IACzC,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,kDAAkD;IAClD,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,kCAAkC;IAClC,OAAO,CAAC,EAAE,OAAO,EAAE,CAAA;IACnB,sCAAsC;IACtC,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,uCAAuC;IACvC,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,uCAAuC;IACvC,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,wCAAwC;IACxC,KAAK,CAAC,EAAE,OAAO,EAAE,CAAA;CAClB,CAAA"}
+{"version":3,"file":"array-types.d.ts","sourceRoot":"","sources":["../../../src/oas/array/array-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAC5B,OAAO,EAAE,KAAK,aAAa,EAAiB,MAAM,2BAA2B,CAAA;AAC7E,OAAO,EAAE,KAAK,gBAAgB,EAAoB,MAAM,qBAAqB,CAAA;AAE7E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6DG;AACH,eAAO,MAAM,YAAY,EAAE,CAAC,CAAC,aAAa,CAAC,YAAY,CAUrD,CAAA;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,eAAO,MAAM,wBAAwB,EAAE,CAAC,CAAC,aAAa,CAAC,wBAAwB,CAS7E,CAAA;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwFG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,uCAAuC;IACvC,IAAI,EAAE,OAAO,CAAA;IACb,4EAA4E;IAC5E,KAAK,EAAE,aAAa,GAAG,gBAAgB,CAAA;IACvC,gDAAgD;IAChD,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,uEAAuE;IACvE,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,4DAA4D;IAC5D,OAAO,CAAC,EAAE,OAAO,EAAE,CAAA;IACnB,mDAAmD;IACnD,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,oDAAoD;IACpD,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,oDAAoD;IACpD,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,6DAA6D;IAC7D,KAAK,CAAC,EAAE,OAAO,EAAE,CAAA;CAClB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,MAAM,MAAM,wBAAwB,GAAG;IACrC,uCAAuC;IACvC,IAAI,EAAE,OAAO,CAAA;IACb,gDAAgD;IAChD,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,uEAAuE;IACvE,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,4DAA4D;IAC5D,OAAO,CAAC,EAAE,OAAO,EAAE,CAAA;IACnB,mDAAmD;IACnD,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,oDAAoD;IACpD,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,oDAAoD;IACpD,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,6DAA6D;IAC7D,KAAK,CAAC,EAAE,OAAO,EAAE,CAAA;CAClB,CAAA"}

package/esm/oas/array/array-types.js

@@ -4,9 +4,64 @@ import { oasSchemaRefData } from '../ref/ref-types.js';
 /**
  * Valibot schema for validating OpenAPI array data objects.
  *
- * Validates array schemas including item type definitions, length constraints,
- * uniqueness requirements, and enumeration values. Uses lazy evaluation
- * to handle recursive schema references.
+ * This comprehensive schema validates OpenAPI array schemas according to the OpenAPI v3
+ * specification, including item type definitions, length constraints, uniqueness requirements,
+ * and enumeration values. It uses lazy evaluation to handle recursive schema references,
+ * allowing for complex nested array structures and self-referential schemas.
+ *
+ * The schema supports both direct schema definitions and reference objects for the items
+ * property, enabling flexible array type definitions that can reference other schemas
+ * in the document or define inline item types.
+ *
+ * @example Validating a simple array schema
+ * ```typescript
+ * import { oasArrayData } from '@skmtc/core/oas/array';
+ * import * as v from 'valibot';
+ *
+ * const schema = {
+ *   type: 'array',
+ *   items: {
+ *     type: 'string'
+ *   },
+ *   description: 'List of user names',
+ *   minItems: 1,
+ *   maxItems: 100
+ * };
+ *
+ * const validated = v.parse(oasArrayData, schema);
+ * console.log(validated.minItems); // 1
+ * ```
+ *
+ * @example Validating array with reference items
+ * ```typescript
+ * const refArraySchema = {
+ *   type: 'array',
+ *   items: {
+ *     $ref: '#/components/schemas/User'
+ *   },
+ *   title: 'User List',
+ *   uniqueItems: true,
+ *   default: []
+ * };
+ *
+ * const result = v.parse(oasArrayData, refArraySchema);
+ * console.log(result.uniqueItems); // true
+ * ```
+ *
+ * @example Validating constrained arrays
+ * ```typescript
+ * const constrainedArray = {
+ *   type: 'array',
+ *   items: { type: 'number' },
+ *   minItems: 2,
+ *   maxItems: 10,
+ *   uniqueItems: true,
+ *   enums: [[1, 2, 3], [4, 5, 6]]
+ * };
+ *
+ * const validated = v.parse(oasArrayData, constrainedArray);
+ * console.log(validated.maxItems); // 10
+ * ```
  */
 export const oasArrayData = v.object({
     type: v.literal('array'),
@@ -22,8 +77,45 @@ export const oasArrayData = v.object({
 /**
  * Valibot schema for array data without the items property.
  *
- * Used for parsing array schemas when the items property is handled separately,
- * typically during schema transformation and validation processes.
+ * This specialized schema validates array schemas when the items property is processed
+ * separately from the main array constraints. It's commonly used during schema parsing
+ * and transformation processes where items need special handling, such as when resolving
+ * references or applying schema merging operations.
+ *
+ * This pattern is useful in multi-phase parsing where array constraints (like min/max
+ * items, uniqueness) are validated independently from the item type definitions,
+ * allowing for more flexible processing pipelines.
+ *
+ * @example Validating array constraints without items
+ * ```typescript
+ * import { oasArrayDataWithoutItems } from '@skmtc/core/oas/array';
+ * import * as v from 'valibot';
+ *
+ * const constraintsOnly = {
+ *   type: 'array',
+ *   title: 'Validation Rules',
+ *   minItems: 1,
+ *   maxItems: 50,
+ *   uniqueItems: true,
+ *   default: []
+ * };
+ *
+ * const validated = v.parse(oasArrayDataWithoutItems, constraintsOnly);
+ * console.log(validated.uniqueItems); // true
+ * ```
+ *
+ * @example Usage in two-phase parsing
+ * ```typescript
+ * function parseArraySchema(schema: unknown) {
+ *   // Phase 1: Validate basic array structure
+ *   const arrayConstraints = v.parse(oasArrayDataWithoutItems, schema);
+ *
+ *   // Phase 2: Process items separately (not shown)
+ *   const items = processItemsSchema((schema as any).items);
+ *
+ *   return { ...arrayConstraints, items };
+ * }
+ * ```
  */
 export const oasArrayDataWithoutItems = v.object({
     type: v.literal('array'),

package/esm/oas/boolean/boolean-types.d.ts

@@ -2,27 +2,99 @@ import * as v from 'valibot';
 /**
  * Valibot schema for validating OpenAPI boolean data objects.
  *
- * Validates boolean schemas including default values and enumeration
- * constraints. Boolean enums typically contain [true, false] or single values.
+ * This schema validates OpenAPI boolean schemas according to the OpenAPI v3 specification,
+ * including optional properties like default values, enumeration constraints, title,
+ * and description metadata. Boolean enums are commonly used to restrict values to
+ * specific boolean constants (e.g., [true] for always-true flags).
+ *
+ * @example Validating a basic boolean schema
+ * ```typescript
+ * import { oasBooleanData } from '@skmtc/core/oas/boolean';
+ * import * as v from 'valibot';
+ *
+ * const schema = {
+ *   type: 'boolean',
+ *   description: 'Whether the feature is enabled',
+ *   default: false
+ * };
+ *
+ * const validated = v.parse(oasBooleanData, schema);
+ * console.log(validated.default); // false
+ * ```
+ *
+ * @example Validating boolean with enumeration
+ * ```typescript
+ * const constrainedBoolean = {
+ *   type: 'boolean',
+ *   title: 'Admin Flag',
+ *   description: 'User admin status',
+ *   enum: [true] // Only true values allowed
+ * };
+ *
+ * const result = v.parse(oasBooleanData, constrainedBoolean);
+ * console.log(result.enum); // [true]
+ * ```
  */
 export declare const oasBooleanData: v.GenericSchema<OasBooleanData>;
 /**
  * Data type for OpenAPI boolean schema objects.
  *
- * Represents boolean schemas with optional default values and enumeration
- * constraints. Used throughout the SKMTC pipeline for boolean type
- * processing and code generation.
+ * Represents the structure of OpenAPI boolean schemas as processed by the SKMTC pipeline.
+ * This type includes all standard OpenAPI boolean schema properties including metadata,
+ * default values, and enumeration constraints. It's used throughout the boolean
+ * processing pipeline for type-safe handling of boolean schema definitions.
+ *
+ * ## Usage in SKMTC Pipeline
+ *
+ * This type is used by:
+ * - Schema parsers to validate incoming boolean schema data
+ * - Boolean processors to transform OpenAPI schemas into OAS objects
+ * - Code generators to access boolean schema metadata and constraints
+ * - Validation systems to ensure schema compliance
+ *
+ * @example Basic boolean schema
+ * ```typescript
+ * import type { OasBooleanData } from '@skmtc/core/oas/boolean';
+ *
+ * const isActiveSchema: OasBooleanData = {
+ *   type: 'boolean',
+ *   title: 'Active Status',
+ *   description: 'Whether the record is active',
+ *   default: true
+ * };
+ * ```
+ *
+ * @example Boolean with enumeration constraints
+ * ```typescript
+ * const adminFlagSchema: OasBooleanData = {
+ *   type: 'boolean',
+ *   description: 'Administrative privileges flag',
+ *   enum: [false, true], // Allow both values
+ *   default: false
+ * };
+ * ```
+ *
+ * @example Read-only boolean flag
+ * ```typescript
+ * const systemFlagSchema: OasBooleanData = {
+ *   type: 'boolean',
+ *   title: 'System Generated',
+ *   description: 'Indicates if the record was system-generated',
+ *   enum: [true], // Always true
+ *   default: true
+ * };
+ * ```
  */
 export type OasBooleanData = {
     /** Type identifier (always 'boolean') */
     type: 'boolean';
-    /** Human-readable title for the boolean */
+    /** Human-readable title for the boolean schema */
     title?: string;
-    /** Detailed description of the boolean's purpose */
+    /** Detailed description explaining the boolean's purpose and usage */
     description?: string;
-    /** Default value for the boolean */
+    /** Default value used when no explicit value is provided */
     default?: boolean;
-    /** Array of valid boolean values (typically [true], [false], or [true, false]) */
+    /** Array of valid boolean values for enumeration constraints */
     enum?: boolean[];
 };
 //# sourceMappingURL=boolean-types.d.ts.map

package/esm/oas/boolean/boolean-types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"boolean-types.d.ts","sourceRoot":"","sources":["../../../src/oas/boolean/boolean-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B;;;;;GAKG;AACH,eAAO,MAAM,cAAc,EAAE,CAAC,CAAC,aAAa,CAAC,cAAc,CAMzD,CAAA;AAEF;;;;;;GAMG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B,yCAAyC;IACzC,IAAI,EAAE,SAAS,CAAA;IACf,2CAA2C;IAC3C,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,oDAAoD;IACpD,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,oCAAoC;IACpC,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,kFAAkF;IAClF,IAAI,CAAC,EAAE,OAAO,EAAE,CAAA;CACjB,CAAA"}
+{"version":3,"file":"boolean-types.d.ts","sourceRoot":"","sources":["../../../src/oas/boolean/boolean-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,eAAO,MAAM,cAAc,EAAE,CAAC,CAAC,aAAa,CAAC,cAAc,CAMzD,CAAA;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B,yCAAyC;IACzC,IAAI,EAAE,SAAS,CAAA;IACf,kDAAkD;IAClD,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,sEAAsE;IACtE,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,4DAA4D;IAC5D,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,gEAAgE;IAChE,IAAI,CAAC,EAAE,OAAO,EAAE,CAAA;CACjB,CAAA"}

package/esm/oas/boolean/boolean-types.js

@@ -2,8 +2,38 @@ import * as v from 'valibot';
 /**
  * Valibot schema for validating OpenAPI boolean data objects.
  *
- * Validates boolean schemas including default values and enumeration
- * constraints. Boolean enums typically contain [true, false] or single values.
+ * This schema validates OpenAPI boolean schemas according to the OpenAPI v3 specification,
+ * including optional properties like default values, enumeration constraints, title,
+ * and description metadata. Boolean enums are commonly used to restrict values to
+ * specific boolean constants (e.g., [true] for always-true flags).
+ *
+ * @example Validating a basic boolean schema
+ * ```typescript
+ * import { oasBooleanData } from '@skmtc/core/oas/boolean';
+ * import * as v from 'valibot';
+ *
+ * const schema = {
+ *   type: 'boolean',
+ *   description: 'Whether the feature is enabled',
+ *   default: false
+ * };
+ *
+ * const validated = v.parse(oasBooleanData, schema);
+ * console.log(validated.default); // false
+ * ```
+ *
+ * @example Validating boolean with enumeration
+ * ```typescript
+ * const constrainedBoolean = {
+ *   type: 'boolean',
+ *   title: 'Admin Flag',
+ *   description: 'User admin status',
+ *   enum: [true] // Only true values allowed
+ * };
+ *
+ * const result = v.parse(oasBooleanData, constrainedBoolean);
+ * console.log(result.enum); // [true]
+ * ```
  */
 export const oasBooleanData = v.object({
     type: v.literal('boolean'),