/**
 * Copyright (c) 2020-present, Goldman Sachs
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
import { editor as monacoEditorAPI, languages as monacoLanguagesAPI, type IPosition } from 'monaco-editor';
import type { LambdaEditorState } from '../../stores/shared/LambdaEditorState.js';
import { type Type } from '@finos/legend-graph';
export declare function getCodeSuggestions(position: IPosition, model: monacoEditorAPI.ITextModel, lambdaEditorState: LambdaEditorState): Promise<monacoLanguagesAPI.CompletionItem[]>;
type LambdaEditorBaseProps = {
    className?: string | undefined;
    disabled: boolean;
    lambdaEditorState: LambdaEditorState;
    /**
     * As backdrop element is often shared in the application, and there could be multiple
     * editor using that backdrop, we could end up in situation where some such editors
     * have parser errors and some don't (this can happen when user make edits very quickly 2 lambda
     * editor and causes parsers error simultaneously). In this case, we want to make sure when
     * parser error is fixed in one editor, the backdrop is not dismissed immediately.
     *
     * NOTE: the current approach has a critical flaw, where on the same screen, there could be multiple
     * sets of lambda editors with different values for `forceBackdrop`. So really, the only way to
     * accomondate for this is to have `forceBackdrop` as a global value. Or we should get rid of this
     * backdrop mechanism altogether as it's not a common UX pattern. i.e. quick evaluation makes
     * us believe that this is a good option, user will lose what they type, but the most recent parsable
     * input will still be captured.
     */
    forceBackdrop: boolean;
    autoFocus?: boolean | undefined;
    onEditorFocus?: (() => void) | undefined;
    onEditorBlur?: (() => void) | undefined;
    hideErrorBar?: boolean;
};
export declare const InlineLambdaEditor: ((props: LambdaEditorBaseProps & {
    /**
     * TODO: when we pass in these expected type we should match a type as expected type if it's covariance, i.e. it is a subtype of
     * the expected type. Note that we also have to handle that relationship for Primitive type
     * See https://dzone.com/articles/covariance-and-contravariance
     */
    expectedType?: Type | undefined;
    matchedExpectedType?: (() => boolean) | undefined;
    onExpectedTypeLabelSelect?: (() => void) | undefined;
    /**
     * To whether or not disable expasipn toggler
     */
    disableExpansion?: boolean | undefined;
    /**
     * To whether show the inline editor in expanded mode initially and
     * disable expansion toggler
     *
     * This flag will override the effect of `forceExpansion`
     */
    forceExpansion?: boolean | undefined;
    /**
     * To whether or not disable popup mode
     */
    disablePopUp?: boolean | undefined;
    /**
     * To whether or not hide parser error bar in inline mode
     */
    hideErrorBar?: boolean | undefined;
}) => import("react/jsx-runtime").JSX.Element) & {
    displayName: string;
};
export declare const LambdaEditor: ((props: LambdaEditorBaseProps) => import("react/jsx-runtime").JSX.Element) & {
    displayName: string;
};
export {};
//# sourceMappingURL=LambdaEditor.d.ts.map