@skmtc/core 0.0.924 → 0.0.929

package/script/oas/array/Array.js

@@ -1,108 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OasArray = void 0;
-require("../../_dnt.polyfills.js");
-/**
- * Represents an array schema in the OpenAPI Specification.
- *
- * `OasArray` handles array type definitions with comprehensive validation
- * constraints including item count limits, uniqueness requirements, and
- * item type specifications. It supports nested schemas and references
- * for complex array structures.
- *
- * This class is used throughout the OAS processing pipeline to represent
- * array fields in API schemas, including lists of objects, primitive arrays,
- * and complex nested array structures.
- *
- * ## Key Features
- *
- * - **Item Type Definition**: Support for any schema type as array items
- * - **Size Constraints**: Minimum and maximum item count validation
- * - **Uniqueness Validation**: Ensure array items are unique (like Set behavior)
- * - **Nested Schemas**: Support for complex nested array structures
- * - **Reference Handling**: Seamless integration with schema references
- * - **Nullable Support**: Type-safe nullable array handling
- * - **JSON Schema**: Conversion to standard JSON Schema format
- *
- * @template Nullable - Whether the array value can be null
- *
- * @example String array
- * ```typescript
- * import { OasArray, OasString } from '@skmtc/core';
- *
- * const tagsArray = new OasArray({
- *   title: 'Tags',
- *   description: 'List of tags associated with the item',
- *   items: new OasString({ minLength: 1 }),
- *   minItems: 1,
- *   uniqueItems: true,
- *   example: ['javascript', 'typescript', 'react']
- * });
- * ```
- *
- * @example Object array with references
- * ```typescript
- * import { OasArray, OasRef } from '@skmtc/core';
- *
- * const usersArray = new OasArray({
- *   title: 'Users',
- *   description: 'List of user objects',
- *   items: new OasRef({ refName: 'User' }),
- *   maxItems: 100,
- *   example: [
- *     { id: 1, name: 'John' },
- *     { id: 2, name: 'Jane' }
- *   ]
- * });
- * ```
- *
- * @example Nested array (array of arrays)
- * ```typescript
- * const matrixArray = new OasArray({
- *   title: 'Matrix',
- *   description: '2D array of numbers',
- *   items: new OasArray({
- *     items: new OasInteger({ minimum: 0 })
- *   }),
- *   example: [
- *     [1, 2, 3],
- *     [4, 5, 6],
- *     [7, 8, 9]
- *   ]
- * });
- * ```
- *
- * @example Nullable array with constraints
- * ```typescript
- * const optionalIdsArray = new OasArray<true>({
- *   title: 'Optional IDs',
- *   description: 'Optional list of IDs',
- *   items: new OasInteger({ format: 'int64', minimum: 1 }),
- *   nullable: true,
- *   minItems: 0,
- *   maxItems: 10,
- *   defaultValue: null
- * });
- * ```
- *
- * @example Unique items validation
- * ```typescript
- * const uniqueEmailsArray = new OasArray({
- *   title: 'Email Recipients',
- *   description: 'List of unique email addresses',
- *   items: new OasString({ format: 'email' }),
- *   uniqueItems: true, // Ensures no duplicate emails
- *   minItems: 1,
- *   example: ['user1@example.com', 'user2@example.com']
- * });
- * ```
- */
 class OasArray {
-    /**
-     * Creates a new OasArray instance.
-     *
-     * @param fields - Array configuration fields including items schema, validation constraints, and metadata
-     */
     constructor(fields) {
         /**
          * Object is part the 'schema' set which is used
@@ -220,6 +119,38 @@ class OasArray {
             writable: true,
             value: void 0
         });
+        /**
+         * Creates a new OasArray instance.
+         *
+         * @param fields - Array configuration fields including items schema, validation constraints, and metadata
+         */
+        /**
+         * Whether the array is read-only.
+         */
+        Object.defineProperty(this, "readOnly", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /**
+         * Whether the array is write-only.
+         */
+        Object.defineProperty(this, "writeOnly", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /**
+         * Whether the array is deprecated.
+         */
+        Object.defineProperty(this, "deprecated", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         this.items = fields.items;
         this.title = fields.title;
         this.description = fields.description;
@@ -231,6 +162,9 @@ class OasArray {
         this.minItems = fields.minItems;
         this.enums = fields.enums;
         this.defaultValue = fields.defaultValue;
+        this.readOnly = fields.readOnly;
+        this.writeOnly = fields.writeOnly;
+        this.deprecated = fields.deprecated;
     }
     /**
      * Determines if this array is a reference object.
@@ -274,7 +208,9 @@ class OasArray {
             maxItems: this.maxItems,
             minItems: this.minItems,
             uniqueItems: this.uniqueItems,
-            default: this.defaultValue
+            default: this.defaultValue,
+            readOnly: this.readOnly,
+            writeOnly: this.writeOnly
         };
     }
 }

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

@@ -1,69 +1,4 @@
 import * as v from 'valibot';
-import { type OasSchemaData } from '../schema/schema-types.js';
-import { type OasSchemaRefData } from '../ref/ref-types.js';
-/**
- * Valibot schema for validating OpenAPI array data objects.
- *
- * This comprehensive schema validates OpenAPI array schemas according to the OpenAPI v3
- * specification, including item type definitions, length constraints, uniqueness requirements,
- * and enumeration values. It uses lazy evaluation to handle recursive schema references,
- * allowing for complex nested array structures and self-referential schemas.
- *
- * The schema supports both direct schema definitions and reference objects for the items
- * property, enabling flexible array type definitions that can reference other schemas
- * in the document or define inline item types.
- *
- * @example Validating a simple array schema
- * ```typescript
- * import { oasArrayData } from '@skmtc/core/oas/array';
- * import * as v from 'valibot';
- *
- * const schema = {
- *   type: 'array',
- *   items: {
- *     type: 'string'
- *   },
- *   description: 'List of user names',
- *   minItems: 1,
- *   maxItems: 100
- * };
- *
- * const validated = v.parse(oasArrayData, schema);
- * console.log(validated.minItems); // 1
- * ```
- *
- * @example Validating array with reference items
- * ```typescript
- * const refArraySchema = {
- *   type: 'array',
- *   items: {
- *     $ref: '#/components/schemas/User'
- *   },
- *   title: 'User List',
- *   uniqueItems: true,
- *   default: []
- * };
- *
- * const result = v.parse(oasArrayData, refArraySchema);
- * console.log(result.uniqueItems); // true
- * ```
- *
- * @example Validating constrained arrays
- * ```typescript
- * const constrainedArray = {
- *   type: 'array',
- *   items: { type: 'number' },
- *   minItems: 2,
- *   maxItems: 10,
- *   uniqueItems: true,
- *   enums: [[1, 2, 3], [4, 5, 6]]
- * };
- *
- * const validated = v.parse(oasArrayData, constrainedArray);
- * console.log(validated.maxItems); // 10
- * ```
- */
-export declare const oasArrayData: v.GenericSchema<OasArrayData>;
 /**
  * Valibot schema for array data without the items property.
  *
@@ -108,115 +43,6 @@ export declare const oasArrayData: v.GenericSchema<OasArrayData>;
  * ```
  */
 export declare const oasArrayDataWithoutItems: v.GenericSchema<OasArrayDataWithoutItems>;
-/**
- * Data type for OpenAPI array schema objects.
- *
- * Represents the complete structure of OpenAPI array schemas as processed by the SKMTC
- * pipeline. This type includes all standard OpenAPI array schema properties including
- * item type specifications, length constraints, uniqueness requirements, and metadata
- * fields. It's used throughout the array processing pipeline for type-safe handling
- * of array schema definitions.
- *
- * ## Usage in SKMTC Pipeline
- *
- * This type is used by:
- * - Schema parsers to validate incoming array schema data
- * - Array processors to transform OpenAPI schemas into OAS objects
- * - Code generators to access array constraints and generate validation code
- * - Type generators to create appropriate array type definitions
- *
- * @example Basic string array schema
- * ```typescript
- * import type { OasArrayData } from '@skmtc/core/oas/array';
- *
- * const tagListSchema: OasArrayData = {
- *   type: 'array',
- *   items: {
- *     type: 'string',
- *     minLength: 1,
- *     maxLength: 50
- *   },
- *   title: 'Tag List',
- *   description: 'Collection of tags for categorization',
- *   minItems: 0,
- *   maxItems: 20,
- *   uniqueItems: true,
- *   default: []
- * };
- * ```
- *
- * @example Array of referenced objects
- * ```typescript
- * const userListSchema: OasArrayData = {
- *   type: 'array',
- *   items: {
- *     $ref: '#/components/schemas/User'
- *   },
- *   title: 'User Collection',
- *   description: 'List of user objects',
- *   minItems: 1,
- *   default: []
- * };
- * ```
- *
- * @example Complex nested array schema
- * ```typescript
- * const matrixSchema: OasArrayData = {
- *   type: 'array',
- *   items: {
- *     type: 'array',
- *     items: {
- *       type: 'number'
- *     },
- *     minItems: 3,
- *     maxItems: 3
- *   },
- *   title: '3x3 Matrix',
- *   description: 'Two-dimensional number array representing a 3x3 matrix',
- *   minItems: 3,
- *   maxItems: 3
- * };
- * ```
- *
- * @example Enum array with constraints
- * ```typescript
- * const statusListSchema: OasArrayData = {
- *   type: 'array',
- *   items: {
- *     type: 'string',
- *     enum: ['active', 'inactive', 'pending']
- *   },
- *   title: 'Status List',
- *   description: 'Multiple status values',
- *   uniqueItems: true,
- *   enums: [
- *     ['active'],
- *     ['active', 'pending'],
- *     ['inactive', 'pending']
- *   ]
- * };
- * ```
- */
-export type OasArrayData = {
-    /** Type identifier (always 'array') */
-    type: 'array';
-    /** Schema definition for array items (can be direct schema or reference) */
-    items: OasSchemaData | OasSchemaRefData;
-    /** Human-readable title for the array schema */
-    title?: string;
-    /** Detailed description explaining the array's purpose and contents */
-    description?: string;
-    /** Default value used when no explicit array is provided */
-    default?: unknown[];
-    /** Maximum number of items allowed in the array */
-    maxItems?: number;
-    /** Minimum number of items required in the array */
-    minItems?: number;
-    /** Whether all items in the array must be unique */
-    uniqueItems?: boolean;
-    /** Array of valid enumeration values for the entire array */
-    enums?: unknown[];
-};
 /**
  * Array schema data without the items property.
  *
@@ -279,5 +105,11 @@ export type OasArrayDataWithoutItems = {
     uniqueItems?: boolean;
     /** Array of valid enumeration values for the entire array */
     enums?: unknown[];
+    /** Whether the array is read-only */
+    readOnly?: boolean;
+    /** Whether the array is write-only */
+    writeOnly?: boolean;
+    /** Whether the array is deprecated */
+    deprecated?: boolean;
 };
 //# sourceMappingURL=array-types.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"array-types.d.ts","sourceRoot":"","sources":["../../../src/oas/array/array-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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6DG;AACH,eAAO,MAAM,YAAY,EAAE,CAAC,CAAC,aAAa,CAAC,YAAY,CAUrD,CAAA;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,eAAO,MAAM,wBAAwB,EAAE,CAAC,CAAC,aAAa,CAAC,wBAAwB,CAS7E,CAAA;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwFG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,uCAAuC;IACvC,IAAI,EAAE,OAAO,CAAA;IACb,4EAA4E;IAC5E,KAAK,EAAE,aAAa,GAAG,gBAAgB,CAAA;IACvC,gDAAgD;IAChD,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,uEAAuE;IACvE,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,4DAA4D;IAC5D,OAAO,CAAC,EAAE,OAAO,EAAE,CAAA;IACnB,mDAAmD;IACnD,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,oDAAoD;IACpD,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,oDAAoD;IACpD,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,6DAA6D;IAC7D,KAAK,CAAC,EAAE,OAAO,EAAE,CAAA;CAClB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,MAAM,MAAM,wBAAwB,GAAG;IACrC,uCAAuC;IACvC,IAAI,EAAE,OAAO,CAAA;IACb,gDAAgD;IAChD,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,uEAAuE;IACvE,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,4DAA4D;IAC5D,OAAO,CAAC,EAAE,OAAO,EAAE,CAAA;IACnB,mDAAmD;IACnD,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,oDAAoD;IACpD,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,oDAAoD;IACpD,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,6DAA6D;IAC7D,KAAK,CAAC,EAAE,OAAO,EAAE,CAAA;CAClB,CAAA"}
+{"version":3,"file":"array-types.d.ts","sourceRoot":"","sources":["../../../src/oas/array/array-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,eAAO,MAAM,wBAAwB,EAAE,CAAC,CAAC,aAAa,CAAC,wBAAwB,CAY7E,CAAA;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,MAAM,MAAM,wBAAwB,GAAG;IACrC,uCAAuC;IACvC,IAAI,EAAE,OAAO,CAAA;IACb,gDAAgD;IAChD,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,uEAAuE;IACvE,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,4DAA4D;IAC5D,OAAO,CAAC,EAAE,OAAO,EAAE,CAAA;IACnB,mDAAmD;IACnD,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,oDAAoD;IACpD,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,oDAAoD;IACpD,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,6DAA6D;IAC7D,KAAK,CAAC,EAAE,OAAO,EAAE,CAAA;IACjB,qCAAqC;IACrC,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,sCAAsC;IACtC,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,sCAAsC;IACtC,UAAU,CAAC,EAAE,OAAO,CAAA;CACrB,CAAA"}

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

@@ -33,83 +33,8 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.oasArrayDataWithoutItems = exports.oasArrayData = void 0;
+exports.oasArrayDataWithoutItems = void 0;
 const v = __importStar(require("valibot"));
-const schema_types_js_1 = require("../schema/schema-types.js");
-const ref_types_js_1 = require("../ref/ref-types.js");
-/**
- * Valibot schema for validating OpenAPI array data objects.
- *
- * This comprehensive schema validates OpenAPI array schemas according to the OpenAPI v3
- * specification, including item type definitions, length constraints, uniqueness requirements,
- * and enumeration values. It uses lazy evaluation to handle recursive schema references,
- * allowing for complex nested array structures and self-referential schemas.
- *
- * The schema supports both direct schema definitions and reference objects for the items
- * property, enabling flexible array type definitions that can reference other schemas
- * in the document or define inline item types.
- *
- * @example Validating a simple array schema
- * ```typescript
- * import { oasArrayData } from '@skmtc/core/oas/array';
- * import * as v from 'valibot';
- *
- * const schema = {
- *   type: 'array',
- *   items: {
- *     type: 'string'
- *   },
- *   description: 'List of user names',
- *   minItems: 1,
- *   maxItems: 100
- * };
- *
- * const validated = v.parse(oasArrayData, schema);
- * console.log(validated.minItems); // 1
- * ```
- *
- * @example Validating array with reference items
- * ```typescript
- * const refArraySchema = {
- *   type: 'array',
- *   items: {
- *     $ref: '#/components/schemas/User'
- *   },
- *   title: 'User List',
- *   uniqueItems: true,
- *   default: []
- * };
- *
- * const result = v.parse(oasArrayData, refArraySchema);
- * console.log(result.uniqueItems); // true
- * ```
- *
- * @example Validating constrained arrays
- * ```typescript
- * const constrainedArray = {
- *   type: 'array',
- *   items: { type: 'number' },
- *   minItems: 2,
- *   maxItems: 10,
- *   uniqueItems: true,
- *   enums: [[1, 2, 3], [4, 5, 6]]
- * };
- *
- * const validated = v.parse(oasArrayData, constrainedArray);
- * console.log(validated.maxItems); // 10
- * ```
- */
-exports.oasArrayData = v.object({
-    type: v.literal('array'),
-    items: v.lazy(() => v.union([v.lazy(() => schema_types_js_1.oasSchemaData), ref_types_js_1.oasSchemaRefData])),
-    title: v.optional(v.string()),
-    description: v.optional(v.string()),
-    default: v.optional(v.array(v.unknown())),
-    maxItems: v.optional(v.number()),
-    minItems: v.optional(v.number()),
-    uniqueItems: v.optional(v.boolean()),
-    enums: v.optional(v.array(v.unknown()))
-});
 /**
  * Valibot schema for array data without the items property.
  *
@@ -161,5 +86,8 @@ exports.oasArrayDataWithoutItems = v.object({
     maxItems: v.optional(v.number()),
     minItems: v.optional(v.number()),
     uniqueItems: v.optional(v.boolean()),
-    enums: v.optional(v.array(v.unknown()))
+    enums: v.optional(v.array(v.unknown())),
+    readOnly: v.optional(v.boolean()),
+    writeOnly: v.optional(v.boolean()),
+    deprecated: v.optional(v.boolean())
 });

package/script/oas/array/toArray.d.ts

@@ -73,58 +73,6 @@ type ToParsedArrayArgs<Nullable extends boolean | undefined> = {
     enums: Nullable extends true ? (unknown[] | null)[] | undefined : unknown[] | undefined;
     defaultValue: Nullable extends true ? unknown[] | null | undefined : unknown[] | undefined;
 };
-/**
- * Creates an OAS array instance from pre-parsed array schema components.
- *
- * This function is the final step in the array transformation pipeline, taking
- * already-parsed nullable, example, enum, and default values and combining them
- * with the remaining array properties to create the complete OasArray instance.
- *
- * The function handles type-safe nullable parsing, items schema resolution,
- * and specification extension processing. It uses Valibot for schema validation
- * and maintains proper type relationships between nullable flags and value types.
- *
- * @template Nullable - Boolean type indicating if the array can be null
- * @param args - Pre-parsed array components
- * @param args.value - OpenAPI array object without parsed fields
- * @param args.context - Parse context for tracing and utilities
- * @param args.nullable - Parsed nullable flag
- * @param args.example - Parsed example value (type-safe with nullable)
- * @param args.enums - Parsed enumeration constraints (type-safe with nullable)
- * @param args.defaultValue - Parsed default value (type-safe with nullable)
- * @returns Complete OAS array instance with all properties
- *
- * @example Type-safe nullable array
- * ```typescript
- * const nullableArray = toParsedArray({
- *   context: parseContext,
- *   nullable: true,
- *   example: [1, 2, 3], // Can be null due to nullable: true
- *   enums: [[1], [2], null], // Null allowed in enums
- *   defaultValue: null,
- *   value: {
- *     type: 'array',
- *     items: { type: 'number' },
- *     maxItems: 5
- *   }
- * });
- * ```
- *
- * @example Non-nullable array
- * ```typescript
- * const regularArray = toParsedArray({
- *   context: parseContext,
- *   nullable: false,
- *   example: ['a', 'b'], // Cannot be null
- *   enums: [['x'], ['y']], // No null values allowed
- *   defaultValue: [],
- *   value: {
- *     type: 'array',
- *     items: { type: 'string' }
- *   }
- * });
- * ```
- */
 export declare const toParsedArray: <Nullable extends boolean | undefined>({ context, nullable, example, enums, defaultValue, value }: ToParsedArrayArgs<Nullable>) => OasArray<Nullable>;
 export {};
 //# sourceMappingURL=toArray.d.ts.map

package/script/oas/array/toArray.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"toArray.d.ts","sourceRoot":"","sources":["../../../src/oas/array/toArray.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAC9C,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAErC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAA;AAQjE,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,SAAS,CAAC,iBAAiB,CAAA;IAClC,OAAO,EAAE,YAAY,CAAA;CACtB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AACH,eAAO,MAAM,OAAO,GAAI,oBAAoB,WAAW,KAAG,QAmCzD,CAAA;AAED,KAAK,iBAAiB,CAAC,QAAQ,SAAS,OAAO,GAAG,SAAS,IAAI;IAC7D,KAAK,EAAE,IAAI,CAAC,SAAS,CAAC,iBAAiB,EAAE,UAAU,GAAG,SAAS,GAAG,OAAO,GAAG,SAAS,CAAC,CAAA;IACtF,OAAO,EAAE,YAAY,CAAA;IACrB,QAAQ,EAAE,QAAQ,CAAA;IAClB,OAAO,EAAE,QAAQ,SAAS,IAAI,GAAG,OAAO,EAAE,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,EAAE,GAAG,SAAS,CAAA;IACrF,KAAK,EAAE,QAAQ,SAAS,IAAI,GAAG,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC,EAAE,GAAG,SAAS,GAAG,OAAO,EAAE,GAAG,SAAS,CAAA;IACvF,YAAY,EAAE,QAAQ,SAAS,IAAI,GAAG,OAAO,EAAE,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,EAAE,GAAG,SAAS,CAAA;CAC3F,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH,eAAO,MAAM,aAAa,GAAI,QAAQ,SAAS,OAAO,GAAG,SAAS,EAAE,4DAOjE,iBAAiB,CAAC,QAAQ,CAAC,KAAG,QAAQ,CAAC,QAAQ,CAyCjD,CAAA"}
+{"version":3,"file":"toArray.d.ts","sourceRoot":"","sources":["../../../src/oas/array/toArray.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAC9C,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAErC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAA;AAOjE,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,SAAS,CAAC,iBAAiB,CAAA;IAClC,OAAO,EAAE,YAAY,CAAA;CACtB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AACH,eAAO,MAAM,OAAO,GAAI,oBAAoB,WAAW,KAAG,QA8CzD,CAAA;AAED,KAAK,iBAAiB,CAAC,QAAQ,SAAS,OAAO,GAAG,SAAS,IAAI;IAC7D,KAAK,EAAE,IAAI,CAAC,SAAS,CAAC,iBAAiB,EAAE,UAAU,GAAG,SAAS,GAAG,OAAO,GAAG,SAAS,CAAC,CAAA;IACtF,OAAO,EAAE,YAAY,CAAA;IACrB,QAAQ,EAAE,QAAQ,CAAA;IAClB,OAAO,EAAE,QAAQ,SAAS,IAAI,GAAG,OAAO,EAAE,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,EAAE,GAAG,SAAS,CAAA;IACrF,KAAK,EAAE,QAAQ,SAAS,IAAI,GAAG,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC,EAAE,GAAG,SAAS,GAAG,OAAO,EAAE,GAAG,SAAS,CAAA;IACvF,YAAY,EAAE,QAAQ,SAAS,IAAI,GAAG,OAAO,EAAE,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,EAAE,GAAG,SAAS,CAAA;CAC3F,CAAA;AAED,eAAO,MAAM,aAAa,GAAI,QAAQ,SAAS,OAAO,GAAG,SAAS,EAAE,4DAOjE,iBAAiB,CAAC,QAAQ,CAAC,KAAG,QAAQ,CAAC,QAAQ,CAkDjD,CAAA"}