@pbkware/fielded-text-web 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,3483 @@
+import { DotNetDateTimeStyleFlags } from '@pbkware/dot-net-date-number-formatting';
+import { DotNetDateTimeStyles } from '@pbkware/dot-net-date-number-formatting';
+import { DotNetLocaleSettings } from '@pbkware/dot-net-date-number-formatting';
+import { DotNetNumberStyleFlags } from '@pbkware/dot-net-date-number-formatting';
+import { DotNetNumberStyles } from '@pbkware/dot-net-date-number-formatting';
+import { Result } from '@pbkware/js-utils';
+
+export { DotNetDateTimeStyleFlags }
+
+export { DotNetDateTimeStyles }
+
+export { DotNetLocaleSettings }
+
+export { DotNetNumberStyleFlags }
+
+export { DotNetNumberStyles }
+
+/**
+ * Exception thrown to abort serialization from an event handler.
+ * @public
+ */
+export declare class FtAbortSerializationException extends Error {
+    constructor(message?: string);
+}
+
+/**
+ * Field for boolean values.
+ * @public
+ */
+export declare class FtBooleanField extends FtGenericField<boolean> {
+    private static readonly VALUE_TEXT_NULL_TRIMMABLE;
+    constructor(sequenceInvokation: FtSequenceInvokation, sequenceItem: FtSequenceItem, definition: FtBooleanFieldDefinition);
+    get definition(): FtBooleanFieldDefinition;
+    get falseText(): string;
+    get trueText(): string;
+    get styles(): FtBooleanStyles;
+    get nullableValue(): boolean | null;
+    set nullableValue(value: boolean | null);
+    protected isValueEqual(left: boolean, right: boolean): boolean;
+}
+
+/**
+ * Field definition for boolean fields.
+ * @public
+ */
+export declare class FtBooleanFieldDefinition extends FtGenericFieldDefinition<boolean> {
+    static readonly AUTO_LEFT_PAD = false;
+    protected formatter: FtBooleanFieldFormatter;
+    constructor(index: number);
+    get falseText(): string;
+    get trueText(): string;
+    get styles(): FtBooleanStyles;
+    loadMeta(metaField: FtBooleanMetaField, myCulture: DotNetLocaleSettings | undefined, myMainHeadingIndex: number): void;
+    getValueText(value: boolean): string;
+    parseValueText(text: string): boolean;
+}
+
+/**
+ * Formatter for boolean fields.
+ * Supports various parsing styles including case sensitivity, partial matching, and more.
+ * @public
+ */
+export declare class FtBooleanFieldFormatter extends FtFieldFormatter {
+    private _falseText;
+    private _trueText;
+    private _styles;
+    get falseText(): string;
+    set falseText(value: string);
+    get trueText(): string;
+    set trueText(value: string);
+    get styles(): FtBooleanStyles;
+    set styles(value: FtBooleanStyles);
+    toText(value: boolean): string;
+    parse(text: string): boolean;
+    private compareText;
+    private toUpperCaseChar;
+}
+
+/**
+ * Meta field for boolean values.
+ * @public
+ */
+export declare class FtBooleanMetaField extends FtGenericMetaField<boolean> {
+    static readonly DATA_TYPE: "Boolean";
+    static readonly DEFAULT_FALSE_TEXT = "False";
+    static readonly DEFAULT_TRUE_TEXT = "True";
+    static readonly DEFAULT_STYLES: number;
+    static readonly DEFAULT_VALUE = false;
+    static readonly DEFAULT_SEQUENCE_REDIRECT_TYPE: "Boolean";
+    private _falseText;
+    private _trueText;
+    private _styles;
+    constructor(headingCount?: number);
+    get falseText(): string;
+    set falseText(value: string);
+    get trueText(): string;
+    set trueText(value: string);
+    get styles(): FtBooleanStyles;
+    set styles(value: FtBooleanStyles);
+    static isBooleanMetaField(field: FtMetaField): field is FtBooleanMetaField;
+    loadDefaults(leaveNameAsIs?: boolean): void;
+    createCopy(): FtMetaField;
+    protected getDefaultSequenceRedirectType(): FtSequenceRedirectType;
+    protected assignFrom(source: FtMetaField): void;
+}
+
+/**
+ * Meta sequence redirect that triggers when a field value matches a specific boolean value.
+ * Used in metadata to define sequence transitions based on boolean field values.
+ * @public
+ */
+export declare class FtBooleanMetaSequenceRedirect extends FtMetaSequenceRedirect {
+    /** The standard type identifier for boolean redirects */
+    static readonly TYPE: "Boolean";
+    /** Default boolean value */
+    static readonly DEFAULT_VALUE = false;
+    private _value;
+    constructor();
+    /** The boolean value to match for triggering the redirect */
+    get value(): boolean;
+    set value(val: boolean);
+    loadDefaults(): void;
+    createCopy(sequenceList: FtMetaSequenceList, sourceSequenceList: FtMetaSequenceList): FtMetaSequenceRedirect;
+    protected assign(source: FtMetaSequenceRedirect, sequenceList: FtMetaSequenceList, sourceSequenceList: FtMetaSequenceList): void;
+}
+
+/**
+ * Sequence redirect that triggers when a field equals a specific boolean value.
+ * @public
+ */
+export declare class FtBooleanSequenceRedirect extends FtSequenceRedirect {
+    static readonly TYPE: "Boolean";
+    private _value;
+    constructor(index: number);
+    get value(): boolean;
+    checkTriggered(field: FtField): boolean;
+    /** @internal */
+    loadMeta(metaSequenceRedirect: FtBooleanMetaSequenceRedirect, metaSequenceList: FtMetaSequenceList, sequenceList: FtSequenceList): void;
+}
+
+/**
+ * Flags enum for boolean parsing styles
+ * @public
+ */
+export declare const FtBooleanStyles: {
+    readonly IgnoreCase: number;
+    readonly MatchFirstCharOnly: number;
+    readonly IgnoreTrailingChars: number;
+    readonly FalseIfNotMatchTrue: number;
+};
+
+/**
+ * @public
+ */
+export declare type FtBooleanStyles = (typeof FtBooleanStyles)[keyof typeof FtBooleanStyles];
+
+/**
+ * Callback-based text writer for simple output accumulation.
+ * @public
+ */
+export declare class FtCallbackTextWriter implements FtTextWriter {
+    private readonly callback;
+    private readonly closeCallback?;
+    constructor(callback: (text: string) => void, closeCallback?: (() => void) | undefined);
+    write(text: string): void;
+    flush(): void;
+    close(): void;
+}
+
+/**
+ * Meta sequence redirect that triggers when a field value matches a specific string (case-insensitive).
+ * Used in metadata to define sequence transitions based on string field values without case sensitivity.
+ * @public
+ */
+export declare class FtCaseInsensitiveStringMetaSequenceRedirect extends FtMetaSequenceRedirect {
+    /** The standard type identifier for case-insensitive string redirects */
+    static readonly TYPE: "CaseInsensitiveString";
+    /** Default string value */
+    static readonly DEFAULT_VALUE = "";
+    private _value;
+    constructor();
+    /** The string value to match (case-insensitive) for triggering the redirect */
+    get value(): string;
+    set value(val: string);
+    loadDefaults(): void;
+    createCopy(sequenceList: FtMetaSequenceList, sourceSequenceList: FtMetaSequenceList): FtMetaSequenceRedirect;
+    protected assign(source: FtMetaSequenceRedirect, sequenceList: FtMetaSequenceList, sourceSequenceList: FtMetaSequenceList): void;
+}
+
+/**
+ * Sequence redirect that triggers when a field equals a specific string value (case-insensitive).
+ * @public
+ */
+export declare class FtCaseInsensitiveStringSequenceRedirect extends FtSequenceRedirect {
+    static readonly TYPE: "CaseInsensitiveString";
+    private _value;
+    constructor(index: number);
+    get value(): string;
+    checkTriggered(field: FtField): boolean;
+    /** @internal */
+    loadMeta(metaSequenceRedirect: FtCaseInsensitiveStringMetaSequenceRedirect, metaSequenceList: FtMetaSequenceList, sequenceList: FtSequenceList): void;
+}
+
+/**
+ * @public
+ */
+export declare const FtDataType: {
+    readonly String: "String";
+    readonly Boolean: "Boolean";
+    readonly Integer: "Integer";
+    readonly Float: "Float";
+    readonly Decimal: "Decimal";
+    readonly DateTime: "DateTime";
+};
+
+/**
+ * @public
+ */
+export declare type FtDataType = (typeof FtDataType)[keyof typeof FtDataType];
+
+/**
+ * Meta sequence redirect that triggers when a field's date part matches a specific date (ignoring time).
+ * Used in metadata to define sequence transitions based on date field values (time component ignored).
+ * @public
+ */
+export declare class FtDateMetaSequenceRedirect extends FtMetaSequenceRedirect {
+    /** The standard type identifier for date redirects */
+    static readonly TYPE: "Date";
+    /** Default date value (Unix epoch) */
+    static readonly DEFAULT_VALUE: Date;
+    private _value;
+    constructor();
+    /** The date value to match (time component ignored) for triggering the redirect */
+    get value(): Date;
+    set value(val: Date);
+    loadDefaults(): void;
+    createCopy(sequenceList: FtMetaSequenceList, sourceSequenceList: FtMetaSequenceList): FtMetaSequenceRedirect;
+    protected assign(source: FtMetaSequenceRedirect, sequenceList: FtMetaSequenceList, sourceSequenceList: FtMetaSequenceList): void;
+}
+
+/**
+ * Sequence redirect that triggers when a field's date component equals a specific date value (time ignored).
+ * @public
+ */
+export declare class FtDateSequenceRedirect extends FtSequenceRedirect {
+    static readonly TYPE: "Date";
+    private _value;
+    constructor(index: number);
+    get value(): Date;
+    checkTriggered(field: FtField): boolean;
+    /** @internal */
+    loadMeta(metaSequenceRedirect: FtDateMetaSequenceRedirect, metaSequenceList: FtMetaSequenceList, sequenceList: FtSequenceList): void;
+}
+
+/**
+ * Field for DateTime values.
+ * @public
+ */
+export declare class FtDateTimeField extends FtGenericField<Date> {
+    private static readonly VALUE_TEXT_NULL_TRIMMABLE;
+    constructor(sequenceInvokation: FtSequenceInvokation, sequenceItem: FtSequenceItem, definition: FtDateTimeFieldDefinition);
+    get definition(): FtDateTimeFieldDefinition;
+    get format(): string;
+    get styles(): number;
+    get nullableValue(): Date | null;
+    set nullableValue(value: Date | null);
+    protected isValueEqual(left: Date, right: Date): boolean;
+}
+
+/**
+ * Field definition for DateTime fields.
+ * @public
+ */
+export declare class FtDateTimeFieldDefinition extends FtGenericFieldDefinition<Date> {
+    static readonly AUTO_LEFT_PAD = true;
+    protected formatter: FtDateTimeFieldFormatter;
+    private _constantValue;
+    constructor(index: number);
+    get format(): string;
+    get styles(): DotNetDateTimeStyles;
+    get constantValue(): Date;
+    loadMeta(metaField: FtMetaField, myCulture: DotNetLocaleSettings | undefined, myMainHeadingIndex: number): void;
+    getValueText(value: Date): string;
+    parseValueText(text: string): Date;
+}
+
+/**
+ * Formatter for DateTime fields using .NET-compatible formatting.
+ * Implementation delegates to DotNetDateTimeFormatter from dot-net-date-number-formatting package.
+ * @public
+ */
+export declare class FtDateTimeFieldFormatter extends FtFieldFormatter {
+    private _format;
+    private _styles;
+    private _formatter;
+    constructor();
+    get format(): string;
+    set format(value: string);
+    get styles(): DotNetDateTimeStyles;
+    set styles(value: DotNetDateTimeStyles);
+    toText(value: Date): string;
+    parse(text: string): Date;
+}
+
+/**
+ * Meta field for Date/Time values.
+ * @public
+ */
+export declare class FtDateTimeMetaField extends FtGenericMetaField<Date> {
+    static readonly DATA_TYPE: "DateTime";
+    static readonly DEFAULT_FORMAT = "yyyyMMdd";
+    static readonly DEFAULT_STYLES: 0;
+    static readonly DEFAULT_VALUE: Date;
+    static readonly DEFAULT_SEQUENCE_REDIRECT_TYPE: "ExactDateTime";
+    private _format;
+    private _styles;
+    constructor(headingCount?: number);
+    get format(): string;
+    set format(value: string);
+    get styles(): DotNetDateTimeStyles;
+    set styles(value: DotNetDateTimeStyles);
+    static isDateTimeMetaField(field: FtMetaField): field is FtDateTimeMetaField;
+    loadDefaults(leaveNameAsIs?: boolean): void;
+    createCopy(): FtMetaField;
+    protected getDefaultSequenceRedirectType(): FtSequenceRedirectType;
+    protected assignFrom(source: FtMetaField): void;
+}
+
+/** @public */
+export declare class FtDateTimeStylesMetaSerialization {
+    static allowInnerWhiteMetaValue: string;
+    static allowWhiteSpacesMetaValue: string;
+    static lowerCaseAllowInnerWhiteMetaValue: string;
+    static lowerCaseAllowWhiteSpacesMetaValue: string;
+    static serialize(styles: DotNetDateTimeStyles): string | undefined;
+    static deserialize(value: unknown, warnings: string[]): DotNetDateTimeStyles;
+}
+
+/**
+ * Field for decimal values.
+ * @public
+ */
+export declare class FtDecimalField extends FtGenericField<number> {
+    private static readonly VALUE_TEXT_NULL_TRIMMABLE;
+    constructor(sequenceInvokation: FtSequenceInvokation, sequenceItem: FtSequenceItem, definition: FtDecimalFieldDefinition);
+    get definition(): FtDecimalFieldDefinition;
+    get format(): string;
+    get styles(): number;
+    get nullableValue(): number | null;
+    set nullableValue(value: number | null);
+    protected isValueEqual(left: number, right: number): boolean;
+}
+
+/**
+ * Field definition for decimal fields.
+ * @public
+ */
+export declare class FtDecimalFieldDefinition extends FtGenericFieldDefinition<number> {
+    static readonly AUTO_LEFT_PAD = true;
+    protected formatter: FtDecimalFieldFormatter;
+    constructor(index: number);
+    get format(): string;
+    get styles(): DotNetNumberStyles;
+    loadMeta(metaField: FtDecimalMetaField, myCulture: DotNetLocaleSettings | undefined, myMainHeadingIndex: number): void;
+    getValueText(value: number): string;
+    parseValueText(text: string): number;
+}
+
+/**
+ * Formatter for decimal fields using .NET-compatible formatting.
+ * Implementation delegates to DotNetDecimalFormatter from dot-net-date-number-formatting package.
+ * @public
+ */
+export declare class FtDecimalFieldFormatter extends FtFieldFormatter {
+    private _styles;
+    private _format;
+    private _formatter;
+    get styles(): DotNetNumberStyles;
+    set styles(value: DotNetNumberStyles);
+    get format(): string;
+    set format(value: string);
+    toText(value: number): string;
+    parse(text: string): number;
+}
+
+/**
+ * Meta field for decimal values.
+ * @public
+ */
+export declare class FtDecimalMetaField extends FtGenericMetaField<number> {
+    static readonly DATA_TYPE: "Decimal";
+    static readonly DEFAULT_FORMAT = "G";
+    static readonly DEFAULT_STYLES: number;
+    static readonly DEFAULT_VALUE = 0;
+    static readonly DEFAULT_SEQUENCE_REDIRECT_TYPE: "ExactDecimal";
+    private _format;
+    private _styles;
+    constructor(headingCount?: number);
+    get format(): string;
+    set format(value: string);
+    get styles(): DotNetNumberStyles;
+    set styles(value: DotNetNumberStyles);
+    static isDecimalMetaField(field: FtMetaField): field is FtDecimalMetaField;
+    loadDefaults(leaveNameAsIs?: boolean): void;
+    createCopy(): FtMetaField;
+    protected getDefaultSequenceRedirectType(): FtSequenceRedirectType;
+    protected assignFrom(source: FtMetaField): void;
+}
+
+/**
+ * Parameter record for declared parameters.
+ * @public
+ */
+export declare interface FtDeclaredParameterRec {
+    name: string;
+    value: string;
+}
+
+/**
+ * Container for declared parameters in .ftx file headers.
+ * Manages version and meta reference parameters.
+ * @public
+ */
+export declare class FtDeclaredParameters {
+    private static readonly VERSION_PARAMETER_NAME;
+    private static readonly VERSION_PARTS_SEPARATOR;
+    private static readonly META_URL_PARAMETER_NAME;
+    private static readonly META_FILE_PARAMETER_NAME;
+    private static readonly META_EMBEDDED_PARAMETER_NAME;
+    private static readonly META_EMBEDDED_PARAMETER_VALUE;
+    private _list;
+    get count(): number;
+    getName(idx: number): string;
+    getValue(idx: number): string;
+    add(name: string, value: string): void;
+    remove(name: string): void;
+    clear(): void;
+    indexOfName(name: string): number;
+    indexOfVersion(): number;
+    setVersion(major: number, minor: number, comment?: string): void;
+    tryGetVersion(): Result<Version, boolean>;
+    getMetaReference(): {
+        type: FtMetaReferenceType;
+        reference: string;
+    };
+    setMetaReference(type: FtMetaReferenceType, reference: string): void;
+    tryGetVersionRec(): {
+        success: boolean;
+        rec: FtDeclaredParameterRec;
+    };
+    getAllRecsExceptVersion(): FtDeclaredParameterRec[];
+    private versionToText;
+    private parseVersionValue;
+    private parseMajorMinorVersionText;
+}
+
+/**
+ * Formatter for declared parameters in .ftx file headers.
+ * @public
+ */
+export declare class FtDeclaredParametersFormatter {
+    private static readonly NAME_VALUE_SEPARATOR;
+    private static readonly QUOTE_CHAR;
+    private static readonly DOUBLE_QUOTE_STRING;
+    private static readonly SPACE_CHARACTER;
+    /**
+     * Format the signature line (first declaration line with version).
+     */
+    static toSignatureLineText(parameters: FtDeclaredParameters): string;
+    /**
+     * Format the second declaration line (all parameters except version).
+     */
+    static toLine2Text(parameters: FtDeclaredParameters): string;
+    /**
+     * Convert parameter records to text format.
+     */
+    private static toText;
+}
+
+/**
+ * @public
+ */
+export declare const FtEndOfLineAutoWriteType: {
+    readonly CrLf: "CrLf";
+    readonly Cr: "Cr";
+    readonly Lf: "Lf";
+    readonly Local: "Local";
+};
+
+/**
+ * @public
+ */
+export declare type FtEndOfLineAutoWriteType = (typeof FtEndOfLineAutoWriteType)[keyof typeof FtEndOfLineAutoWriteType];
+
+/**
+ * @public
+ */
+export declare const FtEndOfLineType: {
+    readonly Auto: "Auto";
+    readonly Char: "Char";
+    readonly CrLf: "CrLf";
+};
+
+/**
+ * @public
+ */
+export declare type FtEndOfLineType = (typeof FtEndOfLineType)[keyof typeof FtEndOfLineType];
+
+/**
+ * Meta sequence redirect that triggers when a field value exactly matches a specific date-time value.
+ * Used in metadata to define sequence transitions based on exact date-time field values (including time component).
+ * @public
+ */
+export declare class FtExactDateTimeMetaSequenceRedirect extends FtMetaSequenceRedirect {
+    /** The standard type identifier for exact date-time redirects */
+    static readonly TYPE: "ExactDateTime";
+    /** Default date-time value (Unix epoch) */
+    static readonly DEFAULT_VALUE: Date;
+    private _value;
+    constructor();
+    /** The date-time value to match exactly for triggering the redirect */
+    get value(): Date;
+    set value(val: Date);
+    loadDefaults(): void;
+    createCopy(sequenceList: FtMetaSequenceList, sourceSequenceList: FtMetaSequenceList): FtMetaSequenceRedirect;
+    protected assign(source: FtMetaSequenceRedirect, sequenceList: FtMetaSequenceList, sourceSequenceList: FtMetaSequenceList): void;
+}
+
+/**
+ * Sequence redirect that triggers when a field exactly equals a specific datetime value.
+ * @public
+ */
+export declare class FtExactDateTimeSequenceRedirect extends FtSequenceRedirect {
+    static readonly TYPE: "ExactDateTime";
+    private _value;
+    constructor(index: number);
+    get value(): Date;
+    checkTriggered(field: FtField): boolean;
+    /** @internal */
+    loadMeta(metaSequenceRedirect: FtExactDateTimeMetaSequenceRedirect, metaSequenceList: FtMetaSequenceList, sequenceList: FtSequenceList): void;
+}
+
+/**
+ * Meta sequence redirect that triggers when a field value exactly matches a specific decimal value.
+ * Used in metadata to define sequence transitions based on decimal field values.
+ * @public
+ */
+export declare class FtExactDecimalMetaSequenceRedirect extends FtMetaSequenceRedirect {
+    /** The standard type identifier for exact decimal redirects */
+    static readonly TYPE: "ExactDecimal";
+    /** Default decimal value */
+    static readonly DEFAULT_VALUE = 0;
+    private _value;
+    constructor();
+    /** The decimal value to match exactly for triggering the redirect */
+    get value(): number;
+    set value(val: number);
+    loadDefaults(): void;
+    createCopy(sequenceList: FtMetaSequenceList, sourceSequenceList: FtMetaSequenceList): FtMetaSequenceRedirect;
+    protected assign(source: FtMetaSequenceRedirect, sequenceList: FtMetaSequenceList, sourceSequenceList: FtMetaSequenceList): void;
+}
+
+/**
+ * Sequence redirect that triggers when a field exactly equals a specific decimal value.
+ * @public
+ */
+export declare class FtExactDecimalSequenceRedirect extends FtSequenceRedirect {
+    static readonly TYPE: "ExactDecimal";
+    private _value;
+    constructor(index: number);
+    get value(): number;
+    checkTriggered(field: FtField): boolean;
+    /** @internal */
+    loadMeta(metaSequenceRedirect: FtExactDecimalMetaSequenceRedirect, metaSequenceList: FtMetaSequenceList, sequenceList: FtSequenceList): void;
+}
+
+/**
+ * Meta sequence redirect that triggers when a field value exactly matches a specific float value.
+ * Used in metadata to define sequence transitions based on floating-point field values.
+ * @public
+ */
+export declare class FtExactFloatMetaSequenceRedirect extends FtMetaSequenceRedirect {
+    /** The standard type identifier for exact float redirects */
+    static readonly TYPE: "ExactFloat";
+    /** Default float value */
+    static readonly DEFAULT_VALUE = 0;
+    private _value;
+    constructor();
+    /** The float value to match exactly for triggering the redirect */
+    get value(): number;
+    set value(val: number);
+    loadDefaults(): void;
+    createCopy(sequenceList: FtMetaSequenceList, sourceSequenceList: FtMetaSequenceList): FtMetaSequenceRedirect;
+    protected assign(source: FtMetaSequenceRedirect, sequenceList: FtMetaSequenceList, sourceSequenceList: FtMetaSequenceList): void;
+}
+
+/**
+ * Sequence redirect that triggers when a field exactly equals a specific float (number) value.
+ * @public
+ */
+export declare class FtExactFloatSequenceRedirect extends FtSequenceRedirect {
+    static readonly TYPE: "ExactFloat";
+    private _value;
+    constructor(index: number);
+    get value(): number;
+    checkTriggered(field: FtField): boolean;
+    /** @internal */
+    loadMeta(metaSequenceRedirect: FtExactFloatMetaSequenceRedirect, metaSequenceList: FtMetaSequenceList, sequenceList: FtSequenceList): void;
+}
+
+/**
+ * Meta sequence redirect that triggers when a field value exactly matches a specific integer value.
+ * Used in metadata to define sequence transitions based on integer field values.
+ * @public
+ */
+export declare class FtExactIntegerMetaSequenceRedirect extends FtMetaSequenceRedirect {
+    /** The standard type identifier for exact integer redirects */
+    static readonly TYPE: "ExactInteger";
+    /** Default integer value */
+    static readonly DEFAULT_VALUE = 0n;
+    private _value;
+    constructor();
+    /** The integer value to match exactly for triggering the redirect */
+    get value(): bigint;
+    set value(val: bigint);
+    loadDefaults(): void;
+    createCopy(sequenceList: FtMetaSequenceList, sourceSequenceList: FtMetaSequenceList): FtMetaSequenceRedirect;
+    protected assign(source: FtMetaSequenceRedirect, sequenceList: FtMetaSequenceList, sourceSequenceList: FtMetaSequenceList): void;
+}
+
+/**
+ * Sequence redirect that triggers when a field exactly equals a specific integer value.
+ * @public
+ */
+export declare class FtExactIntegerSequenceRedirect extends FtSequenceRedirect {
+    static readonly TYPE: "ExactInteger";
+    private _value;
+    constructor(index: number);
+    get value(): bigint;
+    checkTriggered(field: FtField): boolean;
+    /** @internal */
+    loadMeta(metaSequenceRedirect: FtExactIntegerMetaSequenceRedirect, metaSequenceList: FtMetaSequenceList, sequenceList: FtSequenceList): void;
+}
+
+/**
+ * Meta sequence redirect that triggers when a field value exactly matches a specific string (case-sensitive).
+ * Used in metadata to define sequence transitions based on exact string field values.
+ * @public
+ */
+export declare class FtExactStringMetaSequenceRedirect extends FtMetaSequenceRedirect {
+    /** The standard type identifier for exact string redirects */
+    static readonly TYPE: "ExactString";
+    /** Default string value */
+    static readonly DEFAULT_VALUE = "";
+    private _value;
+    constructor();
+    /** The string value to match exactly for triggering the redirect */
+    get value(): string;
+    set value(val: string);
+    loadDefaults(): void;
+    createCopy(sequenceList: FtMetaSequenceList, sourceSequenceList: FtMetaSequenceList): FtMetaSequenceRedirect;
+    protected assign(source: FtMetaSequenceRedirect, sequenceList: FtMetaSequenceList, sourceSequenceList: FtMetaSequenceList): void;
+}
+
+/**
+ * Sequence redirect that triggers when a field exactly equals a specific string value (case-sensitive).
+ * @public
+ */
+export declare class FtExactStringSequenceRedirect extends FtSequenceRedirect {
+    static readonly TYPE: "ExactString";
+    private _value;
+    constructor(index: number);
+    get value(): string;
+    checkTriggered(field: FtField): boolean;
+    /** @internal */
+    loadMeta(metaSequenceRedirect: FtExactStringMetaSequenceRedirect, metaSequenceList: FtMetaSequenceList, sequenceList: FtSequenceList): void;
+}
+
+/**
+ * Abstract base class for all field instances.
+ * Fields represent runtime field values during reading or writing.
+ * @public
+ */
+export declare abstract class FtField {
+    static readonly NO_FIELDS_AFFECTED_INDEX = -1;
+    protected static readonly IGNORED_SEQUENCE_INVOKATION_DELAY: "AfterSequence";
+    sequenceRedirectEvent: FtSequenceRedirectDelegate | undefined;
+    protected valueAssigned: boolean;
+    protected quoted: boolean;
+    private _index;
+    private _definition;
+    private _sequence;
+    private _sequenceItem;
+    private _sequenceRedirectList;
+    private _sequenceInvokation;
+    private _sidelined;
+    private _name;
+    private _headings;
+    private _valueTextNullTrimmable;
+    private _valueIsNull;
+    private _loadedPosition;
+    private _loadedLength;
+    private _loadedRawOffset;
+    private _loadedRawLength;
+    private _loadedValueText;
+    protected constructor(sequenceInvokation: FtSequenceInvokation, sequenceItem: FtSequenceItem, valueTextNullTrimmable: boolean);
+    get definition_(): FtFieldDefinition;
+    get index(): number;
+    set index(value: number);
+    get sidelined(): boolean;
+    set sidelined(value: boolean);
+    get definition(): FtFieldDefinition;
+    get sequence(): FtSequence;
+    get sequenceItem(): FtSequenceItem;
+    get sequenceRedirectList(): FtSequenceRedirectList;
+    get sequenceInvokation(): FtSequenceInvokation;
+    get headingCount(): number;
+    get headings(): string[];
+    get valueAssigned_(): boolean;
+    get loadedValueText(): string;
+    get dataType(): FtDataType;
+    get id(): number | undefined;
+    get name(): string;
+    get metaHeadings(): string[];
+    get mainHeadingIndex(): number;
+    get culture(): DotNetLocaleSettings | undefined;
+    get fixedWidth(): boolean;
+    get width(): number;
+    get constant(): boolean;
+    get valueQuotedType(): FtQuotedType;
+    get valueAlwaysWriteOptionalQuote(): boolean;
+    get valueWritePrefixSpace(): boolean;
+    get valuePadAlignment(): FtPadAlignment;
+    get valuePadCharType(): FtPadCharType;
+    get valuePadChar(): string;
+    get valueTruncateType(): FtTruncateType;
+    get valueTruncateChar(): string;
+    get valueEndOfValueChar(): string;
+    get valueNullChar(): string;
+    get headingConstraint(): FtHeadingConstraint;
+    get headingQuotedType(): FtQuotedType;
+    get headingAlwaysWriteOptionalQuote(): boolean;
+    get headingWritePrefixSpace(): boolean;
+    get headingPadAlignment(): FtPadAlignment;
+    get headingPadCharType(): FtPadCharType;
+    get headingPadChar(): string;
+    get headingTruncateType(): FtTruncateType;
+    get headingTruncateChar(): string;
+    get headingEndOfValueChar(): string;
+    get valueType(): string;
+    /** @internal */
+    get asRedirectString(): string;
+    /** @internal */
+    get asRedirectBoolean(): boolean;
+    /** @internal */
+    get asRedirectInteger(): bigint;
+    /** @internal */
+    get asRedirectFloat(): number;
+    /** @internal */
+    get asRedirectDateTime(): Date;
+    /** @internal */
+    get asRedirectDecimal(): number;
+    get asValueText(): string | null;
+    set asValueText(value: string | null);
+    get asObject(): unknown;
+    set asObject(value: unknown);
+    get asString(): string | null;
+    set asString(value: string | null);
+    get asBoolean(): boolean;
+    set asBoolean(value: boolean);
+    get asInteger(): number;
+    set asInteger(value: number);
+    get asBigInt(): bigint;
+    set asBigInt(value: bigint);
+    get asFloat(): number;
+    set asFloat(value: number);
+    get asDateTime(): Date;
+    set asDateTime(value: Date);
+    get asDecimal(): number;
+    set asDecimal(value: number);
+    get asNullableBoolean(): boolean | null;
+    set asNullableBoolean(value: boolean | null);
+    get asNullableInteger(): number | null;
+    set asNullableInteger(value: number | null);
+    get asNullableBigInt(): bigint | null;
+    set asNullableBigInt(value: bigint | null);
+    get asNullableFloat(): number | null;
+    set asNullableFloat(value: number | null);
+    get asNullableDateTime(): Date | null;
+    set asNullableDateTime(value: Date | null);
+    get asNullableDecimal(): number | null;
+    set asNullableDecimal(value: number | null);
+    isNull(): boolean;
+    setNull(): number;
+    loadHeadings(value: string[]): void;
+    loadHeading(idx: number, headingText: string): void;
+    /** @internal */
+    checkNullSequenceRedirect(): number;
+    /** @internal */
+    resetValue(): void;
+    /** @internal */
+    loadPosition(position: number, length: number, rawOffset: number, rawLength: number): void;
+    /** @internal */
+    loadDelimitedValue(valueText: string, quoted: boolean): void;
+    /** @internal */
+    loadFixedWidthValue(valueText: string): void;
+    /** @internal */
+    loadNullValue(): void;
+    /**
+     * Get the field value as text (for writing). Public accessor for protected method.
+     * @internal
+     */
+    getValueText(): string;
+    /**
+     * Check if the field value has been assigned. Public accessor for protected property.
+     * @internal
+     */
+    isValueAssigned(): boolean;
+    protected onSequenceRedirect(sequence: FtSequence | undefined, delay: FtSequenceInvokationDelay): number;
+    protected clearNonConstantNull(): void;
+    private setAsNonNullValueText;
+    private setAsValueText;
+    private setAsObject;
+    private setAsString;
+    protected abstract getAsNonNullValueText(): string;
+    protected abstract loadNonNullValue(valueText: string): void;
+    protected abstract getAsNonNullObject(): unknown;
+    protected abstract getAsNonNullString(): string;
+    protected abstract getAsBoolean(): boolean;
+    protected abstract getAsInteger(): number;
+    protected abstract getAsBigInt(): bigint;
+    protected abstract getAsFloat(): number;
+    protected abstract getAsDateTime(): Date;
+    protected abstract getAsDecimal(): number;
+    protected abstract setAsNonNullObject(newValue: unknown): void;
+    protected abstract setAsNonNullString(newValue: string): void;
+    protected abstract setAsBoolean(newValue: boolean): void;
+    protected abstract setAsInteger(newValue: number): void;
+    protected abstract setAsBigInt(newValue: bigint): void;
+    protected abstract setAsFloat(newValue: number): void;
+    protected abstract setAsDateTime(newValue: Date): void;
+    protected abstract setAsDecimal(newValue: number): void;
+    protected abstract getAsRedirectBoolean(): boolean;
+    protected abstract getAsRedirectInteger(): bigint;
+    protected abstract getAsRedirectFloat(): number;
+    protected abstract getAsRedirectDateTime(): Date;
+    protected abstract getAsRedirectDecimal(): number;
+}
+
+/**
+ * Abstract base class for all field definitions.
+ * Field definitions hold metadata and configuration for fields in fielded text.
+ * @public
+ */
+export declare abstract class FtFieldDefinition {
+    readonly dataType: FtDataType;
+    readonly valueType: string;
+    readonly autoLeftPad: boolean;
+    protected readonly formatter: FtFieldFormatter;
+    private _index;
+    private _id;
+    private _metaName;
+    private _metaHeadings;
+    private _mainHeadingIndex;
+    private _culture;
+    private _fixedWidth;
+    private _width;
+    private _constant;
+    private _null;
+    private _valueQuotedType;
+    private _valueAlwaysWriteOptionalQuote;
+    private _valueWritePrefixSpace;
+    private _valuePadAlignment;
+    private _valuePadCharType;
+    private _valuePadChar;
+    private _valueTruncateType;
+    private _valueTruncateChar;
+    private _valueEndOfValueChar;
+    private _valueNullChar;
+    private _headingConstraint;
+    private _headingQuotedType;
+    private _headingAlwaysWriteOptionalQuote;
+    private _headingWritePrefixSpace;
+    private _headingPadAlignment;
+    private _headingPadCharType;
+    private _headingPadChar;
+    private _headingTruncateType;
+    private _headingTruncateChar;
+    private _headingEndOfValueChar;
+    private _autoPadChar;
+    private _headingLeftPad;
+    private _valueLeftPad;
+    private _fixedWidthNullValueText;
+    protected constructor(dataType: FtDataType, valueType: string, formatter: FtFieldFormatter, autoLeftPad: boolean, index: number);
+    get index(): number;
+    get id(): number | undefined;
+    get metaName(): string;
+    get metaHeadings(): string[];
+    get metaHeadingCount(): number;
+    get mainHeadingIndex(): number;
+    get culture(): DotNetLocaleSettings | undefined;
+    get fixedWidth(): boolean;
+    get width(): number;
+    get constant(): boolean;
+    get null(): boolean;
+    get valueQuotedType(): FtQuotedType;
+    get valueAlwaysWriteOptionalQuote(): boolean;
+    get valueWritePrefixSpace(): boolean;
+    get valuePadAlignment(): FtPadAlignment;
+    get valuePadCharType(): FtPadCharType;
+    get valuePadChar(): string;
+    get valueTruncateType(): FtTruncateType;
+    get valueTruncateChar(): string;
+    get valueEndOfValueChar(): string;
+    get valueNullChar(): string;
+    get headingConstraint(): FtHeadingConstraint;
+    get headingQuotedType(): FtQuotedType;
+    get headingAlwaysWriteOptionalQuote(): boolean;
+    get headingWritePrefixSpace(): boolean;
+    get headingPadAlignment(): FtPadAlignment;
+    get headingPadCharType(): FtPadCharType;
+    get headingPadChar(): string;
+    get headingTruncateType(): FtTruncateType;
+    get headingTruncateChar(): string;
+    get headingEndOfValueChar(): string;
+    get autoPadChar(): string;
+    get headingLeftPad(): boolean;
+    get valueLeftPad(): boolean;
+    get fixedWidthNullValueText(): string;
+    /**
+     * Load metadata from a meta field.
+     * @param metaField - The meta field containing configuration
+     * @param myCulture - The culture settings for formatting
+     * @param myMainHeadingIndex - Index of the main heading
+     */
+    loadMeta(metaField: FtMetaField, myCulture: DotNetLocaleSettings | undefined, myMainHeadingIndex: number): void;
+}
+
+/**
+ * List of field definitions.
+ * @public
+ */
+export declare class FtFieldDefinitionList {
+    private _items;
+    get count(): number;
+    get(index: number): FtFieldDefinition;
+    add(definition: FtFieldDefinition): void;
+    new(dataType: FtDataType): FtFieldDefinition;
+    clear(): void;
+}
+
+/**
+ * Factory for creating field instances based on their definitions.
+ * @public
+ */
+export declare class FtFieldFactory {
+    static createFieldDefinition(dataType: FtDataType, index: number): FtFieldDefinition;
+    static createField(sequenceInvokation: FtSequenceInvokation, sequenceItem: FtSequenceItem): FtField;
+    static createMetaField(dataType: FtDataType, headingCount: number): FtMetaField;
+}
+
+/**
+ * Abstract base class for all field formatters.
+ * Concrete formatters handle type-specific formatting and parsing.
+ * @public
+ */
+export declare abstract class FtFieldFormatter {
+    private _culture;
+    get culture(): DotNetLocaleSettings | undefined;
+    set culture(value: DotNetLocaleSettings | undefined);
+}
+
+/**
+ * @public
+ */
+export declare interface FtFieldHeadingReadyEventArgs {
+    field: FtField;
+    lineIndex: number;
+}
+
+/**
+ * @public
+ */
+declare class FtFieldList {
+    private list;
+    get count(): number;
+    get(index: number): FtField;
+    getByName(name: string): FtField | undefined;
+    indexOf(field: FtField): number;
+    indexOfName(name: string): number;
+    indexOfId(id: number): number;
+    clear(): void;
+    trim(fromIndex: number): void;
+    add(field: FtField): void;
+}
+
+/**
+ * @public
+ */
+export declare interface FtFieldValueReadyEventArgs {
+    field: FtField;
+    recordIndex: number;
+}
+
+/**
+ * Field for float (number) values.
+ * @public
+ */
+export declare class FtFloatField extends FtGenericField<number> {
+    private static readonly VALUE_TEXT_NULL_TRIMMABLE;
+    constructor(sequenceInvokation: FtSequenceInvokation, sequenceItem: FtSequenceItem, definition: FtFloatFieldDefinition);
+    get definition(): FtFloatFieldDefinition;
+    get format(): string;
+    get styles(): number;
+    get nullableValue(): number | null;
+    set nullableValue(value: number | null);
+    protected isValueEqual(left: number, right: number): boolean;
+}
+
+/**
+ * Field definition for float (number) fields.
+ * @public
+ */
+export declare class FtFloatFieldDefinition extends FtGenericFieldDefinition<number> {
+    static readonly AUTO_LEFT_PAD = true;
+    protected formatter: FtFloatFieldFormatter;
+    constructor(index: number);
+    get format(): string;
+    get styles(): number;
+    loadMeta(metaField: FtFloatMetaField, myCulture: DotNetLocaleSettings | undefined, myMainHeadingIndex: number): void;
+    getValueText(value: number): string;
+    parseValueText(text: string): number;
+}
+
+/**
+ * Formatter for float (number) fields using .NET-compatible formatting.
+ * Implementation delegates to DotNetFloatFormatter from dot-net-date-number-formatting package.
+ * @public
+ */
+export declare class FtFloatFieldFormatter extends FtFieldFormatter {
+    private _styles;
+    private _format;
+    private _formatter;
+    get styles(): DotNetNumberStyles;
+    set styles(value: DotNetNumberStyles);
+    get format(): string;
+    set format(value: string);
+    toText(value: number): string;
+    parse(text: string): number;
+}
+
+/**
+ * Meta field for float (number) values.
+ * @public
+ */
+export declare class FtFloatMetaField extends FtGenericMetaField<number> {
+    static readonly DATA_TYPE: "Float";
+    static readonly DEFAULT_FORMAT = "G";
+    static readonly DEFAULT_STYLES: number;
+    static readonly DEFAULT_VALUE = 0;
+    static readonly DEFAULT_SEQUENCE_REDIRECT_TYPE: "ExactFloat";
+    private _format;
+    private _styles;
+    constructor(headingCount?: number);
+    get format(): string;
+    set format(value: string);
+    get styles(): DotNetNumberStyles;
+    set styles(value: DotNetNumberStyles);
+    static isFloatMetaField(field: FtMetaField): field is FtFloatMetaField;
+    loadDefaults(leaveNameAsIs?: boolean): void;
+    createCopy(): FtMetaField;
+    protected getDefaultSequenceRedirectType(): FtSequenceRedirectType;
+    protected assignFrom(source: FtMetaField): void;
+}
+
+/**
+ * Generic base class for typed fields.
+ * Provides type-safe value access and implements conversion methods.
+ * @public
+ */
+export declare abstract class FtGenericField<T> extends FtField {
+    private _value;
+    protected constructor(sequenceInvokation: FtSequenceInvokation, sequenceItem: FtSequenceItem, valueTextNullTrimmable: boolean, definition: FtGenericFieldDefinition<T>);
+    get definition_(): FtGenericFieldDefinition<T>;
+    get value(): T;
+    set value(val: T);
+    setValue(val: T): number;
+    protected getAsNonNullValueText(): string;
+    protected getAsNonNullObject(): unknown;
+    protected getAsNonNullString(): string;
+    protected getAsBoolean(): boolean;
+    protected getAsInteger(): number;
+    protected getAsBigInt(): bigint;
+    protected getAsFloat(): number;
+    protected getAsDateTime(): Date;
+    protected getAsDecimal(): number;
+    protected setAsNonNullObject(newValue: unknown): void;
+    protected setAsNonNullString(newValue: string): void;
+    protected setAsBoolean(newValue: boolean): void;
+    protected setAsInteger(newValue: number): void;
+    protected setAsBigInt(newValue: bigint): void;
+    protected setAsFloat(newValue: number): void;
+    protected setAsDateTime(newValue: Date): void;
+    protected setAsDecimal(newValue: number): void;
+    protected getAsRedirectBoolean(): boolean;
+    protected getAsRedirectInteger(): bigint;
+    protected getAsRedirectFloat(): number;
+    protected getAsRedirectDateTime(): Date;
+    protected getAsRedirectDecimal(): number;
+    protected loadNonNullValue(valueText: string): void;
+    private getValueOrThrowNull;
+    private checkValueSequenceRedirect;
+    /**
+     * Check if two values are equal.
+     * @param left - Left value
+     * @param right - Right value
+     * @returns true if values are equal
+     */
+    protected abstract isValueEqual(left: T, right: T): boolean;
+}
+
+/**
+ * Generic base class for field definitions with typed values.
+ * Extends FtFieldDefinition to add type-specific value handling.
+ * @public
+ */
+export declare abstract class FtGenericFieldDefinition<T> extends FtFieldDefinition {
+    private _value;
+    get value(): T;
+    /**
+     * Load metadata from a meta field.
+     * @param metaField - The meta field containing configuration
+     * @param myCulture - The culture settings for formatting
+     * @param myMainHeadingIndex - Index of the main heading
+     */
+    loadMeta(metaField: FtMetaField, myCulture: DotNetLocaleSettings | undefined, myMainHeadingIndex: number): void;
+    /**
+     * Convert a typed value to its text representation.
+     * @param value - The value to convert
+     * @returns The text representation
+     */
+    abstract getValueText(value: T): string;
+    /**
+     * Parse text into a typed value.
+     * @param text - The text to parse
+     * @returns The parsed value
+     */
+    abstract parseValueText(text: string): T;
+}
+
+/**
+ * Generic base class for typed meta fields.
+ * Provides value storage and management for fields with a specific value type.
+ * @public
+ */
+export declare abstract class FtGenericMetaField<T> extends FtMetaField {
+    private _defaultValue;
+    private _value;
+    protected constructor(dataType: FtDataType, headingCount: number, defaultValue: T);
+    get value(): T;
+    set value(val: T);
+    loadDefaults(leaveNameAsIs?: boolean): void;
+    protected assignFrom(source: FtMetaField): void;
+}
+
+/**
+ * @public
+ */
+export declare const FtHeadingConstraint: {
+    readonly None: "None";
+    readonly AllConstant: "AllConstant";
+    readonly MainConstant: "MainConstant";
+    readonly NameConstant: "NameConstant";
+    readonly NameIsMain: "NameIsMain";
+};
+
+/**
+ * @public
+ */
+export declare type FtHeadingConstraint = (typeof FtHeadingConstraint)[keyof typeof FtHeadingConstraint];
+
+/**
+ * @public
+ */
+export declare interface FtHeadingLineFinishedEventArgs {
+    lineIndex: number;
+}
+
+/**
+ * @public
+ */
+export declare interface FtHeadingLineStartedEventArgs {
+    lineIndex: number;
+}
+
+/**
+ * Field for integer (bigint) values.
+ * @public
+ */
+export declare class FtIntegerField extends FtGenericField<bigint> {
+    private static readonly VALUE_TEXT_NULL_TRIMMABLE;
+    constructor(sequenceInvokation: FtSequenceInvokation, sequenceItem: FtSequenceItem, definition: FtIntegerFieldDefinition);
+    get definition(): FtIntegerFieldDefinition;
+    get format(): string;
+    get styles(): number;
+    get nullableValue(): bigint | null;
+    set nullableValue(value: bigint | null);
+    protected isValueEqual(left: bigint, right: bigint): boolean;
+}
+
+/**
+ * Field definition for integer (bigint) fields.
+ * In TypeScript we use bigint for precision but also support number.
+ * @public
+ */
+export declare class FtIntegerFieldDefinition extends FtGenericFieldDefinition<bigint> {
+    static readonly AUTO_LEFT_PAD = true;
+    protected formatter: FtIntegerFieldFormatter;
+    constructor(index: number);
+    get format(): string;
+    get styles(): number;
+    loadMeta(metaField: FtIntegerMetaField, myCulture: DotNetLocaleSettings | undefined, myMainHeadingIndex: number): void;
+    getValueText(value: bigint): string;
+    parseValueText(text: string): bigint;
+}
+
+/**
+ * Formatter for integer (long) fields using .NET-compatible formatting.
+ * Implementation delegates to DotNetIntegerFormatter from dot-net-date-number-formatting package.
+ * @public
+ */
+export declare class FtIntegerFieldFormatter extends FtFieldFormatter {
+    private _styles;
+    private _format;
+    private _formatter;
+    get styles(): DotNetNumberStyles;
+    set styles(value: DotNetNumberStyles);
+    get format(): string;
+    set format(value: string);
+    toText(value: bigint | number): string;
+    parse(text: string): bigint;
+}
+
+/**
+ * Meta field for integer (bigint) values.
+ * @public
+ */
+export declare class FtIntegerMetaField extends FtGenericMetaField<bigint> {
+    static readonly DATA_TYPE: "Integer";
+    static readonly DEFAULT_FORMAT = "G";
+    static readonly DEFAULT_STYLES: number;
+    static readonly DEFAULT_VALUE = 0n;
+    static readonly DEFAULT_SEQUENCE_REDIRECT_TYPE: "ExactInteger";
+    private _format;
+    private _styles;
+    constructor(headingCount?: number);
+    get format(): string;
+    set format(value: string);
+    get styles(): DotNetNumberStyles;
+    set styles(value: DotNetNumberStyles);
+    static isIntegerMetaField(field: FtMetaField): field is FtIntegerMetaField;
+    loadDefaults(leaveNameAsIs?: boolean): void;
+    createCopy(): FtMetaField;
+    protected getDefaultSequenceRedirectType(): FtSequenceRedirectType;
+    protected assignFrom(source: FtMetaField): void;
+}
+
+/**
+ * Serializes and deserializes FtMeta to/from JSON format.
+ * This provides a simpler alternative to XML serialization.
+ * @public
+ */
+export declare class FtJsonMetaSerialization {
+    /**
+     * Serialize an FtMeta object to JSON string.
+     */
+    serialize(meta: FtMeta, _options?: FtMetaSerializerOptions): string;
+    /**
+     * Deserialize JSON string to an FtMeta object.
+     */
+    deserialize(json: string, _warnings?: string[]): FtMeta;
+    private serializeField;
+    private deserializeFieldProperties;
+}
+
+/** @public */
+export declare namespace FtJsonMetaSerialization {
+    export function serialize(meta: FtMeta, options?: FtMetaSerializerOptions): string;
+    export function deserialize(json: string, warnings?: string[]): FtMeta;
+}
+
+/**
+ * @public
+ */
+export declare const FtLastLineEndedType: {
+    readonly Never: "Never";
+    readonly Always: "Always";
+    readonly Optional: "Optional";
+};
+
+/**
+ * @public
+ */
+export declare type FtLastLineEndedType = (typeof FtLastLineEndedType)[keyof typeof FtLastLineEndedType];
+
+/**
+ * @public
+ */
+export declare const FtLineType: {
+    readonly Comment: "Comment";
+    readonly Signature: "Signature";
+    readonly Declaration2: "Declaration2";
+    readonly EmbeddedMeta: "EmbeddedMeta";
+    readonly Heading: "Heading";
+    readonly Blank: "Blank";
+    readonly Record: "Record";
+};
+
+/**
+ * @public
+ */
+export declare type FtLineType = (typeof FtLineType)[keyof typeof FtLineType];
+
+/**
+ * @public
+ */
+export declare class FtMeta {
+    static readonly DefaultCultureName = "";
+    static readonly DefaultEndOfLineType: "Auto";
+    static readonly DefaultEndOfLineChar = ";";
+    static readonly DefaultEndOfLineAutoWriteType: "Local";
+    static readonly DefaultLastLineEndedType: "Optional";
+    static readonly DefaultQuoteChar = "\"";
+    static readonly DefaultDelimiterChar = ",";
+    static readonly DefaultLineCommentChar = "\u0004";
+    static readonly DefaultAllowEndOfLineCharInQuotes = true;
+    static readonly DefaultIgnoreBlankLines = true;
+    static readonly DefaultIgnoreExtraChars = true;
+    static readonly DefaultAllowIncompleteRecords = false;
+    static readonly DefaultStuffedEmbeddedQuotes = true;
+    static readonly DefaultSubstitutionsEnabled = false;
+    static readonly DefaultSubstitutionChar = "\\";
+    static readonly DefaultHeadingLineCount = 0;
+    static readonly DefaultMainHeadingLineIndex = 0;
+    static readonly DefaultHeadingQuotedType: "Optional";
+    static readonly DefaultHeadingAlwaysWriteOptionalQuote = false;
+    static readonly DefaultHeadingWritePrefixSpace = false;
+    static readonly DefaultHeadingConstraint: "None";
+    static readonly DefaultHeadingPadAlignment: "Auto";
+    static readonly DefaultHeadingPadCharType: "EndOfValue";
+    static readonly DefaultHeadingPadChar = " ";
+    static readonly DefaultHeadingTruncateType: "Right";
+    static readonly DefaultHeadingTruncateChar = "#";
+    static readonly DefaultHeadingEndOfValueChar = "\u0003";
+    culture: DotNetLocaleSettings;
+    endOfLineType: FtEndOfLineType;
+    endOfLineChar: string;
+    endOfLineAutoWriteType: FtEndOfLineAutoWriteType;
+    lastLineEndedType: FtLastLineEndedType;
+    quoteChar: string;
+    delimiterChar: string;
+    lineCommentChar: string;
+    allowEndOfLineCharInQuotes: boolean;
+    ignoreBlankLines: boolean;
+    ignoreExtraChars: boolean;
+    allowIncompleteRecords: boolean;
+    stuffedEmbeddedQuotes: boolean;
+    substitutionsEnabled: boolean;
+    substitutionChar: string;
+    mainHeadingLineIndex: number;
+    headingConstraint: FtHeadingConstraint;
+    headingQuotedType: FtQuotedType;
+    headingAlwaysWriteOptionalQuote: boolean;
+    headingWritePrefixSpace: boolean;
+    headingPadAlignment: FtPadAlignment;
+    headingPadCharType: FtPadCharType;
+    headingPadChar: string;
+    headingTruncateType: FtTruncateType;
+    headingTruncateChar: string;
+    headingEndOfValueChar: string;
+    private _fieldList;
+    private _sequenceList;
+    private _substitutionList;
+    private _headingLineCount;
+    constructor();
+    get fieldList(): FtMetaFieldList;
+    get sequenceList(): FtMetaSequenceList;
+    get substitutionList(): FtMetaSubstitutionList;
+    get headingLineCount(): number;
+    set headingLineCount(value: number);
+    static create(): FtMeta;
+    reset(): void;
+    createCopy(): FtMeta;
+    assign(source: FtMeta): void;
+    validate(): {
+        valid: boolean;
+        errorMessage: string;
+    };
+    private handleFieldListBeforeRemove;
+    private handleFieldListBeforeClear;
+    private validateEndOfLineTypeChar;
+    private endOfLineTypeCharToString;
+}
+
+/**
+ * Base constructor class for creating FtMeta instances.
+ * Can be extended to provide custom meta creation logic.
+ * @public
+ */
+export declare class FtMetaConstructor {
+    /**
+     * Create a new FtMeta instance.
+     * Override this method in derived classes to provide custom initialization.
+     */
+    createMeta(): FtMeta;
+}
+
+/**
+ * @public
+ */
+export declare namespace FtMetaDefaults {
+    export namespace Root {
+        const CultureName = "";
+        const EndOfLineType: "Auto";
+        const EndOfLineChar = ";";
+        const EndOfLineAutoWriteType: "Local";
+        const LastLineEndedType: "Optional";
+        const QuoteChar = "\"";
+        const DelimiterChar = ",";
+        const LineCommentChar = "\u0004";
+        const AllowEndOfLineCharInQuotes = true;
+        const IgnoreBlankLines = true;
+        const IgnoreExtraChars = true;
+        const AllowIncompleteRecords = false;
+        const StuffedEmbeddedQuotes = true;
+        const SubstitutionsEnabled = false;
+        const SubstitutionChar = "\\";
+        const HeadingLineCount = 0;
+        const MainHeadingLineIndex = 0;
+        const HeadingConstraint: "None";
+        const HeadingQuotedType: "Optional";
+        const HeadingAlwaysWriteOptionalQuote = false;
+        const HeadingWritePrefixSpace = false;
+        const HeadingPadAlignment: "Auto";
+        const HeadingPadCharType: "EndOfValue";
+        const HeadingPadChar = " ";
+        const HeadingTruncateType: "Right";
+        const HeadingTruncateChar = "#";
+        const HeadingEndOfValueChar = "\u0003";
+    }
+    export namespace Field {
+        const Id = 0;
+        const Name = "";
+        const DataType: "String";
+        const FixedWidth = false;
+        const Width = 1;
+        const Constant = false;
+        const Null = false;
+        const ValueQuotedType: "Optional";
+        const ValueAlwaysWriteOptionalQuote = false;
+        const ValueWritePrefixSpace = false;
+        const ValuePadAlignment: "Auto";
+        const ValuePadCharType: "EndOfValue";
+        const ValuePadChar = " ";
+        const ValueTruncateType: "Exception";
+        const ValueTruncateChar = "#";
+        const ValueEndOfValueChar = "\u0003";
+        const ValueNullChar = "*";
+        export namespace RootOverriding {
+            const HeadingConstraint: "None";
+            const HeadingQuotedType: "Optional";
+            const HeadingAlwaysWriteOptionalQuote = false;
+            const HeadingWritePrefixSpace = false;
+            const HeadingPadAlignment: "Auto";
+            const HeadingPadCharType: "EndOfValue";
+            const HeadingPadChar = " ";
+            const HeadingTruncateType: "Right";
+            const HeadingTruncateChar = "#";
+            const HeadingEndOfValueChar = "\u0003";
+        }
+    }
+    export namespace StringField {
+        const Value = "";
+        const SequenceRedirectType: "ExactString";
+    }
+    export namespace BooleanField {
+        const FalseText = "False";
+        const TrueText = "True";
+        const Styles: number;
+        const Value = false;
+        const SequenceRedirectType: "Boolean";
+    }
+    export namespace IntegerField {
+        const Styles: number;
+        const Format = "G";
+        const Value = 0n;
+        const SequenceRedirectType: "ExactInteger";
+    }
+    export namespace FloatField {
+        const Styles: number;
+        const Format = "G";
+        const Value = 0;
+        const SequenceRedirectType: "ExactFloat";
+    }
+    export namespace DecimalField {
+        const Styles: number;
+        const Format = "G";
+        const Value = 0;
+        const SequenceRedirectType: "ExactDecimal";
+    }
+    export namespace DateTimeField {
+        const Styles: 0;
+        const Format = "yyyyMMdd";
+        const Value: Date;
+        const SequenceRedirectType: "ExactDateTime";
+        const DateFormat = "yyyyMMdd";
+        const DateFormatLength: number;
+        const TimeFormat = "HHmmss";
+        const TimeFormatLength: number;
+        const DateTimeFormat: string;
+        const DateTimeFormatLength: number;
+        const FractionFormat = "fffffff";
+        const MaxFractionLength: number;
+        const TimeAndFractionSeparatorChar = ".";
+        const TimeWithFractionFormat: string;
+        const DateTimeWithFractionFormat: string;
+    }
+    export namespace Substitution {
+        const Token = "\\";
+        const Type: "String";
+    }
+    export namespace Sequence {
+        const Root = false;
+    }
+    export namespace SequenceRedirect {
+        const InvokationDelay: "AfterField";
+    }
+}
+
+/**
+ * @public
+ */
+export declare const FtMetaElementType: {
+    readonly FieldedText: "FieldedText";
+    readonly Substitution: "Substitution";
+    readonly Field: "Field";
+    readonly Sequence: "Sequence";
+    readonly SequenceItem: "SequenceItem";
+    readonly SequenceRedirect: "SequenceRedirect";
+};
+
+/**
+ * @public
+ */
+export declare type FtMetaElementType = (typeof FtMetaElementType)[keyof typeof FtMetaElementType];
+
+/**
+ * Factory for creating FtMeta instances.
+ * Provides a global constructor that can be replaced to customize meta creation.
+ * @public
+ */
+export declare class FtMetaFactory {
+    private static _constructor;
+    /**
+     * Get the current meta constructor.
+     */
+    static getConstructor(): FtMetaConstructor;
+    /**
+     * Set a custom meta constructor.
+     * Use this to provide custom initialization logic for all meta instances.
+     */
+    static setConstructor(value: FtMetaConstructor): void;
+    /**
+     * Create a new FtMeta instance using the current constructor.
+     */
+    static createMeta(): FtMeta;
+}
+
+/**
+ * Abstract base class for meta field definitions.
+ * Meta fields define the structure and formatting of fields in a fielded text document.
+ * @public
+ */
+export declare abstract class FtMetaField {
+    onDefaultHeadingConstraintRequired: (() => FtHeadingConstraint) | undefined;
+    onDefaultHeadingQuotedTypeRequired: (() => FtQuotedType) | undefined;
+    onDefaultHeadingAlwaysWriteOptionalQuoteRequired: (() => boolean) | undefined;
+    onDefaultHeadingWritePrefixSpaceRequired: (() => boolean) | undefined;
+    onDefaultHeadingPadAlignmentRequired: (() => FtPadAlignment) | undefined;
+    onDefaultHeadingPadCharTypeRequired: (() => FtPadCharType) | undefined;
+    onDefaultHeadingPadCharRequired: (() => string) | undefined;
+    onDefaultHeadingTruncateTypeRequired: (() => FtTruncateType) | undefined;
+    onDefaultHeadingTruncateCharRequired: (() => string) | undefined;
+    onDefaultHeadingEndOfValueCharRequired: (() => string) | undefined;
+    private _index;
+    private _dataType;
+    private _id;
+    private _name;
+    private _headings;
+    private _fixedWidth;
+    private _width;
+    private _constant;
+    private _null;
+    private _valueQuotedType;
+    private _valueAlwaysWriteOptionalQuote;
+    private _valueWritePrefixSpace;
+    private _valuePadAlignment;
+    private _valuePadCharType;
+    private _valuePadChar;
+    private _valueTruncateType;
+    private _valueTruncateChar;
+    private _valueEndOfValueChar;
+    private _valueNullChar;
+    private _headingConstraint;
+    private _headingQuotedType;
+    private _headingAlwaysWriteOptionalQuote;
+    private _headingWritePrefixSpace;
+    private _headingPadAlignment;
+    private _headingPadCharType;
+    private _headingPadChar;
+    private _headingTruncateType;
+    private _headingTruncateChar;
+    private _headingEndOfValueChar;
+    protected constructor(dataType: FtDataType, headingCount: number);
+    get index(): number;
+    set index(value: number);
+    get dataType(): FtDataType;
+    set dataType(value: FtDataType);
+    get id(): number | undefined;
+    set id(value: number | undefined);
+    get name(): string;
+    set name(value: string);
+    get headings(): string[];
+    set headings(value: string[]);
+    get fixedWidth(): boolean;
+    set fixedWidth(value: boolean);
+    get width(): number;
+    set width(value: number);
+    get constant(): boolean;
+    set constant(value: boolean);
+    get null(): boolean;
+    set null(value: boolean);
+    get valueQuotedType(): FtQuotedType;
+    set valueQuotedType(value: FtQuotedType);
+    get valueAlwaysWriteOptionalQuote(): boolean;
+    set valueAlwaysWriteOptionalQuote(value: boolean);
+    get valueWritePrefixSpace(): boolean;
+    set valueWritePrefixSpace(value: boolean);
+    get valuePadAlignment(): FtPadAlignment;
+    set valuePadAlignment(value: FtPadAlignment);
+    get valuePadCharType(): FtPadCharType;
+    set valuePadCharType(value: FtPadCharType);
+    get valuePadChar(): string;
+    set valuePadChar(value: string);
+    get valueTruncateType(): FtTruncateType;
+    set valueTruncateType(value: FtTruncateType);
+    get valueTruncateChar(): string;
+    set valueTruncateChar(value: string);
+    get valueEndOfValueChar(): string;
+    set valueEndOfValueChar(value: string);
+    get valueNullChar(): string;
+    set valueNullChar(value: string);
+    get headingConstraint(): FtHeadingConstraint;
+    set headingConstraint(value: FtHeadingConstraint);
+    get headingQuotedType(): FtQuotedType;
+    set headingQuotedType(value: FtQuotedType);
+    get headingAlwaysWriteOptionalQuote(): boolean;
+    set headingAlwaysWriteOptionalQuote(value: boolean);
+    get headingWritePrefixSpace(): boolean;
+    set headingWritePrefixSpace(value: boolean);
+    get headingPadAlignment(): FtPadAlignment;
+    set headingPadAlignment(value: FtPadAlignment);
+    get headingPadCharType(): FtPadCharType;
+    set headingPadCharType(value: FtPadCharType);
+    get headingPadChar(): string;
+    set headingPadChar(value: string);
+    get headingTruncateType(): FtTruncateType;
+    set headingTruncateType(value: FtTruncateType);
+    get headingTruncateChar(): string;
+    set headingTruncateChar(value: string);
+    get headingEndOfValueChar(): string;
+    set headingEndOfValueChar(value: string);
+    get headingCount(): number;
+    getDefaultHeadings(): string[];
+    loadDefaults(leaveNameAsIs?: boolean): void;
+    /** @internal */
+    setHeadingCount(value: number): void;
+    validateEndOfLineTypeChar(eolTypeChar: string, headingLineCount: number): {
+        valid: boolean;
+        errorMessage: string;
+    };
+    protected assignFrom(source: FtMetaField): void;
+    private endOfLineTypeCharToString;
+    abstract createCopy(): FtMetaField;
+    protected abstract getDefaultSequenceRedirectType(): FtSequenceRedirectType;
+}
+
+/**
+ * @public
+ */
+export declare class FtMetaFieldList {
+    /** @internal */
+    onBeforeRemove: ((fieldIdx: number) => void) | undefined;
+    /** @internal */
+    onBeforeClear: (() => void) | undefined;
+    /** @internal */
+    onDefaultHeadingConstraintRequired: (() => FtHeadingConstraint) | undefined;
+    /** @internal */
+    onDefaultHeadingQuotedTypeRequired: (() => FtQuotedType) | undefined;
+    /** @internal */
+    onDefaultHeadingAlwaysWriteOptionalQuoteRequired: (() => boolean) | undefined;
+    /** @internal */
+    onDefaultHeadingWritePrefixSpaceRequired: (() => boolean) | undefined;
+    /** @internal */
+    onDefaultHeadingPadAlignmentRequired: (() => FtPadAlignment) | undefined;
+    /** @internal */
+    onDefaultHeadingPadCharTypeRequired: (() => FtPadCharType) | undefined;
+    /** @internal */
+    onDefaultHeadingPadCharRequired: (() => string) | undefined;
+    /** @internal */
+    onDefaultHeadingTruncateTypeRequired: (() => FtTruncateType) | undefined;
+    /** @internal */
+    onDefaultHeadingTruncateCharRequired: (() => string) | undefined;
+    /** @internal */
+    onDefaultHeadingEndOfValueCharRequired: (() => string) | undefined;
+    /** @internal */
+    private fields;
+    /** @internal */
+    private _headingCount;
+    get count(): number;
+    get headingCount(): number;
+    set headingCount(value: number);
+    get(index: number): FtMetaField;
+    indexOf(field: FtMetaField): number;
+    findById(id: number): FtMetaField | undefined;
+    find(name: string): FtMetaField | undefined;
+    new(dataType: FtDataType): FtMetaField;
+    removeAt(index: number): void;
+    remove(field: FtMetaField): void;
+    clear(): void;
+    set(value: FtMetaField[]): void;
+    assign(source: FtMetaFieldList): void;
+    private add;
+    private bindFieldEvents;
+    private unbindFieldEvents;
+}
+
+/**
+ * @public
+ */
+export declare const FtMetaPropertyId: {
+    readonly Culture: "Culture";
+    readonly EndOfLineType: "EndOfLineType";
+    readonly EndOfLineChar: "EndOfLineChar";
+    readonly EndOfLineAutoWriteType: "EndOfLineAutoWriteType";
+    readonly LastLineEndedType: "LastLineEndedType";
+    readonly QuoteChar: "QuoteChar";
+    readonly DelimiterChar: "DelimiterChar";
+    readonly LineCommentChar: "LineCommentChar";
+    readonly AllowEndOfLineCharInQuotes: "AllowEndOfLineCharInQuotes";
+    readonly IgnoreBlankLines: "IgnoreBlankLines";
+    readonly IgnoreExtraChars: "IgnoreExtraChars";
+    readonly AllowIncompleteRecords: "AllowIncompleteRecords";
+    readonly StuffedEmbeddedQuotes: "StuffedEmbeddedQuotes";
+    readonly SubstitutionsEnabled: "SubstitutionsEnabled";
+    readonly SubstitutionChar: "SubstitutionChar";
+    readonly HeadingLineCount: "HeadingLineCount";
+    readonly MainHeadingLineIndex: "MainHeadingLineIndex";
+    readonly HeadingConstraint: "HeadingConstraint";
+    readonly HeadingQuotedType: "HeadingQuotedType";
+    readonly HeadingAlwaysWriteOptionalQuote: "HeadingAlwaysWriteOptionalQuote";
+    readonly HeadingWritePrefixSpace: "HeadingWritePrefixSpace";
+    readonly HeadingPadAlignment: "HeadingPadAlignment";
+    readonly HeadingPadCharType: "HeadingPadCharType";
+    readonly HeadingPadChar: "HeadingPadChar";
+    readonly HeadingTruncateType: "HeadingTruncateType";
+    readonly HeadingTruncateChar: "HeadingTruncateChar";
+    readonly HeadingEndOfValueChar: "HeadingEndOfValueChar";
+    readonly LegacyEndOfLineIsSeparator: "LegacyEndOfLineIsSeparator";
+    readonly LegacyIncompleteRecordsAllowed: "LegacyIncompleteRecordsAllowed";
+};
+
+/**
+ * @public
+ */
+export declare type FtMetaPropertyId = (typeof FtMetaPropertyId)[keyof typeof FtMetaPropertyId];
+
+/**
+ * @public
+ */
+export declare const FtMetaReferenceType: {
+    readonly None: "None";
+    readonly Embedded: "Embedded";
+    readonly File: "File";
+    readonly Url: "Url";
+};
+
+/**
+ * @public
+ */
+export declare type FtMetaReferenceType = (typeof FtMetaReferenceType)[keyof typeof FtMetaReferenceType];
+
+/**
+ * @public
+ */
+export declare class FtMetaSequence {
+    rootedEvent: RootedEventHandler | undefined;
+    private readonly _itemList;
+    private _name;
+    private _root;
+    constructor();
+    get name(): string;
+    set name(value: string);
+    get root(): boolean;
+    set root(value: boolean);
+    get itemList(): FtMetaSequenceItemList;
+    static sameName(left: string, right: string): boolean;
+    setItemList(items: readonly FtMetaSequenceItem[]): void;
+    loadDefaults(): void;
+    removeItemsWithField(field: FtMetaField): void;
+    removeAllItems(): void;
+    createCopyExcludingRedirects(fieldList: FtMetaFieldList, sourceFieldList: FtMetaFieldList): FtMetaSequence;
+    assignExcludingRedirects(source: FtMetaSequence, fieldList: FtMetaFieldList, sourceFieldList: FtMetaFieldList): void;
+    assignRedirects(sequenceList: FtMetaSequenceList, sourceSequenceList: FtMetaSequenceList): void;
+    anyItemWithUndefinedField(): {
+        found: boolean;
+        itemIndex: number;
+    };
+    anyItemWithConstantFieldHasRedirects(): {
+        found: boolean;
+        itemIndex: number;
+    };
+}
+
+/**
+ * @public
+ */
+export declare class FtMetaSequenceItem {
+    private readonly _redirectList;
+    private _field;
+    constructor(field: FtMetaField);
+    get field(): FtMetaField;
+    set field(value: FtMetaField);
+    get redirectList(): FtMetaSequenceRedirectList;
+    setRedirectList(redirects: readonly FtMetaSequenceRedirect[]): void;
+    loadDefaults(): void;
+    createCopyExcludingRedirects(fieldList: FtMetaFieldList, sourceFieldList: FtMetaFieldList): FtMetaSequenceItem;
+    assignRedirects(sequenceList: FtMetaSequenceList, sourceSequenceList: FtMetaSequenceList): void;
+    hasConstantFieldAndHasRedirects(): boolean;
+    private assignExcludingRedirects;
+    private findSourceField;
+}
+
+/**
+ * @public
+ */
+export declare class FtMetaSequenceItemList {
+    private readonly _list;
+    get count(): number;
+    get(index: number): FtMetaSequenceItem;
+    set(items: readonly FtMetaSequenceItem[]): void;
+    new(field: FtMetaField): FtMetaSequenceItem;
+    remove(item: FtMetaSequenceItem): void;
+    removeAt(index: number): void;
+    clear(): void;
+    moveItemToBefore(fromIndex: number, beforeIndex: number): void;
+    moveItemToAfter(fromIndex: number, afterIndex: number): void;
+    assignExcludingRedirects(source: FtMetaSequenceItemList, fieldList: FtMetaFieldList, sourceFieldList: FtMetaFieldList): void;
+    assignRedirects(sequenceList: FtMetaSequenceList, sourceSequenceList: FtMetaSequenceList): void;
+    private add;
+}
+
+/**
+ * @public
+ */
+export declare class FtMetaSequenceList {
+    private readonly _list;
+    get count(): number;
+    get(index: number): FtMetaSequence;
+    getByName(name: string): FtMetaSequence;
+    set(value: readonly FtMetaSequence[]): void;
+    new(name?: string): FtMetaSequence;
+    removeAt(index: number): void;
+    remove(sequence: FtMetaSequence): void;
+    clear(): void;
+    removeField(field: FtMetaField): void;
+    removeAllFields(): void;
+    indexOf(sequence: FtMetaSequence): number;
+    indexOfName(name: string): number;
+    indexOfRoot(): number;
+    assign(source: FtMetaSequenceList, fieldList: FtMetaFieldList, sourceFieldList: FtMetaFieldList): void;
+    isMoreThanOneRoot(): {
+        found: boolean;
+        firstRootSequenceName: string;
+        secondRootSequenceName: string;
+    };
+    hasDuplicateName(): {
+        found: boolean;
+        duplicateName: string;
+    };
+    anyItemWithUndefinedField(sequenceIndex: number): {
+        found: boolean;
+        itemIndex: number;
+    };
+    anyItemWithConstantFieldHasRedirects(sequenceIndex: number): {
+        found: boolean;
+        itemIndex: number;
+    };
+    private add;
+    private bindSequenceEvents;
+    private unbindSequenceEvents;
+    private handleSequenceRootedEvent;
+}
+
+/**
+ * Abstract base class for meta sequence redirects.
+ * Sequence redirects define conditional transitions from one sequence to another
+ * based on field values in the metadata.
+ * @public
+ */
+export declare abstract class FtMetaSequenceRedirect {
+    private readonly _type;
+    private _sequence;
+    private _invokationDelay;
+    protected constructor(type: FtSequenceRedirectType);
+    /** The type identifier for this redirect */
+    get type(): FtSequenceRedirectType;
+    /** The target sequence to redirect to when this redirect is triggered */
+    get sequence(): FtMetaSequence | undefined;
+    set sequence(value: FtMetaSequence | undefined);
+    /** When the redirect should be invoked relative to field processing */
+    get invokationDelay(): FtSequenceInvokationDelay;
+    set invokationDelay(value: FtSequenceInvokationDelay);
+    /** Reset this redirect to default values */
+    loadDefaults(): void;
+    /**
+     * Assign values from another redirect to this one.
+     * @param source - The source redirect to copy from
+     * @param sequenceList - The destination sequence list
+     * @param sourceSequenceList - The source sequence list
+     * @internal
+     */
+    protected assign(source: FtMetaSequenceRedirect, sequenceList: FtMetaSequenceList, sourceSequenceList: FtMetaSequenceList): void;
+    /**
+     * Create a deep copy of this redirect.
+     * @param sequenceList - The destination sequence list
+     * @param sourceSequenceList - The source sequence list
+     * @returns A new redirect instance with copied values
+     */
+    abstract createCopy(sequenceList: FtMetaSequenceList, sourceSequenceList: FtMetaSequenceList): FtMetaSequenceRedirect;
+}
+
+/**
+ * List of meta sequence redirects for a sequence item.
+ * Manages the collection of redirects that determine when to switch sequences.
+ * @public
+ */
+export declare class FtMetaSequenceRedirectList {
+    private readonly _list;
+    get count(): number;
+    get(index: number): FtMetaSequenceRedirect;
+    set(redirects: readonly FtMetaSequenceRedirect[]): void;
+    new(type: FtSequenceRedirectType): FtMetaSequenceRedirect;
+    remove(redirect: FtMetaSequenceRedirect): void;
+    removeAt(index: number): void;
+    clear(): void;
+    assign(source: FtMetaSequenceRedirectList, sequenceList: FtMetaSequenceList, sourceSequenceList: FtMetaSequenceList): void;
+    private add;
+    private createMetaSequenceRedirect;
+}
+
+/**
+ * API for serializing and deserializing FtMeta objects.
+ * Provides a unified interface for both XML and JSON formats.
+ * @public
+ */
+export declare class FtMetaSerialization {
+    /**
+     * Deserialize an FtMeta object from a string.
+     * @param content - The serialized meta content (XML or JSON)
+     * @param format - The format of the content (default: auto-detect)
+     * @param warnings - Optional array to collect warnings during deserialization
+     * @returns The deserialized FtMeta object
+     */
+    deserialize(content: string, warnings?: string[], format?: FtMetaSerializationFormat): FtMeta;
+    /**
+     * Serialize an FtMeta object to a string.
+     * @param meta - The FtMeta object to serialize
+     * @param format - The output format (default: XML)
+     * @returns The serialized string
+     */
+    serialize(meta: FtMeta, options?: FtMetaSerializerOptions, format?: FtMetaSerializationFormat): string;
+}
+
+/** @public */
+export declare namespace FtMetaSerialization {
+    export function serialize(meta: FtMeta, options?: FtMetaSerializerOptions, format?: FtMetaSerializationFormat): string;
+    export function deserialize(content: string, warnings?: string[], format?: FtMetaSerializationFormat): FtMeta;
+}
+
+/**
+ * Meta serialization format.
+ * @public
+ */
+export declare const FtMetaSerializationFormat: {
+    /**
+     * XML format (compatible with Standard 0.9).
+     */
+    readonly XML: "XML";
+    /**
+     * JSON format (Alternative for experimental use).
+     */
+    readonly JSON: "JSON";
+};
+
+/**
+ * @public
+ */
+export declare type FtMetaSerializationFormat = (typeof FtMetaSerializationFormat)[keyof typeof FtMetaSerializationFormat];
+
+/**
+ * Options for serialization formatting.
+ * @public
+ */
+export declare interface FtMetaSerializerOptions {
+    explicitIndices?: boolean;
+    indent?: boolean;
+    indentChars?: string;
+    newLineOnAttributes?: boolean;
+}
+
+/**
+ * Default values for meta serialization formatting.
+ * @public
+ */
+export declare namespace FtMetaSerializerOptions {
+    const DEFAULT_EXPLICIT_INDICES = false;
+    const DEFAULT_INDENT = true;
+    const DEFAULT_INDENT_CHARS = "  ";
+    const DEFAULT_NEW_LINE_ON_ATTRIBUTES = false;
+}
+
+/**
+ * @public
+ */
+export declare class FtMetaSubstitution {
+    id: number;
+    token: string;
+    type: FtSubstitutionType;
+    value: string;
+    constructor(id?: number, token?: string, type?: FtSubstitutionType, value?: string);
+}
+
+/**
+ * @public
+ */
+export declare class FtMetaSubstitutionList {
+    private substitutions;
+    get count(): number;
+    get(index: number): FtMetaSubstitution;
+    new(type?: FtSubstitutionType, token?: string, value?: string): FtMetaSubstitution;
+    clear(): void;
+    assign(source: FtMetaSubstitutionList): void;
+}
+
+/**
+ * Meta sequence redirect that triggers when a field value is null.
+ * Used in metadata to define sequence transitions based on null field values.
+ * @public
+ */
+export declare class FtNullMetaSequenceRedirect extends FtMetaSequenceRedirect {
+    /** The standard type identifier for null redirects */
+    static readonly TYPE: "Null";
+    constructor();
+    createCopy(sequenceList: FtMetaSequenceList, sourceSequenceList: FtMetaSequenceList): FtMetaSequenceRedirect;
+}
+
+/**
+ * Sequence redirect that triggers when a field is null.
+ * @public
+ */
+export declare class FtNullSequenceRedirect extends FtSequenceRedirect {
+    static readonly TYPE: "Null";
+    constructor(index: number);
+    checkTriggered(field: FtField): boolean;
+    /** @internal */
+    loadMeta(metaSequenceRedirect: FtNullMetaSequenceRedirect, metaSequenceList: FtMetaSequenceList, sequenceList: FtSequenceList): void;
+}
+
+/**
+ * @public
+ */
+declare type FtNumberDataType = typeof FtDataType.Integer | typeof FtDataType.Float | typeof FtDataType.Decimal;
+
+/** @public */
+export declare class FtNumberStylesMetaSerialization {
+    static allowInnerWhiteMetaValue: string;
+    static allowWhiteSpacesMetaValue: string;
+    static lowerCaseAllowInnerWhiteMetaValue: string;
+    static lowerCaseAllowWhiteSpacesMetaValue: string;
+    static serialize(styles: DotNetNumberStyles, dataType: FtNumberDataType): string | undefined;
+    static deserialize(value: unknown, dataType: FtNumberDataType, warnings: string[]): DotNetNumberStyles;
+    private static getDefaultNumberStyles;
+}
+
+/**
+ * @public
+ */
+export declare const FtPadAlignment: {
+    readonly Auto: "Auto";
+    readonly Left: "Left";
+    readonly Right: "Right";
+};
+
+/**
+ * @public
+ */
+export declare type FtPadAlignment = (typeof FtPadAlignment)[keyof typeof FtPadAlignment];
+
+/**
+ * @public
+ */
+export declare const FtPadCharType: {
+    readonly Auto: "Auto";
+    readonly Specified: "Specified";
+    readonly EndOfValue: "EndOfValue";
+};
+
+/**
+ * @public
+ */
+export declare type FtPadCharType = (typeof FtPadCharType)[keyof typeof FtPadCharType];
+
+/**
+ * @public
+ */
+export declare const FtQuotedType: {
+    readonly Never: "Never";
+    readonly Always: "Always";
+    readonly Optional: "Optional";
+};
+
+/**
+ * @public
+ */
+export declare type FtQuotedType = (typeof FtQuotedType)[keyof typeof FtQuotedType];
+
+/**
+ * High-level reader for fielded text files.
+ * Provides a convenient API for reading CSV and other delimited/fixed-width text.
+ * This is a thin wrapper around SerializationReader with simpler constructors.
+ * @public
+ */
+export declare class FtReader extends FtSerializationReader {
+    /**
+     * Create a reader with or without metadata.
+     * If metadata is provided, it will be loaded immediately. If not, you must call loadMeta() before reading.
+     * You must call open() before reading.
+     * @param meta - The metadata defining the file structure
+     */
+    constructor(meta?: FtMeta);
+    /**
+     * Create a reader with metadata and input text.
+     * You must call open() before reading.
+     * @param meta - The metadata defining the file structure
+     * @param input - The text content to read
+     * @param immediatelyReadHeader - Whether to automatically read header lines (default: true)
+     */
+    constructor(meta: FtMeta, input: string, immediatelyReadHeader?: boolean);
+    /**
+     * Create a reader with metadata and a TextReader.
+     * @param meta - The metadata defining the file structure
+     * @param textReader - The TextReader to read from
+     * @param immediatelyReadHeader - Whether to automatically read header lines (default: true)
+     */
+    constructor(meta: FtMeta, textReader: FtTextReader, immediatelyReadHeader?: boolean);
+    /**
+     * Create a reader with input text but no metadata.
+     * You must call loadMeta() before reading.
+     * @param input - The text content to read
+     * @param immediatelyReadHeader - Whether to automatically read header lines (default: true)
+     */
+    constructor(input: string, immediatelyReadHeader?: boolean);
+    /**
+     * Create a reader with a TextReader but no metadata.
+     * You must call loadMeta() before reading.
+     * @param textReader - The TextReader to read from
+     * @param immediatelyReadHeader - Whether to automatically read header lines (default: true)
+     */
+    constructor(textReader: FtTextReader, immediatelyReadHeader?: boolean);
+    /**
+     * Open the reader with a text string.
+     * @param textReaderOrText - Text reader or string providing the data to read
+     * @param immediatelyReadHeader - Whether to automatically read header lines (default: true)
+     */
+    open(textReaderOrText: FtTextReader | string, immediatelyReadHeader?: boolean): void;
+}
+
+/**
+ * @public
+ */
+export declare const FtReadRecordResult: {
+    readonly SameTable: "SameTable";
+    readonly NewTable: "NewTable";
+    readonly NoMoreRecords: "NoMoreRecords";
+};
+
+/**
+ * @public
+ */
+export declare type FtReadRecordResult = (typeof FtReadRecordResult)[keyof typeof FtReadRecordResult];
+
+/**
+ * @public
+ */
+export declare interface FtRecordFinishedEventArgs {
+    recordIndex: number;
+}
+
+/**
+ * @public
+ */
+export declare interface FtRecordStartedEventArgs {
+    recordIndex: number;
+}
+
+/**
+ * Represents a sequence of fielded text items.
+ * A sequence defines a pattern of fields that can be repeated.
+ * @public
+ */
+export declare class FtSequence {
+    private static readonly AUTO_ROOT_NAME;
+    private _index;
+    private _name;
+    private _root;
+    private _itemList;
+    constructor(index: number);
+    get index(): number;
+    get name(): string;
+    get root(): boolean;
+    get itemList(): FtSequenceItemList;
+    /** @internal */
+    setRoot(value: boolean): void;
+    /** @internal */
+    loadMeta(metaSequence: FtMetaSequence, metaFieldList: FtMetaFieldList, fieldDefinitionList: FtFieldDefinitionList): void;
+    /** @internal */
+    loadMetaSequenceRedirects(metaSequence: FtMetaSequence, metaSequenceList: FtMetaSequenceList, sequenceList: FtSequenceList): void;
+    /** @internal */
+    loadRootFieldDefinitionList(fieldDefinitionList: FtFieldDefinitionList): void;
+}
+
+/**
+ * Constructor for creating sequence instances.
+ * @public
+ */
+export declare class FtSequenceConstructor {
+    createSequence(index: number): FtSequence;
+}
+
+/**
+ * Factory for creating sequences.
+ * @public
+ */
+export declare class FtSequenceFactory {
+    private static _constructor;
+    static getConstructor(): FtSequenceConstructor;
+    static setConstructor(value: FtSequenceConstructor): void;
+    static createSequence(index: number): FtSequence;
+}
+
+/**
+ * Represents an invokation of a sequence during reading or writing.
+ * Manages the fields that make up an instance of a sequence pattern.
+ * @public
+ */
+export declare class FtSequenceInvokation {
+    sequenceRedirectEvent: FtSequenceRedirectDelegate | undefined;
+    private _index;
+    private _sequence;
+    private _startFieldIndex;
+    private _fieldList;
+    private _fieldsSidelinedFromIndex;
+    private _redirectingField;
+    constructor(index: number, sequence: FtSequence, startFieldIndex: number);
+    get index(): number;
+    get sequence(): FtSequence;
+    get startFieldIndex(): number;
+    get fieldCount(): number;
+    get fieldsSidelinedFromIndex(): number;
+    get redirectingField(): FtField | undefined;
+    getField(index: number): FtField;
+    /** @internal */
+    createPreviousCopy(): FtSequenceInvokation;
+    /** @internal */
+    matches(other: FtSequenceInvokation): boolean;
+    /** @internal */
+    resetFields(startFieldIndex: number): void;
+    /** @internal */
+    sidelineFields(): void;
+    /** @internal */
+    sidelineFieldsOverload(fromFieldIndex: number): void;
+    /** @internal */
+    unsidelineFields(): void;
+    /** @internal */
+    restart(startFieldIndex: number): void;
+    private handleSequenceRedirectEvent;
+    private sidelineFieldsFrom;
+}
+
+/**
+ * @public
+ */
+export declare const FtSequenceInvokationDelay: {
+    readonly AfterField: "AfterField";
+    readonly AfterSequence: "AfterSequence";
+};
+
+/**
+ * @public
+ */
+export declare type FtSequenceInvokationDelay = (typeof FtSequenceInvokationDelay)[keyof typeof FtSequenceInvokationDelay];
+
+/**
+ * @public
+ */
+declare class FtSequenceInvokationList {
+    sequenceRedirectEvent?: FtSequenceRedirectDelegate;
+    private list;
+    private _count;
+    get count(): number;
+    get predictCount(): number;
+    get(index: number): FtSequenceInvokation;
+    new(sequence: FtSequence, fieldIndex: number): FtSequenceInvokation;
+    clear(): void;
+    trim(fromIndex: number): void;
+    tryPredictedNew(index: number, sequence: FtSequence, fieldIndex: number): FtSequenceInvokation | undefined;
+    predictTrim(fromIndex: number): void;
+    matches(other: FtSequenceInvokationList): boolean;
+    assign(other: FtSequenceInvokationList): void;
+}
+
+/**
+ * Represents an item in a sequence.
+ * Each sequence item references a field definition and has optional redirects.
+ * @public
+ */
+export declare class FtSequenceItem {
+    private _index;
+    private _fieldDefinition;
+    private _redirectList;
+    constructor(index: number);
+    get index(): number;
+    get fieldDefinition(): FtFieldDefinition | undefined;
+    get redirectList(): FtSequenceRedirectList;
+    /** @internal */
+    loadMeta(metaSequenceItem: FtMetaSequenceItem, metaFieldList: FtMetaFieldList, fieldDefinitionList: FtFieldDefinitionList): void;
+    /** @internal */
+    loadMetaSequenceRedirects(metaSequenceItem: FtMetaSequenceItem, metaSequenceList: FtMetaSequenceList, sequenceList: FtSequenceList): void;
+    /** @internal */
+    setFieldDefinition(definition: FtFieldDefinition): void;
+}
+
+/**
+ * Constructor for creating sequence item instances.
+ * @public
+ */
+export declare class FtSequenceItemConstructor {
+    createSequenceItem(index: number): FtSequenceItem;
+}
+
+/**
+ * Factory for creating sequence items.
+ * @public
+ */
+export declare class FtSequenceItemFactory {
+    private static _constructor;
+    static getConstructor(): FtSequenceItemConstructor;
+    static setConstructor(value: FtSequenceItemConstructor): void;
+    static createSequenceItem(index: number): FtSequenceItem;
+}
+
+/**
+ * List of sequence items.
+ * @public
+ */
+export declare class FtSequenceItemList {
+    private _list;
+    get count(): number;
+    /** @internal */
+    get capacity(): number;
+    set capacity(value: number);
+    get(index: number): FtSequenceItem;
+    /** @internal */
+    clear(): void;
+    /** @internal */
+    new(): FtSequenceItem;
+}
+
+/**
+ * List of sequences.
+ * @public
+ */
+export declare class FtSequenceList {
+    private _list;
+    get count(): number;
+    /** @internal */
+    get capacity(): number;
+    set capacity(value: number);
+    get(index: number): FtSequence;
+    getByName(name: string): FtSequence;
+    /** @internal */
+    clear(): void;
+    /** @internal */
+    new(fieldDefinitionList?: FtFieldDefinitionList): FtSequence;
+    indexOfName(name: string): number;
+    indexOfRoot(): number;
+}
+
+/**
+ * Abstract base class for sequence redirects.
+ * Redirects determine when to switch from one sequence to another based on field values.
+ * These are the runtime instances that use metadata definitions to perform actual redirections.
+ * @public
+ */
+export declare abstract class FtSequenceRedirect {
+    private _index;
+    private _type;
+    private _sequence;
+    private _invokationDelay;
+    protected constructor(index: number, type: FtSequenceRedirectType);
+    get index(): number;
+    get type(): FtSequenceRedirectType;
+    get sequence(): FtSequence | undefined;
+    get invokationDelay(): FtSequenceInvokationDelay;
+    /** @internal */
+    loadMeta(metaSequenceRedirect: FtMetaSequenceRedirect, metaSequenceList: FtMetaSequenceList, sequenceList: FtSequenceList): void;
+    /**
+     * Check if this redirect is triggered based on the field's current state.
+     * @param field - The field to check
+     * @returns true if redirect should be triggered
+     */
+    abstract checkTriggered(field: FtField): boolean;
+}
+
+/**
+ * Abstract base class for sequence redirect constructors.
+ * @public
+ */
+export declare abstract class FtSequenceRedirectConstructor {
+    get sequenceRedirectType(): FtSequenceRedirectType;
+    get sequenceRedirectTypeName(): string;
+    abstract createSequenceRedirect(index: number): FtSequenceRedirect;
+    protected abstract getSequenceRedirectType(): FtSequenceRedirectType;
+}
+
+/**
+ * Delegate for sequence redirect events.
+ * @public
+ */
+export declare type FtSequenceRedirectDelegate = (field: FtField, sequence: FtSequence | undefined, delay: FtSequenceInvokationDelay) => number;
+
+/**
+ * @public
+ */
+export declare interface FtSequenceRedirectedEventArgs {
+    redirectingField: FtField;
+    fieldsAffectedFromIndex: number;
+}
+
+/**
+ * Factory for creating sequence redirects.
+ * Manages a registry of redirect types and their constructors.
+ * @public
+ */
+export declare class FtSequenceRedirectFactory {
+    private static constructorList;
+    private static initialized;
+    static registerConstructor(constructor: FtSequenceRedirectConstructor): void;
+    static getRegisteredConstructors(): FtSequenceRedirectConstructor[];
+    static unregisterAllConstructors(): void;
+    static unregisterConstructor(constructorOrType: FtSequenceRedirectConstructor | FtSequenceRedirectType | string): void;
+    static createSequenceRedirect(index: number, typeOrName: FtSequenceRedirectType | string): FtSequenceRedirect;
+    static getName(type: FtSequenceRedirectType): string;
+    static tryGetType(typeName: string): Result<FtSequenceRedirectType, boolean>;
+    private static tryFindConstructorByType;
+    private static tryFindConstructorByName;
+}
+
+/**
+ * List of sequence redirects for a sequence item.
+ * @public
+ */
+export declare class FtSequenceRedirectList {
+    private _items;
+    get count(): number;
+    /** @internal */
+    get capacity(): number;
+    set capacity(value: number);
+    get(index: number): FtSequenceRedirect;
+    /** @internal */
+    clear(): void;
+    /** @internal */
+    new(type: FtSequenceRedirectType): FtSequenceRedirect;
+}
+
+/**
+ * @public
+ */
+export declare const FtSequenceRedirectType: {
+    readonly Null: "Null";
+    readonly ExactString: "ExactString";
+    readonly CaseInsensitiveString: "CaseInsensitiveString";
+    readonly Boolean: "Boolean";
+    readonly ExactInteger: "ExactInteger";
+    readonly ExactFloat: "ExactFloat";
+    readonly ExactDateTime: "ExactDateTime";
+    readonly Date: "Date";
+    readonly ExactDecimal: "ExactDecimal";
+};
+
+/**
+ * @public
+ */
+export declare type FtSequenceRedirectType = (typeof FtSequenceRedirectType)[keyof typeof FtSequenceRedirectType];
+
+/**
+ * High-level API for event-driven serialization and deserialization of fielded text.
+ * Simplifies reading and writing by hooking into field and record events.
+ * @public
+ */
+export declare class FtSerialization {
+    static readonly VERSION_MAJOR = 1;
+    static readonly VERSION_MINOR = 1;
+    static readonly PREFIX_SPACE_CHAR = " ";
+    onFieldHeadingReadReady: ((args: FtFieldHeadingReadyEventArgs) => void) | undefined;
+    onFieldHeadingWriteReady: ((args: FtFieldHeadingReadyEventArgs) => void) | undefined;
+    onFieldValueReadReady: ((args: FtFieldValueReadyEventArgs) => void) | undefined;
+    onFieldValueWriteReady: ((args: FtFieldValueReadyEventArgs) => void) | undefined;
+    onHeadingLineStarted: ((args: FtHeadingLineStartedEventArgs) => void) | undefined;
+    onHeadingLineFinished: ((args: FtHeadingLineFinishedEventArgs) => void) | undefined;
+    onRecordStarted: ((args: FtRecordStartedEventArgs) => void) | undefined;
+    onRecordFinished: ((args: FtRecordFinishedEventArgs) => void) | undefined;
+    onSequenceRedirected: ((args: FtSequenceRedirectedEventArgs) => void) | undefined;
+    private _meta;
+    private _core;
+    constructor(meta: FtMeta);
+    get fieldDefinitionList(): FtFieldDefinitionList | undefined;
+    get fieldList(): FtFieldList | undefined;
+    get substitutionList(): FtSubstitutionList | undefined;
+    get sequenceList(): FtSequenceList | undefined;
+    get sequenceInvokationList(): FtSequenceInvokationList | undefined;
+    get rootSequence(): FtSequence | undefined;
+    get rootFieldCount(): number;
+    get rootSequenceInvokation(): FtSequenceInvokation | undefined;
+    get recordCount(): number;
+    get tableCount(): number;
+    /**
+     * Read all records from a reader, invoking events for each field and record.
+     * @param reader - The reader to deserialize from
+     */
+    deserialize(reader: FtReader): void;
+    /**
+     * Read all records from text input, invoking events for each field and record.
+     * @param input - The text content to deserialize
+     */
+    deserialize(input: string): void;
+    /**
+     * Write records until aborted by throwing FtAbortSerializationException from an event handler.
+     * @param writer - The writer to serialize to
+     */
+    serialize(writer: FtWriter): void;
+    /**
+     * Write records until aborted by throwing FtAbortSerializationException from an event handler.
+     * @param output - The TextWriter to serialize to
+     * @param settings - Optional writer settings
+     */
+    serialize(output: FtTextWriter, settings?: FtWriterSettings): void;
+    private setCore;
+}
+
+/**
+ * Enumeration of serialization error codes.
+ * @public
+ */
+export declare const FtSerializationError: {
+    readonly Abort: "Abort";
+    readonly DeclarationParameterNameIsZeroLength: "DeclarationParameterNameIsZeroLength";
+    readonly DeclaredParameterNameContainsSeparator: "DeclaredParameterNameContainsSeparator";
+    readonly DeclarationParameterNameNotTerminated: "DeclarationParameterNameNotTerminated";
+    readonly DeclarationParameterMissingValue: "DeclarationParameterMissingValue";
+    readonly DeclarationParameterValueNotQuoted: "DeclarationParameterValueNotQuoted";
+    readonly DeclarationParameterValueNotTerminated: "DeclarationParameterValueNotTerminated";
+    readonly DeclarationParametersMissingVersion: "DeclarationParametersMissingVersion";
+    readonly DeclarationParameterVersionIsNotFirst: "DeclarationParameterVersionIsNotFirst";
+    readonly DeclarationParameterInvalidVersion: "DeclarationParameterInvalidVersion";
+    readonly EmbeddedMetaNotFound: "EmbeddedMetaNotFound";
+    readonly IncompleteEmbeddedMeta: "IncompleteEmbeddedMeta";
+    readonly HeadingLineNotEnoughFields: "HeadingLineNotEnoughFields";
+    readonly RecordNotEnoughFields: "RecordNotEnoughFields";
+    readonly HeadingLineTooManyFields: "HeadingLineTooManyFields";
+    readonly RecordTooManyFields: "RecordTooManyFields";
+    readonly HeadingQuotedFieldMissingEndQuoteChar: "HeadingQuotedFieldMissingEndQuoteChar";
+    readonly ValueQuotedFieldMissingEndQuoteChar: "ValueQuotedFieldMissingEndQuoteChar";
+    readonly HeadingNonWhiteSpaceCharBeforeQuotesOpened: "HeadingNonWhiteSpaceCharBeforeQuotesOpened";
+    readonly ValueNonWhiteSpaceCharBeforeQuotesOpened: "ValueNonWhiteSpaceCharBeforeQuotesOpened";
+    readonly HeadingNonWhiteSpaceCharAfterQuotesClosed: "HeadingNonWhiteSpaceCharAfterQuotesClosed";
+    readonly ValueNonWhiteSpaceCharAfterQuotesClosed: "ValueNonWhiteSpaceCharAfterQuotesClosed";
+    readonly HeadingWidthNotReached: "HeadingWidthNotReached";
+    readonly ValueWidthNotReached: "ValueWidthNotReached";
+    readonly HeadingWidthExceeded: "HeadingWidthExceeded";
+    readonly ValueWidthExceeded: "ValueWidthExceeded";
+    readonly FieldValueToText: "FieldValueToText";
+    readonly FieldTruncated: "FieldTruncated";
+    readonly FieldConstantValueMismatch: "FieldConstantValueMismatch";
+    readonly FieldConstNameHeadingMismatch: "FieldConstNameHeadingMismatch";
+    readonly FieldTextParse: "FieldTextParse";
+    readonly MoreThanOneRootSequence: "MoreThanOneRootSequence";
+    readonly HeaderAlreadyWritten: "HeaderAlreadyWritten";
+    readonly LastLineEndedError: "LastLineEndedError";
+    readonly IncompleteDeclaration: "IncompleteDeclaration";
+    readonly InsufficientHeadingLines: "InsufficientHeadingLines";
+    readonly InvalidMeta: "InvalidMeta";
+    readonly LoadMetaFromText: "LoadMetaFromText";
+    readonly MetaReferenceFileNoHandler: "MetaReferenceFileNoHandler";
+    readonly LoadMetaFromFile: "LoadMetaFromFile";
+    readonly MetaReferenceUrlNoHandler: "MetaReferenceUrlNoHandler";
+    readonly LoadMetaFromUrl: "LoadMetaFromUrl";
+};
+
+/**
+ * @public
+ */
+export declare type FtSerializationError = (typeof FtSerializationError)[keyof typeof FtSerializationError];
+
+/**
+ * Exception thrown during fielded text serialization/deserialization.
+ * @public
+ */
+export declare class FtSerializationException extends Error {
+    private readonly _error;
+    private readonly _fieldName;
+    private readonly _fieldIndex;
+    private readonly _sequenceName;
+    private readonly _sequenceItemIndex;
+    constructor(error: FtSerializationError, fieldOrMessage: FtField | string | undefined, messageOrInner?: string | Error, innerException?: Error);
+    get error(): FtSerializationError;
+    get fieldName(): string | undefined;
+    get fieldIndex(): number;
+    get sequenceName(): string | undefined;
+    get sequenceItemIndex(): number;
+}
+
+/**
+ * Reader for fielded text streams. Coordinates all parsing components.
+ * @public
+ */
+export declare class FtSerializationReader extends SerializationCore {
+    /**
+     * Event fired when seeking through records.
+     */
+    onRecordSeeked: FtSerializationReader.OnRecordSeeked | undefined;
+    /**
+     * Event fired when needing to access file to get meta. This library is browser-compatible and does not have direct file system access, so this event allows the consumer to provide file content as text.
+     */
+    onRequireFileMetaAsText: FtSerializationReader.OnRequireFileMetaAsText | undefined;
+    /**
+     * Event fired when needing to access URL to get meta. Deferred to consumer as need to handle encoding and also must be returned synchronously
+     */
+    onRequireUrlMetaAsText: FtSerializationReader.OnRequireUrlMetaAsText | undefined;
+    private readonly _charReader;
+    private readonly _lineParser;
+    private readonly _declarationParser;
+    private readonly _declaredParameters;
+    private readonly _embeddedMetaParser;
+    private readonly _headingLineParser;
+    private readonly _recordParser;
+    private readonly _lineBuilder;
+    private _headerRead;
+    private _declarationRead;
+    private _embeddedMetaRead;
+    private _headingLineReadCount;
+    private _headingLinesRead;
+    private _finished;
+    private _declared;
+    private _metaReferenceType;
+    private _metaReference;
+    private _metaEmbedded;
+    private _newTableStarted;
+    private _tableStartSuspended;
+    private _tableStartRecordPeeked;
+    private _lineType;
+    private _autoNextTable;
+    constructor();
+    /**
+     * Gets or sets whether Read() will automatically continue reading records when new tables begin.
+     */
+    get autoNextTable(): boolean;
+    set autoNextTable(value: boolean);
+    /**
+     * Gets whether the fielded text stream was declared (has |!Fielded Text^| signature).
+     */
+    get declared(): boolean;
+    /**
+     * Gets the number of heading lines read.
+     */
+    get headingLineReadCount(): number;
+    /**
+     * Gets whether the header has been fully read.
+     */
+    get headerRead(): boolean;
+    /**
+     * Gets the meta reference type.
+     */
+    get metaReferenceType(): FtMetaReferenceType;
+    /**
+     * Gets the meta reference (file path or URL).
+     */
+    get metaReference(): string;
+    /**
+     * Gets the type of the last line read.
+     */
+    get lineType(): FtLineType;
+    /**
+     * Gets the last line read as a string.
+     */
+    get line(): string;
+    /**
+     * Gets whether the last record read was the start of a new table.
+     */
+    get newTableStarted(): boolean;
+    /**
+     * Gets the number of records read (accounting for table start peeking).
+     */
+    get recordCount(): number;
+    /**
+     * Gets the number of tables read (accounting for table start suspension).
+     */
+    get tableCount(): number;
+    /**
+     * Gets the active field index for the current line.
+     */
+    get activeFieldIndex(): number;
+    /**
+     * Gets the line position where extra characters started being ignored.
+     */
+    get ignoreExtraCharsLinePosition(): number;
+    /**
+     * Gets whether the reader is closed.
+     */
+    get isClosed(): boolean;
+    /**
+     * Close the reader and reset state.
+     */
+    close(): void;
+    /**
+     * Read the header (declaration, embedded meta, heading lines).
+     */
+    readHeader(): void;
+    /**
+     * Read the next line from the stream.
+     * Always reads regardless of table boundaries.
+     * @returns true if a line was read, false if at end of stream.
+     */
+    readLine(): boolean;
+    /**
+     * Read the next record from the stream.
+     * Respects autoNextTable setting for table boundaries.
+     * @returns true if a record was read, false otherwise.
+     */
+    read(): boolean;
+    /**
+     * Read all remaining records.
+     * Normally used with event handlers.
+     */
+    readToEnd(): void;
+    /**
+     * Read the next record and indicate table boundaries.
+     * Always reads regardless of table boundaries.
+     * @returns Result indicating same table, new table, or no more records.
+     */
+    readRecord(): FtReadRecordResult;
+    /**
+     * Move to the next table in the stream.
+     * @returns true if a new table was found, false if at end of stream.
+     */
+    nextTable(): boolean;
+    /**
+     * Alias for nextTable() (IDataReader compatibility).
+     * @returns true if a new table was found, false if at end of stream.
+     */
+    nextResult(): boolean;
+    /**
+     * Seek to a specific record offset.
+     * @param offset - The 1-based record offset to seek to.
+     * @returns true if seek succeeded, false if offset beyond end.
+     */
+    seek(offset: number): boolean;
+    /**
+     * Seek to the end of the stream.
+     */
+    seekEnd(): void;
+    /**
+     * Get a field object by index.
+     */
+    getField(idx: number): FtField;
+    /**
+     * Get a field object by name.
+     */
+    getFieldByName(name: string): FtField | undefined;
+    /**
+     * Get a field value by index.
+     */
+    getFieldValue(idx: number): unknown;
+    /**
+     * Get a field value by name.
+     */
+    getFieldValueByName(name: string): unknown;
+    /**
+     * Load metadata from a pre-parsed FtMeta object.
+     * @param meta - The metadata to load.
+     */
+    loadMetaFromObject(meta: FtMeta): void;
+    protected reset(): void;
+    /**
+     * Open the reader with a TextReader.
+     * @param textReader - The text reader to read from.
+     * @param immediatelyReadHeader - Whether to immediately read the header.
+     */
+    protected open(textReader: FtTextReader, immediatelyReadHeader: boolean): void;
+    protected getFileMetaAsText(fileMetaReference: string): FtSerializationReader.FileMetaAsTextResult | string;
+    protected getUrlMetaAsText(urlMetaReference: string): FtSerializationReader.FileMetaAsTextResult | string;
+    private internalReadLine;
+    private parseChar;
+    private calculateStartLineType;
+    private finish;
+    private finishLastLine;
+    private readDeclaration;
+    private readEmbeddedMeta;
+    private readHeadingLines;
+    private finishDeclaration;
+    private finishEmbeddedMeta;
+    private finishHeadingLine;
+    private finishRecord;
+    private checkCompleteness;
+    private loadMetaFromText;
+}
+
+/** @public */
+export declare namespace FtSerializationReader {
+    export type OnRecordSeeked = (this: void) => void;
+    export type OnRequireFileMetaAsText = (this: void, filePath: string) => FtSerializationReader.FileMetaAsTextResult | string;
+    export type OnRequireUrlMetaAsText = (this: void, url: string) => FtSerializationReader.UrlMetaAsTextResult | string;
+    export interface FileMetaAsTextResult {
+        content: string;
+        format: FtMetaSerializationFormat;
+    }
+    export interface UrlMetaAsTextResult {
+        content: string;
+        format: FtMetaSerializationFormat;
+    }
+}
+
+/**
+ * Writer for fielded text streams. Coordinates all writing logic.
+ * @public
+ */
+export declare class FtSerializationWriter extends SerializationCore {
+    private static readonly DECLARATION_LINE2_BEFORE_COMMENT_CHARS;
+    private static readonly EMBEDDED_META_BEFORE_COMMENT_CHARS;
+    private _loadedMeta;
+    private _writer;
+    private _settings;
+    private readonly _encodeBuilder;
+    private readonly _matchBuilder;
+    private _endOfLineText;
+    private _lastLineEnded;
+    private _headerWritten;
+    private _endOfLinePending;
+    private _activeFieldIndex;
+    constructor(meta: FtMeta);
+    /**
+     * Gets the underlying text writer.
+     */
+    get baseWriter(): FtTextWriter | undefined;
+    /**
+     * Gets whether the writer is closed.
+     */
+    get isClosed(): boolean;
+    /**
+     * Open the writer with a FtTextWriter and optional settings.
+     * @param textWriter - The FtTextWriter to write to
+     * @param settings - Optional writer settings (default: \{\})
+     */
+    open(textWriter: FtTextWriter, settings?: FtWriterSettings): void;
+    /**
+     * Close the writer.
+     */
+    close(): void;
+    /**
+     * Write the header (declaration, embedded meta, heading lines).
+     */
+    writeHeader(): void;
+    /**
+     * Write a record.
+     */
+    write(): void;
+    /**
+     * Write a comment line.
+     */
+    writeComment(comment: string, beforeCommentChars?: string): void;
+    /**
+     * Flush the writer.
+     */
+    flush(): void;
+    /**
+     * Set a field value by index.
+     */
+    setFieldValue(idx: number, value: unknown): void;
+    /**
+     * Set a field value by name.
+     */
+    setFieldValueByName(name: string, value: unknown): void;
+    /**
+     * Set a field to null.
+     */
+    setNull(idx: number): void;
+    /**
+     * Set a boolean field.
+     */
+    setBoolean(idx: number, value: boolean): void;
+    /**
+     * Set a date/time field.
+     */
+    setDateTime(idx: number, value: Date): void;
+    /**
+     * Set a decimal field.
+     */
+    setDecimal(idx: number, value: number): void;
+    /**
+     * Set a float field.
+     */
+    setFloat(idx: number, value: number): void;
+    /**
+     * Set an integer field.
+     */
+    setInteger(idx: number, value: number | bigint): void;
+    /**
+     * Set a string field.
+     */
+    setString(idx: number, value: string): void;
+    /**
+     * Set multiple field values.
+     */
+    setValues(values: unknown[]): void;
+    protected reset(): void;
+    /**
+     * Internal load metadata. Override from SerializationCore.
+     */
+    protected internalLoadMeta(meta: FtMeta): void;
+    /**
+     * Write a single heading line by index.
+     * @param headingLineIndex - The 0-based index of the heading line to write.
+     */
+    private writeHeadingLine;
+    /**
+     * Write a comment line with a specific comment character.
+     * @internal
+     */
+    private writeCommentWithChar;
+    private calculateEndOfLineText;
+    private finishRecord;
+    private doesTextRequireQuotes;
+    private checkWritePendingEndOfLine;
+    private writeOrPendEndOfLine;
+    private writeDeclaration;
+    private writeEmbeddedMeta;
+    private writeHeadingLines;
+    private writeHeadingField;
+    private writeRecord;
+    private writeRecordField;
+    private encodeDelimitedValueHeadingText;
+    private applySubstitutions;
+    private appendToEncodeBuilder;
+    private encodeFixedWidthValueText;
+    private encodeFixedWidthHeadingText;
+    private padFixedWidthText;
+    private truncateFixedWidthText;
+}
+
+/**
+ * Field for string values.
+ * @public
+ */
+export declare class FtStringField extends FtGenericField<string> {
+    private static readonly VALUE_TEXT_NULL_TRIMMABLE;
+    constructor(sequenceInvokation: FtSequenceInvokation, sequenceItem: FtSequenceItem, definition: FtStringFieldDefinition);
+    get nullableValue(): string | null;
+    set nullableValue(value: string | null);
+    setValue(value: string | null): number;
+    protected isValueEqual(left: string, right: string): boolean;
+}
+
+/**
+ * Field definition for string fields.
+ * @public
+ */
+export declare class FtStringFieldDefinition extends FtGenericFieldDefinition<string> {
+    static readonly AUTO_LEFT_PAD = false;
+    protected formatter: FtStringFieldFormatter;
+    constructor(index: number);
+    getValueText(value: string): string;
+    parseValueText(text: string): string;
+}
+
+/**
+ * Formatter for string fields.
+ * @public
+ */
+export declare class FtStringFieldFormatter extends FtFieldFormatter {
+    toText(value: string): string;
+    parse(text: string): string;
+}
+
+/**
+ * Meta field for string values.
+ * @public
+ */
+export declare class FtStringMetaField extends FtGenericMetaField<string> {
+    static readonly DATA_TYPE: "String";
+    static readonly DEFAULT_VALUE = "";
+    static readonly DEFAULT_SEQUENCE_REDIRECT_TYPE: "ExactString";
+    constructor(headingCount?: number);
+    static isStringMetaField(field: FtMetaField): field is FtStringMetaField;
+    createCopy(): FtMetaField;
+    protected getDefaultSequenceRedirectType(): FtSequenceRedirectType;
+}
+
+/**
+ * A TextReader implementation that reads from a string.
+ * @public
+ */
+export declare class FtStringReader implements FtTextReader {
+    private _text;
+    private _position;
+    /**
+     * Creates a new FtStringReader.
+     * @param text - The string to read from.
+     */
+    constructor(text: string);
+    /**
+     * Reads the next character from the string and advances the character position by one.
+     * @returns The character read as a number (charCode), or -1 if the end of the string has been reached.
+     */
+    read(): number;
+    /**
+     * Closes the FtStringReader and releases resources.
+     */
+    close(): void;
+}
+
+/**
+ * Simple text writer that accumulates to a string array.
+ * @public
+ */
+export declare class FtStringWriter implements FtTextWriter {
+    private _parts;
+    write(text: string): void;
+    flush(): void;
+    toString(): string;
+    clear(): void;
+    close(): void;
+}
+
+/**
+ * @public
+ */
+export declare class FtSubstitution {
+    id: number;
+    token: string;
+    value: string;
+    constructor(id: number, token?: string, value?: string);
+}
+
+/**
+ * Base constructor class for creating substitution instances.
+ * Can be extended to provide custom substitution creation logic.
+ * @public
+ */
+export declare class FtSubstitutionConstructor {
+    /**
+     * Create a new FtSubstitution instance for runtime use.
+     * @param index - The index of the substitution in the list
+     */
+    createSubstitution(index: number): FtSubstitution;
+    /**
+     * Create a new FtMetaSubstitution instance for metadata definition.
+     */
+    createMetaSubstitution(): FtMetaSubstitution;
+}
+
+/**
+ * Factory for creating substitution instances.
+ * Provides a global constructor that can be replaced to customize substitution creation.
+ * @public
+ */
+export declare class FtSubstitutionFactory {
+    private static _constructor;
+    /**
+     * Get the current substitution constructor.
+     */
+    static getConstructor(): FtSubstitutionConstructor;
+    /**
+     * Set a custom substitution constructor.
+     * Use this to provide custom initialization logic for all substitution instances.
+     */
+    static setConstructor(value: FtSubstitutionConstructor): void;
+    /**
+     * Create a new FtSubstitution instance using the current constructor.
+     * @param index - The index of the substitution in the list
+     */
+    static createSubstitution(index: number): FtSubstitution;
+    /**
+     * Create a new FtMetaSubstitution instance using the current constructor.
+     */
+    static createMetaSubstitution(): FtMetaSubstitution;
+}
+
+/**
+ * @public
+ */
+declare class FtSubstitutionList {
+    private list;
+    get count(): number;
+    get(index: number): FtSubstitution;
+    clear(): void;
+    new(): FtSubstitution;
+    tryGetValue(token: string): {
+        found: boolean;
+        value: string;
+    };
+    tryGetFirstMatching(text: string, startIndex: number): {
+        found: boolean;
+        token: string;
+        valueLength: number;
+    };
+}
+
+/**
+ * Specifies substitution type
+ * @public
+ */
+export declare const FtSubstitutionType: {
+    /**
+     * Substitution Type where Substitution Pair (Character and Token) are replaced by a string
+     */
+    readonly String: "String";
+    readonly AutoEndOfLine: "AutoEndOfLine";
+};
+
+/**
+ * @public
+ */
+export declare type FtSubstitutionType = (typeof FtSubstitutionType)[keyof typeof FtSubstitutionType];
+
+/**
+ * Interface for reading characters from a text source.
+ * Mirrors .NET's TextReader for compatibility with C# implementation.
+ * @public
+ */
+export declare interface FtTextReader {
+    /**
+     * Reads the next character from the text reader and advances the character position by one character.
+     * @returns The character read as a number (charCode), or -1 if the end of the text has been reached.
+     */
+    read(): number;
+}
+
+/**
+ * Namespace merged with TextReader interface to provide static constants.
+ * @public
+ */
+export declare namespace FtTextReader {
+    /**
+     * Value returned by read() when the end of the text reader has been reached.
+     * Matches .NET's TextReader behavior.
+     */
+    const EofReadResult = -1;
+}
+
+/**
+ * Writer interface for outputting text.
+ * @public
+ */
+export declare interface FtTextWriter {
+    write(text: string): void;
+    flush(): void;
+}
+
+/**
+ * @public
+ */
+export declare const FtTruncateType: {
+    readonly Left: "Left";
+    readonly Right: "Right";
+    readonly TruncateChar: "TruncateChar";
+    readonly NullChar: "NullChar";
+    readonly Exception: "Exception";
+};
+
+/**
+ * @public
+ */
+export declare type FtTruncateType = (typeof FtTruncateType)[keyof typeof FtTruncateType];
+
+/**
+ * High-level writer for fielded text files.
+ * Provides a convenient API for writing CSV and other delimited/fixed-width text.
+ * This is a thin wrapper around SerializationWriter with simpler constructors.
+ * @public
+ */
+export declare class FtWriter extends FtSerializationWriter {
+    /**
+     * Create a writer with metadata and output writer.
+     * @param meta - The metadata defining the file structure
+     * @param textWriter - The FtTextWriter to write to. If not provided, FtWriter will be created but not opened (you must call open() before writing).
+     * @param settings - Optional writer settings
+     */
+    constructor(meta: FtMeta, textWriter?: FtTextWriter, settings?: FtWriterSettings);
+}
+
+/**
+ * Settings for writing fielded text streams.
+ * @public
+ */
+export declare interface FtWriterSettings {
+    /**
+     * Whether to write the |!Fielded Text^| declaration header.
+     */
+    declared?: boolean;
+    /**
+     * Type of meta reference to write.
+     */
+    metaReferenceType?: FtMetaReferenceType;
+    /**
+     * Meta reference (file path or URL).
+     */
+    metaReference?: string;
+    /**
+     * Format of embedded meta to write.
+     */
+    embeddedMetaFormat?: FtMetaSerializationFormat;
+    /**
+     * Whether to include explicit index attributes for fields in embedded meta.
+     */
+    embeddedMetaExplicitIndices?: boolean;
+    /**
+     * Whether to indent embedded XML metadata.
+     */
+    embeddedMetaIndent?: boolean;
+    /**
+     * Characters to use for indenting embedded XML metadata.
+     */
+    embeddedMetaIndentChars?: string;
+    /**
+     * Whether to write XML attributes on separate lines.
+     */
+    embeddedMetaNewLineOnAttributes?: boolean;
+}
+
+/** @public */
+export declare namespace FtWriterSettings {
+    const DEFAULT_DECLARED = false;
+    const DEFAULT_META_REFERENCE_TYPE: "None";
+    const DEFAULT_META_REFERENCE = "";
+    const DEFAULT_EMBEDDED_META_FORMAT: "XML";
+    const DEFAULT_EMBEDDED_META_EXPLICIT_INDICES = false;
+    const DEFAULT_EMBEDDED_META_INDENT = true;
+    const DEFAULT_EMBEDDED_META_INDENT_CHARS = "  ";
+    const DEFAULT_EMBEDDED_META_NEW_LINE_ON_ATTRIBUTES = false;
+    export function loadMetaSerializerOptions(settings: FtWriterSettings, options: Partial<FtMetaSerializerOptions>): void;
+}
+
+/**
+ * Serializes and deserializes FtMeta to/from XML format.
+ * Compatible with the C# XmlMetaSerializationWriter/Reader implementation.
+ *
+ * Note: The "\@_" prefix is used by fast-xml-parser to distinguish XML attributes
+ * from XML elements. Properties starting with "\@_" become XML attributes when
+ * serialized, and XML attributes are prefixed with "\@_" when deserialized.
+ * @public
+ */
+export declare class FtXmlMetaSerialization {
+    /**
+     * Serialize an FtMeta object to XML string.
+     */
+    serialize(meta: FtMeta, options?: FtMetaSerializerOptions): string;
+    /**
+     * Deserialize XML string to an FtMeta object.
+     */
+    deserialize(xml: string, warnings?: string[]): FtMeta;
+    private serializeSubstitution;
+    private serializeField;
+    private serializeSequence;
+    private serializeSequenceItem;
+    private serializeRedirect;
+    private deserializeRootProperties;
+    private deserializeField;
+    private deserializeSequence;
+    private deserializeSequenceItem;
+    private deserializeRedirect;
+}
+
+/** @public */
+export declare namespace FtXmlMetaSerialization {
+    export function serialize(meta: FtMeta, options?: FtMetaSerializerOptions): string;
+    export function deserialize(xml: string, warnings?: string[]): FtMeta;
+}
+
+export { Result }
+
+/**
+ * @public
+ */
+declare type RootedEventHandler = (sequence: FtMetaSequence) => void;
+
+/**
+ * Base class for serialization (reading/writing).
+ * Manages configuration, field lists, sequences, and events.
+ * @public
+ */
+declare abstract class SerializationCore {
+    static readonly VersionMajor = 1;
+    static readonly VersionMinor = 1;
+    static readonly PrefixSpaceChar = " ";
+    protected static readonly Signature = "|!Fielded Text^|";
+    protected static readonly VersionLabel = "Version";
+    protected static readonly VersionSeparator = ".";
+    protected static readonly CarriageReturnChar = "\r";
+    protected static readonly LineFeedChar = "\n";
+    protected static readonly CarriageReturnLineFeedString = "\r\n";
+    onFieldHeadingReadReady?: (args: FtFieldHeadingReadyEventArgs) => void;
+    onFieldHeadingWriteReady?: (args: FtFieldHeadingReadyEventArgs) => void;
+    onFieldValueReadReady?: (args: FtFieldValueReadyEventArgs) => void;
+    onFieldValueWriteReady?: (args: FtFieldValueReadyEventArgs) => void;
+    onHeadingLineStarted?: (args: FtHeadingLineStartedEventArgs) => void;
+    onHeadingLineFinished?: (args: FtHeadingLineFinishedEventArgs) => void;
+    onRecordStarted?: (args: FtRecordStartedEventArgs) => void;
+    onRecordFinished?: (args: FtRecordFinishedEventArgs) => void;
+    onSequenceRedirected?: (args: FtSequenceRedirectedEventArgs) => void;
+    protected _recordCount: number;
+    protected _tableCount: number;
+    private _fieldDefinitionList;
+    private _fieldList;
+    private _substitutionList;
+    private _sequenceList;
+    private _culture;
+    private _endOfLineType;
+    private _endOfLineChar;
+    private _endOfLineAutoWriteType;
+    private _lastLineEndedType;
+    private _quoteChar;
+    private _delimiterChar;
+    private _lineCommentChar;
+    private _allowEndOfLineCharInQuotes;
+    private _ignoreBlankLines;
+    private _ignoreExtraChars;
+    private _allowIncompleteRecords;
+    private _stuffedEmbeddedQuotes;
+    private _substitutionsEnabled;
+    private _substitutionChar;
+    private _headingLineCount;
+    private _mainHeadingLineIndex;
+    private _headingConstraint;
+    private _headingQuotedType;
+    private _headingAlwaysWriteOptionalQuote;
+    private _headingWritePrefixSpace;
+    private _headingPadAlignment;
+    private _headingPadCharType;
+    private _headingPadChar;
+    private _headingTruncateType;
+    private _headingTruncateChar;
+    private _headingEndOfValueChar;
+    private _rootSequence;
+    private _rootFieldCount;
+    private _sequenceInvokationList;
+    private _previousRecordSequenceInvokationList;
+    private _rootSequenceInvokation;
+    private _seeking;
+    protected constructor();
+    get fieldDefinitionList(): FtFieldDefinitionList;
+    get fieldList(): FtFieldList;
+    get substitutionList(): FtSubstitutionList;
+    get sequenceList(): FtSequenceList;
+    get sequenceInvokationList(): FtSequenceInvokationList;
+    get previousRecordSequenceInvokationList(): FtSequenceInvokationList;
+    get rootSequence(): FtSequence | undefined;
+    get rootFieldCount(): number;
+    get rootSequenceInvokation(): FtSequenceInvokation | undefined;
+    get seeking(): boolean;
+    get recordCount(): number;
+    get tableCount(): number;
+    get culture(): DotNetLocaleSettings;
+    get endOfLineType(): FtEndOfLineType;
+    get endOfLineChar(): string;
+    get endOfLineAutoWriteType(): FtEndOfLineAutoWriteType;
+    get lastLineEndedType(): FtLastLineEndedType;
+    get quoteChar(): string;
+    get delimiterChar(): string;
+    get lineCommentChar(): string;
+    get allowEndOfLineCharInQuotes(): boolean;
+    get ignoreBlankLines(): boolean;
+    get ignoreExtraChars(): boolean;
+    get allowIncompleteRecords(): boolean;
+    get stuffedEmbeddedQuotes(): boolean;
+    get substitutionsEnabled(): boolean;
+    get substitutionChar(): string;
+    get headingLineCount(): number;
+    get mainHeadingLineIndex(): number;
+    get headingConstraint(): FtHeadingConstraint;
+    get headingQuotedType(): FtQuotedType;
+    get headingAlwaysWriteOptionalQuote(): boolean;
+    get headingWritePrefixSpace(): boolean;
+    get headingPadAlignment(): FtPadAlignment;
+    get headingPadCharType(): FtPadCharType;
+    get headingPadChar(): string;
+    get headingTruncateType(): FtTruncateType;
+    get headingTruncateChar(): string;
+    get headingEndOfValueChar(): string;
+    get fieldCount(): number;
+    get depth(): number;
+    abstract get isClosed(): boolean;
+    getName(idx: number): string;
+    getOrdinal(name: string): number;
+    getValueType(idx: number): string;
+    isDBNull(idx: number): boolean;
+    tryGetSubstitutionValue(token: string): {
+        found: boolean;
+        value: string;
+    };
+    /**
+     * Load configuration from FtMeta.
+     */
+    loadMeta(meta: FtMeta): void;
+    /**
+     * Invoke the root sequence to begin reading/writing.
+     * @internal For testing purposes, can be called to initialize field list.
+     */
+    invokeRootSequence(): void;
+    /** @internal */
+    fireFieldHeadingReadReady(field: FtField, lineIndex: number): void;
+    /** @internal */
+    fireFieldValueReadReady(field: FtField, recordIndex: number): void;
+    protected internalLoadMeta(meta: FtMeta): void;
+    protected setSeeking(value: boolean): void;
+    protected setLineCommentChar(aChar: string): void;
+    protected redirect(redirectingField: FtField, invokedSequence: FtSequence, invokationDelay: FtSequenceInvokationDelay): number;
+    protected unredirect(unredirectingField: FtField): number;
+    protected fireFieldHeadingWriteReady(field: FtField, lineIndex: number): void;
+    protected fireFieldValueWriteReady(field: FtField, recordIndex: number): void;
+    protected fireHeadingLineStarted(lineIndex: number): void;
+    protected fireHeadingLineFinished(lineIndex: number): void;
+    protected fireRecordStarted(recordIndex: number): void;
+    protected fireRecordFinished(recordIndex: number): void;
+    protected fireSequenceRedirected(redirectingField: FtField, fieldsAffectedFromIndex: number): void;
+    /**
+     * Reset serialization state.
+     */
+    protected reset(): void;
+    private resetAllFieldValues;
+    private resetFieldValues;
+    private handleSequenceRedirectEvent;
+    private calculateAutoEndOfLineSubstitutionValue;
+    abstract close(): void;
+}
+
+declare interface Version {
+    major: number;
+    minor: number;
+    comment: string;
+}
+
+export { }