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

package/vscode/src/vs/workbench/contrib/chat/common/chatSlashCommands.d.ts

@@ -11,7 +11,18 @@ export interface IChatSlashData {
     command: string;
     detail: string;
     sortText?: string;
+    /**
+     * Whether the command should execute as soon
+     * as it is entered. Defaults to `false`.
+     */
     executeImmediately?: boolean;
+    /**
+     * Whether the command should be added as a request/response
+     * turn to the chat history. Defaults to `false`.
+     *
+     * For instance, the `/save` command opens an untitled document
+     * to the side hence does not contain any chatbot responses.
+     */
     silent?: boolean;
     locations: ChatAgentLocation[];
     modes?: ChatModeKind[];

package/vscode/src/vs/workbench/contrib/chat/common/promptFileReferenceErrors.d.ts

@@ -1,38 +1,92 @@
 import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+/**
+ * Base prompt parsing error class.
+ */
 declare abstract class ParseError extends Error {
+    /**
+     * Error type name.
+     */
     abstract readonly errorType: string;
     constructor(message?: string, options?: ErrorOptions);
+    /**
+     * Check if provided object is of the same type as this error.
+     */
     sameTypeAs(other: unknown): other is typeof this;
+    /**
+     * Check if provided object is equal to this error.
+     */
     equal(other: unknown): boolean;
 }
+/**
+ * Base resolve error class used when file reference resolution fails.
+ */
 export declare abstract class ResolveError extends ParseError {
     readonly uri: URI;
     abstract errorType: string;
     constructor(uri: URI, message?: string, options?: ErrorOptions);
 }
+/**
+ * A generic error for failing to resolve prompt contents stream.
+ */
 export declare class FailedToResolveContentsStream extends ResolveError {
     readonly originalError: unknown;
     errorType: string;
     constructor(uri: URI, originalError: unknown, message?: string);
 }
+/**
+ * Error that reflects the case when attempt to open target file fails.
+ */
 export declare class OpenFailed extends FailedToResolveContentsStream {
     errorType: string;
     constructor(uri: URI, originalError: unknown);
 }
+/**
+ * Error that reflects the case when attempt resolve nested file
+ * references failes due to a recursive reference, e.g.,
+ *
+ * ```markdown
+ * // a.md
+ * #file:b.md
+ * ```
+ *
+ * ```markdown
+ * // b.md
+ * #file:a.md
+ * ```
+ */
 export declare class RecursiveReference extends ResolveError {
     readonly recursivePath: readonly string[];
     errorType: string;
+    /**
+     * Cached default string representation of the recursive path.
+     */
     private defaultPathStringCache;
     constructor(uri: URI, recursivePath: readonly string[]);
     get message(): string;
+    /**
+     * Returns a string representation of the recursive path.
+     */
     getRecursivePathString(filename: "basename" | "fullpath", pathJoinCharacter?: string): string;
+    /**
+     * Check if provided object is of the same type as this
+     * error, contains the same recursive path and URI.
+     */
     equal(other: unknown): other is this;
+    /**
+     * Returns a string representation of the error object.
+     */
     toString(): string;
 }
+/**
+ * Error for the case when a resource URI doesn't point to a prompt file.
+ */
 export declare class NotPromptFile extends ResolveError {
     errorType: string;
     constructor(uri: URI, message?: string);
 }
+/**
+ * Error for the case when a resource URI points to a folder.
+ */
 export declare class FolderReference extends NotPromptFile {
     errorType: string;
     constructor(uri: URI, message?: string);

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

@@ -1,9 +1,27 @@
 import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
 import { BaseDecoder } from "./baseDecoder.js";
+/**
+ * Asynchronous iterator wrapper for a decoder.
+ */
 export declare class AsyncDecoder<T extends NonNullable<unknown>, K extends NonNullable<unknown> = NonNullable<unknown>> extends Disposable {
     private readonly decoder;
     private readonly messages;
+    /**
+     * A transient promise that is resolved when a new event
+     * is received. Used in the situation when there is no new
+     * data available and decoder stream did not finish yet,
+     * hence we need to wait until new event is received.
+     */
     private resolveOnNewEvent?;
+    /**
+     * @param decoder The decoder instance to wrap.
+     *
+     * Note! Assumes ownership of the `decoder` object, hence will `dispose`
+     * 		 it when the decoder stream is ended.
+     */
     constructor(decoder: BaseDecoder<T, K>);
+    /**
+     * Async iterator implementation.
+     */
     [Symbol.asyncIterator](): AsyncIterator<T | null>;
 }

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

@@ -1,35 +1,137 @@
 import { Emitter } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
 import { ReadableStream } from "@codingame/monaco-vscode-api/vscode/vs/base/common/stream";
 import { ObservableDisposable } from "../../utils/observableDisposable.js";
+/**
+ * Event names of {@link ReadableStream} stream.
+ */
 export type TStreamListenerNames = "data" | "error" | "end";
+/**
+ * Base decoder class that can be used to convert stream messages data type
+ * from one type to another. For instance, a stream of binary data can be
+ * "decoded" into a stream of well defined objects.
+ * Intended to be a part of "codec" implementation rather than used directly.
+ */
 export declare abstract class BaseDecoder<T extends NonNullable<unknown>, K extends NonNullable<unknown> = NonNullable<unknown>> extends ObservableDisposable implements ReadableStream<T> {
     protected readonly stream: ReadableStream<K>;
+    /**
+     * Private attribute to track if the stream has ended.
+     */
     private _ended;
     protected readonly _onData: Emitter<T>;
     private readonly _onEnd;
     private readonly _onError;
+    /**
+     * A store of currently registered event listeners.
+     */
     private readonly _listeners;
+    /**
+     * This method is called when a new incoming data
+     * is received from the input stream.
+     */
     protected abstract onStreamData(data: K): void;
+    /**
+     * @param stream The input stream to decode.
+     */
     constructor(stream: ReadableStream<K>);
+    /**
+     * Private attribute to track if the stream has started.
+     */
     private started;
+    /**
+     * Promise that resolves when the stream has ended, either by
+     * receiving the `end` event or by a disposal, but not when
+     * the `error` event is received alone.
+     * The promise is true if the stream has ended, and false
+     * if the stream has been disposed without ending.
+     */
     private settledPromise;
+    /**
+     * Promise that resolves when the stream has ended, either by
+     * receiving the `end` event or by a disposal, but not when
+     * the `error` event is received alone.
+     * The promise is true if the stream has ended, and false
+     * if the stream has been disposed without ending.
+     *
+     * @throws If the stream was not yet started to prevent this
+     * 		   promise to block the consumer calls indefinitely.
+     */
     get settled(): Promise<boolean>;
+    /**
+     * Start receiving data from the stream.
+     * @throws if the decoder stream has already ended.
+     */
     start(): this;
+    /**
+     * Check if the decoder has been ended hence has
+     * no more data to produce.
+     */
     get ended(): boolean;
+    /**
+     * Automatically catch and dispatch errors thrown inside `onStreamData`.
+     */
     private tryOnStreamData;
     on(event: "data", callback: (data: T) => void): void;
     on(event: "error", callback: (err: Error) => void): void;
     on(event: "end", callback: () => void): void;
+    /**
+     * Add listener for the `data` event.
+     * @throws if the decoder stream has already ended.
+     */
     onData(callback: (data: T) => void): void;
+    /**
+     * Add listener for the `error` event.
+     * @throws if the decoder stream has already ended.
+     */
     onError(callback: (error: Error) => void): void;
+    /**
+     * Add listener for the `end` event.
+     * @throws if the decoder stream has already ended.
+     */
     onEnd(callback: () => void): void;
+    /**
+     * Pauses the stream.
+     */
     pause(): void;
+    /**
+     * Resumes the stream if it has been paused.
+     * @throws if the decoder stream has already ended.
+     */
     resume(): void;
+    /**
+     * Destroys(disposes) the stream.
+     */
     destroy(): void;
+    /**
+     * Removes a previously-registered event listener for a specified event.
+     *
+     * Note!
+     *  - the callback function must be the same as the one that was used when
+     * 	  registering the event listener as it is used as an identifier to
+     *    remove the listener
+     *  - this method is idempotent and results in no-op if the listener is
+     *    not found, therefore passing incorrect `callback` function may
+     *    result in silent unexpected behavior
+     */
     removeListener(eventName: TStreamListenerNames, callback: Function): void;
+    /**
+     * This method is called when the input stream ends.
+     */
     protected onStreamEnd(): void;
+    /**
+     * This method is called when the input stream emits an error.
+     * We re-emit the error here by default, but subclasses can
+     * override this method to handle the error differently.
+     */
     private onStreamError;
+    /**
+     * Consume all messages from the stream, blocking until the stream finishes.
+     * @throws if the decoder stream has already ended.
+     */
     consumeAll(): Promise<T[]>;
+    /**
+     * Async iterator interface for the decoder.
+     * @throws if the decoder stream has already ended.
+     */
     [Symbol.asyncIterator](): AsyncIterator<T | null>;
     dispose(): void;
 }

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

@@ -1,15 +1,57 @@
 import { IRange, Range } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range";
+/**
+ * Base class for all tokens with a `range` that reflects
+ * token position in the original text.
+ */
 export declare abstract class BaseToken<TText extends string = string> {
     private tokenRange;
     constructor(tokenRange: Range);
+    /**
+     * Range of the token in the original text.
+     */
     get range(): Range;
+    /**
+     * Text representation of the token.
+     */
     abstract get text(): TText;
+    /**
+     * Check if this token has the same range as another one.
+     */
     sameRange(other: Range): boolean;
+    /**
+     * Returns a string representation of the token.
+     */
     abstract toString(): string;
+    /**
+     * Check if this token is equal to another one.
+     */
     equals(other: BaseToken): other is typeof this;
+    /**
+     * Change `range` of the token with provided range components.
+     */
     withRange(components: Partial<IRange>): this;
+    /**
+     * Collapse range of the token to its start position.
+     * See {@link Range.collapseToStart} for more details.
+     */
     collapseRangeToStart(): this;
+    /**
+     * Render a list of tokens into a string.
+     */
     static render(tokens: readonly BaseToken[], delimiter?: string): string;
+    /**
+     * Returns the full range of a list of tokens in which the first token is
+     * used as the start of a tokens sequence and the last token reflects the end.
+     *
+     * @throws if:
+     * 	- provided {@link tokens} list is empty
+     *  - the first token start number is greater than the start line of the last token
+     *  - if the first and last token are on the same line, the first token start column must
+     * 	  be smaller than the start column of the last token
+     */
     static fullRange(tokens: readonly BaseToken[]): Range;
+    /**
+     * Shorten version of the {@link text} property.
+     */
     shortText(maxLength?: number): string;
 }

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

@@ -1,10 +1,24 @@
 import { BaseToken } from "./baseToken.js";
+/**
+ * Composite token consists of a list of other tokens.
+ * Composite token consists of a list of other tokens.
+ */
 export declare abstract class CompositeToken<TTokens extends readonly BaseToken[]> extends BaseToken {
+    /**
+     * Reference to the list of child tokens.
+     */
     protected readonly childTokens: [
         ...TTokens
     ];
     constructor(tokens: TTokens);
     get text(): string;
+    /**
+     * Tokens that this composite token consists of.
+     */
     get children(): TTokens;
+    /**
+     * Check if this token is equal to another one,
+     * including all of its child tokens.
+     */
     equals(other: BaseToken): other is typeof this;
 }

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

@@ -1,4 +1,8 @@
 import { NewLine } from "../linesCodec/tokens/newLine.js";
 import { CarriageReturn } from "../linesCodec/tokens/carriageReturn.js";
 import { FormFeed, SpacingToken } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/codecs/base/simpleCodec/tokens/tokens";
+/**
+ * List of valid "space" tokens that are valid between different
+ * records of a Front Matter header.
+ */
 export declare const VALID_INTER_RECORD_SPACING_TOKENS: readonly (typeof SpacingToken | typeof FormFeed | typeof NewLine | typeof CarriageReturn)[];

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

@@ -4,12 +4,25 @@ import { FrontMatterRecord } from "@codingame/monaco-vscode-api/vscode/vs/workbe
 import { BaseDecoder } from "../baseDecoder.js";
 import { type TSimpleDecoderToken } from "../simpleCodec/simpleDecoder.js";
 import { ObjectStream } from "../utils/objectStream.js";
+/**
+ * Tokens produced by this decoder.
+ */
 export type TFrontMatterToken = FrontMatterRecord | TSimpleDecoderToken;
+/**
+ * Decoder capable of parsing Front Matter contents from a sequence of simple tokens.
+ */
 export declare class FrontMatterDecoder extends BaseDecoder<TFrontMatterToken, TSimpleDecoderToken> {
+    /**
+     * Current parser reference responsible for parsing a specific sequence
+     * of tokens into a standalone token.
+     */
     private current?;
     private readonly parserFactory;
     constructor(stream: ReadableStream<VSBuffer> | ObjectStream<TSimpleDecoderToken>);
     protected onStreamData(token: TSimpleDecoderToken): void;
     protected onStreamEnd(): void;
+    /**
+     * Re-emit tokens accumulated so far in the current parser object.
+     */
     protected reEmitCurrentTokens(): void;
 }

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

@@ -3,12 +3,31 @@ import { TSimpleDecoderToken } from "../../simpleCodec/simpleDecoder.js";
 import { LeftBracket } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/codecs/base/simpleCodec/tokens/tokens";
 import { ParserBase, TAcceptTokenResult } from "../../simpleCodec/parserBase.js";
 import { type FrontMatterParserFactory } from "./frontMatterParserFactory.js";
+/**
+ * Responsible for parsing an array syntax (or "inline sequence"
+ * in YAML terms), e.g. `[1, '2', true, 2.54]`
+*/
 export declare class PartialFrontMatterArray extends ParserBase<TSimpleDecoderToken, PartialFrontMatterArray | FrontMatterArray> {
     private readonly factory;
     private readonly startToken;
+    /**
+     * Current parser reference responsible for parsing an array "value".
+     */
     private currentValueParser?;
+    /**
+     * Whether an array item is allowed in the current position of the token
+     * sequence. E.g., items are allowed after a command or a open bracket,
+     * but not immediately after another item in the array.
+     */
     private arrayItemAllowed;
     constructor(factory: FrontMatterParserFactory, startToken: LeftBracket);
     accept(token: TSimpleDecoderToken): TAcceptTokenResult<PartialFrontMatterArray | FrontMatterArray>;
+    /**
+     * Convert current parser into a {@link FrontMatterArray} token,
+     * if possible.
+     *
+     * @throws if the last token in the accumulated token list
+     * 		   is not a closing bracket ({@link RightBracket}).
+     */
     asArrayToken(): FrontMatterArray;
 }

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

@@ -2,17 +2,47 @@ import { type TSimpleDecoderToken } from "../../../simpleCodec/simpleDecoder.js"
 import { ParserBase, type TAcceptTokenResult } from "../../../simpleCodec/parserBase.js";
 import { FrontMatterRecordName, FrontMatterRecordDelimiter, FrontMatterRecord } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/codecs/base/frontMatterCodec/tokens/index";
 import { type FrontMatterParserFactory } from "../frontMatterParserFactory.js";
+/**
+ * Type of a next parser that can be returned by {@link PartialFrontMatterRecord}.
+ */
 type TNextParser = PartialFrontMatterRecord | FrontMatterRecord;
+/**
+ * Parser for a `record` inside a Front Matter header.
+ *
+ *  * E.g., `name: 'value'` in the example below:
+ *
+ * ```
+ * ---
+ * name: 'value'
+ * isExample: true
+ * ---
+ * ```
+ */
 export declare class PartialFrontMatterRecord extends ParserBase<TSimpleDecoderToken, TNextParser> {
     private readonly factory;
+    /**
+     * Token that represents the 'name' part of the record.
+     */
     private readonly recordNameToken;
+    /**
+     * Token that represents the 'delimiter' part of the record.
+     */
     private readonly recordDelimiterToken;
     constructor(factory: FrontMatterParserFactory, tokens: [
         FrontMatterRecordName,
         FrontMatterRecordDelimiter
     ]);
+    /**
+     * Current parser reference responsible for parsing the "value" part of the record.
+     */
     private valueParser?;
     accept(token: TSimpleDecoderToken): TAcceptTokenResult<TNextParser>;
+    /**
+     * Convert current parser into a {@link FrontMatterRecord} token.
+     *
+     * @throws if no current parser is present, or it is not of the {@link PartialFrontMatterValue}
+     *         or {@link PartialFrontMatterSequence} types
+     */
     asRecordToken(): FrontMatterRecord;
 }
 export {};

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

@@ -4,7 +4,19 @@ import { Word } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/c
 import { type PartialFrontMatterRecordNameWithDelimiter } from "./frontMatterRecordNameWithDelimiter.js";
 import { ParserBase, type TAcceptTokenResult } from "../../../simpleCodec/parserBase.js";
 import { type FrontMatterParserFactory } from "../frontMatterParserFactory.js";
+/**
+ * Type of a next parser that can be returned by {@link PartialFrontMatterRecordName}.
+ */
 type TNextParser = PartialFrontMatterRecordName | PartialFrontMatterRecordNameWithDelimiter;
+/**
+ * Parser for a `name` part of a Front Matter record.
+ *
+ * E.g., `'name'` in the example below:
+ *
+ * ```
+ * name: 'value'
+ * ```
+ */
 export declare class PartialFrontMatterRecordName extends ParserBase<TRecordNameToken, TNextParser> {
     private readonly factory;
     constructor(factory: FrontMatterParserFactory, startToken: Word);

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

@@ -4,8 +4,23 @@ import { type TSimpleDecoderToken } from "../../../simpleCodec/simpleDecoder.js"
 import { FrontMatterRecordName } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/codecs/base/frontMatterCodec/tokens/index";
 import { ParserBase, type TAcceptTokenResult } from "../../../simpleCodec/parserBase.js";
 import { type FrontMatterParserFactory } from "../frontMatterParserFactory.js";
+/**
+ * Type for tokens that stop a front matter record name sequence.
+ */
 export type TNameStopToken = Colon | SpacingToken;
+/**
+ * Type for the next parser that can be returned by {@link PartialFrontMatterRecordNameWithDelimiter}.
+ */
 type TNextParser = PartialFrontMatterRecordNameWithDelimiter | PartialFrontMatterRecord;
+/**
+ * Parser for a record `name` with the `: ` delimiter.
+ *
+ *  * E.g., `name:` in the example below:
+ *
+ * ```
+ * name: 'value'
+ * ```
+ */
 export declare class PartialFrontMatterRecordNameWithDelimiter extends ParserBase<FrontMatterRecordName | TNameStopToken, TNextParser> {
     private readonly factory;
     constructor(factory: FrontMatterParserFactory, tokens: readonly [

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

@@ -2,10 +2,41 @@ import { BaseToken } from "../../baseToken.js";
 import { FrontMatterSequence } from "../tokens/frontMatterSequence.js";
 import { TSimpleDecoderToken } from "../../simpleCodec/simpleDecoder.js";
 import { ParserBase, TAcceptTokenResult } from "../../simpleCodec/parserBase.js";
+/**
+ * Parser responsible for parsing a "generic sequence of tokens"
+ * of an arbitrary length in a Front Matter header.
+ */
 export declare class PartialFrontMatterSequence extends ParserBase<TSimpleDecoderToken, PartialFrontMatterSequence | FrontMatterSequence> {
+    /**
+     * Callback function that is called to check if the current token
+     * should stop the parsing process of the current generic "value"
+     * sequence of arbitrary tokens by returning `true`.
+     *
+     * When this happens, the parser *will not consume* the token that
+     * was passed to the `shouldStop` callback or to its `accept` method.
+     * On the other hand, the parser will be "consumed" hence using it
+     * to process other tokens will yield an error.
+     */
     private readonly shouldStop;
-    constructor(shouldStop: (token: BaseToken) => boolean);
+    constructor(
+    /**
+     * Callback function that is called to check if the current token
+     * should stop the parsing process of the current generic "value"
+     * sequence of arbitrary tokens by returning `true`.
+     *
+     * When this happens, the parser *will not consume* the token that
+     * was passed to the `shouldStop` callback or to its `accept` method.
+     * On the other hand, the parser will be "consumed" hence using it
+     * to process other tokens will yield an error.
+     */
+    shouldStop: (token: BaseToken) => boolean);
     accept(token: TSimpleDecoderToken): TAcceptTokenResult<PartialFrontMatterSequence | FrontMatterSequence>;
+    /**
+     * Add provided tokens to the list of the current parsed tokens.
+     */
     addTokens(tokens: readonly TSimpleDecoderToken[]): this;
+    /**
+     * Convert the current parser into a {@link FrontMatterSequence} token.
+     */
     asSequenceToken(): FrontMatterSequence;
 }

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

@@ -1,9 +1,18 @@
 import { TSimpleDecoderToken } from "../../simpleCodec/simpleDecoder.js";
 import { FrontMatterString, type TQuoteToken } from "../tokens/frontMatterString.js";
 import { ParserBase, type TAcceptTokenResult } from "../../simpleCodec/parserBase.js";
+/**
+ * Parser responsible for parsing a string value.
+ */
 export declare class PartialFrontMatterString extends ParserBase<TSimpleDecoderToken, PartialFrontMatterString | FrontMatterString<TQuoteToken>> {
     private readonly startToken;
     constructor(startToken: TQuoteToken);
     accept(token: TSimpleDecoderToken): TAcceptTokenResult<PartialFrontMatterString | FrontMatterString<TQuoteToken>>;
+    /**
+     * Convert the current parser into a {@link FrontMatterString} token,
+     * if possible.
+     *
+     * @throws if the first and last tokens are not quote tokens of the same type.
+     */
     asStringToken(): FrontMatterString<TQuoteToken>;
 }

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

@@ -5,17 +5,57 @@ import { TSimpleDecoderToken } from "../../simpleCodec/simpleDecoder.js";
 import { Word, Quote, DoubleQuote, LeftBracket } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/codecs/base/simpleCodec/tokens/tokens";
 import { ParserBase, TAcceptTokenResult } from "../../simpleCodec/parserBase.js";
 import { type FrontMatterParserFactory } from "./frontMatterParserFactory.js";
+/**
+ * List of tokens that can start a "value" sequence.
+ *
+ * - {@link Word} - can be a `boolean` value
+ * - {@link Quote}, {@link DoubleQuote} - can start a `string` value
+ * - {@link LeftBracket} - can start an `array` value
+ */
 export declare const VALID_VALUE_START_TOKENS: readonly (typeof Quote | typeof DoubleQuote | typeof LeftBracket)[];
+/**
+ * Type alias for a token that can start a "value" sequence.
+ */
 type TValueStartToken = InstanceType<typeof VALID_VALUE_START_TOKENS[number]>;
+/**
+ * Parser responsible for parsing a "value" sequence in a Front Matter header.
+ */
 export declare class PartialFrontMatterValue extends ParserBase<TSimpleDecoderToken, PartialFrontMatterValue | FrontMatterValueToken> {
     private readonly factory;
+    /**
+     * Callback function to pass to the {@link PartialFrontMatterSequence}
+     * if the current "value" sequence is not of a specific type.
+     */
     private readonly shouldStop;
+    /**
+     * Current parser reference responsible for parsing
+     * a specific "value" sequence.
+     */
     private currentValueParser?;
+    /**
+     * Get the tokens that were accumulated so far.
+     */
     get tokens(): readonly TSimpleDecoderToken[];
-    constructor(factory: FrontMatterParserFactory, shouldStop: (token: BaseToken) => boolean);
+    constructor(factory: FrontMatterParserFactory, 
+    /**
+     * Callback function to pass to the {@link PartialFrontMatterSequence}
+     * if the current "value" sequence is not of a specific type.
+     */
+    shouldStop: (token: BaseToken) => boolean);
     accept(token: TSimpleDecoderToken): TAcceptTokenResult<PartialFrontMatterValue | FrontMatterValueToken>;
+    /**
+     * Check if provided token can be a start of a "value" sequence.
+     * See {@link VALID_VALUE_START_TOKENS} for the list of valid tokens.
+     */
     static isValueStartToken(token: BaseToken): token is TValueStartToken | Word<"true" | "false">;
+    /**
+     * Check if the current 'value' sequence does not have a specific type
+     * and is represented by a generic sequence of tokens ({@link PartialFrontMatterSequence}).
+     */
     get isSequence(): boolean;
+    /**
+     * Convert current parser into a generic sequence of tokens.
+     */
     asSequenceToken(): FrontMatterSequence;
 }
 export {};

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

@@ -1,11 +1,20 @@
 import { LeftBracket, RightBracket } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/codecs/base/simpleCodec/tokens/tokens";
 import { FrontMatterValueToken, type TValueTypeName } from "./frontMatterToken.js";
+/**
+ * Token that represents an `array` value in a Front Matter header.
+ */
 export declare class FrontMatterArray extends FrontMatterValueToken<"array", [
     LeftBracket,
     ...FrontMatterValueToken<TValueTypeName>[],
     RightBracket
 ]> {
+    /**
+     * Name of the `array` value type.
+     */
     readonly valueTypeName = "array";
+    /**
+     * List of the array items.
+     */
     get items(): readonly FrontMatterValueToken<TValueTypeName>[];
     toString(): string;
 }