@skmtc/core 0.0.926 → 0.0.930

package/script/oas/integer/toInteger.js

@@ -37,27 +37,29 @@ exports.toParsedInteger = exports.toInteger = void 0;
 const Integer_js_1 = require("./Integer.js");
 const toSpecificationExtensionsV3_js_1 = require("../specificationExtensions/toSpecificationExtensionsV3.js");
 const integer_types_js_1 = require("./integer-types.js");
-const v = __importStar(require("valibot"));
 const parseNullable_js_1 = require("../_helpers/parseNullable.js");
-const parseExample_js_1 = require("../_helpers/parseExample.js");
 const parseEnum_js_1 = require("../_helpers/parseEnum.js");
-const parseFormat_js_1 = require("../_helpers/parseFormat.js");
+const v = __importStar(require("valibot"));
 const toInteger = ({ value, context }) => {
     const { nullable, value: valueWithoutNullable } = (0, parseNullable_js_1.parseNullable)({
         value,
         context
     });
-    const { example, value: valueWithoutExample } = (0, parseExample_js_1.parseExample)({
-        value: valueWithoutNullable,
-        nullable,
-        valibotSchema: integer_types_js_1.integerSchema,
-        context
+    const { example: unparsedExample, ...valueWithoutExample } = valueWithoutNullable;
+    const example = parseExample({
+        example: unparsedExample,
+        context,
+        parent: valueWithoutNullable,
+        nullable
     });
-    const { enum: enums, value: valueWithoutEnums } = (0, parseEnum_js_1.parseEnum)({
-        value: valueWithoutExample,
+    const { enum: unparsedEnums, ...valueWithoutEnums } = valueWithoutExample;
+    const enums = (0, parseEnum_js_1.parseEnum)({
+        value: unparsedEnums,
         nullable,
-        valibotSchema: integer_types_js_1.integerSchema,
-        context
+        parent: valueWithoutExample,
+        context,
+        check: Number.isInteger,
+        toMessage: item => `Removed invalid enum. Expected "integer", got: ${item}`
     });
     return (0, exports.toParsedInteger)({
         context,
@@ -69,12 +71,16 @@ const toInteger = ({ value, context }) => {
 };
 exports.toInteger = toInteger;
 const toParsedInteger = ({ context, nullable, example, enums, value: valueWithoutEnums }) => {
-    const { format, value: valueWithoutFormat } = (0, parseFormat_js_1.parseFormat)({
-        value: valueWithoutEnums,
-        valibotSchema: integer_types_js_1.integerFormat,
-        context
+    const { format: unparsedFormat, ...valueWithoutFormat } = valueWithoutEnums;
+    const format = parseIntegerFormat({
+        format: unparsedFormat,
+        context,
+        parent: valueWithoutEnums
     });
-    const { type: _type, title, description, default: defaultValue, multipleOf, maximum, exclusiveMaximum, minimum, exclusiveMinimum, ...skipped } = v.parse(integer_types_js_1.oasIntegerData, valueWithoutFormat);
+    if (!v.is(integer_types_js_1.oasIntegerData, valueWithoutFormat)) {
+        v.parse(integer_types_js_1.oasIntegerData, valueWithoutFormat);
+    }
+    const { type: _type, title, description, default: defaultValue, multipleOf, maximum, exclusiveMaximum, minimum, exclusiveMinimum, readOnly, writeOnly, deprecated, ...skipped } = valueWithoutFormat;
     const extensionFields = (0, toSpecificationExtensionsV3_js_1.toSpecificationExtensionsV3)({
         skipped,
         parent: valueWithoutEnums,
@@ -94,7 +100,48 @@ const toParsedInteger = ({ context, nullable, example, enums, value: valueWithou
         minimum,
         exclusiveMinimum,
         default: defaultValue,
-        extensionFields
+        readOnly,
+        writeOnly,
+        extensionFields,
+        deprecated
     });
 };
 exports.toParsedInteger = toParsedInteger;
+const parseIntegerFormat = ({ format, context, parent }) => {
+    if (format === undefined) {
+        return undefined;
+    }
+    if (!v.is(integer_types_js_1.integerFormat, format)) {
+        context.logIssue({
+            key: 'format',
+            level: 'warning',
+            message: `Invalid format: ${format}`,
+            parent,
+            type: 'INVALID_FORMAT'
+        });
+        return undefined;
+    }
+    return format;
+};
+const parseExample = ({ example, context, parent, nullable }) => {
+    if (example === undefined) {
+        return undefined;
+    }
+    if (nullable && example === null) {
+        return example;
+    }
+    if (!isInteger(example)) {
+        context.logIssue({
+            key: 'example',
+            level: 'warning',
+            message: `Removed invalid example. Expected "integer", got: ${example}`,
+            parent,
+            type: 'INVALID_EXAMPLE'
+        });
+        return undefined;
+    }
+    return example;
+};
+const isInteger = (value) => {
+    return Number.isInteger(value);
+};

package/script/oas/mediaType/toMediaTypeItemV3.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"toMediaTypeItemV3.d.ts","sourceRoot":"","sources":["../../../src/oas/mediaType/toMediaTypeItemV3.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAC9C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAA;AAGjE,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAI7C;;GAEG;AACH,KAAK,qBAAqB,GAAG;IAC3B,oDAAoD;IACpD,aAAa,EAAE,SAAS,CAAC,eAAe,CAAA;IACxC,qEAAqE;IACrE,SAAS,EAAE,MAAM,CAAA;IACjB,qDAAqD;IACrD,OAAO,EAAE,YAAY,CAAA;CACtB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqGG;AACH,eAAO,MAAM,iBAAiB,GAAI,uCAI/B,qBAAqB,KAAG,YA0B1B,CAAA;AAED;;GAEG;AACH,KAAK,sBAAsB,GAAG;IAC5B,gEAAgE;IAChE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,eAAe,CAAC,CAAA;IAClD,qDAAqD;IACrD,OAAO,EAAE,YAAY,CAAA;CACtB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkFG;AACH,eAAO,MAAM,kBAAkB,GAAI,sBAGhC,sBAAsB,KAAG,MAAM,CAAC,MAAM,EAAE,YAAY,CAatD,CAAA;AAED;;GAEG;AACH,KAAK,8BAA8B,GAAG;IACpC,yEAAyE;IACzE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,eAAe,CAAC,GAAG,SAAS,CAAA;IAC9D,qDAAqD;IACrD,OAAO,EAAE,YAAY,CAAA;CACtB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsFG;AACH,eAAO,MAAM,0BAA0B,GAAI,sBAGxC,8BAA8B,KAAG,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,GAAG,SAMlE,CAAA"}
+{"version":3,"file":"toMediaTypeItemV3.d.ts","sourceRoot":"","sources":["../../../src/oas/mediaType/toMediaTypeItemV3.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAC9C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAA;AAGjE,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAK7C;;GAEG;AACH,KAAK,qBAAqB,GAAG;IAC3B,oDAAoD;IACpD,aAAa,EAAE,SAAS,CAAC,eAAe,CAAA;IACxC,qEAAqE;IACrE,SAAS,EAAE,MAAM,CAAA;IACjB,qDAAqD;IACrD,OAAO,EAAE,YAAY,CAAA;CACtB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqGG;AACH,eAAO,MAAM,iBAAiB,GAAI,uCAI/B,qBAAqB,KAAG,YAiC1B,CAAA;AAED;;GAEG;AACH,KAAK,sBAAsB,GAAG;IAC5B,gEAAgE;IAChE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,eAAe,CAAC,CAAA;IAClD,qDAAqD;IACrD,OAAO,EAAE,YAAY,CAAA;CACtB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkFG;AACH,eAAO,MAAM,kBAAkB,GAAI,sBAGhC,sBAAsB,KAAG,MAAM,CAAC,MAAM,EAAE,YAAY,CAatD,CAAA;AAED;;GAEG;AACH,KAAK,8BAA8B,GAAG;IACpC,yEAAyE;IACzE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,eAAe,CAAC,GAAG,SAAS,CAAA;IAC9D,qDAAqD;IACrD,OAAO,EAAE,YAAY,CAAA;CACtB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsFG;AACH,eAAO,MAAM,0BAA0B,GAAI,sBAGxC,8BAA8B,KAAG,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,GAAG,SAMlE,CAAA"}

package/script/oas/mediaType/toMediaTypeItemV3.js

@@ -5,6 +5,7 @@ const toSchemasV3_js_1 = require("../schema/toSchemasV3.js");
 const toExamplesV3_js_1 = require("../example/toExamplesV3.js");
 const MediaType_js_1 = require("./MediaType.js");
 const toSpecificationExtensionsV3_js_1 = require("../specificationExtensions/toSpecificationExtensionsV3.js");
+const tracer_js_1 = require("../../helpers/tracer.js");
 /**
  * Transforms an OpenAPI v3 media type object into an internal OAS media type representation.
  *
@@ -118,8 +119,8 @@ const toMediaTypeItemV3 = ({ mediaTypeItem, mediaType, context }) => {
     const fields = {
         mediaType,
         encoding,
-        schema: context.trace('schema', () => (0, toSchemasV3_js_1.toOptionalSchemaV3)({ schema, context })),
-        examples: context.trace('examples', () => (0, toExamplesV3_js_1.toExamplesV3)({
+        schema: (0, tracer_js_1.tracer)(context.stackTrail, 'schema', () => (0, toSchemasV3_js_1.toOptionalSchemaV3)({ schema, context })),
+        examples: (0, tracer_js_1.tracer)(context.stackTrail, 'examples', () => (0, toExamplesV3_js_1.toExamplesV3)({
             example,
             examples,
             exampleKey: mediaType,
@@ -214,14 +215,12 @@ exports.toMediaTypeItemV3 = toMediaTypeItemV3;
  * ```
  */
 const toMediaTypeItemsV3 = ({ content, context }) => {
-    return Object.fromEntries(Object.entries(content).map(([mediaType, value]) => [
-        mediaType,
-        context.trace(mediaType, () => (0, exports.toMediaTypeItemV3)({
-            mediaTypeItem: value,
-            mediaType,
-            context
-        }))
-    ]));
+    const output = {};
+    const entries = Object.entries(content);
+    for (const [mediaType, value] of entries) {
+        output[mediaType] = (0, tracer_js_1.tracer)(context.stackTrail, mediaType, () => (0, exports.toMediaTypeItemV3)({ mediaTypeItem: value, mediaType, context }));
+    }
+    return output;
 };
 exports.toMediaTypeItemsV3 = toMediaTypeItemsV3;
 /**

package/script/oas/number/Number.d.ts

@@ -1,4 +1,3 @@
-import "../../_dnt.polyfills.js";
 import type { OasRef } from '../ref/Ref.js';
 import type { OpenAPIV3 } from 'openapi-types';
 import type { ToJsonSchemaOptions } from '../schema/Schema.js';
@@ -34,170 +33,13 @@ export type NumberFields<Nullable extends boolean | undefined> = {
     minimum?: number;
     /** Whether the minimum value is exclusive */
     exclusiveMinimum?: boolean;
+    /** Whether the number is read-only */
+    readOnly?: boolean;
+    /** Whether the number is write-only */
+    writeOnly?: boolean;
+    /** Whether the number is deprecated */
+    deprecated?: boolean;
 };
-/**
- * Represents a number schema in the OpenAPI Specification.
- *
- * The `OasNumber` class handles floating-point numeric data types in OpenAPI schemas,
- * supporting comprehensive validation constraints including ranges, precision formats,
- * and mathematical constraints. This class provides type-safe number handling with
- * optional null value support and extensive validation capabilities.
- *
- * ## Key Features
- *
- * - **Range Validation**: Minimum and maximum constraints with exclusive/inclusive options
- * - **Precision Control**: Float and double format support for different precision needs
- * - **Mathematical Constraints**: Multiple-of validation for specific numeric patterns
- * - **Type Safety**: Generic nullable type support with proper TypeScript inference
- * - **Enum Support**: Constrain numbers to specific allowed values
- * - **Null Handling**: Optional null value support for nullable number types
- *
- * @template Nullable - Whether the number value itself can be null
- *
- * @example Basic number schema with range
- * ```typescript
- * import { OasNumber } from '@skmtc/core';
- *
- * const ageSchema = new OasNumber({
- *   title: 'Age',
- *   description: 'Person age in years',
- *   minimum: 0,
- *   maximum: 150,
- *   example: 25,
- *   default: 18
- * });
- *
- * // This represents: number (0 <= value <= 150)
- * ```
- *
- * @example Price with precision and constraints
- * ```typescript
- * const priceSchema = new OasNumber({
- *   title: 'Product Price',
- *   description: 'Price in USD with cent precision',
- *   format: 'double',
- *   minimum: 0,
- *   exclusiveMinimum: true, // Must be > 0, not >= 0
- *   multipleOf: 0.01, // Must be in cents (e.g., 19.99, 10.50)
- *   example: 29.99
- * });
- *
- * // This represents: number > 0, in multiples of 0.01
- * ```
- *
- * @example Percentage with strict bounds
- * ```typescript
- * const percentageSchema = new OasNumber({
- *   title: 'Completion Percentage',
- *   description: 'Task completion as a percentage',
- *   minimum: 0,
- *   maximum: 100,
- *   multipleOf: 0.1, // One decimal place precision
- *   example: 75.5,
- *   default: 0
- * });
- *
- * // This represents: 0 <= value <= 100, in increments of 0.1
- * ```
- *
- * @example Nullable rating system
- * ```typescript
- * const ratingSchema = new OasNumber<true>({
- *   title: 'User Rating',
- *   description: 'Product rating from 1-5 stars, null if not rated',
- *   nullable: true,
- *   minimum: 1,
- *   maximum: 5,
- *   multipleOf: 0.5, // Allow half-star ratings
- *   enums: [1, 1.5, 2, 2.5, 3, 3.5, 4, 4.5, 5, null],
- *   example: 4.5,
- *   default: null
- * });
- *
- * // This represents: (1 | 1.5 | 2 | 2.5 | 3 | 3.5 | 4 | 4.5 | 5) | null
- * ```
- *
- * @example Scientific measurement with high precision
- * ```typescript
- * const temperatureSchema = new OasNumber({
- *   title: 'Temperature',
- *   description: 'Temperature in Celsius with high precision',
- *   format: 'double',
- *   minimum: -273.15, // Absolute zero
- *   maximum: 1000,
- *   multipleOf: 0.001, // Millikelvin precision
- *   example: 23.456
- * });
- *
- * // For scientific applications requiring high precision
- * ```
- *
- * @example Currency with regional constraints
- * ```typescript
- * const currencySchema = new OasNumber({
- *   title: 'Amount',
- *   description: 'Transaction amount in major currency units',
- *   format: 'double',
- *   minimum: 0,
- *   maximum: 999999.99,
- *   multipleOf: 0.01,
- *   example: 1234.56
- * });
- *
- * // Used in financial applications
- * const transaction = new OasObject({
- *   properties: {
- *     amount: currencySchema,
- *     currency: new OasString({ enum: ['USD', 'EUR', 'GBP'] })
- *   }
- * });
- * ```
- *
- * @example Coordinate system
- * ```typescript
- * const latitudeSchema = new OasNumber({
- *   title: 'Latitude',
- *   description: 'Geographic latitude coordinate',
- *   format: 'double',
- *   minimum: -90,
- *   maximum: 90,
- *   example: 40.7128
- * });
- *
- * const longitudeSchema = new OasNumber({
- *   title: 'Longitude',
- *   description: 'Geographic longitude coordinate',
- *   format: 'double',
- *   minimum: -180,
- *   maximum: 180,
- *   example: -74.0060
- * });
- *
- * // Used for location data
- * ```
- *
- * @example Probability and statistics
- * ```typescript
- * const probabilitySchema = new OasNumber({
- *   title: 'Probability',
- *   description: 'Statistical probability value',
- *   minimum: 0,
- *   maximum: 1,
- *   exclusiveMaximum: false, // Can be exactly 1
- *   example: 0.75,
- *   default: 0.5
- * });
- *
- * const confidenceSchema = new OasNumber({
- *   title: 'Confidence Level',
- *   description: 'Statistical confidence level as percentage',
- *   minimum: 0,
- *   maximum: 100,
- *   enums: [90, 95, 99], // Common confidence levels
- *   example: 95
- * });
- * ```
- */
 export declare class OasNumber<Nullable extends boolean | undefined = boolean | undefined> {
     /**
      * Object is part the 'schema' set which is used
@@ -258,6 +100,18 @@ export declare class OasNumber<Nullable extends boolean | undefined = boolean |
      * Whether the minimum value is exclusive.
      */
     exclusiveMinimum: boolean | undefined;
+    /**
+     * Whether the number is read-only.
+     */
+    readOnly: boolean | undefined;
+    /**
+     * Whether the number is write-only.
+     */
+    writeOnly: boolean | undefined;
+    /**
+     * Whether the number is deprecated.
+     */
+    deprecated: boolean | undefined;
     constructor(fields?: NumberFields<Nullable>);
     isRef(): this is OasRef<'schema'>;
     resolve(): OasNumber<Nullable>;

package/script/oas/number/Number.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Number.d.ts","sourceRoot":"","sources":["../../../src/oas/number/Number.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"Number.d.ts","sourceRoot":"","sources":["../../../src/oas/number/Number.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,eAAe,CAAA;AAC3C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAC9C,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAA;AAE9D;;;;GAIG;AACH,MAAM,MAAM,YAAY,CAAC,QAAQ,SAAS,OAAO,GAAG,SAAS,IAAI;IAC/D,2CAA2C;IAC3C,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,yCAAyC;IACzC,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,2CAA2C;IAC3C,QAAQ,CAAC,EAAE,QAAQ,CAAA;IACnB,sEAAsE;IACtE,OAAO,CAAC,EAAE,QAAQ,SAAS,IAAI,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAAA;IAChF,+CAA+C;IAC/C,eAAe,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IACzC,sEAAsE;IACtE,OAAO,CAAC,EAAE,QAAQ,SAAS,IAAI,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAAA;IAChF,mFAAmF;IACnF,KAAK,CAAC,EAAE,QAAQ,SAAS,IAAI,GAAG,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,GAAG,SAAS,GAAG,MAAM,EAAE,GAAG,SAAS,CAAA;IACpF,2DAA2D;IAC3D,MAAM,CAAC,EAAE,OAAO,GAAG,QAAQ,CAAA;IAC3B,8CAA8C;IAC9C,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,mDAAmD;IACnD,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,6CAA6C;IAC7C,gBAAgB,CAAC,EAAE,OAAO,CAAA;IAC1B,mDAAmD;IACnD,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,6CAA6C;IAC7C,gBAAgB,CAAC,EAAE,OAAO,CAAA;IAC1B,sCAAsC;IACtC,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,uCAAuC;IACvC,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,uCAAuC;IACvC,UAAU,CAAC,EAAE,OAAO,CAAA;CACrB,CAAA;AAED,qBAAa,SAAS,CAAC,QAAQ,SAAS,OAAO,GAAG,SAAS,GAAG,OAAO,GAAG,SAAS;IAC/E;;;OAGG;IACH,OAAO,EAAG,QAAQ,CAAS;IAC3B;;OAEG;IACH,IAAI,EAAG,QAAQ,CAAS;IACxB;;OAEG;IACH,KAAK,EAAE,MAAM,GAAG,SAAS,CAAA;IACzB;;OAEG;IACH,OAAO,EAAE,QAAQ,SAAS,IAAI,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAAA;IAC/E;;OAEG;IACH,WAAW,EAAE,MAAM,GAAG,SAAS,CAAA;IAC/B;;OAEG;IACH,QAAQ,EAAE,QAAQ,GAAG,SAAS,CAAA;IAC9B,qCAAqC;IACrC,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAAA;IACpD;;OAEG;IACH,OAAO,EAAE,QAAQ,SAAS,IAAI,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAAA;IAC/E;;OAEG;IACH,KAAK,EAAE,QAAQ,SAAS,IAAI,GAAG,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,GAAG,SAAS,GAAG,MAAM,EAAE,GAAG,SAAS,CAAA;IACnF;;OAEG;IACH,MAAM,EAAE,OAAO,GAAG,QAAQ,GAAG,SAAS,CAAA;IACtC;;OAEG;IACH,UAAU,EAAE,MAAM,GAAG,SAAS,CAAA;IAC9B;;OAEG;IACH,OAAO,EAAE,MAAM,GAAG,SAAS,CAAA;IAC3B;;OAEG;IACH,gBAAgB,EAAE,OAAO,GAAG,SAAS,CAAA;IACrC;;OAEG;IACH,OAAO,EAAE,MAAM,GAAG,SAAS,CAAA;IAC3B;;OAEG;IACH,gBAAgB,EAAE,OAAO,GAAG,SAAS,CAAA;IACrC;;OAEG;IACH,QAAQ,EAAE,OAAO,GAAG,SAAS,CAAA;IAC7B;;OAEG;IACH,SAAS,EAAE,OAAO,GAAG,SAAS,CAAA;IAC9B;;OAEG;IACH,UAAU,EAAE,OAAO,GAAG,SAAS,CAAA;gBACnB,MAAM,GAAE,YAAY,CAAC,QAAQ,CAAM;IAmB/C,KAAK,IAAI,IAAI,IAAI,MAAM,CAAC,QAAQ,CAAC;IAIjC,OAAO,IAAI,SAAS,CAAC,QAAQ,CAAC;IAI9B,WAAW,IAAI,SAAS,CAAC,QAAQ,CAAC;IAKlC,YAAY,CAAC,OAAO,CAAC,EAAE,mBAAmB,GAAG,SAAS,CAAC,oBAAoB;CAkB5E"}

package/script/oas/number/Number.js

@@ -1,170 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OasNumber = void 0;
-require("../../_dnt.polyfills.js");
-/**
- * Represents a number schema in the OpenAPI Specification.
- *
- * The `OasNumber` class handles floating-point numeric data types in OpenAPI schemas,
- * supporting comprehensive validation constraints including ranges, precision formats,
- * and mathematical constraints. This class provides type-safe number handling with
- * optional null value support and extensive validation capabilities.
- *
- * ## Key Features
- *
- * - **Range Validation**: Minimum and maximum constraints with exclusive/inclusive options
- * - **Precision Control**: Float and double format support for different precision needs
- * - **Mathematical Constraints**: Multiple-of validation for specific numeric patterns
- * - **Type Safety**: Generic nullable type support with proper TypeScript inference
- * - **Enum Support**: Constrain numbers to specific allowed values
- * - **Null Handling**: Optional null value support for nullable number types
- *
- * @template Nullable - Whether the number value itself can be null
- *
- * @example Basic number schema with range
- * ```typescript
- * import { OasNumber } from '@skmtc/core';
- *
- * const ageSchema = new OasNumber({
- *   title: 'Age',
- *   description: 'Person age in years',
- *   minimum: 0,
- *   maximum: 150,
- *   example: 25,
- *   default: 18
- * });
- *
- * // This represents: number (0 <= value <= 150)
- * ```
- *
- * @example Price with precision and constraints
- * ```typescript
- * const priceSchema = new OasNumber({
- *   title: 'Product Price',
- *   description: 'Price in USD with cent precision',
- *   format: 'double',
- *   minimum: 0,
- *   exclusiveMinimum: true, // Must be > 0, not >= 0
- *   multipleOf: 0.01, // Must be in cents (e.g., 19.99, 10.50)
- *   example: 29.99
- * });
- *
- * // This represents: number > 0, in multiples of 0.01
- * ```
- *
- * @example Percentage with strict bounds
- * ```typescript
- * const percentageSchema = new OasNumber({
- *   title: 'Completion Percentage',
- *   description: 'Task completion as a percentage',
- *   minimum: 0,
- *   maximum: 100,
- *   multipleOf: 0.1, // One decimal place precision
- *   example: 75.5,
- *   default: 0
- * });
- *
- * // This represents: 0 <= value <= 100, in increments of 0.1
- * ```
- *
- * @example Nullable rating system
- * ```typescript
- * const ratingSchema = new OasNumber<true>({
- *   title: 'User Rating',
- *   description: 'Product rating from 1-5 stars, null if not rated',
- *   nullable: true,
- *   minimum: 1,
- *   maximum: 5,
- *   multipleOf: 0.5, // Allow half-star ratings
- *   enums: [1, 1.5, 2, 2.5, 3, 3.5, 4, 4.5, 5, null],
- *   example: 4.5,
- *   default: null
- * });
- *
- * // This represents: (1 | 1.5 | 2 | 2.5 | 3 | 3.5 | 4 | 4.5 | 5) | null
- * ```
- *
- * @example Scientific measurement with high precision
- * ```typescript
- * const temperatureSchema = new OasNumber({
- *   title: 'Temperature',
- *   description: 'Temperature in Celsius with high precision',
- *   format: 'double',
- *   minimum: -273.15, // Absolute zero
- *   maximum: 1000,
- *   multipleOf: 0.001, // Millikelvin precision
- *   example: 23.456
- * });
- *
- * // For scientific applications requiring high precision
- * ```
- *
- * @example Currency with regional constraints
- * ```typescript
- * const currencySchema = new OasNumber({
- *   title: 'Amount',
- *   description: 'Transaction amount in major currency units',
- *   format: 'double',
- *   minimum: 0,
- *   maximum: 999999.99,
- *   multipleOf: 0.01,
- *   example: 1234.56
- * });
- *
- * // Used in financial applications
- * const transaction = new OasObject({
- *   properties: {
- *     amount: currencySchema,
- *     currency: new OasString({ enum: ['USD', 'EUR', 'GBP'] })
- *   }
- * });
- * ```
- *
- * @example Coordinate system
- * ```typescript
- * const latitudeSchema = new OasNumber({
- *   title: 'Latitude',
- *   description: 'Geographic latitude coordinate',
- *   format: 'double',
- *   minimum: -90,
- *   maximum: 90,
- *   example: 40.7128
- * });
- *
- * const longitudeSchema = new OasNumber({
- *   title: 'Longitude',
- *   description: 'Geographic longitude coordinate',
- *   format: 'double',
- *   minimum: -180,
- *   maximum: 180,
- *   example: -74.0060
- * });
- *
- * // Used for location data
- * ```
- *
- * @example Probability and statistics
- * ```typescript
- * const probabilitySchema = new OasNumber({
- *   title: 'Probability',
- *   description: 'Statistical probability value',
- *   minimum: 0,
- *   maximum: 1,
- *   exclusiveMaximum: false, // Can be exactly 1
- *   example: 0.75,
- *   default: 0.5
- * });
- *
- * const confidenceSchema = new OasNumber({
- *   title: 'Confidence Level',
- *   description: 'Statistical confidence level as percentage',
- *   minimum: 0,
- *   maximum: 100,
- *   enums: [90, 95, 99], // Common confidence levels
- *   example: 95
- * });
- * ```
- */
 class OasNumber {
     constructor(fields = {}) {
         /**
@@ -301,6 +137,33 @@ class OasNumber {
             writable: true,
             value: void 0
         });
+        /**
+         * Whether the number is read-only.
+         */
+        Object.defineProperty(this, "readOnly", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /**
+         * Whether the number is write-only.
+         */
+        Object.defineProperty(this, "writeOnly", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /**
+         * Whether the number is deprecated.
+         */
+        Object.defineProperty(this, "deprecated", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         this.title = fields.title;
         this.description = fields.description;
         this.nullable = fields.nullable;
@@ -314,6 +177,9 @@ class OasNumber {
         this.exclusiveMaximum = fields.exclusiveMaximum;
         this.minimum = fields.minimum;
         this.exclusiveMinimum = fields.exclusiveMinimum;
+        this.readOnly = fields.readOnly;
+        this.writeOnly = fields.writeOnly;
+        this.deprecated = fields.deprecated;
     }
     isRef() {
         return false;
@@ -338,7 +204,9 @@ class OasNumber {
             maximum: this.maximum,
             exclusiveMaximum: this.exclusiveMaximum,
             minimum: this.minimum,
-            exclusiveMinimum: this.exclusiveMinimum
+            exclusiveMinimum: this.exclusiveMinimum,
+            readOnly: this.readOnly,
+            writeOnly: this.writeOnly
         };
     }
 }

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

@@ -5,14 +5,31 @@ import * as v from 'valibot';
  * Defines the precision formats for number types: float for single-precision
  * and double for double-precision floating-point numbers.
  */
-export declare const numberFormat: v.GenericSchema<'float' | 'double'>;
+export declare const numberFormat: v.UnionSchema<[v.LiteralSchema<"float", undefined>, v.LiteralSchema<"double", undefined>], undefined>;
 /**
  * Valibot schema for validating OpenAPI number data objects.
  *
  * Validates number schemas including precision formats, range constraints,
  * multiple validation, and enumeration values.
  */
-export declare const oasNumberData: v.GenericSchema<OasNumberData>;
+export declare const oasNumberData: v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"number", undefined>;
+    readonly title: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly default: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+    readonly format: v.OptionalSchema<v.UnionSchema<[v.LiteralSchema<"float", undefined>, v.LiteralSchema<"double", undefined>], undefined>, undefined>;
+    readonly enum: v.OptionalSchema<v.ArraySchema<v.NumberSchema<undefined>, undefined>, undefined>;
+    readonly nullable: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+    readonly example: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+    readonly multipleOf: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+    readonly maximum: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+    readonly exclusiveMaximum: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+    readonly minimum: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+    readonly exclusiveMinimum: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+    readonly readOnly: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+    readonly writeOnly: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+    readonly deprecated: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+}, undefined>;
 export type OasNumberData = {
     type: 'number';
     title?: string;
@@ -27,5 +44,8 @@ export type OasNumberData = {
     exclusiveMaximum?: boolean;
     minimum?: number;
     exclusiveMinimum?: boolean;
+    readOnly?: boolean;
+    writeOnly?: boolean;
+    deprecated?: boolean;
 };
 //# sourceMappingURL=number-types.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"number-types.d.ts","sourceRoot":"","sources":["../../../src/oas/number/number-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B;;;;;GAKG;AACH,eAAO,MAAM,YAAY,EAAE,CAAC,CAAC,aAAa,CAAC,OAAO,GAAG,QAAQ,CAAsD,CAAA;AAEnH;;;;;GAKG;AACH,eAAO,MAAM,aAAa,EAAE,CAAC,CAAC,aAAa,CAAC,aAAa,CAcvD,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,CAAA;IAChB,MAAM,CAAC,EAAE,OAAO,GAAG,QAAQ,CAAA;IAC3B,IAAI,CAAC,EAAE,MAAM,EAAE,CAAA;IACf,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,gBAAgB,CAAC,EAAE,OAAO,CAAA;IAC1B,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,gBAAgB,CAAC,EAAE,OAAO,CAAA;CAC3B,CAAA"}
+{"version":3,"file":"number-types.d.ts","sourceRoot":"","sources":["../../../src/oas/number/number-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAC5B;;;;;GAKG;AACH,eAAO,MAAM,YAAY,uGAAqD,CAAA;AAE9E;;;;;GAKG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;aAiBxB,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,CAAA;IAChB,MAAM,CAAC,EAAE,OAAO,GAAG,QAAQ,CAAA;IAC3B,IAAI,CAAC,EAAE,MAAM,EAAE,CAAA;IACf,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,gBAAgB,CAAC,EAAE,OAAO,CAAA;IAC1B,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,gBAAgB,CAAC,EAAE,OAAO,CAAA;IAC1B,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,UAAU,CAAC,EAAE,OAAO,CAAA;CACrB,CAAA"}

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

@@ -61,5 +61,8 @@ exports.oasNumberData = v.object({
     maximum: v.optional(v.number()),
     exclusiveMaximum: v.optional(v.boolean()),
     minimum: v.optional(v.number()),
-    exclusiveMinimum: v.optional(v.boolean())
+    exclusiveMinimum: v.optional(v.boolean()),
+    readOnly: v.optional(v.boolean()),
+    writeOnly: v.optional(v.boolean()),
+    deprecated: v.optional(v.boolean())
 });