@atlaskit/jql-editor 4.0.0

package/dist/types/plugins/common/get-document-position/index.d.ts

@@ -0,0 +1,9 @@
+import { Node } from '@atlaskit/editor-prosemirror/model';
+/**
+ * Return the Prosemirror document position that maps to the provided plain text position.
+ *
+ * @param doc Prosemirror document
+ * @param textPosition Text position to find in the Prosemirror document.
+ */
+declare const getDocumentPosition: (doc: Node, textPosition: number) => number;
+export default getDocumentPosition;

package/dist/types/plugins/common/plugin-keymap.d.ts

@@ -0,0 +1,7 @@
+export declare class PluginKeymap {
+    private keymap;
+    bindKey(key: string, handler: () => boolean): void;
+    bindMultipleKeys(keys: string[], handler: () => boolean): void;
+    unbindKey(key: string): void;
+    getKeyBinding(key: string): import("../../schema").JQLEditorCommand;
+}

package/dist/types/plugins/common/react-plugin-view.d.ts

@@ -0,0 +1,48 @@
+import { FunctionComponent } from 'react';
+import { Subject } from 'rxjs/Subject';
+import { PortalActions } from '../../ui/jql-editor-portal-provider/types';
+import { PluginContainerKey } from '../types';
+/**
+ * Abstract class for Prosemirror plugin views which need to mount a React component. Concrete subclasses must implement
+ * {@link ReactPluginView#getComponent} which specifies the React component to render, along with
+ * {@link ReactPluginView#getInitialComponentProps} which returns any props to pass to the component on initial render.
+ *
+ * After the class is constructed, the caller must invoke {@link ReactPluginView#init} in order to mount the component.
+ *
+ * If there are external changes which the component needs to respond to, {@link ReactPluginView#componentSubject} can
+ * be used to trigger a re-render of the component with updated props. For example:
+ * ```
+ * update = (view: EditorView) => {
+ *   this.componentSubject.next(this.getComponentProps(view));
+ * };
+ *
+ * getComponentProps = (view: EditorView) => {
+ *   // Some logic to get props from the Prosemirror view
+ * }
+ * ```
+ */
+export default abstract class ReactPluginView<ComponentProps extends {}> {
+    protected readonly componentSubject: Subject<ComponentProps>;
+    private readonly portalActions;
+    private readonly portalKey;
+    private readonly containerKey;
+    /**
+     * Construct a Prosemirror plugin view which will render a React component in a portal.
+     *
+     * @param portalActions Provides callback functions which can be invoked to create and destroy a portal.
+     * @param portalKey Unique identifier for the plugin component.
+     * @param containerKey Key representing the HTML container the React component will be portalled into.
+     * @protected
+     */
+    protected constructor(portalActions: PortalActions, portalKey: string, containerKey: PluginContainerKey);
+    init: () => void;
+    destroy(): void;
+    /**
+     * Return a React component to render for the plugin.
+     */
+    protected abstract getComponent: () => FunctionComponent<ComponentProps>;
+    /**
+     * Return props to set on the component for initial render.
+     */
+    protected abstract getInitialComponentProps: () => ComponentProps;
+}

package/dist/types/plugins/index.d.ts

@@ -0,0 +1,5 @@
+export { default as autocompletePlugin } from './autocomplete';
+export { default as jqlAstPlugin } from './jql-ast';
+export { default as jqlSyntaxHighlightingPlugin } from './jql-syntax-highlighting';
+export { default as richInlineNodesPlugin } from './rich-inline-nodes';
+export { default as validationTooltipPlugin } from './validation-tooltip';

package/dist/types/plugins/jql-ast/JQLEditorErrorStrategy.d.ts

@@ -0,0 +1,17 @@
+import { MutableRefObject } from 'react';
+import { DefaultErrorStrategy, FailedPredicateException, InputMismatchException, Parser } from 'antlr4ts';
+import { NoViableAltException } from 'antlr4ts/NoViableAltException';
+import { IntlShape } from 'react-intl-next';
+import { JQLParser } from '@atlaskit/jql-parser';
+export declare const getPrintableChar: (char: string) => string;
+export declare const getJavaCodeFromChar: (char: string) => string;
+export default class JQLEditorErrorStrategy extends DefaultErrorStrategy {
+    intlRef: MutableRefObject<IntlShape>;
+    constructor(intlRef: MutableRefObject<IntlShape>);
+    protected reportInputMismatch(recognizer: JQLParser, exception: InputMismatchException): void;
+    protected reportUnwantedToken(recognizer: JQLParser): void;
+    protected reportMissingToken(recognizer: JQLParser): void;
+    protected reportNoViableAlternative(recognizer: JQLParser, exception: NoViableAltException): void;
+    protected reportFailedPredicate(recognizer: Parser, e: FailedPredicateException): void;
+    private handleSyntaxError;
+}

package/dist/types/plugins/jql-ast/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const ignoredTokens: Set<number>;
+export declare const preferredRules: Set<number>;
+export declare const lowPriorityTokens: number[];

package/dist/types/plugins/jql-ast/error-handlers/CustomFieldRuleErrorHandler.d.ts

@@ -0,0 +1,5 @@
+import { IntlShape } from 'react-intl-next';
+/**
+ * Show the appropriate error message when parsing JQL fails and a custom field rule was expected.
+ */
+export declare const handleCustomFieldRuleError: (intl: IntlShape) => string;

package/dist/types/plugins/jql-ast/error-handlers/ExpectedTokensErrorHandler.d.ts

@@ -0,0 +1,11 @@
+import { Token } from 'antlr4ts';
+import { RecognitionException } from 'antlr4ts/RecognitionException';
+import { IntlShape } from 'react-intl-next';
+import { JQLParser } from '@atlaskit/jql-parser';
+/**
+ * Show the appropriate error message when parsing JQL fails and 0 or more tokens were expected.
+ *
+ * If no `expectedTokens` were provided then we'll attempt to find viable tokens to suggest from the provided
+ * exception/parser state.
+ */
+export declare const handleExpectedTokensError: (recognizer: JQLParser, currentToken: Token, expectedTokens: string[], intl: IntlShape, exception?: RecognitionException) => string;

package/dist/types/plugins/jql-ast/error-handlers/FieldPropertyIdErrorHandler.d.ts

@@ -0,0 +1,6 @@
+import { Token } from 'antlr4ts';
+import { IntlShape } from 'react-intl-next';
+/**
+ * Show the appropriate error message when parsing JQL fails and a field property ID rule was expected.
+ */
+export declare const handleFieldPropertyIdRuleError: (currentToken: Token, intl: IntlShape) => string;

package/dist/types/plugins/jql-ast/error-handlers/FieldRuleErrorHandler.d.ts

@@ -0,0 +1,6 @@
+import { Token } from 'antlr4ts';
+import { IntlShape } from 'react-intl-next';
+/**
+ * Show the appropriate error message when parsing JQL fails and a field rule was expected.
+ */
+export declare const handleFieldRuleError: (currentToken: Token, intl: IntlShape) => string;

package/dist/types/plugins/jql-ast/error-handlers/FunctionArgumentRuleErrorHandler.d.ts

@@ -0,0 +1,6 @@
+import { Token } from 'antlr4ts';
+import { IntlShape } from 'react-intl-next';
+/**
+ * Show the appropriate error message when parsing JQL fails and a function argument rule was expected.
+ */
+export declare const handleFunctionArgumentRuleError: (currentToken: Token, intl: IntlShape) => string;

package/dist/types/plugins/jql-ast/error-handlers/OperandRuleErrorHandler.d.ts

@@ -0,0 +1,9 @@
+import { Token } from 'antlr4ts';
+import { RecognitionException } from 'antlr4ts/RecognitionException';
+import { IntlShape } from 'react-intl-next';
+import { JQLRuleSuggestions } from '@atlaskit/jql-autocomplete';
+import { JQLParser } from '@atlaskit/jql-parser';
+/**
+ * Show the appropriate error message when parsing JQL fails and an operand rule was expected.
+ */
+export declare const handleOperandRuleError: (recognizer: JQLParser, currentToken: Token, expectedTokens: string[], rules: JQLRuleSuggestions, intl: IntlShape, exception?: RecognitionException) => string;

package/dist/types/plugins/jql-ast/error-handlers/OperatorRuleErrorHandler.d.ts

@@ -0,0 +1,6 @@
+import { Token } from 'antlr4ts';
+import { IntlShape } from 'react-intl-next';
+/**
+ * Show the appropriate error message when parsing JQL fails and an operator rule was expected.
+ */
+export declare const handleOperatorRuleError: (currentToken: Token, intl: IntlShape) => string;

package/dist/types/plugins/jql-ast/index.d.ts

@@ -0,0 +1,7 @@
+import { MutableRefObject } from 'react';
+import { IntlShape } from 'react-intl-next';
+import { EditorState, Plugin } from '@atlaskit/editor-prosemirror/state';
+import { Jast } from '@atlaskit/jql-ast';
+export declare const getJastFromState: (state: EditorState) => Jast;
+declare const jqlAstPlugin: (intlRef: MutableRefObject<IntlShape>) => Plugin<Jast>;
+export default jqlAstPlugin;

package/dist/types/plugins/jql-ast/messages.d.ts

@@ -0,0 +1,172 @@
+export declare const errorMessages: {
+    expectingOperatorButReceived: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    expectingOperatorBeforeEOF: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    expectingFieldButReceived: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    expectingFieldBeforeEOF: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    expectingCFButReceived: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    expectingCustomFieldId: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    expectingOperandButReceived: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    expectingOperandBeforeEOF: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    expectingValueOrFunctionButReceived: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    expectingValueOrFunctionBeforeEOF: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    expectingListOrFunctionButReceived: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    expectingListOrFunctionBeforeEOF: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    expectingValueButReceived: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    expectingValueBeforeEOF: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    expectingListButReceived: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    expectingListBeforeEOF: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    expectingFunctionButReceived: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    expectingFunctionBeforeEOF: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    expectingFieldPropertyIdButReceived: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    expectingFieldPropertyIdBeforeEOF: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    expectingFunctionArgButReceived: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    expectingFunctionArgBeforeEOF: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    expectingMultipleTokensButReceived: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    expectingMultipleTokensBeforeEOF: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    expectingTokenButReceived: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    expectingTokenBeforeEOF: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    unknownErrorAtToken: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    reservedChar: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    reservedWord: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    unfinishedString: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    unfinishedStringBlank: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    illegalEscape: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    illegalEscapeBlank: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+    illegalChar: {
+        id: string;
+        defaultMessage: string;
+        description: string;
+    };
+};

package/dist/types/plugins/jql-ast/utils.d.ts

@@ -0,0 +1,4 @@
+import { RecognitionException } from 'antlr4ts/RecognitionException';
+import { JQLParser } from '@atlaskit/jql-parser';
+export declare const getTokenDisplayNames: (parser: JQLParser, tokens: number[]) => string[];
+export declare const getExpectedTokensFromParserOrException: (parser: JQLParser, exception?: RecognitionException) => number[];

package/dist/types/plugins/jql-syntax-highlighting/index.d.ts

@@ -0,0 +1,4 @@
+import { Plugin } from '@atlaskit/editor-prosemirror/state';
+import { Highlight } from './types';
+declare const jqlSyntaxHighlightingPlugin: () => Plugin<Highlight[]>;
+export default jqlSyntaxHighlightingPlugin;

package/dist/types/plugins/jql-syntax-highlighting/types.d.ts

@@ -0,0 +1,5 @@
+export type Highlight = {
+    documentFrom: number;
+    documentTo: number;
+    tokenType: string;
+};

package/dist/types/plugins/jql-syntax-highlighting/visitor.d.ts

@@ -0,0 +1,19 @@
+import { EditorState } from '@atlaskit/editor-prosemirror/state';
+import { AbstractJastVisitor, AstNode, CompoundOperator, Field, NotClauseOperator, Operator, OrderByDirection, OrderByOperator, PredicateOperator } from '@atlaskit/jql-ast';
+import { Highlight } from './types';
+export declare class SyntaxHighlightingVisitor extends AbstractJastVisitor<Highlight[]> {
+    state: EditorState;
+    constructor(state: EditorState);
+    visitCompoundOperator: (compoundOperator: CompoundOperator) => Highlight[];
+    visitNotClauseOperator: (notClauseOperator: NotClauseOperator) => Highlight[];
+    visitOrderByOperator: (orderByOperator: OrderByOperator) => Highlight[];
+    visitOrderByDirection: (orderByDirection: OrderByDirection) => Highlight[];
+    visitField: (field: Field) => Highlight[];
+    visitOperator: (operator: Operator) => Highlight[];
+    visitPredicateOperator: (predicateOperator: PredicateOperator) => Highlight[];
+    protected shouldVisitNextChild(node: AstNode): boolean;
+    protected aggregateResult(aggregate: Highlight[], nextResult: Highlight[]): Highlight[];
+    protected defaultResult(): never[];
+    private getHighlightsIfPosition;
+    private createHighlight;
+}

package/dist/types/plugins/rich-inline-nodes/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const RICH_INLINE_NODE = "rich_inline";
+export declare const SELECTED_NODE = "selected";
+export declare const ERROR_NODE = "error";

package/dist/types/plugins/rich-inline-nodes/index.d.ts

@@ -0,0 +1,4 @@
+import { Plugin } from '@atlaskit/editor-prosemirror/state';
+import { PortalActions } from '../../ui/jql-editor-portal-provider/types';
+declare const richInlineNodesPlugin: (portalActions: PortalActions) => Plugin<void>;
+export default richInlineNodesPlugin;

package/dist/types/plugins/rich-inline-nodes/nodes/index.d.ts

@@ -0,0 +1,3 @@
+export declare const richInlineNodes: {
+    user: import("./types").JQLNodeSpec<import("./user").Props>;
+};

package/dist/types/plugins/rich-inline-nodes/nodes/types.d.ts

@@ -0,0 +1,9 @@
+import { FunctionComponent } from 'react';
+import { AttributeSpec } from '@atlaskit/editor-prosemirror/model';
+import { NodeViewProps } from '../util/react-node-view';
+export type JQLNodeSpec<Props> = {
+    component: FunctionComponent<NodeViewProps<Props>>;
+    attrs: {
+        [name: string]: AttributeSpec;
+    };
+};

package/dist/types/plugins/rich-inline-nodes/nodes/user/index.d.ts

@@ -0,0 +1,7 @@
+import { JQLNodeSpec } from '../types';
+export type Props = {
+    id: string;
+    name: string;
+    fieldName: string;
+};
+export declare const user: JQLNodeSpec<Props>;

package/dist/types/plugins/rich-inline-nodes/nodes/user/styled.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+export declare const UserContainer: import("@emotion/styled-base").StyledComponent<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, {
+    selected: boolean;
+    error: boolean;
+}, object>;
+export declare const NameContainer: import("@emotion/styled-base").StyledComponent<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, Pick<import("react").ClassAttributes<HTMLSpanElement> & import("react").HTMLAttributes<HTMLSpanElement>, keyof import("react").HTMLAttributes<HTMLSpanElement>>, object>;
+export declare const AvatarWrapper: import("@emotion/styled-base").StyledComponent<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, Pick<import("react").ClassAttributes<HTMLSpanElement> & import("react").HTMLAttributes<HTMLSpanElement>, keyof import("react").HTMLAttributes<HTMLSpanElement>>, object>;

package/dist/types/plugins/rich-inline-nodes/types.d.ts

@@ -0,0 +1,2 @@
+import { ERROR_NODE, SELECTED_NODE } from './constants';
+export type RichInlineNodeDecoration = typeof SELECTED_NODE | typeof ERROR_NODE;

package/dist/types/plugins/rich-inline-nodes/util/create-node-spec.d.ts

@@ -0,0 +1,4 @@
+import { AttributeSpec, NodeSpec } from '@atlaskit/editor-prosemirror/model';
+export declare const createNodeSpec: (name: string, attrs: {
+    [name: string]: AttributeSpec;
+}) => NodeSpec;

package/dist/types/plugins/rich-inline-nodes/util/react-node-view.d.ts

@@ -0,0 +1,24 @@
+import { FunctionComponent } from 'react';
+import { Node } from '@atlaskit/editor-prosemirror/model';
+import { Decoration, NodeView } from '@atlaskit/editor-prosemirror/view';
+import { PortalActions } from '../../../ui/jql-editor-portal-provider/types';
+export type NodeViewProps<Props> = Props & {
+    selected: boolean;
+    error: boolean;
+};
+export declare class ReactNodeView<Props> implements NodeView {
+    private readonly component;
+    private readonly componentSubject;
+    private readonly node;
+    private readonly portalActions;
+    private readonly portalKey;
+    readonly dom: HTMLSpanElement;
+    constructor(component: FunctionComponent<NodeViewProps<Props>>, portalActions: PortalActions, node: Node);
+    static for<Props>(component: FunctionComponent<NodeViewProps<Props>>, portalActions: PortalActions, node: Node, decorations: readonly Decoration[]): ReactNodeView<Props>;
+    init: (decorations: readonly Decoration[]) => this;
+    destroy: () => void;
+    update: (node: Node, decorations: readonly Decoration[]) => boolean;
+    getProps: (node: Node) => Props;
+    private isSelected;
+    private hasError;
+}

package/dist/types/plugins/rich-inline-nodes/util/replace-nodes-transaction.d.ts

@@ -0,0 +1,3 @@
+import { EditorState, Transaction } from '@atlaskit/editor-prosemirror/state';
+import { HydratedValuesMap } from '../../../state/types';
+export declare const replaceRichInlineNodes: (editorState: EditorState, hydratedValues: HydratedValuesMap) => Transaction;

package/dist/types/plugins/types.d.ts

@@ -0,0 +1,16 @@
+export type { AutocompleteProvider, AutocompleteOptions, AutocompleteOption, AutocompleteValueType, } from './autocomplete/types';
+export type PluginContainers = {
+    /**
+     * Container for plugin components which should be appended to the top level container element.
+     */
+    main?: HTMLElement;
+    /**
+     * Container for plugin components which should be appended to the footer underneath the editor input.
+     */
+    footer?: HTMLElement;
+    /**
+     * Container for plugin components which should be appended at the end of the editor input.
+     */
+    editor_controls?: HTMLElement;
+};
+export type PluginContainerKey = keyof PluginContainers;

package/dist/types/plugins/validation-tooltip/constants.d.ts

@@ -0,0 +1,5 @@
+import { PluginKey } from '@atlaskit/editor-prosemirror/state';
+export declare const JQLValidationTooltipPluginKey: PluginKey<boolean>;
+export declare const TOOLTIP_CLASSNAME = "jql-validation-tooltip";
+export declare const TOOLTIP_ENTER_CLASSNAME = "jql-validation-tooltip-enter";
+export declare const TOOLTIP_EXIT_CLASSNAME = "jql-validation-tooltip-exit";

package/dist/types/plugins/validation-tooltip/index.d.ts

@@ -0,0 +1,3 @@
+import { Plugin } from '@atlaskit/editor-prosemirror/state';
+declare const validationTooltipPlugin: (mainId: string) => Plugin<boolean>;
+export default validationTooltipPlugin;

package/dist/types/plugins/validation-tooltip/view.d.ts

@@ -0,0 +1,18 @@
+import { EditorState } from '@atlaskit/editor-prosemirror/state';
+import { EditorView } from '@atlaskit/editor-prosemirror/view';
+import { JQLSyntaxError } from '@atlaskit/jql-ast';
+type Coords = {
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+};
+export declare class ValidationTooltipPluginView {
+    tooltip: HTMLElement;
+    constructor(mainId: string);
+    showTooltip: (error: JQLSyntaxError, start: Coords, end: Coords) => void;
+    hideTooltip: () => void;
+    update(view: EditorView, lastState: EditorState): void;
+    destroy(): void;
+}
+export {};

package/dist/types/schema/index.d.ts

@@ -0,0 +1,28 @@
+import { MutableRefObject } from 'react';
+import { IntlShape } from 'react-intl-next';
+import { ResolvedPos, Schema, Slice } from '@atlaskit/editor-prosemirror/model';
+import { EditorState, Transaction } from '@atlaskit/editor-prosemirror/state';
+import { EditorView } from '@atlaskit/editor-prosemirror/view';
+import { richInlineNodes } from '../plugins/rich-inline-nodes/nodes';
+import { PortalActions } from '../ui/jql-editor-portal-provider/types';
+type Nodes = 'doc' | 'paragraph' | 'text' | keyof typeof richInlineNodes;
+type Marks = 'token' | 'cursor';
+export declare const JQLEditorSchema: Schema<Nodes, Marks>;
+/**
+ * Emulate the behaviour of the default https://prosemirror.net/docs/ref/#view.EditorProps.clipboardTextSerializer but
+ * preserves consecutive empty block nodes.
+ */
+export declare const clipboardTextSerializer: (slice: Slice) => string;
+/**
+ * Emulate the behaviour of the default https://prosemirror.net/docs/ref/#view.EditorProps.clipboardTextParser but
+ * preserves consecutive empty lines.
+ */
+export declare const clipboardTextParser: (text: string, $context: ResolvedPos) => Slice;
+export declare const defaultEditorState: EditorState;
+export type JQLEditorSchemaType = typeof JQLEditorSchema;
+export type JQLEditorCommand = (state: EditorState, dispatch?: (tr: Transaction) => void, view?: EditorView) => boolean;
+export type JQLEditorKeymap = {
+    [key: string]: JQLEditorCommand;
+};
+export declare const configurePlugins: (editorState: EditorState, onSearchCommand: JQLEditorCommand | undefined, intlRef: MutableRefObject<IntlShape>, mainId: string, portalActions: PortalActions | void, enableRichInlineNodes: boolean) => EditorState;
+export {};

package/dist/types/state/analytics/index.d.ts

@@ -0,0 +1,9 @@
+import { Action } from 'react-sweet-state';
+import { Subscription } from 'rxjs/Subscription';
+import { OptionsKey, Props, State } from '../types';
+export declare const ANALYTICS_DEBOUNCE_MS = 2000;
+export type AutocompleteEvent = {
+    analyticsSubscription: Subscription;
+    onStopAutocompleteEvent: (isSuccess: boolean, optionTypes: OptionsKey[], hasOptions: boolean) => void;
+};
+export declare const onStartAutocompleteEvent: () => Action<State, Props, AutocompleteEvent>;

package/dist/types/state/autocomplete/index.d.ts

@@ -0,0 +1,4 @@
+import { Observable } from 'rxjs/Observable';
+import { AutocompleteOptions } from '@atlaskit/jql-editor-common';
+export declare const ORDERED_OPERATORS: string[];
+export declare const sortOperators: (operators$: Observable<AutocompleteOptions>) => Observable<AutocompleteOptions>;

package/dist/types/state/hydration/index.d.ts

@@ -0,0 +1,3 @@
+import { Action } from 'react-sweet-state';
+import { Props, State } from '../types';
+export declare const hydrateQuery: () => Action<State, Props, Promise<void>>;

package/dist/types/state/hydration/util.d.ts

@@ -0,0 +1,23 @@
+import { AbstractJastVisitor, CompoundClause, ListOperand, NotClause, Query, TerminalClause, ValueOperand } from '@atlaskit/jql-ast';
+/**
+ * Given an AST with parse errors, this visitor returns a valid query that is equivalent for hydration purposes
+ * (i.e. just fields, operators and values). Resulting query is generated on a best-effort basis and depends on
+ * a successful parser error recovery.
+ *
+ * Example 1:
+ * - Original query: "assignee in (abc-123-def"
+ * - Equivalent query: "assignee in (abc-123-def)"
+ *
+ * Example 2:
+ * - Original query: "project = EM and status in (Done, currentUser(), EMPTY) and reporter in"
+ * - Equivalent query: "project = EM and status in (Done)"
+ */
+export declare class ValidQueryVisitor extends AbstractJastVisitor<string> {
+    visitQuery: (query: Query) => string;
+    visitCompoundClause: (compoundClause: CompoundClause) => string;
+    visitTerminalClause: (terminalClause: TerminalClause) => string;
+    visitNotClause: (notClause: NotClause) => string;
+    visitValueOperand: (valueOperand: ValueOperand) => string;
+    visitListOperand: (listOperand: ListOperand) => string;
+    protected defaultResult(): string;
+}