@skmtc/core 0.0.808 → 0.0.810

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

@@ -2,27 +2,99 @@ import * as v from 'valibot';
 /**
  * Valibot schema for validating OpenAPI boolean data objects.
  *
- * Validates boolean schemas including default values and enumeration
- * constraints. Boolean enums typically contain [true, false] or single values.
+ * This schema validates OpenAPI boolean schemas according to the OpenAPI v3 specification,
+ * including optional properties like default values, enumeration constraints, title,
+ * and description metadata. Boolean enums are commonly used to restrict values to
+ * specific boolean constants (e.g., [true] for always-true flags).
+ *
+ * @example Validating a basic boolean schema
+ * ```typescript
+ * import { oasBooleanData } from '@skmtc/core/oas/boolean';
+ * import * as v from 'valibot';
+ *
+ * const schema = {
+ *   type: 'boolean',
+ *   description: 'Whether the feature is enabled',
+ *   default: false
+ * };
+ *
+ * const validated = v.parse(oasBooleanData, schema);
+ * console.log(validated.default); // false
+ * ```
+ *
+ * @example Validating boolean with enumeration
+ * ```typescript
+ * const constrainedBoolean = {
+ *   type: 'boolean',
+ *   title: 'Admin Flag',
+ *   description: 'User admin status',
+ *   enum: [true] // Only true values allowed
+ * };
+ *
+ * const result = v.parse(oasBooleanData, constrainedBoolean);
+ * console.log(result.enum); // [true]
+ * ```
  */
 export declare const oasBooleanData: v.GenericSchema<OasBooleanData>;
 /**
  * Data type for OpenAPI boolean schema objects.
  *
- * Represents boolean schemas with optional default values and enumeration
- * constraints. Used throughout the SKMTC pipeline for boolean type
- * processing and code generation.
+ * Represents the structure of OpenAPI boolean schemas as processed by the SKMTC pipeline.
+ * This type includes all standard OpenAPI boolean schema properties including metadata,
+ * default values, and enumeration constraints. It's used throughout the boolean
+ * processing pipeline for type-safe handling of boolean schema definitions.
+ *
+ * ## Usage in SKMTC Pipeline
+ *
+ * This type is used by:
+ * - Schema parsers to validate incoming boolean schema data
+ * - Boolean processors to transform OpenAPI schemas into OAS objects
+ * - Code generators to access boolean schema metadata and constraints
+ * - Validation systems to ensure schema compliance
+ *
+ * @example Basic boolean schema
+ * ```typescript
+ * import type { OasBooleanData } from '@skmtc/core/oas/boolean';
+ *
+ * const isActiveSchema: OasBooleanData = {
+ *   type: 'boolean',
+ *   title: 'Active Status',
+ *   description: 'Whether the record is active',
+ *   default: true
+ * };
+ * ```
+ *
+ * @example Boolean with enumeration constraints
+ * ```typescript
+ * const adminFlagSchema: OasBooleanData = {
+ *   type: 'boolean',
+ *   description: 'Administrative privileges flag',
+ *   enum: [false, true], // Allow both values
+ *   default: false
+ * };
+ * ```
+ *
+ * @example Read-only boolean flag
+ * ```typescript
+ * const systemFlagSchema: OasBooleanData = {
+ *   type: 'boolean',
+ *   title: 'System Generated',
+ *   description: 'Indicates if the record was system-generated',
+ *   enum: [true], // Always true
+ *   default: true
+ * };
+ * ```
  */
 export type OasBooleanData = {
     /** Type identifier (always 'boolean') */
     type: 'boolean';
-    /** Human-readable title for the boolean */
+    /** Human-readable title for the boolean schema */
     title?: string;
-    /** Detailed description of the boolean's purpose */
+    /** Detailed description explaining the boolean's purpose and usage */
     description?: string;
-    /** Default value for the boolean */
+    /** Default value used when no explicit value is provided */
     default?: boolean;
-    /** Array of valid boolean values (typically [true], [false], or [true, false]) */
+    /** Array of valid boolean values for enumeration constraints */
     enum?: boolean[];
 };
 //# sourceMappingURL=boolean-types.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"boolean-types.d.ts","sourceRoot":"","sources":["../../../src/oas/boolean/boolean-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B;;;;;GAKG;AACH,eAAO,MAAM,cAAc,EAAE,CAAC,CAAC,aAAa,CAAC,cAAc,CAMzD,CAAA;AAEF;;;;;;GAMG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B,yCAAyC;IACzC,IAAI,EAAE,SAAS,CAAA;IACf,2CAA2C;IAC3C,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,oDAAoD;IACpD,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,oCAAoC;IACpC,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,kFAAkF;IAClF,IAAI,CAAC,EAAE,OAAO,EAAE,CAAA;CACjB,CAAA"}
+{"version":3,"file":"boolean-types.d.ts","sourceRoot":"","sources":["../../../src/oas/boolean/boolean-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,eAAO,MAAM,cAAc,EAAE,CAAC,CAAC,aAAa,CAAC,cAAc,CAMzD,CAAA;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B,yCAAyC;IACzC,IAAI,EAAE,SAAS,CAAA;IACf,kDAAkD;IAClD,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,sEAAsE;IACtE,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,4DAA4D;IAC5D,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,gEAAgE;IAChE,IAAI,CAAC,EAAE,OAAO,EAAE,CAAA;CACjB,CAAA"}

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

@@ -38,8 +38,38 @@ const v = __importStar(require("valibot"));
 /**
  * Valibot schema for validating OpenAPI boolean data objects.
  *
- * Validates boolean schemas including default values and enumeration
- * constraints. Boolean enums typically contain [true, false] or single values.
+ * This schema validates OpenAPI boolean schemas according to the OpenAPI v3 specification,
+ * including optional properties like default values, enumeration constraints, title,
+ * and description metadata. Boolean enums are commonly used to restrict values to
+ * specific boolean constants (e.g., [true] for always-true flags).
+ *
+ * @example Validating a basic boolean schema
+ * ```typescript
+ * import { oasBooleanData } from '@skmtc/core/oas/boolean';
+ * import * as v from 'valibot';
+ *
+ * const schema = {
+ *   type: 'boolean',
+ *   description: 'Whether the feature is enabled',
+ *   default: false
+ * };
+ *
+ * const validated = v.parse(oasBooleanData, schema);
+ * console.log(validated.default); // false
+ * ```
+ *
+ * @example Validating boolean with enumeration
+ * ```typescript
+ * const constrainedBoolean = {
+ *   type: 'boolean',
+ *   title: 'Admin Flag',
+ *   description: 'User admin status',
+ *   enum: [true] // Only true values allowed
+ * };
+ *
+ * const result = v.parse(oasBooleanData, constrainedBoolean);
+ * console.log(result.enum); // [true]
+ * ```
  */
 exports.oasBooleanData = v.object({
     type: v.literal('boolean'),

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/header/Header.d.ts

@@ -34,15 +34,6 @@ export type HeaderFields = {
  * This class provides comprehensive support for header definitions with typed
  * values, validation schemas, examples, and documentation.
  *
- * ## Key Features
- *
- * - **Schema Validation**: Typed header values through schema definitions
- * - **Examples**: Multiple example values for documentation and testing
- * - **Content Types**: Support for complex header values with media types
- * - **Deprecation Support**: Mark headers as deprecated with proper warnings
- * - **Required/Optional**: Control whether headers are mandatory
- * - **Documentation**: Rich description support for API documentation
- *
  * @example Basic authentication header
  * ```typescript
  * import { OasHeader, OasString } from '@skmtc/core';
@@ -62,192 +53,24 @@ export type HeaderFields = {
  *   }
  * });
  * ```
- *
- * @example Pagination headers
- * ```typescript
- * const totalCountHeader = new OasHeader({
- *   description: 'Total number of items available',
- *   required: false,
- *   schema: new OasInteger({
- *     minimum: 0,
- *     description: 'Non-negative integer count'
- *   }),
- *   examples: {
- *     empty: new OasExample({ value: 0, description: 'No items' }),
- *     normal: new OasExample({ value: 150, description: 'Normal case' }),
- *     large: new OasExample({ value: 10000, description: 'Large dataset' })
- *   }
- * });
- *
- * const linkHeader = new OasHeader({
- *   description: 'Pagination links (RFC 5988)',
- *   required: false,
- *   schema: new OasString({
- *     description: 'Comma-separated list of link relations'
- *   }),
- *   examples: {
- *     withNext: new OasExample({
- *       value: '</api/users?page=2>; rel="next", </api/users?page=10>; rel="last"'
- *     }),
- *     lastPage: new OasExample({
- *       value: '</api/users?page=9>; rel="prev", </api/users?page=1>; rel="first"'
- *     })
- *   }
- * });
- * ```
- *
- * @example Content type and encoding headers
- * ```typescript
- * const contentTypeHeader = new OasHeader({
- *   description: 'MIME type of the response content',
- *   required: true,
- *   schema: new OasString({
- *     enum: [
- *       'application/json',
- *       'application/xml',
- *       'text/csv',
- *       'application/pdf',
- *       'application/octet-stream'
- *     ]
- *   }),
- *   examples: {
- *     json: new OasExample({ value: 'application/json' }),
- *     xml: new OasExample({ value: 'application/xml' }),
- *     csv: new OasExample({ value: 'text/csv' })
- *   }
- * });
- *
- * const contentLengthHeader = new OasHeader({
- *   description: 'Size of the response body in bytes',
- *   required: false,
- *   schema: new OasInteger({
- *     minimum: 0,
- *     description: 'Content size in bytes'
- *   })
- * });
- * ```
- *
- * @example Rate limiting headers
- * ```typescript
- * const rateLimitHeader = new OasHeader({
- *   description: 'Number of requests remaining in the current window',
- *   required: false,
- *   schema: new OasInteger({
- *     minimum: 0,
- *     description: 'Remaining request count'
- *   }),
- *   examples: {
- *     available: new OasExample({ value: 95, description: '95 requests remaining' }),
- *     depleted: new OasExample({ value: 0, description: 'Rate limit reached' })
- *   }
- * });
- *
- * const rateLimitResetHeader = new OasHeader({
- *   description: 'Unix timestamp when the rate limit window resets',
- *   required: false,
- *   schema: new OasInteger({
- *     minimum: 0,
- *     description: 'Unix timestamp in seconds'
- *   }),
- *   examples: {
- *     reset: new OasExample({
- *       value: 1634567890,
- *       description: 'Reset at 2021-10-18 12:31:30 UTC'
- *     })
- *   }
- * });
- * ```
- *
- * @example Custom application headers
- * ```typescript
- * const requestIdHeader = new OasHeader({
- *   description: 'Unique identifier for request tracing',
- *   required: false,
- *   schema: new OasString({
- *     format: 'uuid',
- *     description: 'UUID v4 request identifier'
- *   }),
- *   examples: {
- *     uuid: new OasExample({
- *       value: '123e4567-e89b-12d3-a456-426614174000',
- *       description: 'Request tracking ID'
- *     })
- *   }
- * });
- *
- * const serverTimingHeader = new OasHeader({
- *   description: 'Server-side performance metrics',
- *   required: false,
- *   schema: new OasString({
- *     description: 'Server-Timing header format (RFC 8760)'
- *   }),
- *   examples: {
- *     timing: new OasExample({
- *       value: 'db;dur=53, app;dur=47.2',
- *       description: 'Database took 53ms, app logic 47.2ms'
- *     })
- *   }
- * });
- * ```
- *
- * @example Deprecated header
- * ```typescript
- * const deprecatedHeader = new OasHeader({
- *   description: 'Legacy API version header (deprecated)',
- *   required: false,
- *   deprecated: true,
- *   schema: new OasString({
- *     enum: ['v1', 'v2'],
- *     description: 'Use Accept or Content-Type header instead'
- *   }),
- *   examples: {
- *     legacy: new OasExample({
- *       value: 'v1',
- *       description: 'Legacy version (use Accept header instead)'
- *     })
- *   }
- * });
- * ```
- *
- * @example Using in response definitions
- * ```typescript
- * const successResponse = new OasResponse({
- *   description: 'Paginated user list',
- *   headers: {
- *     'X-Total-Count': totalCountHeader,
- *     'Link': linkHeader,
- *     'X-Rate-Limit-Remaining': rateLimitHeader,
- *     'X-Rate-Limit-Reset': rateLimitResetHeader,
- *     'X-Request-ID': requestIdHeader
- *   },
- *   content: {
- *     'application/json': new OasMediaType({
- *       schema: new OasArray({
- *         items: new OasRef({ $ref: '#/components/schemas/User' })
- *       })
- *     })
- *   }
- * });
- * ```
  */
 export declare class OasHeader {
-    #private;
     oasType: 'header';
-    constructor(fields: HeaderFields);
     /** Brief description of header */
-    get description(): string | undefined;
+    description: string | undefined;
     /** Indicates if header is mandatory. Default value is `false` */
-    get required(): boolean | undefined;
+    required: boolean | undefined;
     /** Indicates if header is deprecated and should no longer be used. Default value is false */
-    get deprecated(): boolean | undefined;
+    deprecated: boolean | undefined;
     /** Schema for the header */
-    get schema(): OasSchema | OasRef<'schema'> | undefined;
+    schema: OasSchema | OasRef<'schema'> | undefined;
     /** Examples of the header */
-    get examples(): Record<string, OasExample | OasRef<'example'>> | undefined;
+    examples: Record<string, OasExample | OasRef<'example'>> | undefined;
     /** Content of the header */
-    get content(): Record<string, OasMediaType> | undefined;
+    content: Record<string, OasMediaType> | undefined;
     /** Specification Extension fields */
-    get extensionFields(): Record<string, unknown> | undefined;
+    extensionFields: Record<string, unknown> | undefined;
+    constructor(fields: HeaderFields);
     /** Returns true if object is a reference */
     isRef(): this is OasRef<'header'>;
     /** Returns itself */

package/script/oas/header/Header.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Header.d.ts","sourceRoot":"","sources":["../../../src/oas/header/Header.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAA;AAC7D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,eAAe,CAAA;AAC3C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAA;AACvD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAA;AACpD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAA;AAC9D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAE9C;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,wCAAwC;IACxC,WAAW,EAAE,MAAM,GAAG,SAAS,CAAA;IAC/B,qCAAqC;IACrC,QAAQ,EAAE,OAAO,GAAG,SAAS,CAAA;IAC7B,uCAAuC;IACvC,UAAU,EAAE,OAAO,GAAG,SAAS,CAAA;IAC/B,6CAA6C;IAC7C,MAAM,EAAE,SAAS,GAAG,MAAM,CAAC,QAAQ,CAAC,GAAG,SAAS,CAAA;IAChD,oCAAoC;IACpC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM,CAAC,SAAS,CAAC,CAAC,GAAG,SAAS,CAAA;IACpE,oDAAoD;IACpD,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,GAAG,SAAS,CAAA;IACjD,+CAA+C;IAC/C,eAAe,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAC1C,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8MG;AACH,qBAAa,SAAS;;IACpB,OAAO,EAAE,QAAQ,CAAW;gBAGhB,MAAM,EAAE,YAAY;IAIhC,kCAAkC;IAClC,IAAI,WAAW,IAAI,MAAM,GAAG,SAAS,CAEpC;IAED,iEAAiE;IACjE,IAAI,QAAQ,IAAI,OAAO,GAAG,SAAS,CAElC;IAED,6FAA6F;IAC7F,IAAI,UAAU,IAAI,OAAO,GAAG,SAAS,CAEpC;IAED,4BAA4B;IAC5B,IAAI,MAAM,IAAI,SAAS,GAAG,MAAM,CAAC,QAAQ,CAAC,GAAG,SAAS,CAErD;IAED,6BAA6B;IAC7B,IAAI,QAAQ,IAAI,MAAM,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM,CAAC,SAAS,CAAC,CAAC,GAAG,SAAS,CAEzE;IAED,4BAA4B;IAC5B,IAAI,OAAO,IAAI,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,GAAG,SAAS,CAEtD;IAED,qCAAqC;IACrC,IAAI,eAAe,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAEzD;IAED,4CAA4C;IAC5C,KAAK,IAAI,IAAI,IAAI,MAAM,CAAC,QAAQ,CAAC;IAIjC,qBAAqB;IACrB,OAAO,IAAI,SAAS;IAIpB,WAAW,IAAI,SAAS;IAIxB;;;;OAIG;IACH,QAAQ,CAAC,SAAS,GAAE,MAA2B,GAAG,SAAS,GAAG,MAAM,CAAC,QAAQ,CAAC;IAc9E,YAAY,CAAC,OAAO,EAAE,mBAAmB,GAAG,SAAS,CAAC,YAAY;CASnE"}
+{"version":3,"file":"Header.d.ts","sourceRoot":"","sources":["../../../src/oas/header/Header.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAA;AAC7D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,eAAe,CAAA;AAC3C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAA;AACvD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAA;AACpD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAA;AAC9D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAE9C;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,wCAAwC;IACxC,WAAW,EAAE,MAAM,GAAG,SAAS,CAAA;IAC/B,qCAAqC;IACrC,QAAQ,EAAE,OAAO,GAAG,SAAS,CAAA;IAC7B,uCAAuC;IACvC,UAAU,EAAE,OAAO,GAAG,SAAS,CAAA;IAC/B,6CAA6C;IAC7C,MAAM,EAAE,SAAS,GAAG,MAAM,CAAC,QAAQ,CAAC,GAAG,SAAS,CAAA;IAChD,oCAAoC;IACpC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM,CAAC,SAAS,CAAC,CAAC,GAAG,SAAS,CAAA;IACpE,oDAAoD;IACpD,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,GAAG,SAAS,CAAA;IACjD,+CAA+C;IAC/C,eAAe,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAC1C,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,qBAAa,SAAS;IACpB,OAAO,EAAE,QAAQ,CAAW;IAC5B,kCAAkC;IAClC,WAAW,EAAE,MAAM,GAAG,SAAS,CAAA;IAC/B,iEAAiE;IACjE,QAAQ,EAAE,OAAO,GAAG,SAAS,CAAA;IAC7B,6FAA6F;IAC7F,UAAU,EAAE,OAAO,GAAG,SAAS,CAAA;IAC/B,4BAA4B;IAC5B,MAAM,EAAE,SAAS,GAAG,MAAM,CAAC,QAAQ,CAAC,GAAG,SAAS,CAAA;IAChD,6BAA6B;IAC7B,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM,CAAC,SAAS,CAAC,CAAC,GAAG,SAAS,CAAA;IACpE,4BAA4B;IAC5B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,GAAG,SAAS,CAAA;IACjD,qCAAqC;IACrC,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAAA;gBAExC,MAAM,EAAE,YAAY;IAUhC,4CAA4C;IAC5C,KAAK,IAAI,IAAI,IAAI,MAAM,CAAC,QAAQ,CAAC;IAIjC,qBAAqB;IACrB,OAAO,IAAI,SAAS;IAIpB,WAAW,IAAI,SAAS;IAIxB;;;;OAIG;IACH,QAAQ,CAAC,SAAS,GAAE,MAA2B,GAAG,SAAS,GAAG,MAAM,CAAC,QAAQ,CAAC;IAc9E,YAAY,CAAC,OAAO,EAAE,mBAAmB,GAAG,SAAS,CAAC,YAAY;CASnE"}