@qxs-bns/components 0.0.90 → 0.0.92

package/types/image-upload.d.ts

@@ -0,0 +1,68 @@
+import { LitElement } from 'lit';
+export type ImageUploadFile = {
+    uid?: string | number;
+    name: string;
+    url?: string;
+    size?: number;
+    status?: 'ready' | 'uploading' | 'success' | 'fail';
+    progress?: number;
+    file?: File;
+};
+export declare class QxsImageUpload extends LitElement {
+    private static _scrollLockCount;
+    private static _previousHtmlOverflow;
+    private static _previousBodyOverflow;
+    static styles: import("lit").CSSResult;
+    action: string;
+    headers?: Record<string, string>;
+    data?: Record<string, string | Blob>;
+    name: string;
+    size: number;
+    width: number;
+    height: number;
+    accept: string;
+    placeholder: string;
+    notip: boolean;
+    tipText: string;
+    disabled: boolean;
+    limit: number;
+    fileList: ImageUploadFile[];
+    private _internalFiles;
+    private _viewerVisible;
+    private _viewerIndex;
+    private _message;
+    private _messageType;
+    private _input?;
+    private _hasScrollLock;
+    private _pendingRequests;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    updated(changed: Map<string, unknown>): void;
+    private get _exts();
+    private get _tipMessage();
+    private _syncFileList;
+    private _setMessage;
+    private _clearMessage;
+    private _revokeFileUrl;
+    private _emitFileListChange;
+    private _emitSuccess;
+    private _getFileKey;
+    private _updateFileByKey;
+    private _emitRemove;
+    private _validateFile;
+    private _handleSelectedFiles;
+    private _handleInputChange;
+    private _uploadFile;
+    private _handlePreview;
+    private _closeViewer;
+    private _prevImage;
+    private _nextImage;
+    private _handleRemove;
+    private _syncScrollLock;
+    render(): import("lit").TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'qxs-image-upload': QxsImageUpload;
+    }
+}

package/types/index.d.ts

@@ -1,6 +1,21 @@
-import installer from './src/defaults';
-export * from './src/components';
-export declare const install: (app: any) => void;
-export declare const version: string;
-export default installer;
-//# sourceMappingURL=index.d.ts.map
+import './entry-subject';
+import './entry-editor';
+import './entry-icon';
+import './entry-fixed-action-bar';
+import './entry-photo-crop-tool';
+import './entry-file-upload';
+import './entry-image-upload';
+import './entry-data-chart';
+export * from './entry-editor';
+export * from './entry-subject';
+export * from './entry-fixed-action-bar';
+export * from './entry-photo-crop-tool';
+export * from './entry-file-upload';
+export * from './entry-image-upload';
+export * from './entry-data-chart';
+export { QxsIcon } from './icon';
+export { QxsFixedActionBar } from './fixed-action-bar';
+export { QxsPhotoCropTool } from './photo-crop-tool';
+export { QxsFileUpload } from './file-upload';
+export { QxsImageUpload } from './image-upload';
+export { QxsDataChart } from './data-chart';

package/types/photo-crop-tool.d.ts

@@ -0,0 +1,43 @@
+import { LitElement } from 'lit';
+type ZoomType = 'fixed' | 'free';
+export declare class QxsPhotoCropTool extends LitElement {
+    static styles: import("lit").CSSResult;
+    imgFile: File | null;
+    aspectRatio: string;
+    defaultWidth: number;
+    defaultHeight: number;
+    zoomType: ZoomType;
+    private _errorMessage;
+    private _imageUrl;
+    private _cropRect;
+    private _imageRect;
+    private _container?;
+    private _image?;
+    private _resizeObserver;
+    private _dragType;
+    private _dragOrigin;
+    private _dragStartRect;
+    private _pendingReset;
+    private _rafId;
+    connectedCallback(): void;
+    firstUpdated(): void;
+    disconnectedCallback(): void;
+    updated(changed: Map<string, unknown>): void;
+    crop(): Promise<File | null>;
+    resize(): void;
+    private _applyImageFile;
+    private _revokeImageUrl;
+    private _scheduleLayoutSync;
+    private _syncImageRect;
+    private _resetCropRect;
+    private _handleImageLoad;
+    private _handlePointerDown;
+    private _handlePointerMove;
+    private _handlePointerUp;
+    private _clampMoveRect;
+    private _resizeByHandle;
+    private _resizeFree;
+    private _resizeFixed;
+    render(): import("lit").TemplateResult<1>;
+}
+export {};

package/types/subject/action.d.ts

@@ -0,0 +1,37 @@
+import { LitElement } from 'lit';
+export declare class QxsSubjectAction extends LitElement {
+    static styles: import("lit").CSSResult[];
+    'is-edit': boolean;
+    'is-set': boolean;
+    'is-key': boolean;
+    'answer-check-type': number;
+    'show-other-option': boolean;
+    'show-answer-setting': boolean;
+    'show-key': boolean;
+    'show-rich-text': boolean;
+    'hide-add-rich-text': boolean;
+    'show-delete-action': boolean;
+    'show-save-action': boolean;
+    'page-end': boolean;
+    'show-move': boolean;
+    'show-add': boolean;
+    'show-jump': boolean;
+    'exam-answer-relation-type': number;
+    private _modalOpen;
+    private _currentCheckType;
+    private _addMenuOpen;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    updated(changed: Map<string, unknown>): void;
+    private _handleDocumentClick;
+    private _emit;
+    private get _answerText();
+    private get _showAnswerSetting();
+    private get _showKey();
+    private _renderEditMode;
+    private _renderViewMode;
+    private _renderModal;
+    private _renderAddMenu;
+    render(): import("lit").TemplateResult<1>;
+}
+export declare function register(): void;

package/types/subject/blank-fill.d.ts

@@ -0,0 +1,79 @@
+import { LitElement } from 'lit';
+import { type Category, type Resource, SubjectError, type TagItem } from './subject-shared';
+export declare class QxsBlankFill extends LitElement {
+    static styles: import("lit").CSSResult[];
+    'order-index': number;
+    'subject-prefix'?: string;
+    title: string;
+    'custom-id': string;
+    'is-edit': boolean;
+    'is-save': boolean;
+    'is-set': boolean;
+    'is-key': boolean;
+    'show-action': boolean;
+    'show-add': boolean;
+    'hide-add-rich-text': boolean;
+    'show-rich-text': boolean;
+    'show-delete-action': boolean;
+    'show-save-action': boolean;
+    sorting: boolean;
+    'show-answer-setting': boolean;
+    'show-analysis': boolean;
+    'rich-text-content': string;
+    analysis: string;
+    'exam-answer-relation-type': number;
+    'exam-expand': string;
+    'exam-id': number;
+    'category-id': string;
+    'exam-answer-setting': {
+        isInOrder: boolean;
+        isIgnoreCase: boolean;
+    };
+    'upload-image': (file: File) => Promise<string>;
+    'answer-list': any[];
+    'tag-list': TagItem[];
+    'category-list': Category[];
+    'resource-list': Resource[];
+    'show-tag': boolean;
+    'show-category': boolean;
+    'show-resource': boolean;
+    'model-value': string;
+    'use-model': boolean;
+    private _title;
+    private _analysis;
+    private _answers;
+    private _isInOrder;
+    private _isIgnoreCase;
+    private _showRichText;
+    private _richText;
+    private _selectedTagList;
+    private _categoryId;
+    private readonly TITLE_MAX;
+    willUpdate(changed: Map<string, unknown>): void;
+    private _normalizeAnswerTitle;
+    private _blankCount;
+    private _syncAnswersToBlankCount;
+    private _syncProps;
+    private _emit;
+    private _addBlank;
+    private _onTitleInput;
+    private _emitModelUpdate;
+    private _handleAddTag;
+    private _closeTag;
+    private _onCategoryChange;
+    private _imageResources;
+    private _videoResource;
+    private _categoryLabel;
+    private _previewAnswerText;
+    private _renderInlineBlankTitle;
+    toJSON(): Promise<any>;
+    private _save;
+    validate(): SubjectError[];
+    private _renderPreview;
+    private _renderCategorySection;
+    private _renderResourceSection;
+    private _renderSorting;
+    private _renderEdit;
+    render(): import("lit").TemplateResult<1>;
+}
+export declare function register(): void;

package/types/subject/draft.d.ts

@@ -0,0 +1,63 @@
+import { type AnswerType, type SubjectItemType, SubjectType } from './types';
+export interface CreateSubjectDraftOptions {
+    examAnswerRelationType?: number | null;
+}
+export declare function createSubjectDraft(type: SubjectItemType, options?: CreateSubjectDraftOptions): {
+    customId: string;
+    answerType: SubjectType;
+} | {
+    examAnswerRelationType?: number | undefined;
+    leastAnswerCount?: null | undefined;
+    examExpand?: string | undefined;
+    answers: {
+        title: string;
+        isCorrect: boolean;
+    }[];
+    customId: string;
+    answerType: AnswerType;
+    title: string;
+    analysis: string;
+    isEdit: boolean;
+    examRichTextContent: string;
+} | {
+    answers: never[];
+    examAnswerSettingBO: {
+        isInOrder: boolean;
+        isIgnoreCase: boolean;
+    };
+    customId: string;
+    answerType: AnswerType;
+    title: string;
+    analysis: string;
+    isEdit: boolean;
+    examRichTextContent: string;
+} | {
+    answers: {
+        title: string;
+        tag: string;
+        showInput: boolean;
+    }[];
+    examAnswerSettingBO: {
+        isInOrder: boolean;
+        isIgnoreCase: boolean;
+    };
+    examExpand: string;
+    customId: string;
+    answerType: AnswerType;
+    title: string;
+    analysis: string;
+    isEdit: boolean;
+    examRichTextContent: string;
+} | {
+    answers: {
+        title: string;
+        orderIndex: number;
+    }[];
+    scaleQuestionList: never[];
+    customId: string;
+    answerType: AnswerType;
+    title: string;
+    analysis: string;
+    isEdit: boolean;
+    examRichTextContent: string;
+};

package/types/subject/index.d.ts

@@ -0,0 +1,13 @@
+import { QxsSubjectAction } from './action';
+import { QxsBlankFill } from './blank-fill';
+import { createSubjectDraft } from './draft';
+import { QxsSubjectLayout } from './layout';
+import { QxsPageEnd } from './page-end';
+import { getPaginationMeta, insertPageBreak, rebuildPageBreaksFromPageIndex, removePageBreak, serializeSubjectsWithPageIndex } from './pagination';
+import { collectSubjectElements, serializeSubjectElements, validateSubjectElements } from './runtime';
+import { QxsScale } from './scale';
+import { QxsSubjectSingle } from './single';
+import { moveSubjectItem, reorderSubjects } from './sort-controller';
+import { QxsSubjectSortable } from './sortable';
+import { QxsTextFill } from './text-fill';
+export { collectSubjectElements, createSubjectDraft, getPaginationMeta, insertPageBreak, moveSubjectItem, QxsBlankFill, QxsPageEnd, QxsScale, QxsSubjectAction, QxsSubjectLayout, QxsSubjectSingle, QxsSubjectSortable, QxsTextFill, rebuildPageBreaksFromPageIndex, removePageBreak, reorderSubjects, serializeSubjectElements, serializeSubjectsWithPageIndex, validateSubjectElements, };

package/types/subject/layout.d.ts

@@ -0,0 +1,7 @@
+import { LitElement } from 'lit';
+export declare class QxsSubjectLayout extends LitElement {
+    static styles: import("lit").CSSResult;
+    'show-edit': boolean;
+    render(): import("lit").TemplateResult<1>;
+}
+export declare function register(): void;

package/types/subject/page-end.d.ts

@@ -0,0 +1,16 @@
+import { LitElement } from 'lit';
+export declare class QxsPageEnd extends LitElement {
+    static styles: import("lit").CSSResult[];
+    'current-page-index': number;
+    'total-page': number;
+    'show-action': boolean;
+    'show-add': boolean;
+    'show-delete-action': boolean;
+    'custom-id': string;
+    sorting: boolean;
+    private _emit;
+    toJSON(): Promise<any>;
+    validate(): never[];
+    render(): import("lit").TemplateResult<1>;
+}
+export declare function register(): void;

package/types/subject/pagination.d.ts

@@ -0,0 +1,23 @@
+export interface SubjectLikeItem {
+    answerType: string;
+    customId?: string;
+    pageIndex?: number;
+    [key: string]: any;
+}
+export interface PageBreakItem extends SubjectLikeItem {
+    answerType: 'page_end';
+    customId: string;
+}
+export interface PaginationMetaItem {
+    customId: string;
+    currentPageIndex: number;
+    totalPage: number;
+    itemIndex: number;
+}
+export declare function isPageBreakItem(item: SubjectLikeItem | null | undefined): item is PageBreakItem;
+export declare function normalizePageBreaks(items: SubjectLikeItem[]): SubjectLikeItem[];
+export declare function rebuildPageBreaksFromPageIndex(items: SubjectLikeItem[]): SubjectLikeItem[];
+export declare function serializeSubjectsWithPageIndex(items: SubjectLikeItem[]): SubjectLikeItem[];
+export declare function insertPageBreak(items: SubjectLikeItem[], index?: number): SubjectLikeItem[];
+export declare function removePageBreak(items: SubjectLikeItem[], customId: string): SubjectLikeItem[];
+export declare function getPaginationMeta(items: SubjectLikeItem[]): PaginationMetaItem[];

package/types/subject/runtime.d.ts

@@ -0,0 +1,12 @@
+import { SubjectError } from './subject-shared';
+export declare const SUBJECT_ELEMENT_SELECTOR: string;
+export type SubjectElement = HTMLElement & {
+    toJSON?: () => Promise<any>;
+    validate?: () => SubjectError[];
+};
+export declare function collectSubjectElements(root: ParentNode): SubjectElement[];
+export declare function validateSubjectElements(elements: Iterable<SubjectElement>): {
+    valid: boolean;
+    errors: SubjectError[];
+};
+export declare function serializeSubjectElements(elements: Iterable<SubjectElement>): Promise<any[]>;

package/types/subject/scale.d.ts

@@ -0,0 +1,55 @@
+import { LitElement } from 'lit';
+import { SubjectError } from './subject-shared';
+export declare class QxsScale extends LitElement {
+    static styles: import("lit").CSSResult[];
+    'order-index': number;
+    'subject-prefix'?: string;
+    title: string;
+    'custom-id': string;
+    'is-edit': boolean;
+    'is-save': boolean;
+    'is-set': boolean;
+    'show-action': boolean;
+    'show-add': boolean;
+    'hide-add-rich-text': boolean;
+    'show-rich-text': boolean;
+    'show-delete-action': boolean;
+    'show-save-action': boolean;
+    sorting: boolean;
+    'show-analysis': boolean;
+    analysis: string;
+    'rich-text-content': string;
+    'exam-answer-relation-type': number;
+    'upload-image': (file: File) => Promise<string>;
+    get 'answer-list'(): any;
+    set 'answer-list'(value: any);
+    get 'scale-question-list'(): any;
+    set 'scale-question-list'(value: any);
+    get 'scale-questions'(): any;
+    set 'scale-questions'(value: any);
+    private _answers;
+    private _scaleQuestions;
+    private _rowTitle;
+    private _title;
+    private _analysis;
+    private _showRichText;
+    private _richText;
+    'model-value': string;
+    'use-model': boolean;
+    private readonly TITLE_MAX;
+    willUpdate(changed: Map<string, unknown>): void;
+    private _syncProps;
+    private _emit;
+    private _onTitleInput;
+    private _resolvedQuestions;
+    private _resolvedAnswers;
+    private _createAnswerCountError;
+    toJSON(): Promise<any>;
+    private _save;
+    validate(): SubjectError[];
+    private _renderPreview;
+    private _renderEdit;
+    private _renderSorting;
+    render(): import("lit").TemplateResult<1>;
+}
+export declare function register(): void;

package/types/subject/shared-methods.d.ts

@@ -0,0 +1,8 @@
+export declare function emitSubjectEvent(host: EventTarget, name: string, detail?: unknown): void;
+export declare function emitSubjectModelValue(host: EventTarget, value: string): void;
+export declare function showSubjectToast(msg: string): void;
+export declare function getSubjectImageResources(resourceList?: any[]): string[];
+export declare function getSubjectVideoResource(resourceList?: any[]): any;
+export declare function resolveSubjectCategoryLabel(categoryList?: any[], categoryId?: string | number): any;
+export declare function buildSubjectPreviewTitle(subjectPrefix: unknown, orderIndex: number, title: string): string;
+export declare function buildSubjectSortingTitle(subjectPrefix: unknown, orderIndex: number, title: string): string;

package/types/subject/shared-styles.d.ts

@@ -0,0 +1,5 @@
+export declare const subjectControlResetStyles: import("lit").CSSResult;
+export declare const subjectHostStyles: import("lit").CSSResult;
+export declare const subjectPreviewBaseStyles: import("lit").CSSResult;
+export declare const subjectFormBaseStyles: import("lit").CSSResult;
+export declare const subjectTextareaStyles: import("lit").CSSResult;

package/types/subject/single-interactions.d.ts

@@ -0,0 +1,46 @@
+import type { AnswerType } from './types';
+import { type SearchResult, SubjectError } from './subject-shared';
+export interface SingleSearchDependencies {
+    answerType: AnswerType;
+    query: string;
+    searchApi?: string;
+    searchHandler?: (query: string, answerType: number) => Promise<SearchResult[]>;
+    fetcher?: typeof fetch;
+}
+export interface SingleSearchSelection {
+    selectedTitle: string;
+    detail: SearchResult & {
+        id: string | number;
+        customId: string;
+    };
+}
+export interface SingleDialogState {
+    correctHintDialogOpen: boolean;
+    changeTypeDialogOpen: boolean;
+    hasShownCorrectHint: boolean;
+}
+export type SingleSaveDecision = {
+    kind: 'error';
+    error: SubjectError;
+} | {
+    kind: 'confirm-change-type';
+} | {
+    kind: 'confirm-correct-hint';
+} | {
+    kind: 'save';
+};
+export declare function resolveSingleSearchAnswerType(type: AnswerType): 0 | 1 | 5;
+export declare function hasSingleSearchSource(searchApi?: string, searchHandler?: SingleSearchDependencies['searchHandler']): boolean;
+export declare function normalizeSingleSearchResults(payload: any): SearchResult[];
+export declare function buildSingleSearchUrl(searchApi: string, query: string, answerType: number): string;
+export declare function searchSingleSubjects({ answerType, query, searchApi, searchHandler, fetcher, }: SingleSearchDependencies): Promise<SearchResult[]>;
+export declare function buildSingleSearchSelection(item: SearchResult, customId?: string): SingleSearchSelection;
+export declare function resolveSingleSaveDecision({ errors, hasShownCorrectHint, shouldShowCorrectHint, }: {
+    errors: SubjectError[];
+    hasShownCorrectHint: boolean;
+    shouldShowCorrectHint: boolean;
+}): SingleSaveDecision;
+export declare function applySingleSaveDecisionToDialogs(state: SingleDialogState, decision: SingleSaveDecision): SingleDialogState;
+export declare function dismissSingleCorrectHintDialog(state: SingleDialogState): SingleDialogState;
+export declare function acknowledgeSingleCorrectHint(state: SingleDialogState): SingleDialogState;
+export declare function dismissSingleChangeTypeDialog(state: SingleDialogState): SingleDialogState;

package/types/subject/single-model.d.ts

@@ -0,0 +1,88 @@
+import type { AnswerType } from './types';
+import { SubjectError, type TagItem } from './subject-shared';
+export interface SingleAnswer {
+    title: string;
+    isCorrect: boolean;
+    customAnswerId?: string | number;
+    answerId?: string | number;
+    resultItem?: string;
+    orderIndex?: number;
+    answerRelations?: any[];
+    relationType?: number | null;
+    [key: string]: any;
+}
+export interface SingleSnapshot {
+    title: string;
+    answers: SingleAnswer[];
+    analysis: string;
+    leastAnswerCount: number | null;
+    selectedTagList: TagItem[];
+    examExpand: string;
+    showRichText: boolean;
+    richText: string;
+    orderList: string[];
+}
+export interface SingleEditorState {
+    title: string;
+    analysis: string;
+    leastAnswerCount: number | null;
+    answerCheckType: number;
+    isKey: boolean;
+    selectedTagList: TagItem[];
+    categoryId: string;
+    richText: string;
+    showRichText: boolean;
+    answers?: SingleAnswer[];
+    orderList?: string[];
+}
+export interface SingleValidationResult {
+    errors: SubjectError[];
+    isSetCorrectAnswer: boolean;
+    correctAnswerCount: number;
+}
+export declare function createDefaultSingleAnswers(): SingleAnswer[];
+export declare function supportsLeastAnswerCount(answerType: AnswerType): answerType is "sort" | "multiple";
+export declare function normalizeLeastAnswerCount(value: unknown, answerType: AnswerType): number | null;
+export declare function leastAnswerCountSuffix(value: number | null, answerType: AnswerType): string;
+export declare function normalizeSingleAnswerItem(answer: any): SingleAnswer;
+export declare function normalizeSingleAnswerList(value: unknown): SingleAnswer[];
+export declare function resolveSingleOrderList({ examExpand, answers, labelForIndex, }: {
+    examExpand?: string;
+    answers?: any[];
+    labelForIndex: (index: number) => string;
+}): string[];
+export declare function buildSingleEditorState({ answerType, title, analysis, leastAnswerCount, answerCheckType, isKey, tagList, categoryId, richTextContent, answerList, examExpand, labelForIndex, includeOrderList, }: {
+    answerType: AnswerType;
+    title?: string;
+    analysis?: string;
+    leastAnswerCount?: unknown;
+    answerCheckType?: number;
+    isKey?: boolean;
+    tagList?: unknown;
+    categoryId?: unknown;
+    richTextContent?: string;
+    answerList?: unknown;
+    examExpand?: string;
+    labelForIndex: (index: number) => string;
+    includeOrderList?: boolean;
+}): SingleEditorState;
+export declare function buildSingleSnapshot({ answerType, title, answers, analysis, leastAnswerCount, selectedTagList, examExpand, showRichText, richText, orderList, sortAnswerValue, }: {
+    answerType: AnswerType;
+    title?: string;
+    answers?: any[];
+    analysis?: string;
+    leastAnswerCount?: unknown;
+    selectedTagList?: TagItem[];
+    examExpand?: string;
+    showRichText?: boolean;
+    richText?: string;
+    orderList?: string[];
+    sortAnswerValue?: (letter: string) => string | number;
+}): SingleSnapshot;
+export declare function validateSingleSnapshot(snapshot: SingleSnapshot, answerType: AnswerType, row?: any): SingleValidationResult;
+export declare function serializeSingleSnapshot(snapshot: SingleSnapshot, { answerType, isSetCorrectAnswer, examAnswerRelationType, customId, }: {
+    answerType: AnswerType;
+    isSetCorrectAnswer: boolean;
+    examAnswerRelationType?: number;
+    customId?: string;
+}): any;

package/types/subject/single-state.d.ts

@@ -0,0 +1,42 @@
+import type { AnswerType } from './types';
+import type { SingleAnswer } from './single-model';
+export declare function applySingleAiAnswer({ answers, aiAnswer, answerType, }: {
+    answers: SingleAnswer[];
+    aiAnswer: string;
+    answerType: AnswerType;
+}): {
+    answers: {
+        isCorrect: boolean;
+        title: string;
+        customAnswerId?: string | number;
+        answerId?: string | number;
+        resultItem?: string;
+        orderIndex?: number;
+        answerRelations?: any[];
+        relationType?: number | null;
+    }[];
+    matchedCount: number;
+};
+export declare function updateSingleAnswerTitle(answers: SingleAnswer[], answerIndex: number, value: string, maxLength: number): SingleAnswer[];
+export declare function insertSingleAnswerAfter(answers: SingleAnswer[], answerIndex: number, createId: () => string | number): SingleAnswer[];
+export declare function deleteSingleAnswerAt(answers: SingleAnswer[], answerIndex: number, minimumLength?: number): SingleAnswer[];
+export declare function setSingleCorrectState(answers: SingleAnswer[], answerType: AnswerType, answerIndex: number, value: boolean): {
+    isCorrect: boolean;
+    title: string;
+    customAnswerId?: string | number;
+    answerId?: string | number;
+    resultItem?: string;
+    orderIndex?: number;
+    answerRelations?: any[];
+    relationType?: number | null;
+}[];
+export declare function toggleSingleSortLetter(orderList: string[], letter: string): string[];
+export declare function removeSingleSortLetter(orderList: string[], letter: string): string[];
+export declare function getSingleSortOrder(orderList: string[], letter: string): number | null;
+export declare function resolveSingleSortAnswerValue(letter: string, answers: SingleAnswer[]): any;
+export declare function countSingleRelationAnswers(relations?: any[]): any;
+export declare function shouldShowSingleCorrectHint({ answerType, answers, orderList, }: {
+    answerType: AnswerType;
+    answers: SingleAnswer[];
+    orderList: string[];
+}): boolean;