@skmtc/core 0.0.926 → 0.0.930

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

@@ -1,273 +0,0 @@
-import { type OasParameterData } from '../parameter/parameter-types.js';
-import { type OasPathItemData } from '../pathItem/pathItem-types.js';
-import { type OasParameterRefData, type OasRequestBodyRefData, type OasResponseRefData } from '../ref/ref-types.js';
-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/esm/oas/operation/operation-types.d.ts.map

@@ -1 +0,0 @@
-{"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/esm/oas/operation/operation-types.js

@@ -1,133 +0,0 @@
-import { markdown } from '../markdown/markdown-types.js';
-import { oasParameterData } from '../parameter/parameter-types.js';
-import { oasPathItemData } from '../pathItem/pathItem-types.js';
-import { oasParameterRefData, oasRequestBodyRefData, oasResponseRefData } from '../ref/ref-types.js';
-import { oasRequestBodyData } from '../requestBody/requestBody-types.js';
-import { oasResponseData } from '../response/response-types.js';
-import * as v from '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
- * }
- * ```
- */
-export const oasOperationData = v.object({
-    oasType: v.literal('operation'),
-    pathItem: oasPathItemData,
-    path: v.string(),
-    method: v.enum({
-        get: 'get',
-        put: 'put',
-        post: 'post',
-        delete: 'delete',
-        options: 'options',
-        head: 'head',
-        patch: 'patch',
-        trace: 'trace'
-    }),
-    operationId: v.optional(v.string()),
-    tags: v.optional(v.array(v.string())),
-    summary: v.optional(v.string()),
-    description: v.optional(markdown),
-    // externalDocs: externalDocs.optional(),
-    // operationId: z.string().optional(),
-    parameters: v.optional(v.array(v.union([oasParameterData, oasParameterRefData]))),
-    requestBody: v.optional(v.union([oasRequestBodyData, oasRequestBodyRefData])),
-    responses: v.record(v.string(), v.union([oasResponseData, oasResponseRefData])),
-    // callbacks: z.never(),
-    deprecated: v.optional(v.boolean())
-    // security: z.never(),
-    // servers: z.array(server).optional()
-});

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

@@ -1,12 +0,0 @@
-import { type OasParameterData } from '../parameter/parameter-types.js';
-import { type OasParameterRefData } from '../ref/ref-types.js';
-import * as v from 'valibot';
-export type OasPathItemData = {
-    oasType: 'pathItem';
-    $ref?: string;
-    summary?: string;
-    description?: string;
-    parameters?: (OasParameterData | OasParameterRefData)[];
-};
-export declare const oasPathItemData: v.GenericSchema<OasPathItemData>;
-//# sourceMappingURL=pathItem-types.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"pathItem-types.d.ts","sourceRoot":"","sources":["../../../src/oas/pathItem/pathItem-types.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,gBAAgB,EAAoB,MAAM,iCAAiC,CAAA;AACzF,OAAO,EAAE,KAAK,mBAAmB,EAAuB,MAAM,qBAAqB,CAAA;AACnF,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B,MAAM,MAAM,eAAe,GAAG;IAC5B,OAAO,EAAE,UAAU,CAAA;IACnB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,WAAW,CAAC,EAAE,MAAM,CAAA;IAEpB,UAAU,CAAC,EAAE,CAAC,gBAAgB,GAAG,mBAAmB,CAAC,EAAE,CAAA;CACxD,CAAA;AAED,eAAO,MAAM,eAAe,EAAE,CAAC,CAAC,aAAa,CAAC,eAAe,CAO3D,CAAA"}

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

@@ -1,12 +0,0 @@
-import { markdown } from '../markdown/markdown-types.js';
-import { oasParameterData } from '../parameter/parameter-types.js';
-import { oasParameterRefData } from '../ref/ref-types.js';
-import * as v from 'valibot';
-export const oasPathItemData = v.object({
-    oasType: v.literal('pathItem'),
-    $ref: v.optional(v.string()),
-    summary: v.optional(v.string()),
-    description: v.optional(markdown),
-    // servers: z.array(server).optional(),
-    parameters: v.optional(v.array(v.union([oasParameterData, oasParameterRefData])))
-});

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

@@ -1,10 +0,0 @@
-import { type OasMediaTypeData } from '../mediaType/mediaType-types.js';
-import * as v from 'valibot';
-export type OasRequestBodyData = {
-    oasType: 'requestBody';
-    description?: string;
-    content: Record<string, OasMediaTypeData>;
-    required?: boolean;
-};
-export declare const oasRequestBodyData: v.GenericSchema<OasRequestBodyData>;
-//# sourceMappingURL=requestBody-types.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"requestBody-types.d.ts","sourceRoot":"","sources":["../../../src/oas/requestBody/requestBody-types.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,gBAAgB,EAAoB,MAAM,iCAAiC,CAAA;AACzF,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B,MAAM,MAAM,kBAAkB,GAAG;IAC/B,OAAO,EAAE,aAAa,CAAA;IACtB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAA;IACzC,QAAQ,CAAC,EAAE,OAAO,CAAA;CACnB,CAAA;AAED,eAAO,MAAM,kBAAkB,EAAE,CAAC,CAAC,aAAa,CAAC,kBAAkB,CAKjE,CAAA"}

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

@@ -1,9 +0,0 @@
-import { markdown } from '../markdown/markdown-types.js';
-import { oasMediaTypeData } from '../mediaType/mediaType-types.js';
-import * as v from 'valibot';
-export const oasRequestBodyData = v.object({
-    oasType: v.literal('requestBody'),
-    description: v.optional(markdown),
-    content: v.record(v.string(), oasMediaTypeData),
-    required: v.optional(v.boolean())
-});

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

@@ -1,12 +0,0 @@
-import { type OasHeaderData } from '../header/header-types.js';
-import { type OasMediaTypeData } from '../mediaType/mediaType-types.js';
-import { type OasHeaderRefData } from '../ref/ref-types.js';
-import * as v from 'valibot';
-export type OasResponseData = {
-    oasType: 'response';
-    description: string;
-    headers?: Record<string, OasHeaderData | OasHeaderRefData>;
-    content?: Record<string, OasMediaTypeData>;
-};
-export declare const oasResponseData: v.GenericSchema<OasResponseData>;
-//# sourceMappingURL=response-types.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"response-types.d.ts","sourceRoot":"","sources":["../../../src/oas/response/response-types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,aAAa,EAAiB,MAAM,2BAA2B,CAAA;AAC7E,OAAO,EAAE,KAAK,gBAAgB,EAAoB,MAAM,iCAAiC,CAAA;AACzF,OAAO,EAAE,KAAK,gBAAgB,EAAoB,MAAM,qBAAqB,CAAA;AAC7E,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B,MAAM,MAAM,eAAe,GAAG;IAC5B,OAAO,EAAE,UAAU,CAAA;IACnB,WAAW,EAAE,MAAM,CAAA;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,GAAG,gBAAgB,CAAC,CAAA;IAC1D,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAA;CAE3C,CAAA;AAED,eAAO,MAAM,eAAe,EAAE,CAAC,CAAC,aAAa,CAAC,eAAe,CAM3D,CAAA"}

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

@@ -1,11 +0,0 @@
-import { oasHeaderData } from '../header/header-types.js';
-import { oasMediaTypeData } from '../mediaType/mediaType-types.js';
-import { oasHeaderRefData } from '../ref/ref-types.js';
-import * as v from 'valibot';
-export const oasResponseData = v.object({
-    oasType: v.literal('response'),
-    description: v.string(),
-    headers: v.optional(v.record(v.string(), v.union([oasHeaderData, oasHeaderRefData]))),
-    content: v.optional(v.record(v.string(), oasMediaTypeData))
-    // links: z.record(z.union([link, ref])).optional()
-});

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

@@ -1,12 +0,0 @@
-import * as v from 'valibot';
-import { type OasArrayData } from '../array/array-types.js';
-import { type OasBooleanData } from '../boolean/boolean-types.js';
-import { type OasUnknownData } from '../unknown/unknown-types.js';
-import { type OasUnionData } from '../union/union-types.js';
-import { type OasIntegerData } from '../integer/integer-types.js';
-import { type OasNumberData } from '../number/number-types.js';
-import { type OasStringData } from '../string/string-types.js';
-import { type OasObjectData } from '../object/object-types.js';
-export type OasSchemaData = OasArrayData | OasBooleanData | OasIntegerData | OasNumberData | OasStringData | OasObjectData | OasUnionData | OasUnknownData;
-export declare const oasSchemaData: v.GenericSchema<OasSchemaData>;
-//# sourceMappingURL=schema-types.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"schema-types.d.ts","sourceRoot":"","sources":["../../../src/oas/schema/schema-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAC5B,OAAO,EAAgB,KAAK,YAAY,EAAE,MAAM,yBAAyB,CAAA;AACzE,OAAO,EAAkB,KAAK,cAAc,EAAE,MAAM,6BAA6B,CAAA;AACjF,OAAO,EAAkB,KAAK,cAAc,EAAE,MAAM,6BAA6B,CAAA;AACjF,OAAO,EAAgB,KAAK,YAAY,EAAE,MAAM,yBAAyB,CAAA;AACzE,OAAO,EAAkB,KAAK,cAAc,EAAE,MAAM,6BAA6B,CAAA;AACjF,OAAO,EAAiB,KAAK,aAAa,EAAE,MAAM,2BAA2B,CAAA;AAC7E,OAAO,EAAiB,KAAK,aAAa,EAAE,MAAM,2BAA2B,CAAA;AAC7E,OAAO,EAAiB,KAAK,aAAa,EAAE,MAAM,2BAA2B,CAAA;AAE7E,MAAM,MAAM,aAAa,GACrB,YAAY,GACZ,cAAc,GACd,cAAc,GACd,aAAa,GACb,aAAa,GACb,aAAa,GACb,YAAY,GACZ,cAAc,CAAA;AAElB,eAAO,MAAM,aAAa,EAAE,CAAC,CAAC,aAAa,CAAC,aAAa,CASvD,CAAA"}

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

@@ -1,19 +0,0 @@
-import * as v from 'valibot';
-import { oasArrayData } from '../array/array-types.js';
-import { oasBooleanData } from '../boolean/boolean-types.js';
-import { oasUnknownData } from '../unknown/unknown-types.js';
-import { oasUnionData } from '../union/union-types.js';
-import { oasIntegerData } from '../integer/integer-types.js';
-import { oasNumberData } from '../number/number-types.js';
-import { oasStringData } from '../string/string-types.js';
-import { oasObjectData } from '../object/object-types.js';
-export const oasSchemaData = v.union([
-    oasObjectData,
-    v.lazy(() => oasArrayData),
-    oasBooleanData,
-    oasStringData,
-    oasNumberData,
-    oasIntegerData,
-    oasUnionData,
-    oasUnknownData
-]);

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

@@ -1,34 +0,0 @@
-import * as v from 'valibot';
-import { type OasSchemaData } from '../schema/schema-types.js';
-import { type OasSchemaRefData } from '../ref/ref-types.js';
-import { type OasDiscriminatorData } from '../discriminator/discriminator-types.js';
-/**
- * Data type for OpenAPI union schema objects.
- *
- * Represents union types (oneOf/anyOf) that allow values to match
- * one or more of several possible schemas. Includes support for
- * discriminator properties for efficient type resolution.
- */
-export type OasUnionData = {
-    /** Type category identifier for schema objects */
-    oasType: 'schema';
-    /** Type identifier (always 'union') */
-    type: 'union';
-    /** Human-readable title for the union */
-    title?: string;
-    /** Detailed description of the union's purpose */
-    description?: string;
-    /** Array of schemas that comprise the union */
-    members: (OasSchemaData | OasSchemaRefData)[];
-    /** Optional discriminator for efficient type resolution */
-    discriminator?: OasDiscriminatorData;
-};
-/**
- * Valibot schema for validating OpenAPI union data objects.
- *
- * Validates union schemas including member schema arrays and optional
- * discriminator properties. Uses lazy evaluation to handle recursive
- * schema references in union members.
- */
-export declare const oasUnionData: v.GenericSchema<OasUnionData>;
-//# sourceMappingURL=union-types.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"union-types.d.ts","sourceRoot":"","sources":["../../../src/oas/union/union-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;AAC7E,OAAO,EACL,KAAK,oBAAoB,EAE1B,MAAM,yCAAyC,CAAA;AAEhD;;;;;;GAMG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,kDAAkD;IAClD,OAAO,EAAE,QAAQ,CAAA;IACjB,uCAAuC;IACvC,IAAI,EAAE,OAAO,CAAA;IACb,yCAAyC;IACzC,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,kDAAkD;IAClD,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,+CAA+C;IAC/C,OAAO,EAAE,CAAC,aAAa,GAAG,gBAAgB,CAAC,EAAE,CAAA;IAC7C,2DAA2D;IAC3D,aAAa,CAAC,EAAE,oBAAoB,CAAA;CACrC,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,YAAY,EAAE,CAAC,CAAC,aAAa,CAAC,YAAY,CAOrD,CAAA"}

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

@@ -1,19 +0,0 @@
-import * as v from 'valibot';
-import { oasSchemaData } from '../schema/schema-types.js';
-import { oasSchemaRefData } from '../ref/ref-types.js';
-import { oasDiscriminatorData } from '../discriminator/discriminator-types.js';
-/**
- * Valibot schema for validating OpenAPI union data objects.
- *
- * Validates union schemas including member schema arrays and optional
- * discriminator properties. Uses lazy evaluation to handle recursive
- * schema references in union members.
- */
-export const oasUnionData = v.object({
-    oasType: v.literal('schema'),
-    type: v.literal('union'),
-    title: v.optional(v.string()),
-    description: v.optional(v.string()),
-    members: v.lazy(() => v.array(v.union([oasSchemaData, oasSchemaRefData]))),
-    discriminator: v.optional(oasDiscriminatorData)
-});