survey-core 1.12.21 → 1.12.23

package/typings/src/defaultTitle.d.ts

@@ -0,0 +1,3 @@
+export declare class DefaultTitleModel {
+    static getIconCss(cssClasses: any, isCollapsed: boolean): string;
+}

package/typings/src/dragdrop/choices.d.ts

@@ -0,0 +1,21 @@
+import { ItemValue } from "../itemvalue";
+import { QuestionSelectBase } from "../question_baseselect";
+import { DragDropCore } from "./core";
+export declare class DragDropChoices extends DragDropCore<QuestionSelectBase> {
+    private imagepickerControlsNode;
+    protected get draggedElementType(): string;
+    protected createDraggedElementShortcut(text: string, draggedElementNode: HTMLElement, event: PointerEvent): HTMLElement;
+    onShortcutCreated: (node: HTMLElement) => void;
+    private createImagePickerShortcut;
+    protected getDropTargetByDataAttributeValue(dataAttributeValue: string): ItemValue;
+    private getVisibleChoices;
+    protected doDragOver: () => any;
+    protected isDropTargetValid(dropTarget: ItemValue, dropTargetNode?: HTMLElement): boolean;
+    protected doBanDropHere: () => any;
+    protected isDropTargetDoesntChanged(newIsBottom: boolean): boolean;
+    protected calculateIsBottom(clientY: number, dropTargetNode?: HTMLElement): boolean;
+    protected afterDragOver(dropTargetNode: HTMLElement): void;
+    protected doDrop(): any;
+    clear(): void;
+    private updateVisibleChoices;
+}

package/typings/src/dragdrop/core.d.ts

@@ -0,0 +1,55 @@
+import { SurveyModel } from "../survey";
+import { EventBase } from "../base";
+import { IShortcutText, ISurvey } from "../base-interfaces";
+import { IDragDropEngine } from "./engine";
+import { IDragDropDOMAdapter } from "./dom-adapter";
+export declare abstract class DragDropCore<T> implements IDragDropEngine {
+    private surveyValue?;
+    private creator?;
+    private _isBottom;
+    get isBottom(): boolean;
+    set isBottom(val: boolean);
+    onGhostPositionChanged: EventBase<{}>;
+    protected ghostPositionChanged(): void;
+    onDragStart: EventBase<DragDropCore<T>>;
+    onDragEnd: EventBase<DragDropCore<T>>;
+    onDragClear: EventBase<DragDropCore<T>>;
+    onBeforeDrop: EventBase<DragDropCore<T>, any>;
+    onAfterDrop: EventBase<DragDropCore<T>, any>;
+    draggedElement: any;
+    protected abstract get draggedElementType(): string;
+    protected parentElement: T;
+    dropTarget: any;
+    protected get dropTargetDataAttributeName(): string;
+    protected get survey(): SurveyModel;
+    prevDropTarget: any;
+    protected allowDropHere: boolean;
+    protected domAdapter: IDragDropDOMAdapter;
+    constructor(surveyValue?: ISurvey, creator?: any, longTap?: boolean, domAdapter?: IDragDropDOMAdapter);
+    startDrag(event: PointerEvent, draggedElement: any, parentElement?: any, draggedElementNode?: HTMLElement, preventSaveTargetNode?: boolean): void;
+    private getRootElement;
+    dragInit(event: PointerEvent, draggedElement: any, parentElement?: any, draggedElementNode?: HTMLElement): void;
+    protected onStartDrag(event?: PointerEvent): void;
+    protected isDropTargetDoesntChanged(newIsBottom: boolean): boolean;
+    protected getShortcutText(draggedElement: IShortcutText): string;
+    protected createDraggedElementShortcut(text: string, draggedElementNode?: HTMLElement, event?: PointerEvent): HTMLElement;
+    protected getDraggedElementClass(): string;
+    protected doDragOver(): void;
+    protected afterDragOver(dropTargetNode: HTMLElement): void;
+    protected abstract isDropTargetValid(dropTarget: any, dropTargetNode?: HTMLElement): boolean;
+    protected banDropHere: () => void;
+    protected doBanDropHere: () => void;
+    protected findDropTargetNodeFromPoint(clientX: number, clientY: number): HTMLElement;
+    protected getDataAttributeValueByNode(node: HTMLElement): string;
+    protected getDropTargetByNode(dropTargetNode: HTMLElement, event: PointerEvent): any;
+    private capitalizeFirstLetter;
+    protected abstract getDropTargetByDataAttributeValue(dataAttributeValue: string, dropTargetNode?: HTMLElement, event?: PointerEvent): any;
+    protected calculateVerticalMiddleOfHTMLElement(HTMLElement: HTMLElement): number;
+    protected calculateHorizontalMiddleOfHTMLElement(HTMLElement: HTMLElement): number;
+    protected calculateIsBottom(clientY: number, dropTargetNode?: HTMLElement): boolean;
+    protected findDropTargetNodeByDragOverNode(dragOverNode: HTMLElement): HTMLElement;
+    dragOver(event: PointerEvent): void;
+    protected abstract doDrop(): any;
+    drop(): void;
+    clear(): void;
+}

package/typings/src/dragdrop/dom-adapter.d.ts

@@ -0,0 +1,49 @@
+import { IDragDropEngine } from "./engine";
+export interface IDragDropDOMAdapter {
+    startDrag(event: PointerEvent, draggedElement: any, parentElement: any, draggedElementNode: HTMLElement, preventSaveTargetNode: boolean): void;
+    draggedElementShortcut: HTMLElement;
+    rootContainer: HTMLElement;
+    documentOrShadowRoot: Document | ShadowRoot;
+    rootElement?: HTMLElement;
+}
+export declare class DragDropDOMAdapter implements IDragDropDOMAdapter {
+    private dd;
+    private longTap;
+    private fitToContainer;
+    static PreventScrolling: boolean;
+    private timeoutID;
+    private startX;
+    private startY;
+    private currentX;
+    private currentY;
+    private savedTargetNode;
+    private savedTargetNodeParent;
+    private savedTargetNodeIndex;
+    private scrollIntervalId;
+    constructor(dd: IDragDropEngine, longTap?: boolean, fitToContainer?: boolean);
+    get documentOrShadowRoot(): Document | ShadowRoot;
+    get rootElement(): any;
+    private stopLongTapIfMoveEnough;
+    private get isMicroMovement();
+    private stopLongTap;
+    private startLongTapProcessing;
+    private handlePointerCancel;
+    private handleEscapeButton;
+    private onContextMenu;
+    private moveShortcutElement;
+    private getShortcutBottomCoordinate;
+    private getShortcutRightCoordinate;
+    protected requestAnimationFrame(callback: any): number;
+    protected scrollByDrag(scrollableParentNode: HTMLElement, clientY: number, clientX: number): void;
+    private doScroll;
+    private dragOver;
+    private clear;
+    private drop;
+    private doStartDrag;
+    private returnUserSelectBack;
+    draggedElementShortcut: any;
+    rootContainer: HTMLElement;
+    startDrag(event: PointerEvent, draggedElement: any, parentElement?: any, draggedElementNode?: HTMLElement, preventSaveTargetNode?: boolean): void;
+    private getNodeIndexInParent;
+    private insertNodeToParentAtIndex;
+}

package/typings/src/dragdrop/engine.d.ts

@@ -0,0 +1,6 @@
+export interface IDragDropEngine {
+    dragInit(event: PointerEvent, draggedElement: any, parentElement: any, draggedElementNode: HTMLElement): void;
+    dragOver(event: PointerEvent): void;
+    drop(): void;
+    clear(): void;
+}

package/typings/src/dragdrop/matrix-rows.d.ts

@@ -0,0 +1,19 @@
+import { MatrixDropdownRowModelBase } from "../question_matrixdropdownbase";
+import { QuestionMatrixDynamicModel, MatrixDynamicRowModel } from "../question_matrixdynamic";
+import { DragDropCore } from "./core";
+export declare class DragDropMatrixRows extends DragDropCore<QuestionMatrixDynamicModel> {
+    protected get draggedElementType(): string;
+    protected restoreUserSelectValue: string;
+    protected onStartDrag(): void;
+    private get shortcutClass();
+    protected createDraggedElementShortcut(text: string, draggedElementNode: HTMLElement, event: PointerEvent): HTMLElement;
+    private fromIndex;
+    private toIndex;
+    protected getDropTargetByDataAttributeValue(dataAttributeValue: any): MatrixDropdownRowModelBase;
+    canInsertIntoThisRow(row: MatrixDynamicRowModel): boolean;
+    protected isDropTargetValid(dropTarget: any, dropTargetNode?: HTMLElement): boolean;
+    protected calculateIsBottom(clientY: number): boolean;
+    protected afterDragOver(dropTargetNode: HTMLElement): void;
+    protected doDrop: () => QuestionMatrixDynamicModel;
+    clear(): void;
+}

package/typings/src/dragdrop/ranking-choices.d.ts

@@ -0,0 +1,26 @@
+import { ItemValue } from "../itemvalue";
+import { DragDropChoices } from "./choices";
+import { QuestionRankingModel } from "../question_ranking";
+export declare class DragDropRankingChoices extends DragDropChoices {
+    protected get draggedElementType(): string;
+    protected createDraggedElementShortcut(text: string, draggedElementNode: HTMLElement, event: PointerEvent): HTMLElement;
+    private get shortcutClass();
+    protected getDropTargetByDataAttributeValue(dataAttributeValue: string): ItemValue;
+    private isDragOverRootNode;
+    protected findDropTargetNodeByDragOverNode(dragOverNode: HTMLElement): HTMLElement;
+    private getIsDragOverRootNode;
+    protected isDropTargetValid(dropTarget: ItemValue, dropTargetNode?: HTMLElement): boolean;
+    protected calculateIsBottom(clientY: number, dropTargetNode?: HTMLElement): boolean;
+    protected doDragOver: () => any;
+    getIndices(model: any, fromChoicesArray: Array<ItemValue>, toChoicesArray: Array<ItemValue>): {
+        fromIndex: number;
+        toIndex: number;
+    };
+    protected afterDragOver(dropTargetNode: HTMLElement): void;
+    reorderRankedItem: (questionModel: QuestionRankingModel, fromIndex: number, toIndex: number) => void;
+    protected updateDraggedElementShortcut(newIndex: number): void;
+    protected ghostPositionChanged(): void;
+    protected doBanDropHere: () => any;
+    protected doDrop(): any;
+    clear(): void;
+}

package/typings/src/dragdrop/ranking-select-to-rank.d.ts

@@ -0,0 +1,17 @@
+import { ItemValue } from "../itemvalue";
+import { DragDropRankingChoices } from "./ranking-choices";
+import { QuestionRankingModel } from "../question_ranking";
+export declare class DragDropRankingSelectToRank extends DragDropRankingChoices {
+    protected findDropTargetNodeByDragOverNode(dragOverNode: HTMLElement): HTMLElement;
+    protected getDropTargetByDataAttributeValue(dataAttributeValue: string): ItemValue;
+    protected getDropTargetByNode(dropTargetNode: HTMLElement, event: PointerEvent): any;
+    protected isDropTargetValid(dropTarget: ItemValue | string, dropTargetNode?: HTMLElement): boolean;
+    protected afterDragOver(dropTargetNode: HTMLElement): void;
+    doRankBetween(dropTargetNode: HTMLElement, fromChoicesArray: Array<ItemValue>, toChoicesArray: Array<ItemValue>, rankFunction: Function): void;
+    private get isDraggedElementRanked();
+    private get isDropTargetRanked();
+    private get isDraggedElementUnranked();
+    private updateChoices;
+    selectToRank: (questionModel: QuestionRankingModel, fromIndex: number, toIndex: number) => void;
+    unselectFromRank: (questionModel: QuestionRankingModel, fromIndex: number, toIndex?: number) => void;
+}

package/typings/src/dropdownListModel.d.ts

@@ -0,0 +1,97 @@
+import { IAction } from "./actions/action";
+import { Base } from "./base";
+import { ItemValue } from "./itemvalue";
+import { ListModel } from "./list";
+import { PopupModel } from "./popup";
+import { Question } from "./question";
+export declare class DropdownListModel extends Base {
+    protected question: Question;
+    protected onSelectionChanged?: (item: IAction, ...params: any[]) => void;
+    readonly minPageSize = 25;
+    readonly loadingItemHeight = 40;
+    timer: any;
+    private htmlCleanerElement;
+    private _markdownMode;
+    private _popupModel;
+    private filteredItems;
+    focused: boolean;
+    private get focusFirstInputSelector();
+    protected readonly selectedItemSelector = ".sv-list__item--selected";
+    protected readonly itemSelector = ".sv-list__item";
+    protected getFocusFirstInputSelector(): string;
+    private itemsSettings;
+    protected listModel: ListModel<ItemValue>;
+    protected listModelFilterStringChanged: (newValue: string) => void;
+    private resetItemsSettings;
+    private setItems;
+    private loadQuestionChoices;
+    private updateQuestionChoices;
+    private resetTimer;
+    private updatePopupFocusFirstInputSelector;
+    private getDropdownMenuOptions;
+    protected createPopup(): void;
+    private setFilterStringToListModel;
+    private setTextWrapEnabled;
+    protected popupRecalculatePosition(isResetHeight: boolean): void;
+    protected onHidePopup(): void;
+    protected getAvailableItems(): Array<ItemValue>;
+    protected setOnTextSearchCallbackForListModel(listModel: ListModel<ItemValue>): void;
+    protected createListModel(): ListModel<ItemValue>;
+    protected updateAfterListModelCreated(model: ListModel<ItemValue>): void;
+    protected getPopupCssClasses(): string;
+    updateCssClasses(popupCssClass: string, listCssClasses: any): void;
+    protected resetFilterString(): void;
+    clear(): void;
+    protected onSetFilterString(): void;
+    get isAllDataLoaded(): boolean;
+    get canShowSelectedItem(): boolean;
+    searchEnabled: boolean;
+    filterString: string;
+    inputString: string;
+    showInputFieldComponent: boolean;
+    ariaActivedescendant: string;
+    private applyInputString;
+    private cleanHtml;
+    protected fixInputCase(): void;
+    protected applyHintString(item: ItemValue): void;
+    get inputStringRendered(): string;
+    set inputStringRendered(val: string);
+    get placeholderRendered(): any;
+    get listElementId(): string;
+    hasScroll: boolean;
+    hintString: string;
+    private get hintStringLC();
+    private get inputStringLC();
+    get showHintPrefix(): boolean;
+    get hintStringPrefix(): string;
+    get showHintString(): boolean;
+    get hintStringSuffix(): string;
+    get hintStringMiddle(): string;
+    private questionPropertyChangedHandler;
+    constructor(question: Question, onSelectionChanged?: (item: IAction, ...params: any[]) => void);
+    get popupModel(): PopupModel;
+    get noTabIndex(): boolean;
+    get filterReadOnly(): boolean;
+    get filterStringEnabled(): boolean;
+    get inputMode(): "none" | "text";
+    setSearchEnabled(newValue: boolean): void;
+    setChoicesLazyLoadEnabled(newValue: boolean): void;
+    updateItems(): void;
+    onClick(event: any): void;
+    chevronPointerDown(event: any): void;
+    protected onPropertyChangedHandler(sender: any, options: any): void;
+    protected focusItemOnClickAndPopup(): void;
+    onClear(event: any): void;
+    getSelectedAction(): ItemValue;
+    changeSelectionWithKeyboard(reverse: boolean): void;
+    protected beforeScrollToFocusedItem(focusedItem: ItemValue): void;
+    protected afterScrollToFocusedItem(): void;
+    keyHandler(event: any): void;
+    protected onEscape(): void;
+    onScroll(event: Event): void;
+    onBlur(event: any): void;
+    onFocus(event: any): void;
+    setInputStringFromSelectedItem(newValue: any): void;
+    dispose(): void;
+    scrollToFocusedItem(): void;
+}

package/typings/src/dropdownMultiSelectListModel.d.ts

@@ -0,0 +1,37 @@
+import { IAction } from "./actions/action";
+import { DropdownListModel } from "./dropdownListModel";
+import { ItemValue } from "./itemvalue";
+import { MultiSelectListModel } from "./multiSelectListModel";
+import { Question } from "./question";
+export declare class DropdownMultiSelectListModel extends DropdownListModel {
+    filterStringPlaceholder: string;
+    closeOnSelect: boolean;
+    locStrsChanged(): void;
+    private updateListState;
+    private syncFilterStringPlaceholder;
+    private getSelectedActions;
+    protected getFocusFirstInputSelector(): string;
+    protected getPopupCssClasses(): string;
+    protected createListModel(): MultiSelectListModel<ItemValue>;
+    protected resetFilterString(): void;
+    previousValue: any;
+    doneButtonCaption: string;
+    private get shouldResetAfterCancel();
+    protected createPopup(): void;
+    selectAllItems(): void;
+    selectNoneItem(): void;
+    selectItem(id: string): void;
+    deselectItem(id: string): void;
+    clear(): void;
+    onClear(event: any): void;
+    setHideSelectedItems(newValue: boolean): void;
+    removeLastSelectedItem(): void;
+    constructor(question: Question, onSelectionChanged?: (item: IAction, ...params: any[]) => void);
+    inputKeyHandler(event: any): void;
+    setInputStringFromSelectedItem(newValue: any): void;
+    protected focusItemOnClickAndPopup(): void;
+    protected onEscape(): void;
+    protected beforeScrollToFocusedItem(focusedItem: ItemValue): void;
+    protected afterScrollToFocusedItem(): void;
+    protected onPropertyChangedHandler(sender: any, options: any): void;
+}

package/typings/src/dxSurveyService.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The class contains methods to work with api.surveyjs.io service.
+ */
+export declare class dxSurveyService {
+    locale: string;
+    static get serviceUrl(): string;
+    static set serviceUrl(val: string);
+    loadSurvey(surveyId: string, onLoad: (success: boolean, result: string, response: any) => void): void;
+    getSurveyJsonAndIsCompleted(surveyId: string, clientId: string, onLoad: (success: boolean, surveyJson: any, result: string, response: any) => void): void;
+    canSendResult(result: JSON): boolean;
+    get isSurveJSIOService(): boolean;
+    sendResult(postId: string, result: JSON, onSendResult: (success: boolean, response: any, request?: any) => void, clientId?: string, isPartialCompleted?: boolean): void;
+    protected sendResultCore(postId: string, result: JSON, onSendResult: (success: boolean, response: any, request?: any) => void, clientId?: string, isPartialCompleted?: boolean): void;
+    sendFile(postId: string, file: File, onSendFile: (success: boolean, response: any) => void): void;
+    getResult(resultId: string, name: string, onGetResult: (success: boolean, data: any, dataList: Array<any>, response: any) => void): void;
+    isCompleted(resultId: string, clientId: string, onIsCompleted: (success: boolean, result: string, response: any) => void): void;
+    private get serviceUrl();
+}

package/typings/src/element-helper.d.ts

@@ -0,0 +1,8 @@
+export declare class ElementHelper {
+    static focusElement(element: Element): void;
+    static visibility(node: Element): boolean;
+    static getNextElementPreorder(element: Element): Element;
+    static getNextElementPostorder(element: Element): Element;
+    static hasHorizontalScroller(element: HTMLElement): boolean;
+    static hasVerticalScroller(element: HTMLElement): boolean;
+}

package/typings/src/error.d.ts

@@ -0,0 +1,81 @@
+import { SurveyError } from "./survey-error";
+import { ISurveyErrorOwner } from "./base-interfaces";
+export declare class AnswerRequiredError extends SurveyError {
+    text: string;
+    constructor(text?: string, errorOwner?: ISurveyErrorOwner);
+    getErrorType(): string;
+    protected getDefaultText(): string;
+}
+export declare class OneAnswerRequiredError extends SurveyError {
+    text: string;
+    constructor(text?: string, errorOwner?: ISurveyErrorOwner);
+    getErrorType(): string;
+    protected getDefaultText(): string;
+}
+export declare class RequreNumericError extends SurveyError {
+    text: string;
+    constructor(text?: string, errorOwner?: ISurveyErrorOwner);
+    getErrorType(): string;
+    protected getDefaultText(): string;
+}
+export declare class ExceedSizeError extends SurveyError {
+    private maxSize;
+    constructor(maxSize: number, errorOwner?: ISurveyErrorOwner);
+    getErrorType(): string;
+    getDefaultText(): string;
+    private getTextSize;
+}
+export declare class WebRequestError extends SurveyError {
+    status: string;
+    response: string;
+    constructor(status: string, response: string, errorOwner?: ISurveyErrorOwner);
+    getErrorType(): string;
+    protected getDefaultText(): string;
+}
+export declare class WebRequestEmptyError extends SurveyError {
+    text: string;
+    constructor(text: string, errorOwner?: ISurveyErrorOwner);
+    getErrorType(): string;
+    protected getDefaultText(): string;
+}
+export declare class OtherEmptyError extends SurveyError {
+    text: string;
+    constructor(text: string, errorOwner?: ISurveyErrorOwner);
+    getErrorType(): string;
+    protected getDefaultText(): string;
+}
+export declare class UploadingFileError extends SurveyError {
+    text: string;
+    constructor(text: string, errorOwner?: ISurveyErrorOwner);
+    getErrorType(): string;
+    protected getDefaultText(): string;
+}
+export declare class RequiredInAllRowsError extends SurveyError {
+    text: string;
+    constructor(text: string, errorOwner?: ISurveyErrorOwner);
+    getErrorType(): string;
+    protected getDefaultText(): string;
+}
+export declare class EachRowUniqueError extends SurveyError {
+    text: string;
+    constructor(text: string, errorOwner?: ISurveyErrorOwner);
+    getErrorType(): string;
+    protected getDefaultText(): string;
+}
+export declare class MinRowCountError extends SurveyError {
+    minRowCount: number;
+    constructor(minRowCount: number, errorOwner?: ISurveyErrorOwner);
+    getErrorType(): string;
+    protected getDefaultText(): string;
+}
+export declare class KeyDuplicationError extends SurveyError {
+    text: string;
+    constructor(text: string, errorOwner?: ISurveyErrorOwner);
+    getErrorType(): string;
+    protected getDefaultText(): string;
+}
+export declare class CustomError extends SurveyError {
+    text: string;
+    constructor(text: string, errorOwner?: ISurveyErrorOwner);
+    getErrorType(): string;
+}

package/typings/src/expressionItems.d.ts

@@ -0,0 +1,57 @@
+import { Base } from "./base";
+import { ISurvey } from "./base-interfaces";
+import { ILocalizableOwner, LocalizableString } from "./localizablestring";
+/**
+ * Base class for HtmlConditionItem and UrlConditionItem classes.
+ */
+export declare class ExpressionItem extends Base implements ILocalizableOwner {
+    locOwner: ILocalizableOwner;
+    constructor(expression?: string);
+    getType(): string;
+    runCondition(values: any, properties: any): boolean;
+    /**
+     * The expression property. If this expression returns true, then survey will use html property to show on complete page.
+     */
+    get expression(): string;
+    set expression(val: string);
+    get locHtml(): LocalizableString;
+    getLocale(): string;
+    getMarkdownHtml(text: string, name: string): string;
+    getRenderer(name: string): string;
+    getRendererContext(locStr: LocalizableString): any;
+    getProcessedText(text: string): string;
+    getSurvey(isLive?: boolean): ISurvey;
+}
+/**
+ * A class that contains expression and html propeties. It uses in survey.completedHtmlOnCondition array.
+ * If the expression returns true then html of this item uses instead of survey.completedHtml property
+ * @see SurveyModel.completedHtmlOnCondition
+ * @see SurveyModel.completedHtml
+ */
+export declare class HtmlConditionItem extends ExpressionItem {
+    constructor(expression?: string, html?: string);
+    getType(): string;
+    /**
+     * The html that shows on completed ('Thank you') page. The expression should return true
+     * @see expression
+     */
+    get html(): string;
+    set html(value: string);
+    get locHtml(): LocalizableString;
+}
+/**
+ * A class that contains expression and url propeties. It uses in survey.navigateToUrlOnCondition array.
+ * If the expression returns true then url of this item uses instead of survey.navigateToUrl property
+ * @see SurveyModel.navigateToUrl
+ */
+export declare class UrlConditionItem extends ExpressionItem {
+    constructor(expression?: string, url?: string);
+    getType(): string;
+    /**
+     * The url that survey navigates to on completing the survey. The expression should return true
+     * @see expression
+     */
+    get url(): string;
+    set url(value: string);
+    get locUrl(): LocalizableString;
+}

package/typings/src/expressions/expressionParser.d.ts

@@ -0,0 +1,54 @@
+export interface IFilePosition {
+    offset: number;
+    line: number;
+    column: number;
+}
+export interface IFileRange {
+    start: IFilePosition;
+    end: IFilePosition;
+}
+export interface ILiteralExpectation {
+    type: "literal";
+    text: string;
+    ignoreCase: boolean;
+}
+export interface IClassParts extends Array<string | IClassParts> {
+}
+export interface IClassExpectation {
+    type: "class";
+    parts: IClassParts;
+    inverted: boolean;
+    ignoreCase: boolean;
+}
+export interface IAnyExpectation {
+    type: "any";
+}
+export interface IEndExpectation {
+    type: "end";
+}
+export interface IOtherExpectation {
+    type: "other";
+    description: string;
+}
+export type Expectation = ILiteralExpectation | IClassExpectation | IAnyExpectation | IEndExpectation | IOtherExpectation;
+export declare class SyntaxError extends Error {
+    static buildMessage(expected: Expectation[], found: string | null): string;
+    message: string;
+    expected: Expectation[];
+    found: string | null;
+    location: IFileRange;
+    name: string;
+    constructor(message: string, expected: Expectation[], found: string | null, location: IFileRange);
+}
+export interface ICached {
+    nextPos: number;
+    result: any;
+}
+export interface IParseOptions {
+    filename?: string;
+    startRule?: string;
+    tracer?: any;
+    [key: string]: any;
+}
+export type ParseFunction = (input: string, options?: IParseOptions) => any;
+export declare const parse: ParseFunction;