@codingame/monaco-vscode-chat-service-override 20.1.1 → 20.2.0

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/codecs/base/frontMatterCodec/tokens/frontMatterBoolean.d.ts

@@ -1,14 +1,34 @@
 import { BaseToken } from "../../baseToken.js";
 import { Word } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/codecs/base/simpleCodec/tokens/tokens";
 import { FrontMatterValueToken } from "./frontMatterToken.js";
+/**
+ * Token that represents a `boolean` value in a Front Matter header.
+ */
 export declare class FrontMatterBoolean extends FrontMatterValueToken<"boolean", readonly [
     Word
 ]> {
+    /**
+     * Name of the `boolean` value type.
+     */
     readonly valueTypeName = "boolean";
+    /**
+     * Value of the `boolean` token.
+     */
     readonly value: boolean;
+    /**
+     * @throws if provided {@link Word} cannot be converted to a `boolean` value.
+     */
     constructor(token: Word);
+    /**
+     * Try creating a {@link FrontMatterBoolean} out of provided token.
+     * Unlike the constructor, this method does not throw, returning
+     * a 'null' value on failure instead.
+     */
     static tryFromToken(token: BaseToken): FrontMatterBoolean | null;
     equals(other: BaseToken): other is typeof this;
     toString(): string;
 }
+/**
+ * Try to convert a {@link Word} token to a `boolean` value.
+ */
 export declare function asBoolean(token: Word): boolean | null;

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/codecs/base/frontMatterCodec/tokens/frontMatterRecord.d.ts

@@ -1,22 +1,83 @@
 import { Colon, Word, Dash, SpacingToken } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/codecs/base/simpleCodec/tokens/tokens";
 import { FrontMatterToken, FrontMatterValueToken, type TValueTypeName } from "./frontMatterToken.js";
+/**
+ * Type for tokens that can be used inside a record name.
+ */
 export type TNameToken = Word | Dash;
+/**
+ * Token representing a `record name` inside a Front Matter record.
+ *
+ * E.g., `name` in the example below:
+ *
+ * ```
+ * ---
+ * name: 'value'
+ * ---
+ * ```
+ */
 export declare class FrontMatterRecordName extends FrontMatterToken<readonly TNameToken[]> {
     toString(): string;
 }
+/**
+ * Token representing a delimiter of a record inside a Front Matter header.
+ *
+ * E.g., `: ` in the example below:
+ *
+ * ```
+ * ---
+ * name: 'value'
+ * ---
+ * ```
+ */
 export declare class FrontMatterRecordDelimiter extends FrontMatterToken<readonly [
     Colon,
     SpacingToken
 ]> {
     toString(): string;
 }
+/**
+ * Token representing a `record` inside a Front Matter header.
+ *
+ * E.g., `name: 'value'` in the example below:
+ *
+ * ```
+ * ---
+ * name: 'value'
+ * ---
+ * ```
+ */
 export declare class FrontMatterRecord extends FrontMatterToken<readonly [
     FrontMatterRecordName,
     FrontMatterRecordDelimiter,
     FrontMatterValueToken<TValueTypeName>
 ]> {
+    /**
+     * Token that represent `name` of the record.
+     *
+     * E.g., `tools` in the example below:
+     *
+     * ```
+     * ---
+     * tools: ['value']
+     * ---
+     * ```
+     */
     get nameToken(): FrontMatterRecordName;
+    /**
+     * Token that represent `value` of the record.
+     *
+     * E.g., `['value']` in the example below:
+     *
+     * ```
+     * ---
+     * tools: ['value']
+     * ---
+     * ```
+     */
     get valueToken(): FrontMatterValueToken<TValueTypeName>;
+    /**
+     * Trim spacing tokens at the end of the record.
+     */
     trimValueEnd(): readonly SpacingToken[];
     toString(): string;
 }

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/codecs/base/frontMatterCodec/tokens/frontMatterSequence.d.ts

@@ -1,9 +1,27 @@
 import { FrontMatterValueToken } from "./frontMatterToken.js";
 import { SpacingToken } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/codecs/base/simpleCodec/tokens/tokens";
 import { type TSimpleDecoderToken } from "../../simpleCodec/simpleDecoder.js";
+/**
+ * Token represents a generic sequence of tokens in a Front Matter header.
+ */
 export declare class FrontMatterSequence extends FrontMatterValueToken<FrontMatterSequence, readonly TSimpleDecoderToken[]> {
+    /**
+     * @override Because this token represent a generic sequence of tokens,
+     *           the type name is represented by the sequence of tokens itself
+     */
     get valueTypeName(): this;
+    /**
+     * Text of the sequence value. The method exists to provide a
+     * consistent interface with {@link FrontMatterString} token.
+     *
+     * Note! that this method does not automatically trim spacing tokens
+     *       in the sequence. If you need to get a trimmed value, call
+     *       {@link trimEnd} method first.
+     */
     get cleanText(): string;
+    /**
+     * Trim spacing tokens at the end of the sequence.
+     */
     trimEnd(): readonly SpacingToken[];
     toString(): string;
 }

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/codecs/base/frontMatterCodec/tokens/frontMatterString.d.ts

@@ -1,13 +1,25 @@
 import { BaseToken } from "../../baseToken.js";
 import { FrontMatterValueToken } from "./frontMatterToken.js";
 import { Quote, DoubleQuote } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/codecs/base/simpleCodec/tokens/tokens";
+/**
+ * Type for any quote token that can be used to wrap a string.
+ */
 export type TQuoteToken = Quote | DoubleQuote;
+/**
+ * Token that represents a string value in a Front Matter header.
+ */
 export declare class FrontMatterString<TQuote extends TQuoteToken = Quote> extends FrontMatterValueToken<"quoted-string", readonly [
     TQuote,
     ...BaseToken[],
     TQuote
 ]> {
+    /**
+     * Name of the `string` value type.
+     */
     readonly valueTypeName = "quoted-string";
+    /**
+     * Text of the string value without the wrapping quotes.
+     */
     get cleanText(): string;
     toString(): string;
 }

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/codecs/base/frontMatterCodec/tokens/frontMatterToken.d.ts

@@ -1,9 +1,21 @@
 import { BaseToken } from "../../baseToken.js";
 import { CompositeToken } from "../../compositeToken.js";
 import { FrontMatterSequence } from "./frontMatterSequence.js";
+/**
+ * Base class for all tokens inside a Front Matter header.
+ */
 export declare abstract class FrontMatterToken<TTokens extends readonly BaseToken[] = readonly BaseToken[]> extends CompositeToken<TTokens> {
 }
+/**
+ * List of all currently supported value types.
+ */
 export type TValueTypeName = "quoted-string" | "boolean" | "array" | FrontMatterSequence;
+/**
+ * Base class for all tokens that represent a `value` inside a Front Matter header.
+ */
 export declare abstract class FrontMatterValueToken<TTypeName extends TValueTypeName = TValueTypeName, TTokens extends readonly BaseToken[] = readonly BaseToken[]> extends FrontMatterToken<TTokens> {
+    /**
+     * Type name of the `value` represented by this token.
+     */
     abstract readonly valueTypeName: TTypeName;
 }

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/codecs/base/linesCodec/linesDecoder.d.ts

@@ -3,14 +3,58 @@ import { NewLine } from "./tokens/newLine.js";
 import { CarriageReturn } from "./tokens/carriageReturn.js";
 import { VSBuffer } from "@codingame/monaco-vscode-api/vscode/vs/base/common/buffer";
 import { BaseDecoder } from "../baseDecoder.js";
+/**
+ * Any line break token type.
+ */
 export type TLineBreakToken = CarriageReturn | NewLine;
+/**
+ * Tokens produced by the {@link LinesDecoder}.
+ */
 export type TLineToken = Line | TLineBreakToken;
+/**
+ * The `decoder` part of the `LinesCodec` and is able to transform
+ * data from a binary stream into a stream of text lines(`Line`).
+ */
 export declare class LinesDecoder extends BaseDecoder<TLineToken, VSBuffer> {
+    /**
+     * Buffered received data yet to be processed.
+     */
     private buffer;
+    /**
+     * The last emitted `Line` token, if any. The value is used
+     * to correctly emit remaining line range in the `onStreamEnd`
+     * method when underlying input stream ends and `buffer` still
+     * contains some data that must be emitted as the last line.
+     */
     private lastEmittedLine?;
+    /**
+     * Process data received from the input stream.
+     */
     protected onStreamData(chunk: VSBuffer): void;
+    /**
+     * Process buffered data.
+     *
+     * @param streamEnded Flag that indicates if the input stream has ended,
+     * 					  which means that is the last call of this method.
+     * @throws If internal logic implementation error is detected.
+     */
     private processData;
+    /**
+     * Find the end of line tokens in the data buffer.
+     * Can return:
+     *  - [`\r`, `\n`] tokens if the sequence is found
+     *  - [`\r`] token if only the carriage return is found
+     *  - [`\n`] token if only the newline is found
+     *  - an `empty array` if no end of line tokens found
+     */
     private findEndOfLineTokens;
+    /**
+     * Emit a provided line as the `Line` token to the output stream.
+     */
     private emitLine;
+    /**
+     * Handle the end of the input stream - if the buffer still has some data,
+     * emit it as the last available line token before firing the `onEnd` event.
+     */
     protected onStreamEnd(): void;
 }

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/codecs/base/linesCodec/tokens/carriageReturn.d.ts

@@ -1,9 +1,28 @@
 import { VSBuffer } from "@codingame/monaco-vscode-api/vscode/vs/base/common/buffer";
 import { SimpleToken } from "../../simpleCodec/tokens/simpleToken.js";
+/**
+ * Token that represent a `carriage return` with a `range`. The `range`
+ * value reflects the position of the token in the original data.
+ */
 export declare class CarriageReturn extends SimpleToken<"\r"> {
+    /**
+     * The underlying symbol of the token.
+     */
     static readonly symbol: "\r";
+    /**
+     * The byte representation of the {@link symbol}.
+     */
     static readonly byte: VSBuffer;
+    /**
+     * The byte representation of the token.
+     */
     get byte(): VSBuffer;
+    /**
+     * Return text representation of the token.
+     */
     get text(): "\r";
+    /**
+     * Returns a string representation of the token.
+     */
     toString(): string;
 }

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/codecs/base/linesCodec/tokens/line.d.ts

@@ -1,6 +1,13 @@
 import { BaseToken } from "../../baseToken.js";
+/**
+ * Token representing a line of text with a `range` which
+ * reflects the line's position in the original data.
+ */
 export declare class Line extends BaseToken {
     readonly text: string;
     constructor(lineNumber: number, text: string);
+    /**
+     * Returns a string representation of the token.
+     */
     toString(): string;
 }

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/codecs/base/linesCodec/tokens/newLine.d.ts

@@ -1,9 +1,28 @@
 import { VSBuffer } from "@codingame/monaco-vscode-api/vscode/vs/base/common/buffer";
 import { SimpleToken } from "../../simpleCodec/tokens/simpleToken.js";
+/**
+ * A token that represent a `new line` with a `range`. The `range`
+ * value reflects the position of the token in the original data.
+ */
 export declare class NewLine extends SimpleToken<"\n"> {
+    /**
+     * The underlying symbol of the `NewLine` token.
+     */
     static readonly symbol: "\n";
+    /**
+     * The byte representation of the {@link symbol}.
+     */
     static readonly byte: VSBuffer;
+    /**
+     * Return text representation of the token.
+     */
     get text(): "\n";
+    /**
+     * The byte representation of the token.
+     */
     get byte(): VSBuffer;
+    /**
+     * Returns a string representation of the token.
+     */
     toString(): string;
 }

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/codecs/base/markdownCodec/markdownDecoder.d.ts

@@ -3,8 +3,18 @@ import { VSBuffer } from "@codingame/monaco-vscode-api/vscode/vs/base/common/buf
 import { ReadableStream } from "@codingame/monaco-vscode-api/vscode/vs/base/common/stream";
 import { TSimpleDecoderToken } from "../simpleCodec/simpleDecoder.js";
 import { BaseDecoder } from "../baseDecoder.js";
+/**
+ * Tokens produced by this decoder.
+ */
 export type TMarkdownToken = MarkdownToken | TSimpleDecoderToken;
+/**
+ * Decoder capable of parsing markdown entities (e.g., links) from a sequence of simple tokens.
+ */
 export declare class MarkdownDecoder extends BaseDecoder<TMarkdownToken, TSimpleDecoderToken> {
+    /**
+     * Current parser object that is responsible for parsing a sequence of tokens into
+     * some markdown entity. Set to `undefined` when no parsing is in progress at the moment.
+     */
     private current?;
     constructor(stream: ReadableStream<VSBuffer>);
     protected onStreamData(token: TSimpleDecoderToken): void;

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/codecs/base/markdownCodec/parsers/markdownComment.d.ts

@@ -4,10 +4,18 @@ import { TSimpleDecoderToken } from "../../simpleCodec/simpleDecoder.js";
 import { ExclamationMark } from "../../simpleCodec/tokens/exclamationMark.js";
 import { LeftAngleBracket } from "../../simpleCodec/tokens/angleBrackets.js";
 import { ParserBase, TAcceptTokenResult } from "../../simpleCodec/parserBase.js";
+/**
+ * The parser responsible for parsing the `<!--` sequence - the start of a `markdown comment`.
+ */
 export declare class PartialMarkdownCommentStart extends ParserBase<TSimpleDecoderToken, PartialMarkdownCommentStart | MarkdownCommentStart> {
     constructor(token: LeftAngleBracket);
     accept(token: TSimpleDecoderToken): TAcceptTokenResult<PartialMarkdownCommentStart | MarkdownCommentStart>;
 }
+/**
+ * The parser responsible for a `markdown comment` sequence of tokens.
+ * E.g. `<!-- some comment` which may or may not end with `-->`. If it does,
+ * then the parser transitions to the {@link MarkdownComment} token.
+ */
 export declare class MarkdownCommentStart extends ParserBase<TSimpleDecoderToken, MarkdownCommentStart | MarkdownComment> {
     constructor(tokens: [
         LeftAngleBracket,
@@ -16,7 +24,19 @@ export declare class MarkdownCommentStart extends ParserBase<TSimpleDecoderToken
         Dash
     ]);
     accept(token: TSimpleDecoderToken): TAcceptTokenResult<MarkdownCommentStart | MarkdownComment>;
+    /**
+     * Convert the current token sequence into a {@link MarkdownComment} token.
+     *
+     * Note! that this method marks the current parser object as "consumed"
+     *       hence it should not be used after this method is called.
+     */
     asMarkdownComment(): MarkdownComment;
+    /**
+     * Get range of current token sequence.
+     */
     private get range();
+    /**
+     * Whether the current token sequence ends with two dashes.
+     */
     private get endsWithDashes();
 }

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/codecs/base/markdownCodec/parsers/markdownImage.d.ts

@@ -2,9 +2,19 @@ import { MarkdownImage } from "../tokens/markdownImage.js";
 import { TSimpleDecoderToken } from "../../simpleCodec/simpleDecoder.js";
 import { ExclamationMark } from "../../simpleCodec/tokens/exclamationMark.js";
 import { ParserBase, TAcceptTokenResult } from "../../simpleCodec/parserBase.js";
+/**
+ * The parser responsible for parsing the `markdown image` sequence of characters.
+ * E.g., `![alt text](./path/to/image.jpeg)` syntax.
+ */
 export declare class PartialMarkdownImage extends ParserBase<TSimpleDecoderToken, PartialMarkdownImage | MarkdownImage> {
+    /**
+     * Current active parser instance, if in the mode of actively parsing the markdown link sequence.
+     */
     private markdownLinkParser;
     constructor(token: ExclamationMark);
+    /**
+     * Get all currently available tokens of the `markdown link` sequence.
+     */
     get tokens(): readonly TSimpleDecoderToken[];
     accept(token: TSimpleDecoderToken): TAcceptTokenResult<PartialMarkdownImage | MarkdownImage>;
 }

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/codecs/base/markdownCodec/parsers/markdownLink.d.ts

@@ -3,15 +3,69 @@ import { TSimpleDecoderToken } from "../../simpleCodec/simpleDecoder.js";
 import { LeftBracket } from "../../simpleCodec/tokens/brackets.js";
 import { ParserBase, TAcceptTokenResult } from "../../simpleCodec/parserBase.js";
 import { LeftParenthesis } from "../../simpleCodec/tokens/parentheses.js";
+/**
+ * The parser responsible for parsing a `markdown link caption` part of a markdown
+ * link (e.g., the `[caption text]` part of the `[caption text](./some/path)` link).
+ *
+ * The parsing process starts with single `[` token and collects all tokens until
+ * the first `]` token is encountered. In this successful case, the parser transitions
+ * into the {@link MarkdownLinkCaption} parser type which continues the general
+ * parsing process of the markdown link.
+ *
+ * Otherwise, if one of the stop characters defined in the {@link MARKDOWN_LINK_STOP_CHARACTERS}
+ * is encountered before the `]` token, the parsing process is aborted which is communicated to
+ * the caller by returning a `failure` result. In this case, the caller is assumed to be responsible
+ * for re-emitting the {@link tokens} accumulated so far as standalone entities since they are no
+ * longer represent a coherent token entity of a larger size.
+ */
 export declare class PartialMarkdownLinkCaption extends ParserBase<TSimpleDecoderToken, PartialMarkdownLinkCaption | MarkdownLinkCaption> {
     constructor(token: LeftBracket);
     accept(token: TSimpleDecoderToken): TAcceptTokenResult<PartialMarkdownLinkCaption | MarkdownLinkCaption>;
 }
+/**
+ * The parser responsible for transitioning from a {@link PartialMarkdownLinkCaption}
+ * parser to the {@link PartialMarkdownLink} one, therefore serves a parser glue between
+ * the `[caption]` and the `(./some/path)` parts of the `[caption](./some/path)` link.
+ *
+ * The only successful case of this parser is the `(` token that initiated the process
+ * of parsing the `reference` part of a markdown link and in this case the parser
+ * transitions into the `PartialMarkdownLink` parser type.
+ *
+ * Any other character is considered a failure result. In this case, the caller is assumed
+ * to be responsible for re-emitting the {@link tokens} accumulated so far as standalone
+ * entities since they are no longer represent a coherent token entity of a larger size.
+ */
 export declare class MarkdownLinkCaption extends ParserBase<TSimpleDecoderToken, MarkdownLinkCaption | PartialMarkdownLink> {
     accept(token: TSimpleDecoderToken): TAcceptTokenResult<MarkdownLinkCaption | PartialMarkdownLink>;
 }
+/**
+ * The parser responsible for parsing a `link reference` part of a markdown link
+ * (e.g., the `(./some/path)` part of the `[caption text](./some/path)` link).
+ *
+ * The parsing process starts with tokens that represent the `[caption]` part of a markdown
+ * link, followed by the `(` token. The parser collects all subsequent tokens until final closing
+ * parenthesis (`)`) is encountered (*\*see [1] below*). In this successful case, the parser object
+ * transitions into the {@link MarkdownLink} token type which signifies the end of the entire
+ * parsing process of the link text.
+ *
+ * Otherwise, if one of the stop characters defined in the {@link MARKDOWN_LINK_STOP_CHARACTERS}
+ * is encountered before the final `)` token, the parsing process is aborted which is communicated to
+ * the caller by returning a `failure` result. In this case, the caller is assumed to be responsible
+ * for re-emitting the {@link tokens} accumulated so far as standalone entities since they are no
+ * longer represent a coherent token entity of a larger size.
+ *
+ * `[1]` The `reference` part of the markdown link can contain any number of nested parenthesis, e.g.,
+ * 	  `[caption](/some/p(th/file.md)` is a valid markdown link and a valid folder name, hence number
+ *     of open parenthesis must match the number of closing ones and the path sequence is considered
+ *     to be complete as soon as this requirement is met. Therefore the `final` word is used in
+ *     the description comments above to highlight this important detail.
+ */
 export declare class PartialMarkdownLink extends ParserBase<TSimpleDecoderToken, PartialMarkdownLink | MarkdownLink> {
     protected readonly captionTokens: TSimpleDecoderToken[];
+    /**
+     * Number of open parenthesis in the sequence.
+     * See comment in the {@link accept} method for more details.
+     */
     private openParensCount;
     constructor(captionTokens: TSimpleDecoderToken[], token: LeftParenthesis);
     get tokens(): readonly TSimpleDecoderToken[];

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/codecs/base/markdownCodec/tokens/markdownComment.d.ts

@@ -1,8 +1,18 @@
 import { Range } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range";
 import { MarkdownToken } from "./markdownToken.js";
+/**
+ * A token that represent a `markdown comment` with a `range`. The `range`
+ * value reflects the position of the token in the original data.
+ */
 export declare class MarkdownComment extends MarkdownToken {
     readonly text: string;
     constructor(range: Range, text: string);
+    /**
+     * Whether the comment has an end comment marker `-->`.
+     */
     get hasEndMarker(): boolean;
+    /**
+     * Returns a string representation of the token.
+     */
     toString(): string;
 }

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/codecs/base/markdownCodec/tokens/markdownImage.d.ts

@@ -1,12 +1,50 @@
 import { MarkdownToken } from "./markdownToken.js";
 import { IRange } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range";
+/**
+ * A token that represent a `markdown image` with a `range`. The `range`
+ * value reflects the position of the token in the original data.
+ */
 export declare class MarkdownImage extends MarkdownToken {
+    /**
+     * The caption of the image, including the `!` and `square brackets`.
+     */
     private readonly caption;
+    /**
+     * The reference of the image, including the parentheses.
+     */
     private readonly reference;
+    /**
+     * Check if this `markdown image link` points to a valid URL address.
+     */
     readonly isURL: boolean;
-    constructor(lineNumber: number, columnNumber: number, caption: string, reference: string);
+    constructor(
+    /**
+     * The starting line number of the image (1-based indexing).
+     */
+    lineNumber: number, 
+    /**
+     * The starting column number of the image (1-based indexing).
+     */
+    columnNumber: number, 
+    /**
+     * The caption of the image, including the `!` and `square brackets`.
+     */
+    caption: string, 
+    /**
+     * The reference of the image, including the parentheses.
+     */
+    reference: string);
     get text(): string;
+    /**
+     * Returns the `reference` part of the link without enclosing parentheses.
+     */
     get path(): string;
+    /**
+     * Get the range of the `link part` of the token.
+     */
     get linkRange(): IRange | undefined;
+    /**
+     * Returns a string representation of the token.
+     */
     toString(): string;
 }

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/codecs/base/markdownCodec/tokens/markdownLink.d.ts

@@ -1,12 +1,50 @@
 import { MarkdownToken } from "./markdownToken.js";
 import { IRange } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range";
+/**
+ * A token that represent a `markdown link` with a `range`. The `range`
+ * value reflects the position of the token in the original data.
+ */
 export declare class MarkdownLink extends MarkdownToken {
+    /**
+     * The caption of the original link, including the square brackets.
+     */
     readonly caption: string;
+    /**
+     * The reference of the original link, including the parentheses.
+     */
     readonly reference: string;
+    /**
+     * Check if this `markdown link` points to a valid URL address.
+     */
     readonly isURL: boolean;
-    constructor(lineNumber: number, columnNumber: number, caption: string, reference: string);
+    constructor(
+    /**
+     * The starting line number of the link (1-based indexing).
+     */
+    lineNumber: number, 
+    /**
+     * The starting column number of the link (1-based indexing).
+     */
+    columnNumber: number, 
+    /**
+     * The caption of the original link, including the square brackets.
+     */
+    caption: string, 
+    /**
+     * The reference of the original link, including the parentheses.
+     */
+    reference: string);
     get text(): string;
+    /**
+     * Returns the `reference` part of the link without enclosing parentheses.
+     */
     get path(): string;
+    /**
+     * Get the range of the `link part` of the token.
+     */
     get linkRange(): IRange | undefined;
+    /**
+     * Returns a string representation of the token.
+     */
     toString(): string;
 }

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/codecs/base/markdownCodec/tokens/markdownToken.d.ts

@@ -1,3 +1,7 @@
 import { BaseToken } from "../../baseToken.js";
+/**
+ * Common base token that all `markdown` tokens should
+ * inherit from.
+ */
 export declare abstract class MarkdownToken extends BaseToken {
 }

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/codecs/base/markdownExtensionsCodec/markdownExtensionsDecoder.d.ts

@@ -3,11 +3,25 @@ import { ReadableStream } from "@codingame/monaco-vscode-api/vscode/vs/base/comm
 import { BaseDecoder } from "../baseDecoder.js";
 import { MarkdownExtensionsToken } from "./tokens/markdownExtensionsToken.js";
 import { TSimpleDecoderToken } from "../simpleCodec/simpleDecoder.js";
+/**
+ * Tokens produced by this decoder.
+ */
 export type TMarkdownExtensionsToken = MarkdownExtensionsToken | TSimpleDecoderToken;
+/**
+ * Decoder responsible for decoding extensions of markdown syntax,
+ * e.g., a `Front Matter` header, etc.
+ */
 export declare class MarkdownExtensionsDecoder extends BaseDecoder<TMarkdownExtensionsToken, TSimpleDecoderToken> {
+    /**
+     * Current parser object that is responsible for parsing a sequence of tokens into
+     * some markdown entity. Set to `undefined` when no parsing is in progress at the moment.
+     */
     private current?;
     constructor(stream: ReadableStream<VSBuffer>);
     protected onStreamData(token: TSimpleDecoderToken): void;
     protected onStreamEnd(): void;
+    /**
+     * Re-emit tokens accumulated so far in the current parser object.
+     */
     protected reEmitCurrentTokens(): void;
 }