@skmtc/core 0.0.808 → 0.0.809

package/esm/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/esm/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"}

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

@@ -2,8 +2,34 @@ import * as v from 'valibot';
 /**
  * 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 const stringFormat = v.enum({
     'date-time': 'date-time',
@@ -24,8 +50,54 @@ export const stringFormat = v.enum({
 /**
  * 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 const oasStringData = v.object({
     type: v.literal('string'),

package/esm/types/ModuleExport.d.ts

@@ -1,8 +1,138 @@
 import "../_dnt.polyfills.js";
 import * as v from 'valibot';
+/**
+ * Valibot schema for validating module export configuration objects.
+ *
+ * This schema validates module export structures used throughout the SKMTC
+ * code generation pipeline. Module exports define how generated code modules
+ * are exposed and imported, specifying both the export name and the file path
+ * where the export can be found.
+ *
+ * @example Validating a basic module export
+ * ```typescript
+ * import { moduleExport } from '@skmtc/core/types';
+ * import * as v from 'valibot';
+ *
+ * const config = {
+ *   exportName: 'UserApi',
+ *   exportPath: './generated/UserApi.ts'
+ * };
+ *
+ * const validated = v.parse(moduleExport, config);
+ * console.log(validated.exportName); // 'UserApi'
+ * ```
+ *
+ * @example Validating multiple exports
+ * ```typescript
+ * const exports = [
+ *   { exportName: 'createUser', exportPath: './api/users.ts' },
+ *   { exportName: 'updateUser', exportPath: './api/users.ts' },
+ *   { exportName: 'UserModel', exportPath: './models/User.ts' }
+ * ];
+ *
+ * exports.forEach(exp => {
+ *   const validated = v.parse(moduleExport, exp);
+ *   console.log(`Export: ${validated.exportName} from ${validated.exportPath}`);
+ * });
+ * ```
+ */
 export declare const moduleExport: v.GenericSchema<ModuleExport>;
+/**
+ * Configuration object for module exports in the SKMTC pipeline.
+ *
+ * This type defines the structure for describing how generated code modules
+ * should be exported and made available for import. It's used throughout
+ * the SKMTC system for organizing generated code, managing dependencies,
+ * and creating proper import/export relationships between generated files.
+ *
+ * ## Usage in SKMTC Pipeline
+ *
+ * This type is used by:
+ * - Code generators to define export configurations
+ * - File processors to organize generated modules
+ * - Import managers to resolve module dependencies
+ * - Build systems to understand code structure
+ *
+ * @example Basic module export definition
+ * ```typescript
+ * import type { ModuleExport } from '@skmtc/core/types';
+ *
+ * const apiExport: ModuleExport = {
+ *   exportName: 'UserApiClient',
+ *   exportPath: './generated/api/UserApiClient.ts'
+ * };
+ *
+ * console.log(`Import ${apiExport.exportName} from '${apiExport.exportPath}'`);
+ * // Import UserApiClient from './generated/api/UserApiClient.ts'
+ * ```
+ *
+ * @example Function export configuration
+ * ```typescript
+ * const functionExport: ModuleExport = {
+ *   exportName: 'validateUserData',
+ *   exportPath: './generated/validators/userValidation.ts'
+ * };
+ *
+ * // Used to generate: export { validateUserData } from './generated/validators/userValidation.ts'
+ * ```
+ *
+ * @example Type export configuration
+ * ```typescript
+ * const typeExport: ModuleExport = {
+ *   exportName: 'UserType',
+ *   exportPath: './generated/types/User.ts'
+ * };
+ *
+ * // Used to generate: export type { UserType } from './generated/types/User.ts'
+ * ```
+ *
+ * @example Multiple exports from same file
+ * ```typescript
+ * const userModuleExports: ModuleExport[] = [
+ *   {
+ *     exportName: 'User',
+ *     exportPath: './generated/models/User.ts'
+ *   },
+ *   {
+ *     exportName: 'UserValidator',
+ *     exportPath: './generated/models/User.ts'
+ *   },
+ *   {
+ *     exportName: 'createUser',
+ *     exportPath: './generated/models/User.ts'
+ *   }
+ * ];
+ *
+ * // All exports reference the same file but different symbols
+ * ```
+ *
+ * @example Integration with build systems
+ * ```typescript
+ * class ModuleRegistry {
+ *   private exports: ModuleExport[] = [];
+ *
+ *   addExport(moduleExport: ModuleExport) {
+ *     this.exports.push(moduleExport);
+ *   }
+ *
+ *   generateIndexFile(): string {
+ *     return this.exports
+ *       .map(exp => `export { ${exp.exportName} } from '${exp.exportPath}';`)
+ *       .join('\n');
+ *   }
+ * }
+ *
+ * const registry = new ModuleRegistry();
+ * registry.addExport({
+ *   exportName: 'ApiClient',
+ *   exportPath: './api/client.ts'
+ * });
+ * ```
+ */
 export type ModuleExport = {
+    /** The name of the symbol being exported (function, class, type, etc.) */
     exportName: string;
+    /** The file path where the export can be found */
     exportPath: string;
 };
 //# sourceMappingURL=ModuleExport.d.ts.map

package/esm/types/ModuleExport.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ModuleExport.d.ts","sourceRoot":"","sources":["../../src/types/ModuleExport.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAC9B,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B,eAAO,MAAM,YAAY,EAAE,CAAC,CAAC,aAAa,CAAC,YAAY,CAGrD,CAAA;AAEF,MAAM,MAAM,YAAY,GAAG;IACzB,UAAU,EAAE,MAAM,CAAA;IAClB,UAAU,EAAE,MAAM,CAAA;CACnB,CAAA"}
+{"version":3,"file":"ModuleExport.d.ts","sourceRoot":"","sources":["../../src/types/ModuleExport.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAC9B,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,eAAO,MAAM,YAAY,EAAE,CAAC,CAAC,aAAa,CAAC,YAAY,CAGrD,CAAA;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2FG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,0EAA0E;IAC1E,UAAU,EAAE,MAAM,CAAA;IAClB,kDAAkD;IAClD,UAAU,EAAE,MAAM,CAAA;CACnB,CAAA"}

package/esm/types/ModuleExport.js

@@ -1,5 +1,41 @@
 import "../_dnt.polyfills.js";
 import * as v from 'valibot';
+/**
+ * Valibot schema for validating module export configuration objects.
+ *
+ * This schema validates module export structures used throughout the SKMTC
+ * code generation pipeline. Module exports define how generated code modules
+ * are exposed and imported, specifying both the export name and the file path
+ * where the export can be found.
+ *
+ * @example Validating a basic module export
+ * ```typescript
+ * import { moduleExport } from '@skmtc/core/types';
+ * import * as v from 'valibot';
+ *
+ * const config = {
+ *   exportName: 'UserApi',
+ *   exportPath: './generated/UserApi.ts'
+ * };
+ *
+ * const validated = v.parse(moduleExport, config);
+ * console.log(validated.exportName); // 'UserApi'
+ * ```
+ *
+ * @example Validating multiple exports
+ * ```typescript
+ * const exports = [
+ *   { exportName: 'createUser', exportPath: './api/users.ts' },
+ *   { exportName: 'updateUser', exportPath: './api/users.ts' },
+ *   { exportName: 'UserModel', exportPath: './models/User.ts' }
+ * ];
+ *
+ * exports.forEach(exp => {
+ *   const validated = v.parse(moduleExport, exp);
+ *   console.log(`Export: ${validated.exportName} from ${validated.exportPath}`);
+ * });
+ * ```
+ */
 export const moduleExport = v.object({
     exportName: v.string(),
     exportPath: v.string()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skmtc/core",
-  "version": "0.0.808",
+  "version": "0.0.809",
   "repository": {
     "type": "git",
     "url": "https://github.com/skmtc/skmtc.git"