@skmtc/core 0.0.807 → 0.0.809

package/script/oas/operation/operation-types.d.ts

@@ -4,19 +4,270 @@ import { type OasParameterRefData, type OasRequestBodyRefData, type OasResponseR
 import { type OasRequestBodyData } from '../requestBody/requestBody-types.js';
 import { type OasResponseData } from '../response/response-types.js';
 import * as v from 'valibot';
+/**
+ * Data type for OpenAPI operation objects processed by the SKMTC pipeline.
+ *
+ * This type represents a complete OpenAPI operation (API endpoint) including all
+ * associated metadata, parameters, request body, responses, and path information.
+ * It serves as the internal representation of OpenAPI operations during the
+ * code generation process, combining operation data with its parent path item context.
+ *
+ * ## Usage in SKMTC Pipeline
+ *
+ * This type is used by:
+ * - Operation parsers to validate and structure incoming OpenAPI operations
+ * - Code generators to access operation metadata and generate client code
+ * - Response processors to understand expected API responses
+ * - Parameter handlers to generate request validation and typing
+ *
+ * @example Basic GET operation
+ * ```typescript
+ * import type { OasOperationData } from '@skmtc/core/oas/operation';
+ *
+ * const getUserOperation: OasOperationData = {
+ *   oasType: 'operation',
+ *   path: '/users/{id}',
+ *   method: 'get',
+ *   operationId: 'getUserById',
+ *   summary: 'Get user by ID',
+ *   description: 'Retrieves a specific user by their unique identifier',
+ *   tags: ['users'],
+ *   parameters: [
+ *     {
+ *       name: 'id',
+ *       in: 'path',
+ *       required: true,
+ *       schema: { type: 'string' }
+ *     }
+ *   ],
+ *   responses: {
+ *     '200': {
+ *       description: 'User found',
+ *       content: {
+ *         'application/json': {
+ *           schema: { $ref: '#/components/schemas/User' }
+ *         }
+ *       }
+ *     },
+ *     '404': {
+ *       description: 'User not found'
+ *     }
+ *   },
+ *   pathItem: pathItemData
+ * };
+ * ```
+ *
+ * @example POST operation with request body
+ * ```typescript
+ * const createUserOperation: OasOperationData = {
+ *   oasType: 'operation',
+ *   path: '/users',
+ *   method: 'post',
+ *   operationId: 'createUser',
+ *   summary: 'Create new user',
+ *   description: 'Creates a new user account',
+ *   tags: ['users'],
+ *   requestBody: {
+ *     description: 'User data',
+ *     required: true,
+ *     content: {
+ *       'application/json': {
+ *         schema: { $ref: '#/components/schemas/CreateUserRequest' }
+ *       }
+ *     }
+ *   },
+ *   responses: {
+ *     '201': {
+ *       description: 'User created successfully',
+ *       content: {
+ *         'application/json': {
+ *           schema: { $ref: '#/components/schemas/User' }
+ *         }
+ *       }
+ *     },
+ *     '400': {
+ *       description: 'Invalid request data'
+ *     }
+ *   },
+ *   pathItem: pathItemData
+ * };
+ * ```
+ *
+ * @example Operation with query parameters
+ * ```typescript
+ * const listUsersOperation: OasOperationData = {
+ *   oasType: 'operation',
+ *   path: '/users',
+ *   method: 'get',
+ *   operationId: 'listUsers',
+ *   summary: 'List users',
+ *   description: 'Get paginated list of users',
+ *   tags: ['users'],
+ *   parameters: [
+ *     {
+ *       name: 'page',
+ *       in: 'query',
+ *       schema: { type: 'integer', minimum: 1, default: 1 }
+ *     },
+ *     {
+ *       name: 'limit',
+ *       in: 'query',
+ *       schema: { type: 'integer', minimum: 1, maximum: 100, default: 20 }
+ *     },
+ *     {
+ *       name: 'status',
+ *       in: 'query',
+ *       schema: { type: 'string', enum: ['active', 'inactive'] }
+ *     }
+ *   ],
+ *   responses: {
+ *     '200': {
+ *       description: 'List of users',
+ *       content: {
+ *         'application/json': {
+ *           schema: {
+ *             type: 'object',
+ *             properties: {
+ *               users: {
+ *                 type: 'array',
+ *                 items: { $ref: '#/components/schemas/User' }
+ *               },
+ *               totalCount: { type: 'integer' },
+ *               page: { type: 'integer' },
+ *               limit: { type: 'integer' }
+ *             }
+ *           }
+ *         }
+ *       }
+ *     }
+ *   },
+ *   pathItem: pathItemData
+ * };
+ * ```
+ */
 export type OasOperationData = {
+    /** Type identifier for SKMTC internal processing */
     oasType: 'operation';
+    /** Parent path item containing this operation */
     pathItem: OasPathItemData;
+    /** The API path template (e.g., '/users/{id}') */
     path: string;
+    /** HTTP method for this operation */
     method: 'get' | 'put' | 'post' | 'delete' | 'options' | 'head' | 'patch' | 'trace';
+    /** Unique identifier for this operation (used for client method names) */
     operationId?: string;
+    /** Tags for grouping operations (used for code organization) */
     tags?: string[];
+    /** Brief summary of what the operation does */
     summary?: string;
+    /** Detailed description of the operation behavior */
     description?: string;
+    /** List of parameters (path, query, header, cookie) */
     parameters?: (OasParameterData | OasParameterRefData)[];
+    /** Request body specification for operations that accept data */
     requestBody?: OasRequestBodyData | OasRequestBodyRefData;
+    /** Map of status codes to response specifications */
     responses: Record<string, OasResponseData | OasResponseRefData>;
+    /** Whether this operation is deprecated */
     deprecated?: boolean;
 };
+/**
+ * Valibot schema for validating OpenAPI operation data objects.
+ *
+ * This comprehensive schema validates OpenAPI operations according to the OpenAPI v3
+ * specification, including all standard properties like HTTP methods, parameters,
+ * request bodies, responses, and metadata. It uses lazy evaluation and unions to
+ * handle complex nested structures and reference objects.
+ *
+ * The schema ensures that operation data conforms to OpenAPI standards while also
+ * including SKMTC-specific metadata (like `oasType` and `pathItem`) needed for
+ * the code generation pipeline.
+ *
+ * @example Validating a GET operation
+ * ```typescript
+ * import { oasOperationData } from '@skmtc/core/oas/operation';
+ * import * as v from 'valibot';
+ *
+ * const operation = {
+ *   oasType: 'operation',
+ *   path: '/api/users/{id}',
+ *   method: 'get',
+ *   operationId: 'getUserById',
+ *   summary: 'Get user by ID',
+ *   parameters: [
+ *     {
+ *       name: 'id',
+ *       in: 'path',
+ *       required: true,
+ *       schema: { type: 'string' }
+ *     }
+ *   ],
+ *   responses: {
+ *     '200': {
+ *       description: 'Success',
+ *       content: {
+ *         'application/json': {
+ *           schema: { $ref: '#/components/schemas/User' }
+ *         }
+ *       }
+ *     }
+ *   },
+ *   pathItem: validPathItem
+ * };
+ *
+ * const validated = v.parse(oasOperationData, operation);
+ * console.log(validated.operationId); // 'getUserById'
+ * ```
+ *
+ * @example Validating a POST operation with request body
+ * ```typescript
+ * const postOperation = {
+ *   oasType: 'operation',
+ *   path: '/api/users',
+ *   method: 'post',
+ *   operationId: 'createUser',
+ *   requestBody: {
+ *     description: 'User data',
+ *     required: true,
+ *     content: {
+ *       'application/json': {
+ *         schema: { $ref: '#/components/schemas/CreateUserRequest' }
+ *       }
+ *     }
+ *   },
+ *   responses: {
+ *     '201': {
+ *       description: 'User created',
+ *       content: {
+ *         'application/json': {
+ *           schema: { $ref: '#/components/schemas/User' }
+ *         }
+ *       }
+ *     }
+ *   },
+ *   pathItem: validPathItem
+ * };
+ *
+ * const validated = v.parse(oasOperationData, postOperation);
+ * console.log(validated.method); // 'post'
+ * ```
+ *
+ * @example Validation error handling
+ * ```typescript
+ * const invalidOperation = {
+ *   oasType: 'operation',
+ *   path: '/api/users',
+ *   method: 'invalid', // Invalid HTTP method
+ *   responses: {} // Missing required responses
+ * };
+ *
+ * try {
+ *   v.parse(oasOperationData, invalidOperation);
+ * } catch (error) {
+ *   console.error('Validation failed:', error.message);
+ *   // Handle validation errors
+ * }
+ * ```
+ */
 export declare const oasOperationData: v.GenericSchema<OasOperationData>;
 //# sourceMappingURL=operation-types.d.ts.map

package/script/oas/operation/operation-types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"operation-types.d.ts","sourceRoot":"","sources":["../../../src/oas/operation/operation-types.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,gBAAgB,EAAoB,MAAM,iCAAiC,CAAA;AACzF,OAAO,EAAE,KAAK,eAAe,EAAmB,MAAM,+BAA+B,CAAA;AACrF,OAAO,EACL,KAAK,mBAAmB,EACxB,KAAK,qBAAqB,EAC1B,KAAK,kBAAkB,EAIxB,MAAM,qBAAqB,CAAA;AAC5B,OAAO,EAAE,KAAK,kBAAkB,EAAsB,MAAM,qCAAqC,CAAA;AACjG,OAAO,EAAE,KAAK,eAAe,EAAmB,MAAM,+BAA+B,CAAA;AACrF,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B,MAAM,MAAM,gBAAgB,GAAG;IAC7B,OAAO,EAAE,WAAW,CAAA;IACpB,QAAQ,EAAE,eAAe,CAAA;IACzB,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,KAAK,GAAG,KAAK,GAAG,MAAM,GAAG,QAAQ,GAAG,SAAS,GAAG,MAAM,GAAG,OAAO,GAAG,OAAO,CAAA;IAClF,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAA;IACf,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,WAAW,CAAC,EAAE,MAAM,CAAA;IAGpB,UAAU,CAAC,EAAE,CAAC,gBAAgB,GAAG,mBAAmB,CAAC,EAAE,CAAA;IACvD,WAAW,CAAC,EAAE,kBAAkB,GAAG,qBAAqB,CAAA;IACxD,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,GAAG,kBAAkB,CAAC,CAAA;IAE/D,UAAU,CAAC,EAAE,OAAO,CAAA;CAGrB,CAAA;AAED,eAAO,MAAM,gBAAgB,EAAE,CAAC,CAAC,aAAa,CAAC,gBAAgB,CA2B7D,CAAA"}
+{"version":3,"file":"operation-types.d.ts","sourceRoot":"","sources":["../../../src/oas/operation/operation-types.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,gBAAgB,EAAoB,MAAM,iCAAiC,CAAA;AACzF,OAAO,EAAE,KAAK,eAAe,EAAmB,MAAM,+BAA+B,CAAA;AACrF,OAAO,EACL,KAAK,mBAAmB,EACxB,KAAK,qBAAqB,EAC1B,KAAK,kBAAkB,EAIxB,MAAM,qBAAqB,CAAA;AAC5B,OAAO,EAAE,KAAK,kBAAkB,EAAsB,MAAM,qCAAqC,CAAA;AACjG,OAAO,EAAE,KAAK,eAAe,EAAmB,MAAM,+BAA+B,CAAA;AACrF,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4IG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAC7B,oDAAoD;IACpD,OAAO,EAAE,WAAW,CAAA;IACpB,iDAAiD;IACjD,QAAQ,EAAE,eAAe,CAAA;IACzB,kDAAkD;IAClD,IAAI,EAAE,MAAM,CAAA;IACZ,qCAAqC;IACrC,MAAM,EAAE,KAAK,GAAG,KAAK,GAAG,MAAM,GAAG,QAAQ,GAAG,SAAS,GAAG,MAAM,GAAG,OAAO,GAAG,OAAO,CAAA;IAClF,0EAA0E;IAC1E,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,gEAAgE;IAChE,IAAI,CAAC,EAAE,MAAM,EAAE,CAAA;IACf,+CAA+C;IAC/C,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,qDAAqD;IACrD,WAAW,CAAC,EAAE,MAAM,CAAA;IAGpB,uDAAuD;IACvD,UAAU,CAAC,EAAE,CAAC,gBAAgB,GAAG,mBAAmB,CAAC,EAAE,CAAA;IACvD,iEAAiE;IACjE,WAAW,CAAC,EAAE,kBAAkB,GAAG,qBAAqB,CAAA;IACxD,qDAAqD;IACrD,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,GAAG,kBAAkB,CAAC,CAAA;IAE/D,2CAA2C;IAC3C,UAAU,CAAC,EAAE,OAAO,CAAA;CAGrB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiGG;AACH,eAAO,MAAM,gBAAgB,EAAE,CAAC,CAAC,aAAa,CAAC,gBAAgB,CA2B7D,CAAA"}

package/script/oas/operation/operation-types.js

@@ -41,6 +41,104 @@ const ref_types_js_1 = require("../ref/ref-types.js");
 const requestBody_types_js_1 = require("../requestBody/requestBody-types.js");
 const response_types_js_1 = require("../response/response-types.js");
 const v = __importStar(require("valibot"));
+/**
+ * Valibot schema for validating OpenAPI operation data objects.
+ *
+ * This comprehensive schema validates OpenAPI operations according to the OpenAPI v3
+ * specification, including all standard properties like HTTP methods, parameters,
+ * request bodies, responses, and metadata. It uses lazy evaluation and unions to
+ * handle complex nested structures and reference objects.
+ *
+ * The schema ensures that operation data conforms to OpenAPI standards while also
+ * including SKMTC-specific metadata (like `oasType` and `pathItem`) needed for
+ * the code generation pipeline.
+ *
+ * @example Validating a GET operation
+ * ```typescript
+ * import { oasOperationData } from '@skmtc/core/oas/operation';
+ * import * as v from 'valibot';
+ *
+ * const operation = {
+ *   oasType: 'operation',
+ *   path: '/api/users/{id}',
+ *   method: 'get',
+ *   operationId: 'getUserById',
+ *   summary: 'Get user by ID',
+ *   parameters: [
+ *     {
+ *       name: 'id',
+ *       in: 'path',
+ *       required: true,
+ *       schema: { type: 'string' }
+ *     }
+ *   ],
+ *   responses: {
+ *     '200': {
+ *       description: 'Success',
+ *       content: {
+ *         'application/json': {
+ *           schema: { $ref: '#/components/schemas/User' }
+ *         }
+ *       }
+ *     }
+ *   },
+ *   pathItem: validPathItem
+ * };
+ *
+ * const validated = v.parse(oasOperationData, operation);
+ * console.log(validated.operationId); // 'getUserById'
+ * ```
+ *
+ * @example Validating a POST operation with request body
+ * ```typescript
+ * const postOperation = {
+ *   oasType: 'operation',
+ *   path: '/api/users',
+ *   method: 'post',
+ *   operationId: 'createUser',
+ *   requestBody: {
+ *     description: 'User data',
+ *     required: true,
+ *     content: {
+ *       'application/json': {
+ *         schema: { $ref: '#/components/schemas/CreateUserRequest' }
+ *       }
+ *     }
+ *   },
+ *   responses: {
+ *     '201': {
+ *       description: 'User created',
+ *       content: {
+ *         'application/json': {
+ *           schema: { $ref: '#/components/schemas/User' }
+ *         }
+ *       }
+ *     }
+ *   },
+ *   pathItem: validPathItem
+ * };
+ *
+ * const validated = v.parse(oasOperationData, postOperation);
+ * console.log(validated.method); // 'post'
+ * ```
+ *
+ * @example Validation error handling
+ * ```typescript
+ * const invalidOperation = {
+ *   oasType: 'operation',
+ *   path: '/api/users',
+ *   method: 'invalid', // Invalid HTTP method
+ *   responses: {} // Missing required responses
+ * };
+ *
+ * try {
+ *   v.parse(oasOperationData, invalidOperation);
+ * } catch (error) {
+ *   console.error('Validation failed:', error.message);
+ *   // Handle validation errors
+ * }
+ * ```
+ */
 exports.oasOperationData = v.object({
     oasType: v.literal('operation'),
     pathItem: pathItem_types_js_1.oasPathItemData,

package/script/oas/string/string-types.d.ts

@@ -2,54 +2,228 @@ import * as v from 'valibot';
 /**
  * Union type for OpenAPI string format specifiers.
  *
- * Represents the standard string formats defined in OpenAPI v3,
- * providing semantic meaning for string validation and processing.
- * Used for generating appropriate validation rules in target languages.
+ * Represents the standard string formats defined in the OpenAPI v3 specification,
+ * providing semantic meaning for string validation and processing. These formats
+ * are used by generators to produce appropriate validation rules, UI components,
+ * and type annotations in target languages.
+ *
+ * ## Format Categories
+ *
+ * **Date/Time Formats:**
+ * - `date-time`: Full RFC3339 date-time (e.g., "2018-03-20T09:12:28Z")
+ * - `time`: RFC3339 time only (e.g., "09:12:28")
+ * - `date`: RFC3339 full-date (e.g., "2018-03-20")
+ * - `duration`: RFC3339 duration (e.g., "P3Y6M4DT12H30M5S")
+ *
+ * **Network Formats:**
+ * - `email`: RFC5322 email address
+ * - `hostname`: RFC1123 hostname
+ * - `ipv4`: IPv4 address
+ * - `ipv6`: IPv6 address
+ * - `uri`: RFC3986 URI
+ * - `uuid`: RFC4122 UUID
+ *
+ * **Encoding/Pattern Formats:**
+ * - `regex`: Regular expression pattern
+ * - `password`: Password field hint for UI components
+ * - `byte`: Base64 encoded data
+ * - `binary`: Binary data
+ *
+ * @example Using string formats in schema definitions
+ * ```typescript
+ * import type { StringFormat } from '@skmtc/core/oas/string';
+ *
+ * const emailFormat: StringFormat = 'email';
+ * const timestampFormat: StringFormat = 'date-time';
+ * ```
  */
 export type StringFormat = 'date-time' | 'time' | 'date' | 'duration' | 'email' | 'hostname' | 'ipv4' | 'ipv6' | 'uuid' | 'uri' | 'regex' | 'password' | 'byte' | 'binary';
 /**
  * Valibot enum schema for valid OpenAPI string format values.
  *
- * Defines the standard string formats supported by OpenAPI v3,
- * including date/time formats, network formats, and encoding formats.
+ * This schema validates that string format values conform to the OpenAPI v3
+ * specification's standard format identifiers. It includes date/time formats,
+ * network address formats, and encoding formats that provide semantic meaning
+ * for string validation and UI generation.
+ *
+ * @example Validating string formats
+ * ```typescript
+ * import { stringFormat } from '@skmtc/core/oas/string';
+ * import * as v from 'valibot';
+ *
+ * const validFormat = v.parse(stringFormat, 'email'); // 'email'
+ * const invalidFormat = v.parse(stringFormat, 'invalid'); // Throws ValiError
+ * ```
+ *
+ * @example Using in schema validation
+ * ```typescript
+ * const schema = {
+ *   type: 'string',
+ *   format: 'email',
+ *   description: 'User email address'
+ * };
+ *
+ * // Validate the format field
+ * if (schema.format) {
+ *   const validatedFormat = v.parse(stringFormat, schema.format);
+ *   console.log(`Valid format: ${validatedFormat}`);
+ * }
+ * ```
  */
 export declare const stringFormat: v.GenericSchema<StringFormat>;
 /**
  * Valibot schema for validating OpenAPI string data objects.
  *
- * Validates string schema objects including length constraints,
- * pattern validation, format specifiers, and enumeration values.
+ * This comprehensive schema validates OpenAPI string schemas according to the
+ * OpenAPI v3 specification, including all standard properties like length
+ * constraints, pattern validation, format specifiers, enumeration values,
+ * and metadata fields. Used throughout the SKMTC pipeline for runtime
+ * validation of string schema definitions.
+ *
+ * @example Validating a basic string schema
+ * ```typescript
+ * import { oasStringData } from '@skmtc/core/oas/string';
+ * import * as v from 'valibot';
+ *
+ * const schema = {
+ *   type: 'string',
+ *   description: 'User name',
+ *   minLength: 1,
+ *   maxLength: 100,
+ *   pattern: '^[a-zA-Z\\s]+$'
+ * };
+ *
+ * const validated = v.parse(oasStringData, schema);
+ * console.log(validated.minLength); // 1
+ * ```
+ *
+ * @example Validating formatted strings
+ * ```typescript
+ * const emailSchema = {
+ *   type: 'string',
+ *   format: 'email',
+ *   title: 'Email Address',
+ *   example: 'user@example.com'
+ * };
+ *
+ * const result = v.parse(oasStringData, emailSchema);
+ * console.log(result.format); // 'email'
+ * ```
+ *
+ * @example Validating enumerated strings
+ * ```typescript
+ * const statusSchema = {
+ *   type: 'string',
+ *   enum: ['pending', 'approved', 'rejected'],
+ *   default: 'pending',
+ *   description: 'Application status'
+ * };
+ *
+ * const validated = v.parse(oasStringData, statusSchema);
+ * console.log(validated.enum); // ['pending', 'approved', 'rejected']
+ * ```
  */
 export declare const oasStringData: v.GenericSchema<OasStringData>;
 /**
  * Data type for OpenAPI string schema objects.
  *
- * Represents string schemas with validation constraints,
- * format specifiers, and metadata. Used throughout the
- * SKMTC pipeline for string type processing and code generation.
+ * Represents the complete structure of OpenAPI string schemas as processed by the
+ * SKMTC pipeline. This type includes all standard OpenAPI string schema properties
+ * including validation constraints (length, pattern), format specifiers, enumeration
+ * values, and metadata fields. It's used throughout the string processing pipeline
+ * for type-safe handling of string schema definitions.
+ *
+ * ## Usage in SKMTC Pipeline
+ *
+ * This type is used by:
+ * - Schema parsers to validate incoming string schema data
+ * - String processors to transform OpenAPI schemas into OAS objects
+ * - Code generators to access string constraints and generate validation code
+ * - UI generators to create appropriate form controls based on formats and constraints
+ *
+ * @example Basic string schema
+ * ```typescript
+ * import type { OasStringData } from '@skmtc/core/oas/string';
+ *
+ * const nameSchema: OasStringData = {
+ *   type: 'string',
+ *   title: 'Full Name',
+ *   description: 'User full name',
+ *   minLength: 1,
+ *   maxLength: 200,
+ *   example: 'John Doe'
+ * };
+ * ```
+ *
+ * @example Email string with format
+ * ```typescript
+ * const emailSchema: OasStringData = {
+ *   type: 'string',
+ *   format: 'email',
+ *   title: 'Email Address',
+ *   description: 'User email for notifications',
+ *   example: 'john.doe@example.com'
+ * };
+ * ```
+ *
+ * @example Enumerated string values
+ * ```typescript
+ * const roleSchema: OasStringData = {
+ *   type: 'string',
+ *   title: 'User Role',
+ *   description: 'User access level',
+ *   enum: ['admin', 'moderator', 'user', 'guest'],
+ *   default: 'user'
+ * };
+ * ```
+ *
+ * @example Pattern-constrained string
+ * ```typescript
+ * const phoneSchema: OasStringData = {
+ *   type: 'string',
+ *   title: 'Phone Number',
+ *   description: 'US phone number',
+ *   pattern: '^\\+?1?[2-9]\\d{9}$',
+ *   example: '+1234567890',
+ *   minLength: 10,
+ *   maxLength: 15
+ * };
+ * ```
+ *
+ * @example Nullable string with constraints
+ * ```typescript
+ * const commentSchema: OasStringData = {
+ *   type: 'string',
+ *   title: 'Comment',
+ *   description: 'Optional user comment',
+ *   maxLength: 500,
+ *   nullable: true,
+ *   default: null
+ * };
+ * ```
  */
 export type OasStringData = {
-    /** Human-readable title for the string */
+    /** Human-readable title for the string schema */
     title?: string;
-    /** Detailed description of the string's purpose */
+    /** Detailed description explaining the string's purpose and usage */
     description?: string;
-    /** Default value for the string */
+    /** Default value used when no explicit value is provided */
     default?: string;
     /** Type identifier (always 'string') */
     type: 'string';
-    /** Maximum allowed length */
+    /** Maximum allowed length in characters */
     maxLength?: number;
-    /** Minimum required length */
+    /** Minimum required length in characters */
     minLength?: number;
     /** Regular expression pattern for validation */
     pattern?: string;
     /** Array of valid enumeration values */
     enum?: string[];
-    /** Format specifier (date-time, email, etc.) */
+    /** Format specifier (email, date-time, uuid, etc.) */
     format?: string;
-    /** Whether null values are allowed */
+    /** Whether null values are allowed in addition to string values */
     nullable?: boolean;
-    /** Example value for documentation */
+    /** Example value for documentation and testing */
     example?: string;
 };
 //# sourceMappingURL=string-types.d.ts.map

package/script/oas/string/string-types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"string-types.d.ts","sourceRoot":"","sources":["../../../src/oas/string/string-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B;;;;;;GAMG;AACH,MAAM,MAAM,YAAY,GACpB,WAAW,GACX,MAAM,GACN,MAAM,GACN,UAAU,GACV,OAAO,GACP,UAAU,GACV,MAAM,GACN,MAAM,GACN,MAAM,GACN,KAAK,GACL,OAAO,GACP,UAAU,GACV,MAAM,GACN,QAAQ,CAAA;AAEZ;;;;;GAKG;AACH,eAAO,MAAM,YAAY,EAAE,CAAC,CAAC,aAAa,CAAC,YAAY,CAerD,CAAA;AAEF;;;;;GAKG;AACH,eAAO,MAAM,aAAa,EAAE,CAAC,CAAC,aAAa,CAAC,aAAa,CAYvD,CAAA;AAEF;;;;;;GAMG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,0CAA0C;IAC1C,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,mDAAmD;IACnD,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,mCAAmC;IACnC,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,wCAAwC;IACxC,IAAI,EAAE,QAAQ,CAAA;IACd,6BAA6B;IAC7B,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,8BAA8B;IAC9B,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,gDAAgD;IAChD,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,wCAAwC;IACxC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAA;IACf,gDAAgD;IAChD,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,sCAAsC;IACtC,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,sCAAsC;IACtC,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB,CAAA"}
+{"version":3,"file":"string-types.d.ts","sourceRoot":"","sources":["../../../src/oas/string/string-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,MAAM,MAAM,YAAY,GACpB,WAAW,GACX,MAAM,GACN,MAAM,GACN,UAAU,GACV,OAAO,GACP,UAAU,GACV,MAAM,GACN,MAAM,GACN,MAAM,GACN,KAAK,GACL,OAAO,GACP,UAAU,GACV,MAAM,GACN,QAAQ,CAAA;AAEZ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,eAAO,MAAM,YAAY,EAAE,CAAC,CAAC,aAAa,CAAC,YAAY,CAerD,CAAA;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH,eAAO,MAAM,aAAa,EAAE,CAAC,CAAC,aAAa,CAAC,aAAa,CAYvD,CAAA;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6EG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,iDAAiD;IACjD,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,qEAAqE;IACrE,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,4DAA4D;IAC5D,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,wCAAwC;IACxC,IAAI,EAAE,QAAQ,CAAA;IACd,2CAA2C;IAC3C,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,4CAA4C;IAC5C,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,gDAAgD;IAChD,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,wCAAwC;IACxC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAA;IACf,sDAAsD;IACtD,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,mEAAmE;IACnE,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,kDAAkD;IAClD,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB,CAAA"}