@skmtc/core 0.0.808 → 0.0.809

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

@@ -1,9 +1,185 @@
 import * as v from 'valibot';
+/**
+ * Data type for OpenAPI contact information objects.
+ *
+ * This type represents contact information as specified in the OpenAPI v3 specification's
+ * Info Object. Contact information provides details about the person or organization
+ * responsible for the API, including optional name, website URL, and email address.
+ *
+ * The contact information is typically displayed in API documentation and used by
+ * developers to reach out for support, questions, or feedback about the API.
+ *
+ * ## Usage in SKMTC Pipeline
+ *
+ * This type is used by:
+ * - Info processors to validate and structure contact information
+ * - Documentation generators to display API maintainer information
+ * - Client generators to embed support contact details in generated code
+ * - Validation systems to ensure contact information completeness
+ *
+ * @example Basic contact information
+ * ```typescript
+ * import type { OasContactData } from '@skmtc/core/oas/contact';
+ *
+ * const apiContact: OasContactData = {
+ *   oasType: 'contact',
+ *   name: 'API Support Team',
+ *   url: 'https://company.com/support',
+ *   email: 'api-support@company.com'
+ * };
+ * ```
+ *
+ * @example Minimal contact with only email
+ * ```typescript
+ * const minimalContact: OasContactData = {
+ *   oasType: 'contact',
+ *   email: 'support@api-company.com'
+ * };
+ * ```
+ *
+ * @example Contact with name and URL
+ * ```typescript
+ * const teamContact: OasContactData = {
+ *   oasType: 'contact',
+ *   name: 'Development Team',
+ *   url: 'https://github.com/company/api-repo'
+ * };
+ * ```
+ *
+ * @example Integration in OpenAPI Info object
+ * ```typescript
+ * const apiInfo = {
+ *   title: 'My API',
+ *   version: '1.0.0',
+ *   description: 'A comprehensive API for managing resources',
+ *   contact: {
+ *     oasType: 'contact',
+ *     name: 'Jane Doe',
+ *     url: 'https://janedoe.dev',
+ *     email: 'jane@company.com'
+ *   }
+ * };
+ * ```
+ *
+ * @example Empty contact (valid but not recommended)
+ * ```typescript
+ * const emptyContact: OasContactData = {
+ *   oasType: 'contact'
+ *   // All fields are optional, but at least one should be provided
+ * };
+ * ```
+ */
 export type OasContactData = {
+    /** Type identifier for SKMTC internal processing */
     oasType: 'contact';
+    /** The identifying name of the contact person or organization */
     name?: string;
+    /** The URL pointing to the contact information (website, GitHub, etc.) */
     url?: string;
+    /** The email address of the contact person or organization */
     email?: string;
 };
+/**
+ * Valibot schema for validating OpenAPI contact data objects.
+ *
+ * This schema validates OpenAPI contact information according to the OpenAPI v3
+ * specification. All contact fields are optional, allowing for flexible contact
+ * information configurations. The schema ensures proper string formatting for
+ * name, URL, and email fields while maintaining the required `oasType` identifier.
+ *
+ * Note that while all fields are optional according to the OpenAPI specification,
+ * it's recommended to provide at least one contact method for practical API usage.
+ *
+ * @example Validating complete contact information
+ * ```typescript
+ * import { oasContactData } from '@skmtc/core/oas/contact';
+ * import * as v from 'valibot';
+ *
+ * const contact = {
+ *   oasType: 'contact',
+ *   name: 'API Support',
+ *   url: 'https://api.company.com/support',
+ *   email: 'support@company.com'
+ * };
+ *
+ * const validated = v.parse(oasContactData, contact);
+ * console.log(validated.name); // 'API Support'
+ * console.log(validated.email); // 'support@company.com'
+ * ```
+ *
+ * @example Validating partial contact information
+ * ```typescript
+ * const partialContact = {
+ *   oasType: 'contact',
+ *   email: 'help@api.com'
+ *   // name and url are optional and omitted
+ * };
+ *
+ * const result = v.parse(oasContactData, partialContact);
+ * console.log(result.email); // 'help@api.com'
+ * console.log(result.name); // undefined
+ * console.log(result.url); // undefined
+ * ```
+ *
+ * @example Validation error handling
+ * ```typescript
+ * const invalidContact = {
+ *   oasType: 'contact',
+ *   name: 123, // Invalid: should be string
+ *   email: 'valid@email.com'
+ * };
+ *
+ * try {
+ *   v.parse(oasContactData, invalidContact);
+ * } catch (error) {
+ *   console.error('Contact validation failed:', error.message);
+ *   // Handle validation errors appropriately
+ * }
+ * ```
+ *
+ * @example Usage in OpenAPI document processing
+ * ```typescript
+ * function processApiInfo(infoObject: unknown) {
+ *   // Validate the info object structure
+ *   const info = parseInfoObject(infoObject);
+ *
+ *   // If contact information exists, validate it
+ *   if (info.contact) {
+ *     const validatedContact = v.parse(oasContactData, {
+ *       oasType: 'contact',
+ *       ...info.contact
+ *     });
+ *
+ *     console.log(`API maintained by: ${validatedContact.name || 'Unknown'}`);
+ *     console.log(`Support: ${validatedContact.email || 'No email provided'}`);
+ *   }
+ * }
+ * ```
+ *
+ * @example Integration with documentation generators
+ * ```typescript
+ * class DocumentationGenerator {
+ *   generateContactSection(contactData: OasContactData): string {
+ *     const validated = v.parse(oasContactData, contactData);
+ *
+ *     let contactSection = '## Contact Information\n\n';
+ *
+ *     if (validated.name) {
+ *       contactSection += `**Maintainer:** ${validated.name}\n\n`;
+ *     }
+ *
+ *     if (validated.email) {
+ *       contactSection += `**Email:** [${validated.email}](mailto:${validated.email})\n\n`;
+ *     }
+ *
+ *     if (validated.url) {
+ *       contactSection += `**Website:** [${validated.url}](${validated.url})\n\n`;
+ *     }
+ *
+ *     return contactSection;
+ *   }
+ * }
+ * ```
+ */
 export declare const oasContactData: v.GenericSchema<OasContactData>;
 //# sourceMappingURL=contact-types.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"contact-types.d.ts","sourceRoot":"","sources":["../../../src/oas/contact/contact-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B,MAAM,MAAM,cAAc,GAAG;IAC3B,OAAO,EAAE,SAAS,CAAA;IAClB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,KAAK,CAAC,EAAE,MAAM,CAAA;CACf,CAAA;AAED,eAAO,MAAM,cAAc,EAAE,CAAC,CAAC,aAAa,CAAC,cAAc,CAKzD,CAAA"}
+{"version":3,"file":"contact-types.d.ts","sourceRoot":"","sources":["../../../src/oas/contact/contact-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqEG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B,oDAAoD;IACpD,OAAO,EAAE,SAAS,CAAA;IAClB,iEAAiE;IACjE,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,0EAA0E;IAC1E,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,8DAA8D;IAC9D,KAAK,CAAC,EAAE,MAAM,CAAA;CACf,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqGG;AACH,eAAO,MAAM,cAAc,EAAE,CAAC,CAAC,aAAa,CAAC,cAAc,CAKzD,CAAA"}

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

@@ -35,6 +35,108 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.oasContactData = void 0;
 const v = __importStar(require("valibot"));
+/**
+ * Valibot schema for validating OpenAPI contact data objects.
+ *
+ * This schema validates OpenAPI contact information according to the OpenAPI v3
+ * specification. All contact fields are optional, allowing for flexible contact
+ * information configurations. The schema ensures proper string formatting for
+ * name, URL, and email fields while maintaining the required `oasType` identifier.
+ *
+ * Note that while all fields are optional according to the OpenAPI specification,
+ * it's recommended to provide at least one contact method for practical API usage.
+ *
+ * @example Validating complete contact information
+ * ```typescript
+ * import { oasContactData } from '@skmtc/core/oas/contact';
+ * import * as v from 'valibot';
+ *
+ * const contact = {
+ *   oasType: 'contact',
+ *   name: 'API Support',
+ *   url: 'https://api.company.com/support',
+ *   email: 'support@company.com'
+ * };
+ *
+ * const validated = v.parse(oasContactData, contact);
+ * console.log(validated.name); // 'API Support'
+ * console.log(validated.email); // 'support@company.com'
+ * ```
+ *
+ * @example Validating partial contact information
+ * ```typescript
+ * const partialContact = {
+ *   oasType: 'contact',
+ *   email: 'help@api.com'
+ *   // name and url are optional and omitted
+ * };
+ *
+ * const result = v.parse(oasContactData, partialContact);
+ * console.log(result.email); // 'help@api.com'
+ * console.log(result.name); // undefined
+ * console.log(result.url); // undefined
+ * ```
+ *
+ * @example Validation error handling
+ * ```typescript
+ * const invalidContact = {
+ *   oasType: 'contact',
+ *   name: 123, // Invalid: should be string
+ *   email: 'valid@email.com'
+ * };
+ *
+ * try {
+ *   v.parse(oasContactData, invalidContact);
+ * } catch (error) {
+ *   console.error('Contact validation failed:', error.message);
+ *   // Handle validation errors appropriately
+ * }
+ * ```
+ *
+ * @example Usage in OpenAPI document processing
+ * ```typescript
+ * function processApiInfo(infoObject: unknown) {
+ *   // Validate the info object structure
+ *   const info = parseInfoObject(infoObject);
+ *
+ *   // If contact information exists, validate it
+ *   if (info.contact) {
+ *     const validatedContact = v.parse(oasContactData, {
+ *       oasType: 'contact',
+ *       ...info.contact
+ *     });
+ *
+ *     console.log(`API maintained by: ${validatedContact.name || 'Unknown'}`);
+ *     console.log(`Support: ${validatedContact.email || 'No email provided'}`);
+ *   }
+ * }
+ * ```
+ *
+ * @example Integration with documentation generators
+ * ```typescript
+ * class DocumentationGenerator {
+ *   generateContactSection(contactData: OasContactData): string {
+ *     const validated = v.parse(oasContactData, contactData);
+ *
+ *     let contactSection = '## Contact Information\n\n';
+ *
+ *     if (validated.name) {
+ *       contactSection += `**Maintainer:** ${validated.name}\n\n`;
+ *     }
+ *
+ *     if (validated.email) {
+ *       contactSection += `**Email:** [${validated.email}](mailto:${validated.email})\n\n`;
+ *     }
+ *
+ *     if (validated.url) {
+ *       contactSection += `**Website:** [${validated.url}](${validated.url})\n\n`;
+ *     }
+ *
+ *     return contactSection;
+ *   }
+ * }
+ * ```
+ */
 exports.oasContactData = v.object({
     oasType: v.literal('contact'),
     name: v.optional(v.string()),

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

@@ -1,21 +1,309 @@
 import type { OpenAPIV3 } from 'openapi-types';
 import type { ParseContext } from '../../context/ParseContext.js';
 import { OasMediaType } from './MediaType.js';
+/**
+ * Arguments for transforming an OpenAPI v3 media type item into an OAS media type.
+ */
 type ToMediaTypeItemV3Args = {
+    /** The OpenAPI v3 media type object to transform */
     mediaTypeItem: OpenAPIV3.MediaTypeObject;
+    /** The media type string (e.g., 'application/json', 'text/plain') */
     mediaType: string;
+    /** The parsing context for tracing and processing */
     context: ParseContext;
 };
+/**
+ * Transforms an OpenAPI v3 media type object into an internal OAS media type representation.
+ *
+ * This function processes OpenAPI v3 MediaType objects, extracting schema definitions,
+ * examples, encoding information, and specification extensions. It creates a structured
+ * internal representation that can be used by the SKMTC pipeline for code generation
+ * and validation.
+ *
+ * The transformation handles all standard OpenAPI v3 MediaType properties including
+ * schema references, inline schemas, examples, encoding specifications, and custom
+ * extension fields that begin with 'x-'.
+ *
+ * @param args - Transformation arguments
+ * @param args.mediaTypeItem - The OpenAPI v3 media type object to process
+ * @param args.mediaType - The media type identifier (MIME type)
+ * @param args.context - Parsing context for tracing and error handling
+ * @returns Structured OAS media type object for internal processing
+ *
+ * @example Transforming JSON media type
+ * ```typescript
+ * import { toMediaTypeItemV3 } from '@skmtc/core/oas/mediaType';
+ *
+ * const jsonMediaType = {
+ *   schema: {
+ *     type: 'object',
+ *     properties: {
+ *       name: { type: 'string' },
+ *       email: { type: 'string', format: 'email' }
+ *     }
+ *   },
+ *   example: {
+ *     name: 'John Doe',
+ *     email: 'john@example.com'
+ *   }
+ * };
+ *
+ * const result = toMediaTypeItemV3({
+ *   mediaTypeItem: jsonMediaType,
+ *   mediaType: 'application/json',
+ *   context: parseContext
+ * });
+ *
+ * console.log(result.mediaType); // 'application/json'
+ * console.log(result.schema); // Processed schema object
+ * ```
+ *
+ * @example Processing form data with encoding
+ * ```typescript
+ * const formMediaType = {
+ *   schema: {
+ *     type: 'object',
+ *     properties: {
+ *       file: { type: 'string', format: 'binary' },
+ *       metadata: { type: 'string' }
+ *     }
+ *   },
+ *   encoding: {
+ *     file: {
+ *       contentType: 'image/png',
+ *       headers: {
+ *         'X-Rate-Limit': {
+ *           schema: { type: 'integer' }
+ *         }
+ *       }
+ *     }
+ *   }
+ * };
+ *
+ * const result = toMediaTypeItemV3({
+ *   mediaTypeItem: formMediaType,
+ *   mediaType: 'multipart/form-data',
+ *   context: parseContext
+ * });
+ *
+ * console.log(result.encoding); // Processed encoding configuration
+ * ```
+ *
+ * @example Handling multiple examples
+ * ```typescript
+ * const mediaTypeWithExamples = {
+ *   schema: { type: 'string' },
+ *   examples: {
+ *     success: {
+ *       summary: 'Successful response',
+ *       value: 'Operation completed'
+ *     },
+ *     error: {
+ *       summary: 'Error response',
+ *       value: 'Operation failed'
+ *     }
+ *   }
+ * };
+ *
+ * const result = toMediaTypeItemV3({
+ *   mediaTypeItem: mediaTypeWithExamples,
+ *   mediaType: 'text/plain',
+ *   context: parseContext
+ * });
+ *
+ * console.log(Object.keys(result.examples)); // ['success', 'error']
+ * ```
+ */
 export declare const toMediaTypeItemV3: ({ mediaTypeItem, mediaType, context }: ToMediaTypeItemV3Args) => OasMediaType;
+/**
+ * Arguments for transforming multiple OpenAPI v3 media type items.
+ */
 type ToMediaTypeItemsV3Args = {
+    /** Map of media type strings to OpenAPI v3 MediaType objects */
     content: Record<string, OpenAPIV3.MediaTypeObject>;
+    /** The parsing context for tracing and processing */
     context: ParseContext;
 };
+/**
+ * Transforms multiple OpenAPI v3 media type objects into internal OAS representations.
+ *
+ * This function processes a complete content map from OpenAPI v3, transforming each
+ * media type entry into its internal OAS representation. It's commonly used to process
+ * the `content` property of request bodies, responses, and parameters that support
+ * multiple media types.
+ *
+ * The function maintains the original media type keys while transforming the values
+ * into structured OAS media type objects. Each transformation is traced for debugging
+ * and error tracking purposes.
+ *
+ * @param args - Transformation arguments
+ * @param args.content - Map of media types to OpenAPI MediaType objects
+ * @param args.context - Parsing context for tracing and error handling
+ * @returns Map of media type strings to processed OAS media type objects
+ *
+ * @example Processing multiple content types
+ * ```typescript
+ * import { toMediaTypeItemsV3 } from '@skmtc/core/oas/mediaType';
+ *
+ * const content = {
+ *   'application/json': {
+ *     schema: {
+ *       type: 'object',
+ *       properties: { message: { type: 'string' } }
+ *     }
+ *   },
+ *   'application/xml': {
+ *     schema: {
+ *       type: 'string'
+ *     }
+ *   },
+ *   'text/plain': {
+ *     schema: {
+ *       type: 'string'
+ *     },
+ *     example: 'Plain text response'
+ *   }
+ * };
+ *
+ * const result = toMediaTypeItemsV3({
+ *   content,
+ *   context: parseContext
+ * });
+ *
+ * console.log(Object.keys(result)); // ['application/json', 'application/xml', 'text/plain']
+ * console.log(result['application/json'].mediaType); // 'application/json'
+ * ```
+ *
+ * @example Processing request body content types
+ * ```typescript
+ * const requestBodyContent = {
+ *   'application/json': {
+ *     schema: { $ref: '#/components/schemas/CreateUserRequest' }
+ *   },
+ *   'application/x-www-form-urlencoded': {
+ *     schema: {
+ *       type: 'object',
+ *       properties: {
+ *         name: { type: 'string' },
+ *         email: { type: 'string' }
+ *       }
+ *     },
+ *     encoding: {
+ *       email: {
+ *         style: 'form',
+ *         explode: false
+ *       }
+ *     }
+ *   }
+ * };
+ *
+ * const processed = toMediaTypeItemsV3({
+ *   content: requestBodyContent,
+ *   context: parseContext
+ * });
+ *
+ * // Each media type is processed with its specific configuration
+ * console.log(processed['application/json'].schema); // Reference object
+ * console.log(processed['application/x-www-form-urlencoded'].encoding); // Form encoding config
+ * ```
+ */
 export declare const toMediaTypeItemsV3: ({ content, context }: ToMediaTypeItemsV3Args) => Record<string, OasMediaType>;
+/**
+ * Arguments for optionally transforming OpenAPI v3 media type items.
+ */
 type ToOptionalMediaTypeItemsV3Args = {
+    /** Optional map of media type strings to OpenAPI v3 MediaType objects */
     content: Record<string, OpenAPIV3.MediaTypeObject> | undefined;
+    /** The parsing context for tracing and processing */
     context: ParseContext;
 };
+/**
+ * Optionally transforms OpenAPI v3 media type objects when content is provided.
+ *
+ * This function provides a safe way to process media type content that may or may not
+ * be present in the OpenAPI specification. It handles the common pattern where content
+ * properties are optional in OpenAPI objects (like responses without bodies or
+ * operations without request bodies).
+ *
+ * When content is undefined, the function returns undefined without processing.
+ * When content is provided, it delegates to `toMediaTypeItemsV3` for full processing.
+ *
+ * @param args - Transformation arguments
+ * @param args.content - Optional map of media types to OpenAPI MediaType objects
+ * @param args.context - Parsing context for tracing and error handling
+ * @returns Map of processed media types if content exists, undefined otherwise
+ *
+ * @example Handling optional response content
+ * ```typescript
+ * import { toOptionalMediaTypeItemsV3 } from '@skmtc/core/oas/mediaType';
+ *
+ * // Response with content
+ * const responseWithContent = {
+ *   description: 'Successful response',
+ *   content: {
+ *     'application/json': {
+ *       schema: { type: 'object' }
+ *     }
+ *   }
+ * };
+ *
+ * const withContent = toOptionalMediaTypeItemsV3({
+ *   content: responseWithContent.content,
+ *   context: parseContext
+ * });
+ * console.log(withContent); // { 'application/json': OasMediaType }
+ *
+ * // Response without content (like 204 No Content)
+ * const responseNoContent = {
+ *   description: 'No content response'
+ * };
+ *
+ * const noContent = toOptionalMediaTypeItemsV3({
+ *   content: responseNoContent.content, // undefined
+ *   context: parseContext
+ * });
+ * console.log(noContent); // undefined
+ * ```
+ *
+ * @example Processing operations with optional request bodies
+ * ```typescript
+ * function processOperation(operation: OpenAPIV3.OperationObject) {
+ *   const requestBodyContent = toOptionalMediaTypeItemsV3({
+ *     content: operation.requestBody?.content,
+ *     context: parseContext
+ *   });
+ *
+ *   if (requestBodyContent) {
+ *     console.log('Operation has request body with media types:');
+ *     console.log(Object.keys(requestBodyContent));
+ *   } else {
+ *     console.log('Operation has no request body');
+ *   }
+ * }
+ * ```
+ *
+ * @example Safe processing in response handlers
+ * ```typescript
+ * class ResponseProcessor {
+ *   processResponse(response: OpenAPIV3.ResponseObject) {
+ *     const mediaTypes = toOptionalMediaTypeItemsV3({
+ *       content: response.content,
+ *       context: this.context
+ *     });
+ *
+ *     // Safe to check without worrying about undefined content
+ *     const hasJsonResponse = mediaTypes && 'application/json' in mediaTypes;
+ *
+ *     if (hasJsonResponse) {
+ *       const jsonMediaType = mediaTypes['application/json'];
+ *       return this.generateJsonResponseHandler(jsonMediaType);
+ *     }
+ *
+ *     return this.generateEmptyResponseHandler();
+ *   }
+ * }
+ * ```
+ */
 export declare const toOptionalMediaTypeItemsV3: ({ content, context }: ToOptionalMediaTypeItemsV3Args) => Record<string, OasMediaType> | undefined;
 export {};
 //# sourceMappingURL=toMediaTypeItemV3.d.ts.map

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,KAAK,qBAAqB,GAAG;IAC3B,aAAa,EAAE,SAAS,CAAC,eAAe,CAAA;IACxC,SAAS,EAAE,MAAM,CAAA;IACjB,OAAO,EAAE,YAAY,CAAA;CACtB,CAAA;AAED,eAAO,MAAM,iBAAiB,GAAI,uCAI/B,qBAAqB,KAAG,YA0B1B,CAAA;AAED,KAAK,sBAAsB,GAAG;IAC5B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,eAAe,CAAC,CAAA;IAClD,OAAO,EAAE,YAAY,CAAA;CACtB,CAAA;AAED,eAAO,MAAM,kBAAkB,GAAI,sBAGhC,sBAAsB,KAAG,MAAM,CAAC,MAAM,EAAE,YAAY,CAatD,CAAA;AAED,KAAK,8BAA8B,GAAG;IACpC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,eAAe,CAAC,GAAG,SAAS,CAAA;IAC9D,OAAO,EAAE,YAAY,CAAA;CACtB,CAAA;AAED,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;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"}