@skmtc/core 0.0.926 → 0.0.929

package/esm/oas/_helpers/parseFormat.d.ts

@@ -1,169 +0,0 @@
-import type { OpenAPIV3 } from 'openapi-types';
-import type { ParseContext } from '../../context/ParseContext.js';
-import * as v from 'valibot';
-/**
- * Arguments for parsing OpenAPI schema format values.
- *
- * @template T - The expected type of the format value
- */
-type ParseFormatArgs<T> = {
-    /** The OpenAPI schema object with processed properties removed */
-    value: Omit<OpenAPIV3.SchemaObject, 'nullable' | 'example' | 'enums'>;
-    /** Valibot schema for validating the format value */
-    valibotSchema: v.GenericSchema<T>;
-    /** Parse context for error handling */
-    context: ParseContext;
-};
-/**
- * Return type for parsed format data.
- *
- * @template T - The expected type of the format value
- * @template Value - The OpenAPI schema object type
- */
-type ParseFormatReturn<T, Value extends OpenAPIV3.SchemaObject> = {
-    /** The parsed and validated format string */
-    format: T | undefined;
-    /** The schema object without the format property */
-    value: Omit<Value, 'format'>;
-};
-/**
- * Parses and validates OpenAPI schema format values with type safety.
- *
- * This function extracts and validates format specifiers from OpenAPI schema objects,
- * ensuring they conform to expected format types for the given schema. Invalid format
- * values are removed and logged as warnings through the parse context.
- *
- * The format property provides additional semantic information about the expected
- * structure of string values (like 'email', 'date-time', 'uuid', etc.) and numeric
- * precision (like 'float', 'double' for numbers, 'int32', 'int64' for integers).
- *
- * @template T - The expected type of the format value (usually string)
- * @template Value - The OpenAPI schema object type
- *
- * @param args - Parsing configuration
- * @returns Parsed format data with the validated format and cleaned schema
- *
- * @example String format parsing
- * ```typescript
- * import { parseFormat } from '@skmtc/core/oas/_helpers';
- * import * as v from 'valibot';
- *
- * const result = parseFormat({
- *   value: {
- *     type: 'string',
- *     format: 'email',
- *     maxLength: 100
- *   },
- *   valibotSchema: v.string(),
- *   context: parseContext
- * });
- *
- * console.log(result.format); // 'email'
- * console.log(result.value);  // { type: 'string', maxLength: 100 }
- * ```
- *
- * @example Date-time format
- * ```typescript
- * const result = parseFormat({
- *   value: {
- *     type: 'string',
- *     format: 'date-time',
- *     description: 'ISO 8601 timestamp'
- *   },
- *   valibotSchema: v.string(),
- *   context: parseContext
- * });
- *
- * console.log(result.format); // 'date-time'
- * // Can be used to generate Date objects in TypeScript
- * ```
- *
- * @example Number precision formats
- * ```typescript
- * const result = parseFormat({
- *   value: {
- *     type: 'number',
- *     format: 'float',
- *     minimum: 0
- *   },
- *   valibotSchema: v.string(), // Format is always a string
- *   context: parseContext
- * });
- *
- * console.log(result.format); // 'float'
- * // Indicates single-precision floating-point
- * ```
- *
- * @example Integer format specifiers
- * ```typescript
- * const result = parseFormat({
- *   value: {
- *     type: 'integer',
- *     format: 'int64',
- *     description: 'Large integer ID'
- *   },
- *   valibotSchema: v.string(),
- *   context: parseContext
- * });
- *
- * console.log(result.format); // 'int64'
- * // Indicates 64-bit signed integer
- * ```
- *
- * @example Invalid format handling
- * ```typescript
- * const result = parseFormat({
- *   value: {
- *     type: 'string',
- *     format: 123, // Invalid - should be string
- *     pattern: '^[a-z]+$'
- *   } as any,
- *   valibotSchema: v.string(),
- *   context: parseContext
- * });
- *
- * console.log(result.format); // undefined (invalid format removed)
- * console.log(result.value);  // { type: 'string', pattern: '^[a-z]+$' }
- * // Context will log a warning about the invalid format
- * ```
- *
- * @example Missing format (undefined)
- * ```typescript
- * const result = parseFormat({
- *   value: {
- *     type: 'string',
- *     minLength: 1,
- *     maxLength: 50
- *   },
- *   valibotSchema: v.string(),
- *   context: parseContext
- * });
- *
- * console.log(result.format); // undefined (no format specified)
- * console.log(result.value);  // { type: 'string', minLength: 1, maxLength: 50 }
- * ```
- *
- * @example Common string formats
- * ```typescript
- * // Standard OpenAPI string formats:
- * // - 'date': full-date as defined by RFC3339
- * // - 'date-time': date-time as defined by RFC3339
- * // - 'time': time as defined by RFC3339
- * // - 'email': email address as defined by RFC5322
- * // - 'uri': URI as defined by RFC3986
- * // - 'uuid': UUID as defined by RFC4122
- * // - 'binary': binary data (base64 encoded)
- * // - 'byte': base64 encoded characters
- * // - 'password': hint for UI to obscure input
- *
- * const emailFormat = parseFormat({
- *   value: { type: 'string', format: 'email' },
- *   valibotSchema: v.string(),
- *   context
- * });
- * // Can generate validation: v.pipe(v.string(), v.email())
- * ```
- */
-export declare const parseFormat: <T, Value extends OpenAPIV3.SchemaObject>({ value, valibotSchema, context }: ParseFormatArgs<T>) => ParseFormatReturn<T, Value>;
-export {};
-//# sourceMappingURL=parseFormat.d.ts.map

package/esm/oas/_helpers/parseFormat.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"parseFormat.d.ts","sourceRoot":"","sources":["../../../src/oas/_helpers/parseFormat.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAC9C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAA;AACjE,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B;;;;GAIG;AACH,KAAK,eAAe,CAAC,CAAC,IAAI;IACxB,kEAAkE;IAClE,KAAK,EAAE,IAAI,CAAC,SAAS,CAAC,YAAY,EAAE,UAAU,GAAG,SAAS,GAAG,OAAO,CAAC,CAAA;IACrE,qDAAqD;IACrD,aAAa,EAAE,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,CAAA;IACjC,uCAAuC;IACvC,OAAO,EAAE,YAAY,CAAA;CACtB,CAAA;AAED;;;;;GAKG;AACH,KAAK,iBAAiB,CAAC,CAAC,EAAE,KAAK,SAAS,SAAS,CAAC,YAAY,IAAI;IAChE,6CAA6C;IAC7C,MAAM,EAAE,CAAC,GAAG,SAAS,CAAA;IACrB,oDAAoD;IACpD,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAA;CAC7B,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyIG;AACH,eAAO,MAAM,WAAW,GAAI,CAAC,EAAE,KAAK,SAAS,SAAS,CAAC,YAAY,EAAE,mCAIlE,eAAe,CAAC,CAAC,CAAC,KAAG,iBAAiB,CAAC,CAAC,EAAE,KAAK,CAgBjD,CAAA"}

package/esm/oas/_helpers/parseFormat.js

@@ -1,154 +0,0 @@
-import * as v from 'valibot';
-/**
- * Parses and validates OpenAPI schema format values with type safety.
- *
- * This function extracts and validates format specifiers from OpenAPI schema objects,
- * ensuring they conform to expected format types for the given schema. Invalid format
- * values are removed and logged as warnings through the parse context.
- *
- * The format property provides additional semantic information about the expected
- * structure of string values (like 'email', 'date-time', 'uuid', etc.) and numeric
- * precision (like 'float', 'double' for numbers, 'int32', 'int64' for integers).
- *
- * @template T - The expected type of the format value (usually string)
- * @template Value - The OpenAPI schema object type
- *
- * @param args - Parsing configuration
- * @returns Parsed format data with the validated format and cleaned schema
- *
- * @example String format parsing
- * ```typescript
- * import { parseFormat } from '@skmtc/core/oas/_helpers';
- * import * as v from 'valibot';
- *
- * const result = parseFormat({
- *   value: {
- *     type: 'string',
- *     format: 'email',
- *     maxLength: 100
- *   },
- *   valibotSchema: v.string(),
- *   context: parseContext
- * });
- *
- * console.log(result.format); // 'email'
- * console.log(result.value);  // { type: 'string', maxLength: 100 }
- * ```
- *
- * @example Date-time format
- * ```typescript
- * const result = parseFormat({
- *   value: {
- *     type: 'string',
- *     format: 'date-time',
- *     description: 'ISO 8601 timestamp'
- *   },
- *   valibotSchema: v.string(),
- *   context: parseContext
- * });
- *
- * console.log(result.format); // 'date-time'
- * // Can be used to generate Date objects in TypeScript
- * ```
- *
- * @example Number precision formats
- * ```typescript
- * const result = parseFormat({
- *   value: {
- *     type: 'number',
- *     format: 'float',
- *     minimum: 0
- *   },
- *   valibotSchema: v.string(), // Format is always a string
- *   context: parseContext
- * });
- *
- * console.log(result.format); // 'float'
- * // Indicates single-precision floating-point
- * ```
- *
- * @example Integer format specifiers
- * ```typescript
- * const result = parseFormat({
- *   value: {
- *     type: 'integer',
- *     format: 'int64',
- *     description: 'Large integer ID'
- *   },
- *   valibotSchema: v.string(),
- *   context: parseContext
- * });
- *
- * console.log(result.format); // 'int64'
- * // Indicates 64-bit signed integer
- * ```
- *
- * @example Invalid format handling
- * ```typescript
- * const result = parseFormat({
- *   value: {
- *     type: 'string',
- *     format: 123, // Invalid - should be string
- *     pattern: '^[a-z]+$'
- *   } as any,
- *   valibotSchema: v.string(),
- *   context: parseContext
- * });
- *
- * console.log(result.format); // undefined (invalid format removed)
- * console.log(result.value);  // { type: 'string', pattern: '^[a-z]+$' }
- * // Context will log a warning about the invalid format
- * ```
- *
- * @example Missing format (undefined)
- * ```typescript
- * const result = parseFormat({
- *   value: {
- *     type: 'string',
- *     minLength: 1,
- *     maxLength: 50
- *   },
- *   valibotSchema: v.string(),
- *   context: parseContext
- * });
- *
- * console.log(result.format); // undefined (no format specified)
- * console.log(result.value);  // { type: 'string', minLength: 1, maxLength: 50 }
- * ```
- *
- * @example Common string formats
- * ```typescript
- * // Standard OpenAPI string formats:
- * // - 'date': full-date as defined by RFC3339
- * // - 'date-time': date-time as defined by RFC3339
- * // - 'time': time as defined by RFC3339
- * // - 'email': email address as defined by RFC5322
- * // - 'uri': URI as defined by RFC3986
- * // - 'uuid': UUID as defined by RFC4122
- * // - 'binary': binary data (base64 encoded)
- * // - 'byte': base64 encoded characters
- * // - 'password': hint for UI to obscure input
- *
- * const emailFormat = parseFormat({
- *   value: { type: 'string', format: 'email' },
- *   valibotSchema: v.string(),
- *   context
- * });
- * // Can generate validation: v.pipe(v.string(), v.email())
- * ```
- */
-export const parseFormat = ({ value, valibotSchema, context }) => {
-    const { format, ...rest } = value;
-    const parsedFormat = context.provisionalParse({
-        key: 'format',
-        value: format,
-        parent: value,
-        schema: v.optional(valibotSchema),
-        toMessage: value => `Unexpected "${rest.type}" format: ${value}`,
-        type: 'INVALID_FORMAT'
-    });
-    return {
-        format: parsedFormat,
-        value: rest
-    };
-};

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

@@ -1,19 +0,0 @@
-import { type OasExampleData } from '../example/example-types.js';
-import { type OasHeaderData } from '../header/header-types.js';
-import { type OasParameterData } from '../parameter/parameter-types.js';
-import type { OasExampleRefData, OasHeaderRefData, OasParameterRefData, OasRequestBodyRefData, OasResponseRefData, OasSchemaRefData } from '../ref/ref-types.js';
-import { type OasRequestBodyData } from '../requestBody/requestBody-types.js';
-import { type OasResponseData } from '../response/response-types.js';
-import { type OasSchemaData } from '../schema/schema-types.js';
-import * as v from 'valibot';
-export type OasComponentsData = {
-    oasType: 'components';
-    schemas?: Record<string, OasSchemaData | OasSchemaRefData>;
-    responses?: Record<string, OasResponseData | OasResponseRefData>;
-    parameters?: Record<string, OasParameterData | OasParameterRefData>;
-    examples?: Record<string, OasExampleData | OasExampleRefData>;
-    requestBodies?: Record<string, OasRequestBodyData | OasRequestBodyRefData>;
-    headers?: Record<string, OasHeaderData | OasHeaderRefData>;
-};
-export declare const oasComponentsData: v.GenericSchema<OasComponentsData>;
-//# sourceMappingURL=components-types.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"components-types.d.ts","sourceRoot":"","sources":["../../../src/oas/components/components-types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAAkB,MAAM,6BAA6B,CAAA;AACjF,OAAO,EAAE,KAAK,aAAa,EAAiB,MAAM,2BAA2B,CAAA;AAC7E,OAAO,EAAE,KAAK,gBAAgB,EAAoB,MAAM,iCAAiC,CAAA;AACzF,OAAO,KAAK,EACV,iBAAiB,EACjB,gBAAgB,EAChB,mBAAmB,EACnB,qBAAqB,EACrB,kBAAkB,EAClB,gBAAgB,EACjB,MAAM,qBAAqB,CAAA;AAS5B,OAAO,EAAE,KAAK,kBAAkB,EAAsB,MAAM,qCAAqC,CAAA;AACjG,OAAO,EAAE,KAAK,eAAe,EAAmB,MAAM,+BAA+B,CAAA;AACrF,OAAO,EAAE,KAAK,aAAa,EAAiB,MAAM,2BAA2B,CAAA;AAC7E,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B,MAAM,MAAM,iBAAiB,GAAG;IAC9B,OAAO,EAAE,YAAY,CAAA;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,GAAG,gBAAgB,CAAC,CAAA;IAC1D,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,GAAG,kBAAkB,CAAC,CAAA;IAChE,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,GAAG,mBAAmB,CAAC,CAAA;IACnE,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,GAAG,iBAAiB,CAAC,CAAA;IAC7D,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,GAAG,qBAAqB,CAAC,CAAA;IAC1E,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,GAAG,gBAAgB,CAAC,CAAA;CAC3D,CAAA;AAED,eAAO,MAAM,iBAAiB,EAAE,CAAC,CAAC,aAAa,CAAC,iBAAiB,CAc/D,CAAA"}

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

@@ -1,21 +0,0 @@
-import { oasExampleData } from '../example/example-types.js';
-import { oasHeaderData } from '../header/header-types.js';
-import { oasParameterData } from '../parameter/parameter-types.js';
-import { oasExampleRefData, oasHeaderRefData, oasParameterRefData, oasRequestBodyRefData, oasResponseRefData, oasSchemaRefData } from '../ref/ref-types.js';
-import { oasRequestBodyData } from '../requestBody/requestBody-types.js';
-import { oasResponseData } from '../response/response-types.js';
-import { oasSchemaData } from '../schema/schema-types.js';
-import * as v from 'valibot';
-export const oasComponentsData = v.object({
-    oasType: v.literal('components'),
-    schemas: v.optional(v.record(v.string(), v.union([oasSchemaData, oasSchemaRefData]))),
-    responses: v.optional(v.record(v.string(), v.union([oasResponseData, oasResponseRefData]))),
-    parameters: v.optional(v.record(v.string(), v.union([oasParameterData, oasParameterRefData]))),
-    examples: v.optional(v.record(v.string(), v.union([oasExampleData, oasExampleRefData]))),
-    requestBodies: v.optional(v.record(v.string(), v.union([oasRequestBodyData, oasRequestBodyRefData]))),
-    headers: v.optional(v.record(v.string(), v.union([oasHeaderData, oasHeaderRefData])))
-    // securitySchemes: z.record(z.union([securityScheme, ref])),
-    // links: z.record(z.union([link, ref])),
-    // callbacks: z.never(),
-    // pathItems: z.record(z.union([oasPathItemData, oasPathItemRefData])).optional()
-});

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

@@ -1,16 +0,0 @@
-import { type OasTagData } from '../tag/tag-types.js';
-import { type OasOperationData } from '../operation/operation-types.js';
-import * as v from 'valibot';
-import { type OasComponentsData } from '../components/components-types.js';
-import { type OasInfoData } from '../info/info-types.js';
-export type OasDocumentData = {
-    oasType: 'openapi';
-    openapi: string;
-    info: OasInfoData;
-    jsonSchemaDialect?: string;
-    operations: OasOperationData[];
-    components?: OasComponentsData;
-    tags?: OasTagData[];
-};
-export declare const oasDocumentData: v.GenericSchema<OasDocumentData>;
-//# sourceMappingURL=document-types.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"document-types.d.ts","sourceRoot":"","sources":["../../../src/oas/document/document-types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,UAAU,EAAc,MAAM,qBAAqB,CAAA;AACjE,OAAO,EAAE,KAAK,gBAAgB,EAAoB,MAAM,iCAAiC,CAAA;AACzF,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAC5B,OAAO,EAAE,KAAK,iBAAiB,EAAqB,MAAM,mCAAmC,CAAA;AAC7F,OAAO,EAAE,KAAK,WAAW,EAAe,MAAM,uBAAuB,CAAA;AAErE,MAAM,MAAM,eAAe,GAAG;IAC5B,OAAO,EAAE,SAAS,CAAA;IAClB,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,WAAW,CAAA;IACjB,iBAAiB,CAAC,EAAE,MAAM,CAAA;IAE1B,UAAU,EAAE,gBAAgB,EAAE,CAAA;IAE9B,UAAU,CAAC,EAAE,iBAAiB,CAAA;IAE9B,IAAI,CAAC,EAAE,UAAU,EAAE,CAAA;CACpB,CAAA;AAED,eAAO,MAAM,eAAe,EAAE,CAAC,CAAC,aAAa,CAAC,eAAe,CAY3D,CAAA"}

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

@@ -1,18 +0,0 @@
-import { oasTagData } from '../tag/tag-types.js';
-import { oasOperationData } from '../operation/operation-types.js';
-import * as v from 'valibot';
-import { oasComponentsData } from '../components/components-types.js';
-import { oasInfoData } from '../info/info-types.js';
-export const oasDocumentData = v.object({
-    oasType: v.literal('openapi'),
-    openapi: v.string(),
-    info: oasInfoData,
-    jsonSchemaDialect: v.optional(v.string()),
-    // servers: z.array(server).optional(),
-    operations: v.array(oasOperationData),
-    // webhooks: z.record(z.union([pathItem, ref])).optional(),
-    components: v.optional(oasComponentsData),
-    // security: z.never(),
-    tags: v.optional(v.array(oasTagData))
-    // externalDocs: externalDocs.optional()
-});

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

@@ -1,50 +0,0 @@
-import { type OasExampleData } from '../example/example-types.js';
-import { type OasMediaTypeData } from '../mediaType/mediaType-types.js';
-import { type OasExampleRefData, type OasSchemaRefData } from '../ref/ref-types.js';
-import { type OasSchemaData } from '../schema/schema-types.js';
-import * as v from 'valibot';
-/**
- * Data type for OpenAPI header objects in the SKMTC internal representation.
- *
- * Represents HTTP headers in OpenAPI specifications, including validation
- * rules, examples, and serialization parameters. Headers are used in
- * responses and can include complex schemas and multiple examples.
- */
-export type OasHeaderData = {
-    /** Type identifier for OAS header objects */
-    oasType: 'header';
-    /** Human-readable description of the header */
-    description?: string;
-    /** Whether the header is required */
-    required?: boolean;
-    /** Whether the header is deprecated */
-    deprecated?: boolean;
-    /** Whether empty values are allowed for the header */
-    allowEmptyValue?: boolean;
-    /** Schema definition for the header value */
-    schema?: OasSchemaData | OasSchemaRefData;
-    /** Named examples for the header value */
-    examples?: Record<string, OasExampleData | OasExampleRefData>;
-    /** Media type definitions for complex header content */
-    content?: Record<string, OasMediaTypeData>;
-    /** Serialization style (always 'simple' for headers) */
-    style?: OasHeaderStyle;
-    /** Whether to explode parameter values */
-    explode?: boolean;
-};
-/**
- * Valid serialization styles for OpenAPI headers.
- *
- * Headers can only use the 'simple' serialization style according to
- * the OpenAPI specification.
- */
-export type OasHeaderStyle = 'simple';
-/**
- * Valibot schema for validating OAS header data structures.
- *
- * Validates the structure and content of OpenAPI header objects,
- * ensuring proper types for all fields including nested schemas,
- * examples, and content definitions.
- */
-export declare const oasHeaderData: v.GenericSchema<OasHeaderData>;
-//# sourceMappingURL=header-types.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"header-types.d.ts","sourceRoot":"","sources":["../../../src/oas/header/header-types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAAkB,MAAM,6BAA6B,CAAA;AAEjF,OAAO,EAAE,KAAK,gBAAgB,EAAoB,MAAM,iCAAiC,CAAA;AACzF,OAAO,EACL,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,EAGtB,MAAM,qBAAqB,CAAA;AAC5B,OAAO,EAAE,KAAK,aAAa,EAAiB,MAAM,2BAA2B,CAAA;AAC7E,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B;;;;;;GAMG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,6CAA6C;IAC7C,OAAO,EAAE,QAAQ,CAAA;IACjB,+CAA+C;IAC/C,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,qCAAqC;IACrC,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,uCAAuC;IACvC,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,sDAAsD;IACtD,eAAe,CAAC,EAAE,OAAO,CAAA;IACzB,6CAA6C;IAC7C,MAAM,CAAC,EAAE,aAAa,GAAG,gBAAgB,CAAA;IACzC,0CAA0C;IAC1C,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,GAAG,iBAAiB,CAAC,CAAA;IAC7D,wDAAwD;IACxD,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAA;IAC1C,wDAAwD;IACxD,KAAK,CAAC,EAAE,cAAc,CAAA;IACtB,0CAA0C;IAC1C,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB,CAAA;AAID;;;;;GAKG;AACH,MAAM,MAAM,cAAc,GAAG,QAAQ,CAAA;AAErC;;;;;;GAMG;AACH,eAAO,MAAM,aAAa,EAAE,CAAC,CAAC,aAAa,CAAC,aAAa,CAcvD,CAAA"}

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

@@ -1,30 +0,0 @@
-import { oasExampleData } from '../example/example-types.js';
-import { markdown } from '../markdown/markdown-types.js';
-import { oasMediaTypeData } from '../mediaType/mediaType-types.js';
-import { oasExampleRefData, oasSchemaRefData } from '../ref/ref-types.js';
-import { oasSchemaData } from '../schema/schema-types.js';
-import * as v from 'valibot';
-const oasHeaderStyle = v.literal('simple');
-/**
- * Valibot schema for validating OAS header data structures.
- *
- * Validates the structure and content of OpenAPI header objects,
- * ensuring proper types for all fields including nested schemas,
- * examples, and content definitions.
- */
-export const oasHeaderData = v.object({
-    oasType: v.literal('header'),
-    description: v.optional(markdown),
-    required: v.optional(v.boolean()),
-    deprecated: v.optional(v.boolean()),
-    allowEmptyValue: v.optional(v.boolean()),
-    // Default values (based on value of in): for query - form; for path - simple; for header - simple; for cookie - form.
-    style: v.optional(oasHeaderStyle),
-    explode: v.optional(v.boolean()),
-    // allowReserved: v.boolean().optional(),
-    schema: v.optional(v.union([oasSchemaData, oasSchemaRefData])),
-    // example: z.any().optional(),
-    examples: v.optional(v.record(v.string(), v.union([oasExampleData, oasExampleRefData]))),
-    content: v.optional(v.record(v.string(), oasMediaTypeData))
-});
-// export type OasHeaders = Record<string, OasHeader | OasHeaderRef>

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

@@ -1,29 +0,0 @@
-import { type OasExampleData } from '../example/example-types.js';
-import { type OasExampleRefData, type OasSchemaRefData } from '../ref/ref-types.js';
-import { type OasSchemaData } from '../schema/schema-types.js';
-import * as v from 'valibot';
-/**
- * Data type for OpenAPI media type objects.
- *
- * Represents media type definitions within request/response bodies,
- * specifying the format, schema, and examples for different content types
- * like application/json, multipart/form-data, etc.
- */
-export type OasMediaTypeData = {
-    /** Type identifier for OAS media type objects */
-    oasType: 'mediaType';
-    /** The media type identifier (e.g., 'application/json', 'text/plain') */
-    mediaType: string;
-    /** Schema definition for the media type content */
-    schema?: OasSchemaData | OasSchemaRefData;
-    /** Named examples for the media type content */
-    examples?: Record<string, OasExampleData | OasExampleRefData>;
-};
-/**
- * Valibot schema for validating OpenAPI media type data.
- *
- * Validates the structure of media type objects including content type
- * identifiers, schema definitions, and example collections.
- */
-export declare const oasMediaTypeData: v.GenericSchema<OasMediaTypeData>;
-//# sourceMappingURL=mediaType-types.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"mediaType-types.d.ts","sourceRoot":"","sources":["../../../src/oas/mediaType/mediaType-types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAAkB,MAAM,6BAA6B,CAAA;AACjF,OAAO,EACL,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,EAGtB,MAAM,qBAAqB,CAAA;AAC5B,OAAO,EAAE,KAAK,aAAa,EAAiB,MAAM,2BAA2B,CAAA;AAC7E,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B;;;;;;GAMG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAC7B,iDAAiD;IACjD,OAAO,EAAE,WAAW,CAAA;IACpB,yEAAyE;IACzE,SAAS,EAAE,MAAM,CAAA;IACjB,mDAAmD;IACnD,MAAM,CAAC,EAAE,aAAa,GAAG,gBAAgB,CAAA;IAEzC,gDAAgD;IAChD,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,GAAG,iBAAiB,CAAC,CAAA;CAE9D,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,EAAE,CAAC,CAAC,aAAa,CAAC,gBAAgB,CAO7D,CAAA"}

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

@@ -1,18 +0,0 @@
-import { oasExampleData } from '../example/example-types.js';
-import { oasExampleRefData, oasSchemaRefData } from '../ref/ref-types.js';
-import { oasSchemaData } from '../schema/schema-types.js';
-import * as v from 'valibot';
-/**
- * Valibot schema for validating OpenAPI media type data.
- *
- * Validates the structure of media type objects including content type
- * identifiers, schema definitions, and example collections.
- */
-export const oasMediaTypeData = v.object({
-    oasType: v.literal('mediaType'),
-    mediaType: v.string(),
-    schema: v.optional(v.union([oasSchemaData, oasSchemaRefData])),
-    // example: z.any().optional(),
-    examples: v.optional(v.record(v.string(), v.union([oasExampleData, oasExampleRefData])))
-    // encoding: z.lazy(() => z.record(encoding).optional())
-});

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

@@ -1,19 +0,0 @@
-import * as v from 'valibot';
-import { type OasSchemaData } from '../schema/schema-types.js';
-import { type OasSchemaRefData } from '../ref/ref-types.js';
-export declare const oasObjectData: v.GenericSchema<OasObjectData>;
-export type OasObjectData = {
-    type: 'object';
-    title?: string;
-    description?: string;
-    default?: Record<string, unknown>;
-    deprecated?: boolean;
-    maxProperties?: number;
-    minProperties?: number;
-    properties?: Record<string, OasSchemaData | OasSchemaRefData>;
-    required?: string[];
-    additionalProperties?: boolean | OasSchemaData | OasSchemaRefData;
-    readOnly?: boolean;
-    writeOnly?: boolean;
-};
-//# sourceMappingURL=object-types.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"object-types.d.ts","sourceRoot":"","sources":["../../../src/oas/object/object-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,eAAO,MAAM,aAAa,EAAE,CAAC,CAAC,aAAa,CAAC,aAAa,CAwBvD,CAAA;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,IAAI,EAAE,QAAQ,CAAA;IACd,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IACjC,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,GAAG,gBAAgB,CAAC,CAAA;IAC7D,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;IACnB,oBAAoB,CAAC,EAAE,OAAO,GAAG,aAAa,GAAG,gBAAgB,CAAA;IACjE,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,SAAS,CAAC,EAAE,OAAO,CAAA;CACpB,CAAA"}

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

@@ -1,23 +0,0 @@
-import * as v from 'valibot';
-import { oasSchemaData } from '../schema/schema-types.js';
-import { oasSchemaRefData } from '../ref/ref-types.js';
-export const oasObjectData = v.object({
-    type: v.literal('object'),
-    title: v.optional(v.string()),
-    description: v.optional(v.string()),
-    default: v.optional(v.object({})),
-    deprecated: v.optional(v.boolean()),
-    maxProperties: v.optional(v.number()),
-    minProperties: v.optional(v.number()),
-    properties: v.optional(v.record(v.string(), v.union([v.lazy(() => oasSchemaData), oasSchemaRefData]))),
-    readOnly: v.optional(v.boolean()),
-    writeOnly: v.optional(v.boolean()),
-    // Add soon
-    // patternProperties: z.lazy(() => z.record(jsonSchema4).optional()),
-    required: v.optional(v.array(v.string())),
-    // allOf: z.lazy(() => z.array(oasObject).optional()),
-    // Use oneOf instead of anyOf
-    // anyOf: z.lazy(() => z.array(jsonSchema4).optional()),
-    // oneOf: z.lazy(() => z.array(oasObject).optional()),
-    additionalProperties: v.optional(v.union([v.boolean(), v.lazy(() => oasSchemaData), oasSchemaRefData]))
-});