import { z } from 'zod';
import type { AppEvent, AppEventListerKey } from './events';
import type { PluginAccessDescendantsOfIdScopeSig, PluginAccessDescendantsOfNameScopeSig, PluginAccessFocusedSubtreeSig, PluginAccessFullKbScopeSig, PluginAccessKnowledgeBaseInfoScopeSig, PluginAccessPowerupScopeSig, PluginAccessScopeSig, PluginManifestV1Sig, VersionSig } from './validation';
export declare enum SelectionType {
    Rem = "Rem",
    Text = "Text",
    PDF = "PDF",
    WebReader = "WebReader"
}
export type EditorRange = {
    start: number;
    end: number;
};
export interface ReaderSelection {
    type: SelectionType.WebReader | SelectionType.PDF;
    text: string;
    remId: RemId;
}
export interface RemSelection {
    type: SelectionType.Rem;
    remIds: RemId[];
}
export interface TextSelection {
    type: SelectionType.Text;
    remId: RemId;
    richText: RichTextInterface;
    isReverse: boolean;
    range: EditorRange;
}
export declare const richTextFormatNameCodeMap: {
    quote: string;
    underline: string;
    bold: string;
    italic: string;
};
export declare enum RemColor {
    undefined = 0,
    Red = 1,
    Orange = 2,
    Yellow = 3,
    Green = 4,
    Blue = 6,
    Purple = 5,
    Gray = 7,
    Brown = 8,
    Pink = 9
}
export type RichTextFormatName = keyof typeof richTextFormatNameCodeMap | keyof Omit<typeof RemColor, 'undefined'> | 'cloze';
export type PluginId = string;
export type CallbackFn = (context: Record<string, any>) => unknown | Promise<unknown>;
export type EventCallbackFn = (event: any) => void;
export type Version = z.TypeOf<typeof VersionSig>;
/**
 * @ignore
 */
export declare enum PluginActionPermissionLevel {
    Read = "Read",
    ReadCreate = "ReadCreate",
    ReadCreateModify = "ReadCreateModify",
    ReadCreateModifyDelete = "ReadCreateModifyDelete"
}
/**
 * @ignore
 */
export declare enum PluginAccessScopeType {
    All = "All",
    DescendantsOfName = "DescendantsOfName",
    DescendantsOfId = "DescendantsOfId",
    Powerup = "Powerup",
    FocusedSubtree = "FocusedSubtree",
    KnowledgeBaseInfo = "KnowledgeBaseInfo"
}
/**
 * @ignore
 */
export type PluginAccessScope = z.TypeOf<typeof PluginAccessScopeSig>;
export type PluginAccessKnowledgeBaseInfoScope = z.TypeOf<typeof PluginAccessKnowledgeBaseInfoScopeSig>;
/**
 * @ignore
 */
export type PluginAccessFullKbScope = z.TypeOf<typeof PluginAccessFullKbScopeSig>;
/**
 * @ignore
 */
export type PluginAccessDescendantsOfNameScope = z.TypeOf<typeof PluginAccessDescendantsOfNameScopeSig>;
/**
 * @ignore
 */
export type PluginAccessDescendantsOfIdScope = z.TypeOf<typeof PluginAccessDescendantsOfIdScopeSig>;
/**
 * @ignore
 */
export type PluginAccessPowerupScope = z.TypeOf<typeof PluginAccessPowerupScopeSig>;
/**
 * @ignore
 */
export type PluginAccessFocusedSubtree = z.TypeOf<typeof PluginAccessFocusedSubtreeSig>;
export type PluginManifest = z.TypeOf<typeof PluginManifestV1Sig>;
/** @hidden */
export type PluginMethodName = string;
/** @hidden */
export type PluginMessageId = number;
/** @hidden */
export type APIEventMessage = {
    eventId: AppEvent;
    listenerKey: AppEventListerKey;
    args: Record<string, any>;
};
/** @hidden */
export type APICallMessage = {
    callbackId: string;
    callbackReturnValueHandlerId?: string;
    args: Record<string, any>;
};
/** @hidden */
export type APIErrorResponse = {
    messageId: PluginMessageId;
    error: string;
};
/** @hidden */
export type APIResponsePayload = any;
/** @hidden */
export type PluginAPIResponse = {
    messageId: PluginMessageId;
    response: APIResponsePayload;
} | APIErrorResponse;
/** @hidden */
export type APIMessage = APIEventMessage | APICallMessage | PluginAPIResponse;
/** @hidden */
export type WidgetFileName = string;
export interface WidgetOptions {
    powerupFilter?: PowerupCode;
    onPowerupPageFilter?: PowerupCode;
    remIdFilter?: RemId;
    queueItemTypeFilter?: QueueItemType;
    dimensions?: {
        height?: number | 'auto';
        width?: number | string | 'auto';
    };
    widgetTabTitle?: string;
    widgetTabIcon?: string;
    dontOpenByDefaultInTabLocation?: boolean;
}
export type PowerupCode = string;
export type PowerupSlotCode = string;
/**
 * `WidgetLocation` contains all locations where you could place your custom widget.
 *
 * Use it when registering your widget.
 */
export declare enum WidgetLocation {
    FloatingWidget = "FloatingWidget",
    PaneHeader = "PaneHeader",
    Index = "Index",
    TopBar = "TopBar",
    QueueToolbar = "QueueToolbar",
    QueueBelowTopBar = "QueueBelowTopBar",
    DocumentAboveToolbar = "AboveDocumentToolbar",
    DocumentBelowToolbar = "DocumentBelowToolbar",
    DocumentBelowEditor = "DocumentBelowEditor",
    DocumentBelowTitle = "DocumentBelowTitle",
    SidebarEnd = "SidebarEnd",
    RemReferencePopupStart = "RemReferencePopupStart",
    RemReferencePopupRight = "RemReferencePopupRight",
    Pane = "Pane",
    FlashcardAnswerButtons = "FlashcardAnswerButtons",
    FlashcardAnswer = "FlashcardAnswer",
    Flashcard = "Flashcard",
    FlashcardExtraDetail = "FlashcardExtraDetail",
    FlashcardUnder = "FlashcardUnder",
    RightSidebar = "RightSidebar",
    LeftSidebar = "LeftSidebar",
    Popup = "Popup",
    UnderRemEditor = "UnderRemEditor",
    RightSideOfEditor = "RightSideOfEditor",
    SelectedTextMenu = "SelectedTextMenu",
    PDFHighlightToolbarLocation = "PDFHighlightToolbarLocation",
    PDFHighlightPopupLocation = "PDFHighlightPopupLocation",
    DeckPage = "DeckPage",
    LearningProgressPage = "LearningProgressPage"
}
/**
 * RemNote provides various built in powerups
 */
export declare enum BuiltInPowerupCodes {
    Aliases = "l",
    AutoSort = "a",
    AppliedTemplates = "at",
    AutoTemplate = "m",
    CustomCSS = "c",
    DailyDocument = "d",
    DisableCards = "u",
    Divider = "dv",
    Document = "o",
    DocumentSidebar = "s",
    EditLater = "e",
    Emoji = "j",
    ExtraCardDetail = "x",
    Header = "r",
    Highlight = "h",
    Link = "b",
    List = "i",
    MultipleChoice = "mc",
    MultiLineCard = "w",
    PDFPageNumber = "pn",
    PDFHighlight = "n",
    QuickAdd = "q",
    Quote = "qt",
    RestoredFromTrash = "rt",
    Slot = "y",
    Sources = "os",
    SuperPrivate = "k",
    TableOfContent = "toc",
    TextToSpeech = "tts",
    EmbedWebsite = "ew",
    UsedAsTag = "g",
    Todo = "t",
    UploadedFile = "f",
    WebHighlight = "p",
    Website = "z",
    Code = "cd",
    TypeInAnswer = "ty",
    Deck = "de",
    SearchPortal = "sp",
    Collection = "ct",
    HTMLHighlight = "hh",
    HideQueueAncestors = "ha",
    ImportedDocument = "id",
    Image = "im",
    SavedDocuments = "sd",
    Callout = "clo"
}
export declare const PowerupSlotCodeMap: {
    ha: {};
    l: {
        Aliases: string;
    };
    ct: {
        Template: string;
    };
    a: {
        SortDirection: string;
    };
    cd: {
        Language: string;
        DontWrap: string;
        DontBoundHeight: string;
    };
    m: {};
    c: {};
    d: {
        Timestamp: string;
        Date: string;
    };
    u: {};
    o: {
        Status: string;
        DeprecatedSource: string;
    };
    s: {};
    dv: {};
    e: {
        Message: string;
    };
    j: {};
    x: {};
    r: {
        Size: string;
    };
    h: {
        Color: string;
    };
    b: {
        URL: string;
        Title: string;
        ReadPercent: string;
        LastReadDate: string;
        FileURL: string;
    };
    i: {};
    w: {};
    n: {
        Data: string;
        PdfId: string;
    };
    hh: {
        Data: string;
        HTMLId: string;
    };
    pn: {};
    q: {};
    qt: {};
    rt: {
        Date: string;
    };
    y: {
        SelectTag: string;
        ExtraSlotsOnFrontOfCard: string;
        ExtraSlotsOnBackOfCard: string;
    };
    os: {
        Sources: string;
    };
    at: {
        Templates: string;
    };
    sp: {
        Query: string;
        Filter: string;
        AutomaticBacklinkSearchPortalFor: string;
        DontIncludeNestedDescendants: string;
    };
    k: {};
    g: {
        AutoActivate: string;
        Pinned: string;
        CollapseConfigure: string;
        PrimaryColumnName: string;
    };
    t: {
        Status: string;
    };
    ew: {
        URL: string;
        WIDTH: string;
        HEIGHT: string;
    };
    toc: {};
    tts: {};
    f: {
        Type: string;
        URL: string;
        Name: string;
        Authors: string;
        Keywords: string;
        Title: string;
        ViewerData: string;
        ReadPercent: string;
        LastReadDate: string;
        HasNoTextLayer: string;
        Theme: string;
    };
    p: {
        Data: string;
        Url: string;
    };
    z: {
        Hostname: string;
    };
    clo: {
        BulletIcon: string;
    };
    ty: {};
    de: {
        Topics: string;
        Status: string;
        MaxNewCardsPerDay: string;
        MaxTotalCardsPerDay: string;
        ExamSchedulerDate: string;
        RetrievabilityPeriodStartDate: string;
        ConsolidationPeriodStartDate: string;
        ConsolidationPeriodReIntroSectionLength: string;
        ExamConfig: string;
        SavedExamInfo: string;
        ExamSchedulerDesiredStability: string;
        ExamSchedulerMaxNewCardsPerDay: string;
        ExamSchedulerMaxTotalCardsPerDay: string;
        ExamSchedulerCollection: string;
    };
    id: {};
    sd: {};
    mc: {};
    im: {
        Image: string;
    };
};
interface SettingsDropdownOption {
    key: string;
    label: string;
    value: string;
}
export type PowerupSlotCodeMap = typeof PowerupSlotCodeMap;
export type SlotCodesForPowerup<PowerupCode extends BuiltInPowerupCodes> = keyof PowerupSlotCodeMap[PowerupCode];
export type RemId = string;
export type KnowledgeBaseId = string;
export declare enum SetRemType {
    DEFAULT_TYPE,
    CONCEPT = 1,
    DESCRIPTOR = 2
}
export declare enum RemType {
    DEFAULT_TYPE,
    CONCEPT = 1,
    DESCRIPTOR = 2,
    DEPRECATED_BASIC_CARD = 4,
    PORTAL = 6,
    DEPRECATED_SLOT = 3,
    DEPRECATED_PATTERN = 5,
    DEPRECATED_COLLECTION = 7,
    DEPRECATED_TEXT = 8
}
export declare enum RemTypeTinyGraph {
    DEFAULT_TYPE = 0,
    CONCEPT = 1,
    DESCRIPTOR = 2,
    PORTAL = 3
}
export declare function remTypeToTinyGraphType(remType: RemType): RemTypeTinyGraph;
export declare function remTypeTinyGraphToNormal(remType: RemTypeTinyGraph): RemType.DEFAULT_TYPE | RemType.CONCEPT | RemType.DESCRIPTOR | RemType.PORTAL;
export { Card } from './name_spaces/card';
export { RemObject as PluginRem } from './name_spaces/rem';
export type ComponentFocusId = ComponentFocusableItem[];
export interface FocusContext {
    columnType?: string;
}
export interface ComponentFocusableItem {
    type: ComponentFocusableItemType;
    key?: string;
    focusContext?: FocusContext;
}
export declare enum ComponentFocusableItemType {
    MultipleWindows = "multipleWindows",
    MultipleWindowsPanel = "multipleWindowsPanel",
    Dropdown = "Dropdown",
    Breadcrumbs = "Breadcrumbs",
    FloatingDiscussion = "floatingDiscussion",
    WindowManager = "windowManager",
    RemPage = "RemPage",
    WindowPane = "windowPane",
    MobileTabBar = "MobileTabBar",
    Document = "document",
    NotificationPanel = "notificationPanel",
    EmojiPicker = "EmojiPicker",
    HierarchyEditorTree = "hierarchyEditorTree",
    ChangeCodeLanguage = "ChangeCodeLanguage",
    HierarchyEditorTreePortal = "hierarchyEditorTreePortal",
    HierarchyEditorTreeRem = "hierarchyEditorTreeRem",
    RichTextEditor = "richTextEditor",
    RichTextEditorItem = "richTextEditorItem",
    RichTextEditorAliasPopup = "richTextEditorAliasPopup",
    TableCellList = "tableCellList",
    TableCellPopup = "tableCellPopup",
    Table = "Table",
    ColumnConfigurationMenu = "columnConfigurationMenu",
    Popup = "popup",
    Omnibar = "omnibar",
    QuickAdd = "quickAdd",
    Date = "date",
    Queue = "queue",
    TypeAnswerBox = "typeAnswerBox",
    QueryBuilder = "queryBuilder",
    PublishedKnowledgeBase = "publishedKnowledgeBase",
    ArticleViewer = "articleViewer",
    Article = "article",
    FullPageSearch = "fullPageSearch",
    ExtraDate = "extraDate",
    DropToOpenAsDocument = "dropToOpenAsDocument",
    TableSearch = "TableSearch",
    PDF = "pdf",
    PdfPageNumber = "pdfPageNumber",
    NotesPopup = "notesPopup",
    PDFUploader = "pdfUploader",
    Reader = "reader",
    RemSearchPopup = "remSearchPopup",
    Debugger = "debugger",
    SelectRem = "selectRem",
    ExpressionSelect = "ExpressionSelect",
    HiddenChildren = "hiddenChildren",
    TableTitle = "tableTitle",
    TableTagTitle = "tableTagTitle",
    TableColumnTitle = "tableColumnTitle",
    Toolbar = "toolbar",
    Title = "title",
    SidebarTitleEdit = "sidebarTitleEdit",
    ArticleQueue = "articleQueue",
    UserDocument = "userDocument",
    DocumentSidebar = "documentSidebar",
    RightSidebar = "rightSidebar",
    Documents = "documents",
    AudioVideo = "audioVideo",
    ImageNode = "imageNode",
    QueryNodeEditor = "queryNodeEditor",
    LinkBox = "linkBox",
    SelectedTextMenu = "selectedTextMenu",
    RemReferenceNode = "remReferenceNode",
    DeckTopicsList = "deckTopics",
    DeckTopic = "deckTopic",
    AddDeckTopic = "addDeckTopic",
    DocSources = "docSources",
    DocTags = "docTags",
    AddSources = "addSources",
    AddTags = "addTags",
    InlineLink = "inlineLink",
    ImageSelector = "imageSelector",
    Latex = "latex",
    Image = "image",
    Cloze = "cloze",
    Alias = "alias",
    QueueFolderDropdownSelector = "queueFolderDropdownSelector",
    CustomEditLaterMessage = "customEditLaterMessage",
    DocumentParents = "documentParents",
    AreaHighlight = "areaHighlight",
    WindowOne = "windowOne",
    WindowTwo = "windowTwo",
    Replace = "replace",
    Find = "find",
    Tag = "tag",
    TagBar = "tagBar",
    Menu = "menu",
    Screenshot = "screenshot",
    HelpMessage = "helpMessage",
    AddNode = "addNode",
    EditEdge = "editEdge",
    Controls = "controls",
    DocumentSource = "documentSource",
    Merge = "merge",
    HierarchyEditorTemplateFields = "hierarchyEditorTemplateFields",
    SearchExistingTable = "searchExistingTable",
    FieldKey = "fieldKey",
    PluginRemRichTextEditor = "pluginRemRichTextEditor",
    PluginRichTextViewer = "pluginRichTextViewer",
    RemHierarchyEditorTree = "remHierarchyEditorTree",
    PluginQueue = "pluginQueue",
    RichTextEditorFakeEmbed = "richTextEditorFakeEmbed",
    DocumentHeader = "documentHeader",
    EmbedWebsite = "embedWebsite",
    TemplateValueEditor = "TemplateValueEditor",
    TemplateValueTextEditor = "TemplateValueTextEditor",
    Key = "key",
    Value = "value",
    CtrlF = "ctrlF",
    CtrlFFind = "ctrlFind",
    CtrlFReplace = "ctrlReplace",
    CtrlFFilter = "ctrlFilter",
    SearchResult = "searchResult",
    SearchResultItem = "searchResultItem",
    FocusableInput = "focusableInput",
    UpvoteDownvoteFeedback = "UpvoteDownvoteFeedback",
    RightSidebarHelpInput = "RightSidebarHelpInput",
    LeftSidebarTutorial = "LeftSidebarTutorial",
    CardTableSearchQuery = "cardTableSearchQuery",
    Tab = "tab",
    ExamDeckRemSearchPopup = "ExamDeckRemSearchPopup",
    RightSideImagePopup = "RightSideImagePopup",
    RightSideUploadedImagePopup = "RightSideUploadedImagePopup",
    RemDocumentSidebar = "RemDocumentSidebar",
    RemEmoji = "remEmoji",
    FlashcardPreview = "FlashcardPreview",
    HoverPreview = "HoverPreview"
}
export declare enum FocusPropsType {
    Text = "text",
    SelectedRange = "selectedRange"
}
export type FocusElementProps = Partial<FocusPropsTextType> | Partial<FocusPropsSelectRangeType> | undefined;
export interface FocusPropsTextType {
    type: FocusPropsType.Text;
    anchor: number | null;
    focus: number | null;
    prevAnchor: number | null;
    prevFocus: number | null;
}
export interface FocusPropsSelectRangeType {
    type: FocusPropsType.SelectedRange;
    selectedRangePortal: RemId | null;
    selectedRange: RemId[];
    selectedDeepRemHighestLevelIds: RemId[];
    selectedDeepRemAllIds: {
        remId: RemId;
        portalId: RemId;
    }[];
    selectedRangeReversed: boolean;
    selectedRangeFullDepth: number;
    selectedRangeStart: RemId | null;
    selectedRangeEnd: RemId | null;
    prevTextFocusId: ComponentFocusId;
    prevTextFocusProps: Partial<FocusPropsTextType>;
    draggingSelectedRange?: boolean;
    dropPortal?: boolean;
    selectedColumnsNodes?: string[];
    lastFocusedRem?: RemId;
    isTableSelection: boolean;
    tablePortal?: RemId;
    tableParent?: RemId;
    tableNodeId?: string;
    topLeft?: {
        colIdx: number;
        rowIdx: number;
    };
    bottomRight?: {
        colIdx: number;
        rowIdx: number;
    };
    selectedRowNodeId?: string;
    selectedColumnNodeId?: string;
}
export type MosaicNode<T> = MosaicParent<T> | T;
export type MosaicDirection = 'row' | 'column';
export interface MosaicParent<T> {
    direction: MosaicDirection;
    first: MosaicNode<T>;
    second: MosaicNode<T>;
    splitPercentage?: number;
}
export type PaneTree = MosaicParent<string>;
export type PaneIdWindowTree = MosaicNode<string>;
export type RemIdWindowTree = MosaicNode<string>;
export type PaneRem = {
    remId: string;
    paneId: string;
};
export type PaneRemWindowTree = PaneRem | MosaicParent<PaneRem>;
/**
 * The context in which a command was triggered.
 */
declare enum CommandContext {
    /**
     * The command is always available.
     */
    Global = "global",
    /**
     * The cursor is in a rem for editing.
     */
    RemFocused = "rem-focused",
    /**
     * One or more rems are selected.
     */
    RemSelected = "rem-selected"
}
export interface CommandArgs {
    titleRem?: RemId;
    focusedRem?: RemId;
    selectedRem?: RemId[];
    context: CommandContext;
}
type CommandFn = () => void | Promise<void>;
type CommandId = string;
export interface SimpleCommand {
    id: CommandId;
    action: CommandFn;
}
/** You can register commands in RemNote, which can be executed in the Omnibar.
 *  Commands can do many things and they're an easy way to execute an action.
 *  Make sure to add `keywords`, an `icon` and a `description` to make it user-friendly! */
export interface Command_DUPE_2 extends Omit<SimpleCommand, 'action'> {
    name: string;
    description?: string;
    keywords?: string;
    icon?: any;
    action: CommandFn | string;
    keyboardShortcut?: string;
    quickCode?: string;
}
export declare enum PropertyType {
    IMPLICIT_TEXT,
    NUMBER = "number",
    DEPRECATED_TITLE = "title",
    TEXT = "text",
    CHECKBOX = "checkbox",
    DATE = "date",
    MULTI_SELECT = "multi_select",
    SINGLE_SELECT = "single_select",
    CREATED_AT = "created_at",
    LAST_UPDATED = "last_updated",
    IMAGE = "image",
    URL = "url",
    DEFINITION = "definition"
}
export declare enum PluginCommandMenuLocation {
    PropertyConfigMenu = "PropertyConfigMenu",
    QueueMenu = "QueueMenu",
    ReaderMenu = "ReaderMenu",
    PDFHighlightPopupLocation = "PDFHighlightPopupLocation",
    DocumentMenu = "DocumentMenu"
}
export interface PluginMenuItem extends Omit<SimpleCommand, 'action'> {
    name: string;
    location: PluginCommandMenuLocation;
    action: (args: any) => Promise<void>;
    iconUrl?: string;
}
export interface PluginSettingBase<T extends string | boolean | number> {
    id: string;
    title: string;
    description?: string;
    defaultValue?: T;
}
export interface PluginDropdownSetting extends PluginSettingBase<string> {
    options: SettingsDropdownOption[];
}
export declare const stringValidatorSig: z.ZodUnion<[z.ZodObject<{
    type: z.ZodLiteral<"email">;
}, "strip", z.ZodTypeAny, {
    type: "email";
}, {
    type: "email";
}>, z.ZodObject<{
    type: z.ZodLiteral<"url">;
}, "strip", z.ZodTypeAny, {
    type: "url";
}, {
    type: "url";
}>, z.ZodObject<{
    type: z.ZodLiteral<"regex">;
    arg: z.ZodString;
}, "strip", z.ZodTypeAny, {
    type: "regex";
    arg: string;
}, {
    type: "regex";
    arg: string;
}>, z.ZodObject<{
    type: z.ZodLiteral<"startsWith">;
    arg: z.ZodString;
}, "strip", z.ZodTypeAny, {
    type: "startsWith";
    arg: string;
}, {
    type: "startsWith";
    arg: string;
}>, z.ZodObject<{
    type: z.ZodLiteral<"endsWith">;
    arg: z.ZodString;
}, "strip", z.ZodTypeAny, {
    type: "endsWith";
    arg: string;
}, {
    type: "endsWith";
    arg: string;
}>, z.ZodObject<{
    type: z.ZodLiteral<"min">;
    arg: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    type: "min";
    arg: number;
}, {
    type: "min";
    arg: number;
}>, z.ZodObject<{
    type: z.ZodLiteral<"max">;
    arg: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    type: "max";
    arg: number;
}, {
    type: "max";
    arg: number;
}>, z.ZodObject<{
    type: z.ZodLiteral<"length">;
    arg: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    type: "length";
    arg: number;
}, {
    type: "length";
    arg: number;
}>]>;
export declare const numberValidatorSig: z.ZodUnion<[z.ZodObject<{
    type: z.ZodLiteral<"gte">;
    arg: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    type: "gte";
    arg: number;
}, {
    type: "gte";
    arg: number;
}>, z.ZodObject<{
    type: z.ZodLiteral<"min">;
    arg: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    type: "min";
    arg: number;
}, {
    type: "min";
    arg: number;
}>, z.ZodObject<{
    type: z.ZodLiteral<"gt">;
    arg: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    type: "gt";
    arg: number;
}, {
    type: "gt";
    arg: number;
}>, z.ZodObject<{
    type: z.ZodLiteral<"lt">;
    arg: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    type: "lt";
    arg: number;
}, {
    type: "lt";
    arg: number;
}>, z.ZodObject<{
    type: z.ZodLiteral<"lte">;
    arg: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    type: "lte";
    arg: number;
}, {
    type: "lte";
    arg: number;
}>, z.ZodObject<{
    type: z.ZodLiteral<"int">;
}, "strip", z.ZodTypeAny, {
    type: "int";
}, {
    type: "int";
}>, z.ZodObject<{
    type: z.ZodLiteral<"multipleOf">;
    arg: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    type: "multipleOf";
    arg: number;
}, {
    type: "multipleOf";
    arg: number;
}>, z.ZodObject<{
    type: z.ZodLiteral<"step">;
    arg: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    type: "step";
    arg: number;
}, {
    type: "step";
    arg: number;
}>, z.ZodObject<{
    type: z.ZodLiteral<"positive">;
}, "strip", z.ZodTypeAny, {
    type: "positive";
}, {
    type: "positive";
}>, z.ZodObject<{
    type: z.ZodLiteral<"negative">;
}, "strip", z.ZodTypeAny, {
    type: "negative";
}, {
    type: "negative";
}>, z.ZodObject<{
    type: z.ZodLiteral<"max">;
    arg: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    type: "max";
    arg: number;
}, {
    type: "max";
    arg: number;
}>]>;
export type StringValidatorArray = z.TypeOf<typeof stringValidatorSig>[];
export interface PluginStringSetting extends PluginSettingBase<string> {
    multiline?: boolean;
    validators?: StringValidatorArray;
}
export type NumberValidatorArray = z.TypeOf<typeof numberValidatorSig>[];
export interface PluginNumberSetting extends PluginSettingBase<number> {
    validators?: NumberValidatorArray;
}
export interface SlashCommand extends Command_DUPE_2 {
    quickCode?: string;
}
export declare enum QueueInteractionScore {
    TOO_EARLY = 0.01,
    AGAIN = 0,
    HARD = 0.5,
    GOOD = 1,
    EASY = 1.5,
    VIEWED_AS_LEECH = 2,
    RESET = 3,
    MANUAL_DATE = 4,
    MANUAL_EASE = 5
}
export interface CardData {
    _id: RemId;
    owner: KnowledgeBaseId;
    remId: string;
    cardType: 'f' | 'b' | string;
    createdAt: number;
    history?: RepetitionStatusInterface[];
    nextTime: number;
    activeNextTime?: number;
    timesWrongInRow?: number;
    lastRepetitionTime?: number;
    doesntRequireInternetActiveNextTime?: number;
}
export interface RemData {
    _id: RemId;
    owner: KnowledgeBaseId;
    parent: RemId | null;
    children: RemId[] | undefined;
    type: RemType;
    text: RichTextInterface | undefined;
    backText?: RichTextInterface;
    u: number;
    o: number;
    createdAt: number;
}
export type PluginCardType = 'forward' | 'backward' | {
    clozeId: string;
};
export declare enum EmbedComponentType {
    Queue = "Queue",
    PreviewRemCards = "ViewAsCard",
    LoadingSpinner = "LoadingSpinner",
    RichTextEditor = "RichTextEditor",
    RichText = "RichTextViewer",
    RemRichTextEditor = "RemRichTextEditor",
    RemViewer = "RemViewer",
    RemHierarchyEditorTree = "RemHierarchyEditorTree",
    PDFWebReader = "PDFWebReader",
    DocumentViewer = "DocumentViewer"
}
export declare const RICH_TEXT_ELEMENT_TYPE: {
    readonly REM: "q";
    readonly IMAGE: "i";
    readonly AUDIO: "a";
    readonly PLUGIN: "p";
    readonly DRAWING: "r";
    readonly GLOBAL_NAME: "g";
    readonly DEPRECATED_CODE: "o";
    readonly ANNOTATION: "n";
    readonly TEXT: "m";
    readonly LATEX: "x";
    readonly CARD_DELIMITER: "s";
    readonly FLASHCARD_ICON: "fi";
    readonly DYNAMIC_ICON: "di";
    readonly ADD_ICON: "ai";
};
export declare const RICH_TEXT_FORMATTING: {
    readonly CLOZE: "cId";
    readonly UNDERLINE: "u";
    readonly SUBSCRIPT: "sub";
    readonly SUPERSCRIPT: "sup";
    readonly BOLD: "b";
    readonly STRIKETHROUGH: "str";
    readonly ITALIC: "l";
    readonly INLINE_LINK: "qId";
    readonly INLINE_CODE: "q";
    readonly QUOTE: "qt";
    readonly HIDDEN_CLOZE: "hiddenCloze";
    readonly REVEALED_CLOZE: "revealedCloze";
    readonly HIGHLIGHT: "h";
    readonly TEXT_COLOR: "tc";
    readonly DEPRECATED_LINK: "url";
    readonly CODE: "code";
    readonly CODE_LANGUAGE: "language";
    readonly COMMENT_ID: "c";
    readonly CLOZE_HINT: "cloze-hint";
    readonly CARD_HINT_FRONT: "card-hint-front";
    readonly CARD_HINT_BACK: "card-hint-back";
    readonly MULTILINE_CARD_HINT: "multiline-card-item-hint";
};
export type RICH_TEXT_FORMATTING_KEYS = keyof typeof RICH_TEXT_FORMATTING;
export type RICH_TEXT_FORMATTING_VALUES = (typeof RICH_TEXT_FORMATTING)[RICH_TEXT_FORMATTING_KEYS];
export type RichTextFormattingTypeInterface = 'cId' | 'u' | 'b' | 'l' | 'qId' | 'q' | 'hiddenCloze' | 'revealedCloze' | 'h' | 'url' | 'code' | 'c' | 'language';
export declare const DEPRECATED_RICH_TEXT_ELEMENT_TYPES: {
    UNDERLINE: string;
    BOLD: string;
    ITALIC: string;
    INLINE_CODE: string;
    CLOZE: string;
    HIDDEN_CLOZE: string;
    LINK: string;
    HIGHLIGHT: string;
    DATE: string;
};
export type RichTextStoreHighlightColor = string;
export declare const DEPRECATED_RICH_TEXT_FORMATTING_TYPES: {
    LATEX: string;
};
export declare const DEPRECATED_RICH_TEXT_ELEMENT_TYPES_TO_NEW_FORMATTING: {
    [x: string]: boolean | "url" | "b" | "q" | "u" | "l" | "h" | "cId" | "hiddenCloze";
};
export type RichTextImageClozeBlockInterface = {
    x: number;
    y: number;
    width: number;
    height: number;
    rotation: number;
    cId: string;
    label?: RichTextInterface | string;
    frontLabel?: RichTextInterface | string;
    linkedRemId?: RemId | string;
    detectedText?: string;
    primary?: boolean;
};
export type RichTextElementRemInterface = {
    i: 'q';
    _id: RemId;
    aliasId?: RemId | undefined;
    pin?: boolean;
    content?: boolean;
    showFullName?: boolean;
    textOfDeletedRem?: RichTextInterface;
    [RICH_TEXT_FORMATTING.CLOZE]?: string;
};
export type RichTextElementTextInterface = {
    i: 'm';
    text: string;
    workInProgressTag?: boolean;
    workInProgressRem?: boolean;
    workInProgressPortal?: boolean;
    [RICH_TEXT_FORMATTING.CLOZE]?: string;
    [RICH_TEXT_FORMATTING.UNDERLINE]?: boolean;
    [RICH_TEXT_FORMATTING.BOLD]?: boolean;
    [RICH_TEXT_FORMATTING.ITALIC]?: boolean;
    [RICH_TEXT_FORMATTING.INLINE_CODE]?: boolean;
    [RICH_TEXT_FORMATTING.CODE]?: boolean;
    [RICH_TEXT_FORMATTING.REVEALED_CLOZE]?: boolean;
    [RICH_TEXT_FORMATTING.HIDDEN_CLOZE]?: boolean;
    block?: boolean;
    [RICH_TEXT_FORMATTING.HIGHLIGHT]?: number | string;
    [RICH_TEXT_FORMATTING.TEXT_COLOR]?: number | string;
    [RICH_TEXT_FORMATTING.DEPRECATED_LINK]?: string;
    [RICH_TEXT_FORMATTING.CODE_LANGUAGE]?: string;
    title?: string;
    [RICH_TEXT_FORMATTING.INLINE_LINK]?: string;
    [RICH_TEXT_FORMATTING.SUPERSCRIPT]?: string;
    [RICH_TEXT_FORMATTING.SUBSCRIPT]?: string;
    [RICH_TEXT_FORMATTING.STRIKETHROUGH]?: string;
    [RICH_TEXT_FORMATTING.CLOZE_HINT]?: string;
    [RICH_TEXT_FORMATTING.CARD_HINT_FRONT]?: string;
    [RICH_TEXT_FORMATTING.CARD_HINT_BACK]?: string;
    [RICH_TEXT_FORMATTING.MULTILINE_CARD_HINT]?: string;
};
type ClozeIdentifier = any;
export type RichTextImageInterface = {
    i: 'i';
    url: string;
    blocks?: RichTextImageClozeBlockInterface[];
    clozeOrder?: ClozeIdentifier[];
    width?: number;
    height?: number;
    percent?: 5 | 25 | 50 | 100 | undefined;
    loading?: boolean;
    title?: string;
    transparent?: boolean;
    imgId?: string;
    practiceInOrder?: boolean;
    openOcclusionPopup?: boolean;
    label?: RichTextInterface;
    frontLabel?: RichTextInterface;
};
export type RichTextAudioInterface = {
    i: 'a';
    url: string;
    onlyAudio?: boolean;
    width?: number;
    height?: number;
    percent?: 25 | 50 | 100 | undefined;
};
export type RichTextPluginInterface = {
    i: 'p';
    url: string;
    pluginName?: string;
};
export type RichTextLatexInterface = {
    i: 'x';
    text: string;
    block?: boolean;
    cId?: string;
    latexClozes?: string[];
};
export type RichTextGlobalNameInterface = {
    i: 'g';
    _id: string | null;
};
export type RichTextCardDelimiterInterface = {
    i: 's';
    delimiterCharacterForSerialization?: string;
};
export type RichTextFlashcardIconInterface = {
    i: 'fi';
    size?: string;
};
export type RichTextAddIconInterface = {
    i: 'ai';
    size?: string;
};
export type RichTextDynamicIconInterface = {
    i: 'di';
    icon?: string;
    size?: string;
};
export type RichTextAnnotationInterface = {
    i: 'n';
    url: string;
    text: string;
    highlighterSerialization: {
        text: string;
    };
};
export type RichTextElementItemInterface = RichTextElementTextInterface | RichTextElementRemInterface | RichTextImageInterface | RichTextAudioInterface | RichTextPluginInterface | RichTextGlobalNameInterface | RichTextLatexInterface | RichTextCardDelimiterInterface | RichTextAnnotationInterface | RichTextFlashcardIconInterface | RichTextAddIconInterface | RichTextDynamicIconInterface;
export type RichTextElementInterface = RichTextElementItemInterface | (string & {
    i?: undefined;
});
export type RichTextInterface = RichTextElementInterface[];
export declare enum PORTAL_TYPE {
    PORTAL,
    EMBEDDED_QUEUE = 2,
    SCAFFOLD = 3,
    SEARCH_PORTAL = 4
}
export interface RepetitionStatusInterface {
    date: number;
    score: QueueInteractionScore;
    responseTime?: number;
    isCram?: boolean;
    pluginData?: Record<string, any>;
    /**
     * Scheduled means the date this repetition was originally scheduled for.
     * Different to `date` if the user did the repetition early / late.
     */
    scheduled?: number;
}
export interface WidgetLocationContextDataMap {
    [WidgetLocation.LeftSidebar]: undefined;
    [WidgetLocation.RightSidebar]: undefined;
    [WidgetLocation.FloatingWidget]: {
        floatingWidgetId: string;
    };
    [WidgetLocation.PaneHeader]: {
        paneId: string;
    };
    [WidgetLocation.Index]: undefined;
    [WidgetLocation.TopBar]: undefined;
    [WidgetLocation.QueueToolbar]: {
        cardId?: string;
        remId?: string;
    };
    [WidgetLocation.QueueBelowTopBar]: {
        cardId?: string;
        remId?: string;
    };
    [WidgetLocation.DocumentAboveToolbar]: {
        documentId: string;
    };
    [WidgetLocation.DocumentBelowToolbar]: {
        documentId: string;
    };
    [WidgetLocation.DocumentBelowEditor]: {
        documentId: string;
    };
    [WidgetLocation.DocumentBelowTitle]: {
        documentId: string;
    };
    [WidgetLocation.SidebarEnd]: undefined;
    [WidgetLocation.RemReferencePopupStart]: {
        remId: string;
    };
    [WidgetLocation.RemReferencePopupRight]: {
        remId: string;
    };
    [WidgetLocation.Pane]: {
        paneId: string;
        contextData: any;
    };
    [WidgetLocation.Flashcard]: {
        remId: string;
        cardId?: string;
        revealed: boolean;
    };
    [WidgetLocation.FlashcardAnswerButtons]: {
        remId: string;
        cardId?: string;
        revealed: boolean;
    };
    [WidgetLocation.FlashcardAnswer]: {
        remId: string;
        cardId?: string;
        revealed: boolean;
    };
    [WidgetLocation.FlashcardExtraDetail]: {
        remId: string;
        cardId?: string;
        revealed: boolean;
    };
    [WidgetLocation.FlashcardUnder]: {
        remId: string;
        cardId?: string;
        revealed: boolean;
    };
    [WidgetLocation.Popup]: {
        focusedRemId?: string;
        focusedPortalId?: string;
        contextData: any;
    };
    [WidgetLocation.UnderRemEditor]: {
        remId: string;
    };
    [WidgetLocation.RightSideOfEditor]: {
        remId: string;
    };
    [WidgetLocation.SelectedTextMenu]: undefined;
    [WidgetLocation.PDFHighlightToolbarLocation]: {
        remId?: string;
    };
    [WidgetLocation.PDFHighlightPopupLocation]: {
        remId?: string;
    };
    [WidgetLocation.DeckPage]: undefined;
    [WidgetLocation.LearningProgressPage]: undefined;
}
export declare enum MoveUnit {
    OFFSET = 0,
    UNIT = 1,
    CHARACTER = 2,
    WORD = 3,
    WORD_START = 4,
    WORD_END = 5,
    LINE = 6
}
export type PluginSchedulerParameter = (PluginNumberSetting & {
    type: 'number';
}) | (PluginStringSetting & {
    type: 'string';
}) | (PluginDropdownSetting & {
    type: 'dropdown';
}) | (PluginSettingBase<boolean> & {
    type: 'boolean';
});
export type PluginSchedulerParameterWithValue = (PluginNumberSetting & {
    type: 'number';
    value: number | undefined;
}) | (PluginStringSetting & {
    type: 'string';
    value: string | undefined;
}) | (PluginDropdownSetting & {
    type: 'dropdown';
    value: string | undefined;
}) | (PluginSettingBase<boolean> & {
    type: 'boolean';
    value: boolean | undefined;
});
export declare enum SpecialPluginCallback {
    SRSScheduleCard = "SRSScheduleCard",
    GetNextCard = "GetNextCard"
}
export interface PluginQueueCardData {
    remId: string;
    pluginId: string;
}
export declare enum SchedulerExplanationType {
    RetrievabilityPeriodPreExam = "pre_exam",
    MaintenancePeriod = "maintenance_period",
    EnterConsolidationPeriod = "enter_consolidation_period",
    ConsolidationPeriod = "consolidation_period",
    NotGoodEnoughForExam = "exam_not_good",
    PostponedExamStartDate = "postpone_start",
    NormalRepetition = "normal_repetition"
}
export declare const EXAM_SCHEDULER_EXPLANATION_TYPES: SchedulerExplanationType[];
export type NextSchedulerExplanation = {
    type: SchedulerExplanationType;
    examId?: RemId;
    text?: string;
};
export interface SpecialPluginCallbackInfo {
    [SpecialPluginCallback.SRSScheduleCard]: (args: {
        history: RepetitionStatusInterface[];
        schedulerParameters: Record<string, unknown>;
        cardId: string | undefined;
        remId: string | undefined;
    }) => Promise<{
        nextDate: number;
        explanation?: NextSchedulerExplanation;
        pluginData?: Record<string, any>;
    }>;
    [SpecialPluginCallback.GetNextCard]: (args: {
        mode: 'practice-all' | 'in-order' | 'normal';
        cardsPracticed: number;
        subQueueId: string | undefined;
        numCardsRemaining: number;
    }) => Promise<PluginQueueCardData | null>;
}
export type SRSScheduleCardParams = Parameters<SpecialPluginCallbackInfo[SpecialPluginCallback.SRSScheduleCard]>[0];
export type SRSScheduleCardResult = Awaited<ReturnType<SpecialPluginCallbackInfo[SpecialPluginCallback.SRSScheduleCard]>>;
export declare enum SelectSourceType {
    Enum,
    AnyRem = "any",
    Relation = "relation"
}
export declare enum PageType_DUPE_1 {
    Queue = "Queue"
}
export type OperatingSystem = 'mac' | 'windows' | 'linux' | 'ios' | 'android';
export type Platform = 'app' | 'web';
export declare enum PropertyLocation {
    RIGHT = "right",
    BELOW = "label",
    ONLY_DOCUMENT = "only_document",
    ONLY_IN_TABLE = "only_table",
    INLINE
}
export interface SearchPortalUnaryQueryNode {
    exp: QueryNodeType.Not;
    exp1: SearchPortalQuery;
}
export interface SearchPortalGroupQueryNode {
    exp: QueryNodeType.And | QueryNodeType.Or;
    exps: SearchPortalQuery[];
    cannotRemove?: boolean;
}
export declare enum GetCardInfoNodeCardFields {
    NumReviews = "num_reviews",
    DueDate = "due_date",
    IsEnabled = "is_enabled",
    IsDue = "is_due",
    IsLeech = "is_leech",
    CardMasteryLevel = "card_mastery_level",
    CreatedAt = "created_at"
}
export interface SearchPortalGetCardInfoQueryNode {
    exp: QueryNodeType.GetCardInfo;
    cardField: GetCardInfoNodeCardFields;
    exp1: SearchPortalQuery;
}
export interface SearchPortalSlotQueryNode {
    exp: QueryNodeType.GetSlot;
    slotRemId: RemId | undefined;
    exps: SearchPortalQuery;
}
export interface SearchPortalCardInfoQueryNode {
    exp: QueryNodeType.GetCardInfo;
    cardField?: GetCardInfoNodeCardFields;
    exp1: SearchPortalQuery;
}
export interface SearchPortalRefQueryExpression {
    exp: QueryNodeType.Expression;
    refType: QueryExpressionType.Reference | QueryExpressionType.Portal | QueryExpressionType.Tag | QueryExpressionType.TagWithoutInheritance | QueryExpressionType.IsDescendantOf | QueryExpressionType.InDocument | QueryExpressionType.Connection;
    remId: RemId | undefined;
    cannotRemove?: boolean;
    cannotAdd?: boolean;
}
export type QueryRemType = 'concept' | 'descriptor' | 'none';
export interface SearchPortalRemTypeQueryExpression {
    exp: QueryNodeType.Expression;
    refType: QueryExpressionType.RemType;
    remType: QueryRemType;
}
export interface SearchPortalTextQueryExpression {
    exp: QueryNodeType.Expression;
    refType: QueryExpressionType.Text;
    text: string;
    matcherType: TextMatcher;
}
export interface SearchPortalNumberQueryExpression {
    exp: QueryNodeType.Expression;
    refType: QueryExpressionType.Number;
    text: string;
    matcherType: NumberMatcher;
}
export interface SearchPortalDateQueryExpression {
    exp: QueryNodeType.Expression;
    refType: QueryExpressionType.Date;
    date?: string;
    optionalDate?: string;
    dateRelativeMatcher?: RelativeDateMatcher;
    optionalDateRelativeMatcher?: RelativeDateMatcher;
    relativeDateModifier?: RelativeDateModifier;
    relativePeriodOffset?: number;
    relativeDatePeriod?: RelativeDatePeriod;
    matcherType: DateMatcher;
}
export interface SearchPortalMultiSelectQueryExpression {
    exp: QueryNodeType.Expression;
    refType: QueryExpressionType.MultiSelect;
    matcherType: MultiSelectMatcher;
    remIds?: RemId[];
}
export interface LegacySearchPortalSingleSelectQueryExpression {
    exp: QueryNodeType.Expression;
    refType: QueryExpressionType.LegacySingleSelect;
    matcherType: SingleSelectMatcher;
    remId?: RemId;
}
export interface SearchPortalSingleSelectQueryExpression {
    exp: QueryNodeType.Expression;
    refType: QueryExpressionType.SingleSelect;
    matcherType: SingleSelectMatcher;
    remIds?: RemId[];
}
export interface SearchPortalCheckboxQueryExpression {
    exp: QueryNodeType.Expression;
    refType: QueryExpressionType.Checkbox;
    value: CheckboxMatcher;
}
export type SearchPortalQueryExpression = SearchPortalRefQueryExpression | SearchPortalTextQueryExpression | SearchPortalNumberQueryExpression | SearchPortalRemTypeQueryExpression | SearchPortalDateQueryExpression | SearchPortalMultiSelectQueryExpression | SearchPortalSingleSelectQueryExpression | LegacySearchPortalSingleSelectQueryExpression | SearchPortalCheckboxQueryExpression | SearchPortalDateQueryExpression;
export type SearchPortalQuery = SearchPortalUnaryQueryNode | SearchPortalGroupQueryNode | SearchPortalSlotQueryNode | SearchPortalQueryExpression | SearchPortalCardInfoQueryNode;
export declare enum QueryExpressionType {
    Text = "Text",
    Reference = "Reference",
    Portal = "Portal",
    Tag = "Tag",
    TagWithoutInheritance = "TagWithoutInheritance",
    Connection = "Connection",
    IsDescendantOf = "IsDescendantOf",
    InDocument = "InDocument",
    RemType = "RemType",
    Date = "Date",
    MultiSelect = "Multi Select",
    LegacyMultiSelect = "MultiSelect",
    SingleSelect = "Single Select",
    LegacySingleSelect = "SingleSelect",
    Checkbox = "Checkbox",
    Number = "NumberExpression"
}
export declare enum QueryNodeType {
    Or = "or",
    And = "and",
    Not = "not",
    Expression = "expression",
    GetSlot = "get_slot",
    GetCardInfo = "get_card_info"
}
export declare const SearchPortalUnaryQueryNode: z.ZodType<SearchPortalUnaryQueryNode>;
export declare const SearchPortalGroupQueryNode: z.ZodType<SearchPortalGroupQueryNode>;
export declare const SearchPortalSlotQueryNode: z.ZodType<SearchPortalSlotQueryNode>;
export declare const SearchPortalGetCardInfoQueryNode: z.ZodType<SearchPortalGetCardInfoQueryNode>;
export declare const SearchPortalRefQueryExpression: z.ZodType<SearchPortalRefQueryExpression>;
export declare const QueryRemType: z.ZodType<QueryRemType>;
export declare const SearchPortalRemTypeQueryExpression: z.ZodType<SearchPortalRemTypeQueryExpression>;
export declare enum CheckboxMatcher {
    Checked = "checked",
    Unchecked = "unchecked"
}
export declare enum TextMatcher {
    Contains = "contains",
    DoesNotContain = "doesNotContain",
    Is = "is",
    IsNot = "notIs",
    StartsWith = "startsWith",
    EndsWith = "endsWith",
    IsEmpty = "empty",
    IsNotEmpty = "notEmpty",
    DefaultContains = ""
}
export declare const TextMatchersAllowedWithoutPrimaryQuery: TextMatcher[];
export declare enum NumberMatcher {
    Is = "is",
    IsNot = "notIs",
    GreaterThan = "greaterThan",
    LessThan = "lessThan",
    GreaterThanOrEquals = "greaterThanOrEquals",
    LessThanOrEquals = "lessThanOrEquals",
    IsEmpty = "notEmpty",
    IsNotEmpty = "empty"
}
export declare enum DateMatcher {
    Is = "is",
    IsBefore = "before",
    IsAfter = "after",
    IsOnOrBefore = "onOrBefore",
    IsOnOrAfter = "onOrAfter",
    IsBetween = "between",
    IsRelativeToToday = "relativeToToday",
    IsEmpty = "empty",
    IsNotEmpty = "notEmpty"
}
export declare enum RelativeDateMatcher {
    Today = "today",
    StartOfTheWeek = "startoftheweek",
    StartOfTheMonth = "startofthemonth",
    StartOfTheYear = "startoftheyear",
    EndOfTheWeek = "endoftheweek",
    EndOfTheMonth = "endofthemonth",
    EndOfTheYear = "endoftheyear"
}
export declare const RelativeDateMatcherToLabel: Record<RelativeDateMatcher, string>;
export declare enum MultiSelectMatcher {
    Contains = "contains",
    DoesNotContain = "doesNotContains",
    IsEmpty = "empty",
    IsNotEmpty = "notEmpty"
}
export declare enum SingleSelectMatcher {
    Is = "is",
    IsNot = "notIs",
    IsEmpty = "empty",
    IsNotEmpty = "notEmpty"
}
export declare const NonRelativeMatcherTypes: DateMatcher[];
export declare enum RelativeDateModifier {
    Past = "past",
    Next = "next",
    This = "this"
}
export declare enum RelativeDatePeriod {
    Day = "day",
    Week = "week",
    Month = "month",
    Year = "year"
}
export declare const TextMatcherTypesToDisplayValue: Record<TextMatcher, string>;
export declare const DateMatcherTypesToDisplayValue: Record<DateMatcher, string>;
export declare const NumberMatcherTypesToDisplayValue: Record<NumberMatcher, string>;
export declare const MultiSelectMatcherTypesToDisplayValue: Record<MultiSelectMatcher, string>;
export declare const SingleSelectMatcherTypesToDisplayValue: Record<SingleSelectMatcher, string>;
export declare const SearchPortalTextQueryExpression: z.ZodType<SearchPortalTextQueryExpression>;
export declare const SearchPortalNumberQueryExpression: z.ZodType<SearchPortalNumberQueryExpression>;
export declare const SearchPortalDateQueryExpression: z.ZodType<SearchPortalDateQueryExpression>;
export declare const SearchPortalMultiSelectQueryExpression: z.ZodType<SearchPortalMultiSelectQueryExpression>;
export declare const LegacySearchPortalSingleSelectQueryExpression: z.ZodType<LegacySearchPortalSingleSelectQueryExpression>;
export declare const SearchPortalCheckboxQueryExpression: z.ZodType<SearchPortalCheckboxQueryExpression>;
export declare const SearchPortalSingleSelectQueryExpression: z.ZodType<SearchPortalSingleSelectQueryExpression>;
export declare const SearchPortalQueryExpression: z.ZodType<SearchPortalQueryExpression>;
export declare const SearchPortalQuery: z.ZodType<SearchPortalQuery>;
export declare const RegisterPropertyOptions: z.ZodObject<{
    code: z.ZodString;
    name: z.ZodString;
    onlyProgrammaticModifying: z.ZodOptional<z.ZodBoolean>;
    hidden: z.ZodOptional<z.ZodBoolean>;
    enumValues: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    defaultEnumValue: z.ZodOptional<z.ZodString>;
    propertyType: z.ZodOptional<z.ZodNativeEnum<typeof PropertyType>>;
    propertyLocation: z.ZodOptional<z.ZodNativeEnum<typeof PropertyLocation>>;
    selectSourceType: z.ZodOptional<z.ZodNativeEnum<typeof SelectSourceType>>;
    dontPublishToSharedArticle: z.ZodOptional<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    code: string;
    name: string;
    onlyProgrammaticModifying?: boolean | undefined;
    hidden?: boolean | undefined;
    enumValues?: Record<string, string> | undefined;
    defaultEnumValue?: string | undefined;
    propertyType?: PropertyType | undefined;
    propertyLocation?: PropertyLocation | undefined;
    selectSourceType?: SelectSourceType | undefined;
    dontPublishToSharedArticle?: boolean | undefined;
}, {
    code: string;
    name: string;
    onlyProgrammaticModifying?: boolean | undefined;
    hidden?: boolean | undefined;
    enumValues?: Record<string, string> | undefined;
    defaultEnumValue?: string | undefined;
    propertyType?: PropertyType | undefined;
    propertyLocation?: PropertyLocation | undefined;
    selectSourceType?: SelectSourceType | undefined;
    dontPublishToSharedArticle?: boolean | undefined;
}>;
export declare const RegisterPowerupOptions: z.ZodUnion<[z.ZodObject<{
    slots: z.ZodArray<z.ZodObject<{
        code: z.ZodString;
        name: z.ZodString;
        onlyProgrammaticModifying: z.ZodOptional<z.ZodBoolean>;
        hidden: z.ZodOptional<z.ZodBoolean>;
        enumValues: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        defaultEnumValue: z.ZodOptional<z.ZodString>;
        propertyType: z.ZodOptional<z.ZodNativeEnum<typeof PropertyType>>;
        propertyLocation: z.ZodOptional<z.ZodNativeEnum<typeof PropertyLocation>>;
        selectSourceType: z.ZodOptional<z.ZodNativeEnum<typeof SelectSourceType>>;
        dontPublishToSharedArticle: z.ZodOptional<z.ZodBoolean>;
    }, "strip", z.ZodTypeAny, {
        code: string;
        name: string;
        onlyProgrammaticModifying?: boolean | undefined;
        hidden?: boolean | undefined;
        enumValues?: Record<string, string> | undefined;
        defaultEnumValue?: string | undefined;
        propertyType?: PropertyType | undefined;
        propertyLocation?: PropertyLocation | undefined;
        selectSourceType?: SelectSourceType | undefined;
        dontPublishToSharedArticle?: boolean | undefined;
    }, {
        code: string;
        name: string;
        onlyProgrammaticModifying?: boolean | undefined;
        hidden?: boolean | undefined;
        enumValues?: Record<string, string> | undefined;
        defaultEnumValue?: string | undefined;
        propertyType?: PropertyType | undefined;
        propertyLocation?: PropertyLocation | undefined;
        selectSourceType?: SelectSourceType | undefined;
        dontPublishToSharedArticle?: boolean | undefined;
    }>, "many">;
}, "strip", z.ZodTypeAny, {
    slots: {
        code: string;
        name: string;
        onlyProgrammaticModifying?: boolean | undefined;
        hidden?: boolean | undefined;
        enumValues?: Record<string, string> | undefined;
        defaultEnumValue?: string | undefined;
        propertyType?: PropertyType | undefined;
        propertyLocation?: PropertyLocation | undefined;
        selectSourceType?: SelectSourceType | undefined;
        dontPublishToSharedArticle?: boolean | undefined;
    }[];
}, {
    slots: {
        code: string;
        name: string;
        onlyProgrammaticModifying?: boolean | undefined;
        hidden?: boolean | undefined;
        enumValues?: Record<string, string> | undefined;
        defaultEnumValue?: string | undefined;
        propertyType?: PropertyType | undefined;
        propertyLocation?: PropertyLocation | undefined;
        selectSourceType?: SelectSourceType | undefined;
        dontPublishToSharedArticle?: boolean | undefined;
    }[];
}>, z.ZodObject<{
    properties: z.ZodArray<z.ZodObject<{
        code: z.ZodString;
        name: z.ZodString;
        onlyProgrammaticModifying: z.ZodOptional<z.ZodBoolean>;
        hidden: z.ZodOptional<z.ZodBoolean>;
        enumValues: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        defaultEnumValue: z.ZodOptional<z.ZodString>;
        propertyType: z.ZodOptional<z.ZodNativeEnum<typeof PropertyType>>;
        propertyLocation: z.ZodOptional<z.ZodNativeEnum<typeof PropertyLocation>>;
        selectSourceType: z.ZodOptional<z.ZodNativeEnum<typeof SelectSourceType>>;
        dontPublishToSharedArticle: z.ZodOptional<z.ZodBoolean>;
    }, "strip", z.ZodTypeAny, {
        code: string;
        name: string;
        onlyProgrammaticModifying?: boolean | undefined;
        hidden?: boolean | undefined;
        enumValues?: Record<string, string> | undefined;
        defaultEnumValue?: string | undefined;
        propertyType?: PropertyType | undefined;
        propertyLocation?: PropertyLocation | undefined;
        selectSourceType?: SelectSourceType | undefined;
        dontPublishToSharedArticle?: boolean | undefined;
    }, {
        code: string;
        name: string;
        onlyProgrammaticModifying?: boolean | undefined;
        hidden?: boolean | undefined;
        enumValues?: Record<string, string> | undefined;
        defaultEnumValue?: string | undefined;
        propertyType?: PropertyType | undefined;
        propertyLocation?: PropertyLocation | undefined;
        selectSourceType?: SelectSourceType | undefined;
        dontPublishToSharedArticle?: boolean | undefined;
    }>, "many">;
}, "strip", z.ZodTypeAny, {
    properties: {
        code: string;
        name: string;
        onlyProgrammaticModifying?: boolean | undefined;
        hidden?: boolean | undefined;
        enumValues?: Record<string, string> | undefined;
        defaultEnumValue?: string | undefined;
        propertyType?: PropertyType | undefined;
        propertyLocation?: PropertyLocation | undefined;
        selectSourceType?: SelectSourceType | undefined;
        dontPublishToSharedArticle?: boolean | undefined;
    }[];
}, {
    properties: {
        code: string;
        name: string;
        onlyProgrammaticModifying?: boolean | undefined;
        hidden?: boolean | undefined;
        enumValues?: Record<string, string> | undefined;
        defaultEnumValue?: string | undefined;
        propertyType?: PropertyType | undefined;
        propertyLocation?: PropertyLocation | undefined;
        selectSourceType?: SelectSourceType | undefined;
        dontPublishToSharedArticle?: boolean | undefined;
    }[];
}>]>;
export type RegisterPowerupOptions = z.infer<typeof RegisterPowerupOptions>;
export declare enum QueueItemType {
    ForwardCard = 1,
    BackwardCard = 2,
    EditInQueue = 3,
    QueueNoticeCard = 4,// unused
    ClozeCard = 5,
    DocumentCard = 6,// unused
    SelectCluster = 7,
    SubFolderSelector = 8,// unused
    DailyTargetGoalSelector = 10,// unused
    StreakGoalSelector = 11,// unused
    AddExtraNewOrStaleCards = 12,
    SignUpToSaveProgress = 14,
    Plugin = 15,
    DailyCheckpoint = 16,
    Checkpoint = 17,
    Leech = 18,
    StartExamPractice = 19,
    EndExamPractice = 20,
    TransitionOutOfActive = 21,
    PracticeBuried = 22,
    PracticeAgainForExamTomorrowSlide = 23,
    OfflineImageCards = 24,
    PrivateCards = 25
}
export declare const QueueItemTypeHumanReadable: {
    1: string;
    2: string;
    3: string;
    4: string;
    5: string;
    6: string;
    7: string;
    8: string;
    10: string;
    11: string;
    12: string;
    14: string;
    15: string;
    16: string;
    21: string;
    17: string;
    18: string;
    19: string;
    20: string;
    22: string;
    23: string;
    24: string;
    25: string;
};
export declare const QueueItemTypeHumanReadableTextToSpeech: {
    18: string;
    1: string;
    2: string;
    3: string;
    4: string;
    5: string;
    6: string;
    7: string;
    8: string;
    10: string;
    11: string;
    12: string;
    14: string;
    15: string;
    16: string;
    21: string;
    17: string;
    19: string;
    20: string;
    22: string;
    23: string;
    24: string;
    25: string;
};