@safeaccess/inline 0.1.1 → 0.1.2

package/src/contracts/validatable-parser-interface.ts

@@ -0,0 +1,64 @@
+import type { ParserInterface } from './parser-interface.js';
+
+/**
+ * Extended parser contract adding security validation capabilities.
+ *
+ * Adds structural validation and payload size assertion on top of
+ * the base {@link ParserInterface} CRUD operations.
+ *
+ * @internal Not part of the public API - used only by AbstractAccessor internally.
+ */
+export interface ValidatableParserInterface extends ParserInterface {
+    /**
+     * Retrieve a value at the given path, throwing when not found.
+     *
+     * @param data - Source data object.
+     * @param path - Dot-notation path.
+     * @returns Resolved value.
+     *
+     * @throws {PathNotFoundException} When the path does not exist.
+     */
+    getStrict(data: Record<string, unknown>, path: string): unknown;
+
+    /**
+     * Validate data structure against security constraints.
+     *
+     * Assert key safety, maximum keys, and structural depth
+     * using configured security guards and parser options.
+     *
+     * @param data - Data to validate.
+     *
+     * @throws {SecurityException} When any constraint is violated.
+     */
+    validate(data: Record<string, unknown>): void;
+
+    /**
+     * Assert that a raw string payload does not exceed size limits.
+     *
+     * @param input - Raw input string to check.
+     *
+     * @throws {SecurityException} When the payload exceeds the configured maximum.
+     */
+    assertPayload(input: string): void;
+
+    /**
+     * Return the configured maximum structural nesting depth.
+     *
+     * Used by accessors that perform their own recursive traversal
+     * (e.g. ObjectAccessor) before the post-parse validation step runs.
+     *
+     * @returns Maximum allowed structural depth.
+     */
+    getMaxDepth(): number;
+
+    /**
+     * Return the configured maximum total key count.
+     *
+     * Used by format parsers that enforce a document element-count limit before
+     * structural traversal runs. Accessor implementations that wrap XML parsers
+     * can pass this value as an upper bound to prevent document-bombing attacks.
+     *
+     * @returns Maximum allowed key count.
+     */
+    getMaxKeys(): number;
+}

package/src/contracts/writable-accessors-interface.ts

@@ -3,6 +3,11 @@
  *
  * All mutations return a new instance with the modification applied,
  * preserving the original accessor instance.
+ *
+ * @api
+ *
+ * @see AccessorsInterface  Composite interface extending this contract.
+ * @see AbstractAccessor    Base implementation enforcing readonly guards.
  */
 export interface WritableAccessorsInterface {
     /**

package/src/core/accessor-factory.ts

@@ -0,0 +1,173 @@
+import type { ValidatableParserInterface } from '../contracts/validatable-parser-interface.js';
+import type { ParseIntegrationInterface } from '../contracts/parse-integration-interface.js';
+import { AbstractAccessor } from '../accessors/abstract-accessor.js';
+import { ArrayAccessor } from '../accessors/formats/array-accessor.js';
+import { ObjectAccessor } from '../accessors/formats/object-accessor.js';
+import { JsonAccessor } from '../accessors/formats/json-accessor.js';
+import { XmlAccessor } from '../accessors/formats/xml-accessor.js';
+import { YamlAccessor } from '../accessors/formats/yaml-accessor.js';
+import { IniAccessor } from '../accessors/formats/ini-accessor.js';
+import { EnvAccessor } from '../accessors/formats/env-accessor.js';
+import { NdjsonAccessor } from '../accessors/formats/ndjson-accessor.js';
+import { AnyAccessor } from '../accessors/formats/any-accessor.js';
+import { InvalidFormatException } from '../exceptions/invalid-format-exception.js';
+
+/**
+ * Factory for creating typed format-specific accessors.
+ *
+ * Encapsulates the wiring between a parser and accessor construction,
+ * providing one method per supported format. Used internally by
+ * {@link Inline} to create accessors.
+ *
+ * @internal
+ */
+export class AccessorFactory {
+    /**
+     * Initialize the factory with a parser, optional integration, and optional strict mode.
+     *
+     * @param parser - Parser for dot-notation resolution.
+     * @param defaultIntegration - Default integration for AnyAccessor.
+     * @param strictMode - Override strict mode for created accessors.
+     */
+    constructor(
+        private readonly parser: ValidatableParserInterface,
+        private readonly defaultIntegration: ParseIntegrationInterface | null = null,
+        private readonly strictMode: boolean | null = null,
+    ) {}
+
+    /**
+     * Return the underlying parser used by this factory.
+     *
+     * @returns The parser instance.
+     */
+    getParser(): ValidatableParserInterface {
+        return this.parser;
+    }
+
+    /**
+     * Apply configured strict mode to a new accessor before hydration.
+     *
+     * @param accessor - Unhydrated accessor instance.
+     * @returns Same accessor with strict mode applied if configured.
+     */
+    private applyOptions<T extends AbstractAccessor>(accessor: T): T {
+        if (this.strictMode !== null) {
+            return accessor.strict(this.strictMode) as T;
+        }
+        return accessor;
+    }
+
+    /**
+     * Create an ArrayAccessor from raw array data.
+     *
+     * @param data - Source array or object.
+     * @returns Populated ArrayAccessor.
+     * @throws {SecurityException} When security constraints are violated.
+     */
+    array(data: Record<string, unknown> | unknown[]): ArrayAccessor {
+        return this.applyOptions(new ArrayAccessor(this.parser)).from(data);
+    }
+
+    /**
+     * Create an ObjectAccessor from a source object.
+     *
+     * @param data - Source object.
+     * @returns Populated ObjectAccessor.
+     * @throws {SecurityException} When security constraints are violated.
+     */
+    object(data: object): ObjectAccessor {
+        return this.applyOptions(new ObjectAccessor(this.parser)).from(data);
+    }
+
+    /**
+     * Create a JsonAccessor from a JSON string.
+     *
+     * @param data - Raw JSON string.
+     * @returns Populated JsonAccessor.
+     * @throws {InvalidFormatException} When the JSON is malformed.
+     * @throws {SecurityException} When security constraints are violated.
+     */
+    json(data: string): JsonAccessor {
+        return this.applyOptions(new JsonAccessor(this.parser)).from(data);
+    }
+
+    /**
+     * Create an XmlAccessor from an XML string.
+     *
+     * @param data - Raw XML string.
+     * @returns Populated XmlAccessor.
+     * @throws {InvalidFormatException} When the XML is malformed.
+     * @throws {SecurityException} When DOCTYPE is detected.
+     */
+    xml(data: string): XmlAccessor {
+        return this.applyOptions(new XmlAccessor(this.parser)).from(data);
+    }
+
+    /**
+     * Create a YamlAccessor from a YAML string.
+     *
+     * @param data - Raw YAML string.
+     * @returns Populated YamlAccessor.
+     * @throws {YamlParseException} When the YAML is malformed.
+     * @throws {SecurityException} When security constraints are violated.
+     */
+    yaml(data: string): YamlAccessor {
+        return this.applyOptions(new YamlAccessor(this.parser)).from(data);
+    }
+
+    /**
+     * Create an IniAccessor from an INI string.
+     *
+     * @param data - Raw INI string.
+     * @returns Populated IniAccessor.
+     * @throws {InvalidFormatException} When the INI is malformed.
+     * @throws {SecurityException} When security constraints are violated.
+     */
+    ini(data: string): IniAccessor {
+        return this.applyOptions(new IniAccessor(this.parser)).from(data);
+    }
+
+    /**
+     * Create an EnvAccessor from a dotenv-formatted string.
+     *
+     * @param data - Raw dotenv string.
+     * @returns Populated EnvAccessor.
+     * @throws {SecurityException} When security constraints are violated.
+     */
+    env(data: string): EnvAccessor {
+        return this.applyOptions(new EnvAccessor(this.parser)).from(data);
+    }
+
+    /**
+     * Create an NdjsonAccessor from a newline-delimited JSON string.
+     *
+     * @param data - Raw NDJSON string.
+     * @returns Populated NdjsonAccessor.
+     * @throws {InvalidFormatException} When any JSON line is malformed.
+     * @throws {SecurityException} When security constraints are violated.
+     */
+    ndjson(data: string): NdjsonAccessor {
+        return this.applyOptions(new NdjsonAccessor(this.parser)).from(data);
+    }
+
+    /**
+     * Create an AnyAccessor with automatic format detection.
+     *
+     * @param data - Raw data in any supported format.
+     * @param integration - Override integration (falls back to default).
+     * @returns Populated AnyAccessor.
+     * @throws {InvalidFormatException} When no integration is available.
+     */
+    any(data: unknown, integration?: ParseIntegrationInterface | null): AnyAccessor {
+        const resolved = integration ?? this.defaultIntegration;
+
+        if (resolved === null) {
+            throw new InvalidFormatException(
+                'AnyAccessor requires a ParseIntegrationInterface. ' +
+                    'Pass one directly or configure a default via Inline.withParserIntegration(i).fromAny(data).',
+            );
+        }
+
+        return this.applyOptions(new AnyAccessor(this.parser, resolved)).from(data);
+    }
+}

package/src/core/dot-notation-parser.ts

@@ -1,8 +1,14 @@
 import type { SecurityGuardInterface } from '../contracts/security-guard-interface.js';
 import type { SecurityParserInterface } from '../contracts/security-parser-interface.js';
 import type { PathCacheInterface } from '../contracts/path-cache-interface.js';
+import type { ValidatableParserInterface } from '../contracts/validatable-parser-interface.js';
 import { SecurityGuard } from '../security/security-guard.js';
 import { SecurityParser } from '../security/security-parser.js';
+import { PathNotFoundException } from '../exceptions/path-not-found-exception.js';
+import { SegmentFilterParser } from '../path-query/segment-filter-parser.js';
+import { SegmentParser } from '../path-query/segment-parser.js';
+import { SegmentPathResolver } from '../path-query/segment-path-resolver.js';
+import type { Segment } from '../path-query/segment-type.js';
 
 /**
  * Core dot-notation parser for reading, writing, and removing nested values.
@@ -10,28 +16,40 @@ import { SecurityParser } from '../security/security-parser.js';
  * Provides path-based access to plain objects using dot-separated keys.
  * Delegates security validation to SecurityGuard and SecurityParser.
  *
+ * @internal
+ *
  * @example
  * const parser = new DotNotationParser();
  * parser.get({ user: { name: 'Alice' } }, 'user.name'); // 'Alice'
  */
-export class DotNotationParser {
+export class DotNotationParser implements ValidatableParserInterface {
     private readonly securityGuard: SecurityGuardInterface;
     private readonly securityParser: SecurityParserInterface;
     private readonly pathCache: PathCacheInterface | null;
+    private readonly segmentParser: SegmentParser;
+    private readonly segmentPathResolver: SegmentPathResolver;
 
     /**
      * @param securityGuard - Key-safety guard. Defaults to a new SecurityGuard instance.
      * @param securityParser - Parser depth and size limits. Defaults to a new SecurityParser instance.
      * @param pathCache - Optional path segment cache for repeated lookups.
+     * @param segmentParser - Path-string → segment converter.
+     * @param segmentPathResolver - Segment → value resolver.
      */
     constructor(
         securityGuard?: SecurityGuardInterface,
         securityParser?: SecurityParserInterface,
         pathCache?: PathCacheInterface,
+        segmentParser?: SegmentParser,
+        segmentPathResolver?: SegmentPathResolver,
     ) {
         this.securityGuard = securityGuard ?? new SecurityGuard();
         this.securityParser = securityParser ?? new SecurityParser();
         this.pathCache = pathCache ?? null;
+
+        const filterParser = new SegmentFilterParser(this.securityGuard);
+        this.segmentParser = segmentParser ?? new SegmentParser(filterParser);
+        this.segmentPathResolver = segmentPathResolver ?? new SegmentPathResolver(filterParser);
     }
 
     /**
@@ -52,8 +70,50 @@ export class DotNotationParser {
             return defaultValue;
         }
 
-        const segments = this.parsePath(path);
-        return this.getAt(data, segments, defaultValue);
+        const segments = this.segmentPathCache(path);
+        return this.resolve(data, segments, defaultValue);
+    }
+
+    /**
+     * Resolve a pre-parsed segment array against data, returning the matched value.
+     *
+     * @param data - Source data object.
+     * @param segments - Typed segments from {@link SegmentParser}.
+     * @param defaultValue - Fallback returned when the path does not exist.
+     * @returns Resolved value or the default.
+     */
+    resolve(
+        data: Record<string, unknown>,
+        segments: Segment[],
+        defaultValue: unknown = null,
+    ): unknown {
+        return this.segmentPathResolver.resolve(
+            data,
+            segments,
+            0,
+            defaultValue,
+            this.securityParser.getMaxResolveDepth(),
+        );
+    }
+
+    /**
+     * Retrieve a value at the given path, throwing when not found.
+     *
+     * @param data - Source data object.
+     * @param path - Dot-notation path string.
+     * @returns Resolved value.
+     *
+     * @throws {PathNotFoundException} When the path does not exist.
+     */
+    getStrict(data: Record<string, unknown>, path: string): unknown {
+        const sentinel = Object.create(null) as Record<string, never>;
+        const result = this.get(data, path, sentinel);
+
+        if (result === sentinel) {
+            throw new PathNotFoundException(`Path '${path}' not found.`);
+        }
+
+        return result;
     }
 
     /**
@@ -68,7 +128,7 @@ export class DotNotationParser {
      * parser.set({}, 'user.name', 'Alice'); // { user: { name: 'Alice' } }
      */
     set(data: Record<string, unknown>, path: string, value: unknown): Record<string, unknown> {
-        const segments = this.parsePath(path);
+        const segments = this.segmentParser.parseKeys(path);
         return this.setAt(data, segments, value);
     }
 
@@ -103,7 +163,7 @@ export class DotNotationParser {
      * parser.remove({ a: { b: 1 } }, 'a.b'); // { a: {} }
      */
     remove(data: Record<string, unknown>, path: string): Record<string, unknown> {
-        const segments = this.parsePath(path);
+        const segments = this.segmentParser.parseKeys(path);
         return this.removeAt(data, segments);
     }
 
@@ -188,7 +248,10 @@ export class DotNotationParser {
      * @example
      * parser.removeAt({ a: { b: 1 } }, ['a', 'b']); // { a: {} }
      */
-    removeAt(data: Record<string, unknown>, segments: Array<string | number>): Record<string, unknown> {
+    removeAt(
+        data: Record<string, unknown>,
+        segments: Array<string | number>,
+    ): Record<string, unknown> {
         /* Stryker disable next-line ConditionalExpression,BlockStatement -- equivalent: empty segments → eraseAt hits undefined key → hasOwnProperty false → returns data anyway */
         if (segments.length === 0) {
             return data;
@@ -273,22 +336,22 @@ export class DotNotationParser {
     }
 
     /**
-     * Parse a dot-notation path into segments, using cache when available.
+     * Retrieve parsed segments from cache or parse and cache the path.
      *
      * @param path - Dot-notation path string.
-     * @returns Array of path segments.
+     * @returns Cached or freshly parsed typed segments.
      */
-    private parsePath(path: string): string[] {
+    private segmentPathCache(path: string): Segment[] {
         if (this.pathCache !== null) {
             const cached = this.pathCache.get(path);
             if (cached !== null) {
                 return cached;
             }
-            const segments = path.split('.');
+            const segments = this.segmentParser.parseSegments(path);
             this.pathCache.set(path, segments);
             return segments;
         }
-        return path.split('.');
+        return this.segmentParser.parseSegments(path);
     }
 
     /**

package/src/core/inline-builder-accessor.ts

@@ -0,0 +1,163 @@
+import type { SecurityGuardInterface } from '../contracts/security-guard-interface.js';
+import type { SecurityParserInterface } from '../contracts/security-parser-interface.js';
+import type { ParseIntegrationInterface } from '../contracts/parse-integration-interface.js';
+import type { PathCacheInterface } from '../contracts/path-cache-interface.js';
+import { SecurityGuard } from '../security/security-guard.js';
+import { SecurityParser } from '../security/security-parser.js';
+import { SimplePathCache } from '../cache/simple-path-cache.js';
+import { DotNotationParser } from './dot-notation-parser.js';
+import { AccessorFactory } from './accessor-factory.js';
+import { SegmentFilterParser } from '../path-query/segment-filter-parser.js';
+import { SegmentParser } from '../path-query/segment-parser.js';
+import { SegmentPathResolver } from '../path-query/segment-path-resolver.js';
+
+/**
+ * Builder for configuring and constructing the internal components of SafeAccess Inline.
+ *
+ * Provides an immutable builder API: each `withXxx()` method returns a new
+ * instance with the specified override, leaving the original unchanged.
+ *
+ * Note: PHP's equivalent uses `__callStatic`/`__call` magic to expose
+ * protected methods publicly. TypeScript has no equivalent mechanism, so
+ * builder methods are public directly and static forwarding is explicit
+ * in the {@link Inline} subclass.
+ *
+ * @internal
+ *
+ * @see Inline
+ */
+export class InlineBuilderAccessor {
+    protected readonly _guard: SecurityGuardInterface;
+    protected readonly _secParser: SecurityParserInterface;
+    protected readonly _pathCache: PathCacheInterface | null;
+    protected readonly _integration: ParseIntegrationInterface | null;
+    protected readonly _strictMode: boolean | null;
+
+    /**
+     * Create a builder with optional component overrides.
+     *
+     * @param guard - Custom security guard, or undefined for default.
+     * @param secParser - Custom security parser, or undefined for default.
+     * @param pathCache - Custom path cache, or null/undefined for default.
+     * @param integration - Custom format integration, or null/undefined for none.
+     * @param strictMode - Strict mode override, or null/undefined for accessor default.
+     */
+    constructor(
+        guard?: SecurityGuardInterface,
+        secParser?: SecurityParserInterface,
+        pathCache?: PathCacheInterface | null,
+        integration?: ParseIntegrationInterface | null,
+        strictMode?: boolean | null,
+    ) {
+        this._guard = guard ?? new SecurityGuard();
+        this._secParser = secParser ?? new SecurityParser();
+        this._pathCache = pathCache ?? null;
+        this._integration = integration ?? null;
+        this._strictMode = strictMode ?? null;
+    }
+
+    /**
+     * Initialize the builder with default or provided components.
+     *
+     * @returns Configured factory ready to create typed accessors.
+     */
+    builder(): AccessorFactory {
+        const filterParser = new SegmentFilterParser(this._guard);
+        const segmentParser = new SegmentParser(filterParser);
+        const segmentPathResolver = new SegmentPathResolver(filterParser);
+
+        const dotNotationParser = new DotNotationParser(
+            this._guard,
+            this._secParser,
+            this._pathCache ?? new SimplePathCache(),
+            segmentParser,
+            segmentPathResolver,
+        );
+
+        return new AccessorFactory(dotNotationParser, this._integration, this._strictMode);
+    }
+
+    /**
+     * Set a custom parser integration implementation.
+     *
+     * @param integration - Custom format integration to use.
+     * @returns New builder instance with the integration configured.
+     */
+    withParserIntegration(integration: ParseIntegrationInterface): this {
+        return new (this.constructor as new (
+            guard: SecurityGuardInterface,
+            secParser: SecurityParserInterface,
+            pathCache: PathCacheInterface | null,
+            integration: ParseIntegrationInterface | null,
+            strictMode: boolean | null,
+        ) => this)(this._guard, this._secParser, this._pathCache, integration, this._strictMode);
+    }
+
+    /**
+     * Set a custom security guard implementation.
+     *
+     * @param guard - Custom guard implementation to use.
+     * @returns New builder instance with the guard configured.
+     */
+    withSecurityGuard(guard: SecurityGuardInterface): this {
+        return new (this.constructor as new (
+            guard: SecurityGuardInterface,
+            secParser: SecurityParserInterface,
+            pathCache: PathCacheInterface | null,
+            integration: ParseIntegrationInterface | null,
+            strictMode: boolean | null,
+        ) => this)(guard, this._secParser, this._pathCache, this._integration, this._strictMode);
+    }
+
+    /**
+     * Set a custom security parser implementation.
+     *
+     * @param parser - Custom parser implementation to use.
+     * @returns New builder instance with the parser configured.
+     */
+    withSecurityParser(parser: SecurityParserInterface): this {
+        return new (this.constructor as new (
+            guard: SecurityGuardInterface,
+            secParser: SecurityParserInterface,
+            pathCache: PathCacheInterface | null,
+            integration: ParseIntegrationInterface | null,
+            strictMode: boolean | null,
+        ) => this)(this._guard, parser, this._pathCache, this._integration, this._strictMode);
+    }
+
+    /**
+     * Set a custom path cache implementation.
+     *
+     * @param cache - Custom cache implementation to use.
+     * @returns New builder instance with the cache configured.
+     */
+    withPathCache(cache: PathCacheInterface): this {
+        return new (this.constructor as new (
+            guard: SecurityGuardInterface,
+            secParser: SecurityParserInterface,
+            pathCache: PathCacheInterface | null,
+            integration: ParseIntegrationInterface | null,
+            strictMode: boolean | null,
+        ) => this)(this._guard, this._secParser, cache, this._integration, this._strictMode);
+    }
+
+    /**
+     * Set the strict mode for all accessors created by this builder.
+     *
+     * @param strict - Whether to enable strict security validation.
+     * @returns New builder instance with the strict mode configured.
+     *
+     * @security Passing `false` disables all SecurityGuard and SecurityParser
+     *           validation (key safety, payload size, depth and key-count limits).
+     *           Only use with fully trusted, application-controlled input.
+     */
+    withStrictMode(strict: boolean): this {
+        return new (this.constructor as new (
+            guard: SecurityGuardInterface,
+            secParser: SecurityParserInterface,
+            pathCache: PathCacheInterface | null,
+            integration: ParseIntegrationInterface | null,
+            strictMode: boolean | null,
+        ) => this)(this._guard, this._secParser, this._pathCache, this._integration, strict);
+    }
+}

package/src/exceptions/accessor-exception.ts

@@ -1,6 +1,15 @@
 /**
  * Base exception for all accessor-layer errors.
  *
+ * @api
+ *
+ * @see InvalidFormatException  Thrown on malformed input data.
+ * @see ParserException         Thrown on parser-level operational errors.
+ * @see PathNotFoundException   Thrown when a requested path does not exist.
+ * @see SecurityException       Thrown on security constraint violations.
+ * @see ReadonlyViolationException Thrown on write attempts to a readonly accessor.
+ * @see UnsupportedTypeException   Thrown when an unsupported format is requested.
+ *
  * @example
  * throw new AccessorException('Something went wrong.');
  */

package/src/exceptions/invalid-format-exception.ts

@@ -3,6 +3,11 @@ import { AccessorException } from './accessor-exception.js';
 /**
  * Thrown when the input data cannot be parsed as the expected format.
  *
+ * @api
+ *
+ * @see AccessorException       Parent exception class.
+ * @see YamlParseException      Specialized subclass for YAML parsing errors.
+ *
  * @example
  * throw new InvalidFormatException('Expected JSON string, got number.');
  */

package/src/exceptions/parser-exception.ts

@@ -3,6 +3,10 @@ import { AccessorException } from './accessor-exception.js';
 /**
  * Thrown when an underlying parser encounters a structural error.
  *
+ * @api
+ *
+ * @see AccessorException  Parent exception class.
+ *
  * @example
  * throw new ParserException('Parser failed to process input.');
  */

package/src/exceptions/path-not-found-exception.ts

@@ -3,6 +3,10 @@ import { AccessorException } from './accessor-exception.js';
 /**
  * Thrown when a dot-notation path does not exist in the data.
  *
+ * @api
+ *
+ * @see AccessorException  Parent exception class.
+ *
  * @example
  * throw new PathNotFoundException("Path 'user.address.zip' not found.");
  */

package/src/exceptions/readonly-violation-exception.ts

@@ -3,6 +3,10 @@ import { AccessorException } from './accessor-exception.js';
 /**
  * Thrown when a write operation is attempted on a readonly accessor.
  *
+ * @api
+ *
+ * @see AccessorException  Parent exception class.
+ *
  * @example
  * const accessor = Inline.fromJson('{}').readonly(true);
  * accessor.set('key', 'value'); // throws ReadonlyViolationException

package/src/exceptions/security-exception.ts

@@ -7,6 +7,12 @@ import { AccessorException } from './accessor-exception.js';
  * methods, stream wrapper / protocol URI schemes, Node.js globals),
  * payload size violations, key-count limits, and depth limit violations.
  *
+ * @api
+ *
+ * @see AccessorException   Parent exception class.
+ * @see SecurityGuard       Validates keys against the forbidden list.
+ * @see SecurityParser      Enforces payload, depth, and key-count limits.
+ *
  * @example
  * throw new SecurityException("Forbidden key '__proto__' detected.");
  */

package/src/exceptions/unsupported-type-exception.ts

@@ -3,6 +3,10 @@ import { AccessorException } from './accessor-exception.js';
 /**
  * Thrown when the requested format or TypeFormat value is not supported.
  *
+ * @api
+ *
+ * @see AccessorException  Parent exception class.
+ *
  * @example
  * throw new UnsupportedTypeException('TypeFormat.Csv is not supported.');
  */

package/src/exceptions/yaml-parse-exception.ts

@@ -6,6 +6,10 @@ import { InvalidFormatException } from './invalid-format-exception.js';
  * Unsafe constructs include: tags (!! and !), anchors (&), aliases (*),
  * and merge keys (<<).
  *
+ * @api
+ *
+ * @see InvalidFormatException  Parent exception class.
+ *
  * @example
  * throw new YamlParseException('YAML anchors are not supported (line 3).');
  */