gennady 0.6.1 → 0.7.0

package/dist/services/agent-mon/providers/opencode/db.d.ts

@@ -0,0 +1,41 @@
+import { DatabaseSync } from 'node:sqlite';
+import type { ScanOpts } from '../../model/scan-opts.type.js';
+/** @purpose Raw row shape from the OpenCode session table. */
+export type SessionRow = {
+    /** @purpose Unique session identifier */
+    id: string;
+    /** @purpose URL-friendly unique slug for the session */
+    slug: string;
+    /** @purpose Human-readable session title */
+    title: string | null;
+    /** @purpose Working directory the session was started in */
+    directory: string;
+    /** @purpose Session creation timestamp in epoch ms */
+    time_created: number;
+    /** @purpose Session last update timestamp in epoch ms */
+    time_updated: number;
+    /** @purpose Agent name used for the session */
+    agent: string | null;
+    /** @purpose Model name used for the session */
+    model: string | null;
+    /** @purpose Input token count for the session */
+    tokens_input: number | null;
+    /** @purpose Output token count for the session */
+    tokens_output: number | null;
+    /** @purpose Parent session ID for forked sessions */
+    parent_id: string | null;
+};
+/**
+ * @purpose Query active (non-archived) sessions from the OpenCode database.
+ * @param db Open SQLite database connection.
+ * @param [opts] Optional scan filtering parameters.
+ * @returns Rows matching the active session criteria, ordered by most recently updated.
+ */
+export declare function querySessions(db: DatabaseSync, opts?: ScanOpts): SessionRow[];
+/**
+ * @purpose Retrieve the last message data for a session.
+ * @param db Open SQLite database connection.
+ * @param sessionId The session identifier to look up.
+ * @returns The raw message data string, or null if no messages found.
+ */
+export declare function queryLastMessage(db: DatabaseSync, sessionId: string): string | null;

package/dist/services/agent-mon/providers/opencode/index.d.ts

@@ -0,0 +1,3 @@
+export { OpenCodeProvider } from './opencode-provider.js';
+export { querySessions, queryLastMessage } from './db.js';
+export { parseModelJson } from './model-parser.js';

package/dist/services/agent-mon/providers/opencode/model-parser.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @purpose Extract the model id from a raw OpenCode model JSON string.
+ * @param raw The model JSON string or null.
+ * @returns The extracted model id, 'unknown' on parse failure, undefined for null input.
+ */
+export declare function parseModelJson(raw: string | null): string | undefined;

package/dist/services/agent-mon/providers/opencode/opencode-provider.d.ts

@@ -0,0 +1,45 @@
+import type { AgentSession } from '../../model/agent-session.type.js';
+import type { ScanOpts } from '../../model/scan-opts.type.js';
+import type { AgentProvider } from '../../model/agent-provider.type.js';
+import { querySessions as defaultQuerySessions, queryLastMessage as defaultQueryLastMessage } from './db.js';
+import { parseModelJson as defaultParseModelJson } from './model-parser.js';
+/** @purpose Injectable constructor dependencies for OpenCodeProvider testing and customization. */
+export type OpenCodeProviderDeps = {
+    /** @purpose Custom SQLite database path override */
+    dbPath?: string;
+    /** @purpose Session query function injectable for testing */
+    querySessions?: typeof defaultQuerySessions;
+    /** @purpose Last message query function injectable for testing */
+    queryLastMessage?: typeof defaultQueryLastMessage;
+    /** @purpose Model JSON parser injectable for testing */
+    parseModelJson?: typeof defaultParseModelJson;
+};
+/**
+ * @purpose Adapter scanning OpenCode agent sessions via SQLite.
+ * @implements {AgentProvider} in ../../model/agent-provider.type.ts
+ */
+export declare class OpenCodeProvider implements AgentProvider {
+    /** @purpose Provider identifier key ('opencode') */
+    readonly key = "opencode";
+    /** @purpose Resolved dependency injection container */
+    protected _deps: Required<OpenCodeProviderDeps>;
+    /** @purpose Logger instance for structured logging */
+    protected _logger: import("#logger").SimpleLogger;
+    /**
+     * @purpose Construct with optional dependency injection for testing.
+     * @param [deps] Injectable query functions and db path overrides.
+     */
+    constructor(deps?: OpenCodeProviderDeps);
+    /**
+     * @param [opts] Optional scan filtering parameters.
+     * @returns Parsed agent sessions array.
+     * @see {AgentProvider#scan} in ../../model/agent-provider.type.ts
+     */
+    scan(opts?: ScanOpts): Promise<AgentSession[]>;
+    /**
+     * @purpose Resolve tilde-prefixed path to an absolute path using the home directory.
+     * @param raw Raw path string potentially starting with ~/.
+     * @returns Absolute path with ~ resolved to os.homedir().
+     */
+    protected _resolvePath(raw: string): string;
+}

package/dist/services/ai-client/providers/ai-model.type.d.ts

@@ -3,22 +3,32 @@
  * @behavior Only id and name are guaranteed; other fields depend on the source.
  */
 export type AIModel = {
+    /** @purpose Unique model identifier string */
     id: string;
+    /** @purpose Human-readable model name */
     name: string;
+    /** @purpose Optional model description text */
     description?: string;
+    /** @purpose Pricing info with optional prompt and completion costs */
     pricing?: {
         prompt?: string;
         completion?: string;
     };
+    /** @purpose Top provider metadata */
     top_provider?: {
         context_length?: number;
         max_completion_tokens?: number | null;
         is_moderated?: boolean;
     };
+    /** @purpose Canonical slug for the model */
     canonical_slug?: string;
+    /** @purpose Hugging Face model identifier */
     hugging_face_id?: string;
+    /** @purpose Model creation timestamp */
     created?: number;
+    /** @purpose Context window length in tokens */
     context_length?: number;
+    /** @purpose Model architecture details */
     architecture?: {
         modality?: string;
         tokenizer?: string;
@@ -26,8 +36,12 @@ export type AIModel = {
         input_modalities?: string[];
         output_modalities?: string[];
     };
+    /** @purpose Per-request rate limiting info */
     per_request_limits?: unknown;
+    /** @purpose Supported generation parameters */
     supported_parameters?: string[];
+    /** @purpose Default parameter overrides */
     default_parameters?: Record<string, unknown>;
+    /** @purpose Model expiration date info */
     expiration_date?: unknown;
 };

package/dist/services/ai-client/providers/open-router/open-router-model.type.d.ts

@@ -1,8 +1,5 @@
 import type { AIModel } from '../ai-model.type.js';
-/**
- * @purpose Open Router GET /models API response item (full schema).
- * @see {AIModel} in ./ai-model.type.ts
- */
+/** @purpose Open Router GET /models API response item (full schema). */
 export type OpenRouterModel = AIModel & {
     canonical_slug: string;
     context_length: number;

package/dist/services/ai-client/providers/open-router/open-router-provider.d.ts

@@ -1,9 +1,26 @@
 import { type OpenAIProvider, type OpenAIProviderSettings } from '@ai-sdk/openai';
 import type { AIModel } from '../ai-model.type.js';
+/** @purpose Provider adapter for Open Router API, wrapping OpenAI-compatible SDK. */
 export declare class OpenRouterProvider {
+    /** @purpose OpenAI provider settings */
     protected _settings: OpenAIProviderSettings;
+    /** @purpose OpenAI provider instance */
     protected _provider: OpenAIProvider;
+    /**
+     * @purpose Initialize the provider with OpenAI-compatible settings.
+     * @param settings Provider configuration settings.
+     */
     constructor(settings: OpenAIProviderSettings);
+    /**
+     * @purpose Fetch available AI models from the Open Router API.
+     * @returns Array of available AI models.
+     */
     getModels(): Promise<AIModel[]>;
+    /**
+     * @purpose Generate text completion using a specified model.
+     * @param model Model identifier string.
+     * @param prompt Text prompt to generate from.
+     * @returns Generated text output.
+     */
     generateText(model: string, prompt: string): Promise<string>;
 }

package/dist/services/ai-client/providers/openai-like-provider.d.ts

@@ -1,2 +1,3 @@
 import { createOpenAI } from '@ai-sdk/openai';
+/** @purpose Factory re-export of the OpenAI-compatible provider creation function. */
 export declare const createOpenAiLikeProvider: typeof createOpenAI;

package/dist/services/data-ore/telegram/telegram-data-ore.d.ts

@@ -1,11 +1,28 @@
 import { Dialog, TelegramClient, User, type TelegramClientOptions } from '@mtcute/node';
 import { Dispatcher, MessageContext } from '@mtcute/dispatcher';
 import type { DialogsQuery } from './telegram-data-ore.types.js';
+/** @purpose Telegram client wrapper providing authentication and dialog retrieval. */
 export declare class TelegramDataOre {
+    /** @purpose Underlying mtcute Telegram client instance */
     protected _client: TelegramClient;
+    /** @purpose Message dispatcher for routing incoming updates */
     protected _dispatcher: Dispatcher;
+    /**
+     * @purpose Initialize the Telegram client with given options and wire up message handler.
+     * @param options Telegram client configuration options.
+     */
     constructor(options: TelegramClientOptions);
+    /**
+     * @purpose Authorize the Telegram client, using QR login as fallback.
+     * @returns Authenticated user object.
+     */
     authorize(): Promise<User>;
+    /**
+     * @purpose Retrieve dialogs from Telegram with optional query filters.
+     * @param [query] Optional query parameters for filtering and pagination.
+     * @returns Async iterable iterator of dialogs.
+     */
     getDialogs(query?: DialogsQuery): Promise<AsyncIterableIterator<Dialog>>;
+    /** @purpose Handler for incoming Telegram messages, formats and prints them. */
     protected _handleNewMessage: (update: MessageContext, _state: never) => Promise<void>;
 }

package/dist/services/data-ore/telegram/telegram-data-ore.types.d.ts

@@ -1,5 +1,9 @@
+/** @purpose Query parameters for fetching Telegram dialogs. */
 export type DialogsQuery = {
+    /** @purpose Maximum number of dialogs to return */
     limit?: number;
+    /** @purpose Whether to include archived chats */
     includedArchived?: boolean;
 };
+/** @purpose Query parameters for date-range based filtering (placeholder for future use). */
 export type RangeQuery = {};

package/dist/services/data-ore/telegram/telegram-demo-music-helper.d.ts

@@ -4,6 +4,7 @@ type TelegramSource = Dialog | MessageContext;
 /**
  * @purpose Generate structured music release description from Telegram data.
  * @param source Telegram dialog or message context.
+ * @returns Promise that resolves when music description has been generated and saved.
  */
 export declare function generateMusicDescription(source: TelegramSource): Promise<void>;
 export {};

package/dist/services/data-ore/telegram/telegram-demo.d.ts

@@ -1,2 +1,3 @@
 import { TelegramDataOre } from './telegram-data-ore.js';
+/** @purpose Pre-configured Telegram client instance for demo usage. */
 export declare const tg: TelegramDataOre;

package/dist/services/dbc/linter/dbc-ast-adapter.types.d.ts

@@ -0,0 +1,82 @@
+/** @purpose Describes a single parameter in a function or method signature. */
+export type DbcParamInfo = {
+    /** @purpose Parameter name as declared in source */
+    name: string;
+    /** @purpose TypeScript type annotation as written in source */
+    type: string;
+    /** @purpose Whether the parameter is optional (`x?: T`) */
+    optional: boolean;
+    /** @purpose Whether the parameter is a rest parameter (`...args`) */
+    isRest: boolean;
+};
+/** @purpose Describes the full signature of a callable entity: parameters and return type. */
+export type DbcSignatureInfo = {
+    /** @purpose Ordered list of parameters in the signature */
+    params: DbcParamInfo[];
+    /** @purpose Return type annotation as written in source, or 'void' */
+    returnType: string;
+};
+/**
+ * @purpose Compact representation of a raw JSDoc contract comment associated with an AST node.
+ */
+type DbcContractInfo = {
+    /** @purpose Full text of the JSDoc comment between /** and *​/ */
+    text: string;
+    /** @purpose One-based line number where the comment starts */
+    startLine: number;
+    /** @purpose One-based column number where the comment starts */
+    startCol: number;
+};
+/** @purpose A member of an exported entity: field, method, getter, setter, constructor, or interface/enum member. */
+export type DbcMember = {
+    /** @purpose Member name as declared in source */
+    name: string;
+    /** @purpose Kind of member: 'field' | 'method' | 'getter' | 'setter' | 'constructor' | 'interface-method' | 'interface-property' | 'enum-member' */
+    kind: string;
+    /** @purpose JSDoc contract associated with this member, if any */
+    contract?: DbcContractInfo;
+    /** @purpose Extracted signature information for callable members */
+    signature: DbcSignatureInfo;
+};
+/**
+ * @purpose An exported entity extracted from a source file: const, function, class, interface, type, enum, or default export.
+ * @invariant Every exported entity has a `kind` from the closed set.
+ * @invariant `members` is non-empty only for class, interface, and enum entities.
+ */
+export type DbcExportedEntity = {
+    /** @purpose Entity name as declared in source */
+    name: string;
+    /** @purpose Kind of exported entity: 'const' | 'function' | 'class' | 'interface' | 'type' | 'enum' | 'export-default' */
+    kind: string;
+    /** @purpose Members of the entity (fields, methods, etc.) — populated for class, interface, enum */
+    members: DbcMember[];
+    /** @purpose JSDoc contract associated with this entity, if any */
+    contract?: DbcContractInfo;
+    /** @purpose Extracted signature information for callable entities */
+    signature: DbcSignatureInfo;
+    /** @purpose Whether the class declaration has `implements` clause */
+    implementsInterfaces?: boolean;
+};
+/** @purpose Result of parsing a source file: either a list of exported entities or a parse error. */
+export type DbcParseResult = {
+    ok: true;
+    exported: DbcExportedEntity[];
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * @purpose Abstraction for parsing a source file and extracting exported entities with their contracts and signatures.
+ * @invariant The adapter never throws — all error paths are represented via DbcParseResult.
+ * @invariant `exported` contains all top-level exported entities, excluding re-exports.
+ */
+export interface DbcAstAdapter {
+    /**
+     * @purpose Parse a source file and extract all exported entities with their contracts and signatures.
+     * @param filePath Absolute or relative path to the source file.
+     * @param [content] Pre-read file content. When passed, the adapter uses this instead of reading from disk.
+     * @returns On success: exported entities list. On failure: error description.
+     */
+    parseFile(filePath: string, content?: string): Promise<DbcParseResult>;
+}
+export {};

package/dist/services/dbc/linter/dbc-linter.types.d.ts

@@ -0,0 +1,95 @@
+import type { DbcIssueCode } from '../parser/dbc-parser.types.js';
+/** @purpose Configuration options for linting passes. */
+export type DbcLintOptions = {
+    /** @purpose Linting strategy — only 'full' is supported in v1 */
+    strategy?: 'full';
+    /** @purpose Pre-read file content. When passed, the linter uses this instead of reading from disk. */
+    content?: string;
+};
+/** @purpose Stable string codes for dbc-linter errors. */
+export declare const ERR_DBC_LINT_MISSING_CONTRACT = "ERR_DBC_LINT_MISSING_CONTRACT";
+/** @purpose Stable string code: file could not be parsed syntactically. */
+export declare const ERR_DBC_LINT_PARSE_FAILED = "ERR_DBC_LINT_PARSE_FAILED";
+/** @purpose Stable string code: parameter exists in signature but not in contract. */
+export declare const ERR_DBC_LINT_PARAM_MISSING = "ERR_DBC_LINT_PARAM_MISSING";
+/** @purpose Stable string code: @param in contract has no matching signature parameter. */
+export declare const ERR_DBC_LINT_PARAM_EXTRA = "ERR_DBC_LINT_PARAM_EXTRA";
+/** @purpose Stable string code: @param order in contract does not match signature. */
+export declare const ERR_DBC_LINT_PARAM_ORDER = "ERR_DBC_LINT_PARAM_ORDER";
+/** @purpose Stable string code: non-void return type lacks @returns in contract. */
+export declare const ERR_DBC_LINT_RETURNS_MISSING = "ERR_DBC_LINT_RETURNS_MISSING";
+/** @purpose Stable string code: @returns present where not applicable (void, constructor, setter, field, const). */
+export declare const ERR_DBC_LINT_RETURNS_UNEXPECTED = "ERR_DBC_LINT_RETURNS_UNEXPECTED";
+/** @purpose Stable string code: {dataType} annotation in @param or @returns is redundant in a typed language. */
+export declare const ERR_DBC_LINT_TYPE_REDUNDANT = "ERR_DBC_LINT_TYPE_REDUNDANT";
+/** @purpose Stable string code: @param optionality (brackets) does not match signature optionality. */
+export declare const ERR_DBC_LINT_PARAM_OPTIONAL_MISMATCH = "ERR_DBC_LINT_PARAM_OPTIONAL_MISMATCH";
+/** @purpose Stable string code: @param/@returns present in implements-method contract (redundant — described in interface). */
+export declare const ERR_DBC_LINT_PARAM_REDUNDANT_IN_IMPLEMENTS = "ERR_DBC_LINT_PARAM_REDUNDANT_IN_IMPLEMENTS";
+/** @purpose Union of all supported dbc-linter issue codes. */
+export type DbcLintIssueCode = typeof ERR_DBC_LINT_MISSING_CONTRACT | typeof ERR_DBC_LINT_PARSE_FAILED | typeof ERR_DBC_LINT_PARAM_MISSING | typeof ERR_DBC_LINT_PARAM_EXTRA | typeof ERR_DBC_LINT_PARAM_ORDER | typeof ERR_DBC_LINT_RETURNS_MISSING | typeof ERR_DBC_LINT_RETURNS_UNEXPECTED | typeof ERR_DBC_LINT_TYPE_REDUNDANT | typeof ERR_DBC_LINT_PARAM_OPTIONAL_MISMATCH | typeof ERR_DBC_LINT_PARAM_REDUNDANT_IN_IMPLEMENTS;
+/** @purpose A single lint error bound to a specific file location and issue code. */
+export type DbcLintError = {
+    /** @purpose Absolute or relative path to the source file */
+    file: string;
+    /** @purpose One-based line number where the error was detected */
+    line: number;
+    /** @purpose One-based column number where the error was detected */
+    col: number;
+    /** @purpose Severity level — always 'error' in v1 */
+    severity: 'error';
+    /** @purpose Stable issue code identifying the error category — widened to accept parser codes (FR-23) */
+    code: DbcLintIssueCode | DbcIssueCode;
+    /** @purpose Human-readable description of the error */
+    message: string;
+};
+/**
+ * @purpose Result of a lint pass — carries discovered errors and provides ESLint-compatible formatting.
+ * @invariant `errors` is never null; empty array signals no errors detected.
+ */
+export type DbcLintReport = {
+    /** @purpose All errors discovered during the lint pass, in file-order */
+    errors: DbcLintError[];
+    /**
+     * @purpose Formats errors in ESLint-compatible output.
+     * @returns Multi-line string in `file:line:col: severity: code: message` format.
+     */
+    format(): string;
+};
+/**
+ * @purpose Result of a lint-and-fix pass — carries remaining unfixable errors and the count of auto-fixed issues.
+ * @invariant `autoFixed >= 0`. `autoFixed` = errors_before.length - errors_after.length.
+ */
+export type DbcLintFixReport = {
+    /** @purpose Errors that could not be auto-fixed */
+    errors: DbcLintError[];
+    /** @purpose Number of errors that were automatically resolved */
+    autoFixed: number;
+    /**
+     * @purpose Formats remaining errors in ESLint-compatible output.
+     * @returns Multi-line string in `file:line:col: severity: code: message` format.
+     */
+    format(): string;
+};
+/**
+ * @purpose Abstraction for linting: checks contract coverage, validates contracts, verifies signatures, and auto-fixes fixable errors.
+ * @invariant All errors are returned via report objects — the linter never throws.
+ * @invariant error order is stable (top-to-bottom by file position).
+ */
+export interface DbcLinter {
+    /**
+     * @purpose Run a full lint pass on a source file.
+     * @param filePath Path to the source file to lint.
+     * @param [options] Optional linting configuration (strategy selection).
+     * @returns A report with all discovered errors.
+     */
+    lint(filePath: string, options?: DbcLintOptions): Promise<DbcLintReport>;
+    /**
+     * @purpose Run lint and auto-fix fixable errors, mutating the source file.
+     * @param filePath Path to the source file to lint and fix.
+     * @param [options] Optional linting configuration (strategy selection).
+     * @returns A report with remaining unfixable errors and auto-fix count.
+     * @sideEffect Mutates the source file on disk to apply auto-fixes.
+     */
+    lintAndFix(filePath: string, options?: DbcLintOptions): Promise<DbcLintFixReport>;
+}

package/dist/services/dbc/linter/implementations/ts/dbc-ts-ast-adapter.d.ts

@@ -0,0 +1,183 @@
+import Parser from 'tree-sitter';
+import type { SyntaxNode } from 'tree-sitter';
+import type { DbcAstAdapter, DbcExportedEntity, DbcMember, DbcParamInfo, DbcParseResult, DbcSignatureInfo } from '../../dbc-ast-adapter.types.js';
+/** @purpose In-memory representation of JSDoc contract info before attaching to entities. */
+type RawContract = {
+    text: string;
+    startLine: number;
+    startCol: number;
+};
+/**
+ * @purpose Parses TypeScript source files via tree-sitter to extract exported entities,
+ * their members, JSDoc contracts, and signatures.
+ * @implements {DbcAstAdapter} in ../../dbc-ast-adapter.types.ts
+ * @invariant Adapter never throws — all error paths are represented via DbcParseResult.
+ * @invariant `exported` contains all top-level exported entities, excluding re-exports.
+ */
+export declare class DbcTsAstAdapter implements DbcAstAdapter {
+    /** @purpose Lazy-initialized tree-sitter parser instance */
+    protected _parser: Parser | undefined;
+    /**
+     * @param filePath Absolute path to the TypeScript source file.
+     * @param [content] Optional pre-loaded file content, bypasses disk read.
+     * @returns Parse result with exported entities or an error.
+     * @see {DbcAstAdapter#parseFile} in ../../dbc-ast-adapter.types.ts
+     */
+    parseFile(filePath: string, content?: string): Promise<DbcParseResult>;
+    /**
+     * @purpose Lazy-initializes the tree-sitter Parser with the TypeScript grammar.
+     * @returns Configured Parser instance.
+     */
+    protected _initializeParser(): Parser;
+    /**
+     * @purpose Walks the root AST node and extracts all exported entities,
+     * skipping re-exports.
+     * @param root Root CST node.
+     * @param source Full source text for slicing.
+     * @returns Array of exported entities.
+     */
+    protected _extractExported(root: SyntaxNode, source: string): DbcExportedEntity[];
+    /**
+     * @purpose Extracts a single exported entity from an export_statement node.
+     * Skips re-exports.
+     * @param node export_statement node.
+     * @param source Full source text.
+     * @param pendingContract JSDoc contract that precedes this export, if any.
+     * @returns Exported entity or undefined for re-exports.
+     */
+    protected _extractExportEntity(node: SyntaxNode, source: string, pendingContract: RawContract | undefined): DbcExportedEntity | undefined;
+    /**
+     * @purpose Determines whether an export_statement is a re-export.
+     * @param node export_statement node.
+     * @returns True if the export is a re-export that should be skipped.
+     */
+    protected _isReExport(node: SyntaxNode): boolean;
+    /**
+     * @purpose Maps a declaration node type to an entity kind string.
+     * @param nodeType tree-sitter node type.
+     * @param isDefault Whether this is a default export.
+     * @returns Entity kind.
+     */
+    protected _mapKind(nodeType: string, isDefault: boolean): string;
+    /**
+     * @purpose Extracts the entity name from a declaration node.
+     * @param node Declaration node.
+     * @param source Full source text.
+     * @param isDefault Whether this is a default export.
+     * @returns Entity name.
+     */
+    protected _extractName(node: SyntaxNode, source: string, isDefault: boolean): string;
+    /**
+     * @purpose Extracts signature info (params + returnType) from a callable declaration.
+     * @param node Declaration node.
+     * @param source Full source text.
+     * @returns Signature info with empty arrays for non-callable entities.
+     */
+    protected _extractSignature(node: SyntaxNode, source: string): DbcSignatureInfo;
+    /**
+     * @purpose Extracts a single parameter (required or optional) from the formal_parameters list.
+     * @param paramNode required_parameter or optional_parameter node.
+     * @param source Full source text.
+     * @returns Parameter info.
+     */
+    protected _extractParam(paramNode: SyntaxNode, source: string): DbcParamInfo;
+    /**
+     * @purpose Extracts members of a class, interface, or enum entity.
+     * @param node Declaration node.
+     * @param source Full source text.
+     * @param kind Entity kind.
+     * @returns Array of members (empty for non-collection entities).
+     */
+    protected _extractMembers(node: SyntaxNode, source: string, kind: string): DbcMember[];
+    /**
+     * @purpose Extracts members from a class declaration body.
+     * @param node class_declaration node.
+     * @param source Full source text.
+     * @returns Array of class members.
+     */
+    protected _extractClassMembers(node: SyntaxNode, source: string): DbcMember[];
+    /**
+     * @purpose Extracts members from an interface declaration body.
+     * @param node interface_declaration node.
+     * @param source Full source text.
+     * @returns Array of interface members.
+     */
+    protected _extractInterfaceMembers(node: SyntaxNode, source: string): DbcMember[];
+    /**
+     * @purpose Extracts members from a type alias with an object type literal body.
+     * Delegates to the same logic as interface members since object_type ≡ interface body.
+     * @param node type_alias_declaration node.
+     * @param source Full source text.
+     * @returns Array of object type members.
+     */
+    protected _extractTypeAliasMembers(node: SyntaxNode, source: string): DbcMember[];
+    /**
+     * @purpose Extracts members from an object_type or interface body node.
+     * Shared by type alias (object_type) and interface declarations.
+     * @param body object_type or interface_body node.
+     * @param source Full source text.
+     * @returns Array of members.
+     */
+    protected _extractObjectTypeMembers(body: SyntaxNode, source: string): DbcMember[];
+    /**
+     * @purpose Checks if a property_signature node has a function type annotation.
+     * @param node property_signature node.
+     * @returns True if the property is function-typed.
+     */
+    protected _isFunctionTypedProperty(node: SyntaxNode): boolean;
+    /**
+     * @purpose Finds the function_type node inside a property_signature's type annotation.
+     * @param node property_signature node.
+     * @returns The function_type node, or null.
+     */
+    protected _findFunctionTypeNode(node: SyntaxNode): SyntaxNode | null;
+    /**
+     * @purpose Extracts members from an enum declaration body.
+     * @param node enum_declaration node.
+     * @param source Full source text.
+     * @returns Array of enum members.
+     */
+    protected _extractEnumMembers(node: SyntaxNode, source: string): DbcMember[];
+    /**
+     * @purpose Extracts the method name from a method_definition node,
+     * handling getter/setter property names.
+     * @param node method_definition node.
+     * @param source Full source text.
+     * @returns Method name.
+     */
+    protected _extractMethodName(node: SyntaxNode, source: string): string;
+    /**
+     * @purpose Extracts the field name from a public_field_definition node.
+     * @param node public_field_definition node.
+     * @param source Full source text.
+     * @returns Field name.
+     */
+    protected _extractFieldName(node: SyntaxNode, source: string): string;
+    /**
+     * @purpose Checks if a method_definition has a given token (e.g., 'get', 'set').
+     * @param node method_definition node.
+     * @param token Token text to search for.
+     * @returns True if the token is present.
+     */
+    protected _hasToken(node: SyntaxNode, token: string): boolean;
+    /**
+     * @purpose Checks if a class_declaration node has an implements clause.
+     * @param node class_declaration node.
+     * @returns True if the class has `implements` clause.
+     */
+    protected _hasImplements(node: SyntaxNode): boolean;
+    /**
+     * @purpose Finds a direct child node by type, returning first match.
+     * @param parent Parent node.
+     * @param type Child node type to find.
+     * @returns First matching child or null.
+     */
+    protected _findChild(parent: SyntaxNode, type: string): SyntaxNode | null;
+    /**
+     * @purpose Recursively searches for the first ERROR node in the tree.
+     * @param node Root node to search from.
+     * @returns First ERROR node found, or undefined.
+     */
+    protected _findErrorNode(node: SyntaxNode): SyntaxNode | undefined;
+}
+export {};