@polyv/answer-card-ui-launch 2.2.0 → 2.4.0-rc-20260514.5

package/index.es.d.ts

@@ -2,21 +2,40 @@ import { AnswerCard } from '@polyv/answer-card-sdk';
 import { ComponentOptionsMixin } from 'vue';
 import { ComputedRef } from 'vue';
 import { DefineComponent } from 'vue';
+import { EmitFuncType } from '@polyv/vue-components';
 import { ExtractPropTypes } from 'vue';
+import { PlatformQuestionnaireItemData } from '@polyv/ui-shared';
+import { PlatformQuestionnaireItemData as PlatformQuestionnaireItemData_2 } from '@polyv/ui-shared/src/hooks/use-platform-questionnaire-popup';
+import { PlatformQuestionnairePageContentData } from '@polyv/ui-shared';
+import { PlatformQuestionnairePageContentData as PlatformQuestionnairePageContentData_2 } from '@polyv/ui-shared/src/hooks/use-platform-questionnaire-popup';
+import { PlatformQuestionnairePreviewQuestionData } from '@polyv/ui-shared';
 import { QuestionAnswerType } from '@polyv/questionnaire-sdk';
 import { QuestionContent } from '@polyv/answer-card-sdk';
+import { QuestionDocumentOption } from '@polyv/question-bank/shared';
 import { QuestionItem } from '@polyv/questionnaire-sdk';
+import { QuestionNode } from '@polyv/question-bank/shared';
+import { QuestionNode as QuestionNode_2 } from '@polyv/question-bank';
+import { QuestionNodeTypeValue } from '@polyv/question-bank/shared';
 import { QuestionStatus } from '@polyv/answer-card-sdk';
 import { QuestionType } from '@polyv/answer-card-sdk';
 import { QuestionTypeEnum } from '@polyv/answer-card-sdk';
 import { Ref } from 'vue';
 import { Statistics } from '@polyv/answer-card-sdk';
 import { ValidatorFunction } from 'vue-types/dist/types';
+import { VueEmit } from '@polyv/vue-components';
 import { VueProps } from '@polyv/vue-components';
 import { VueTypeValidableDef } from 'vue-types';
 import { VueTypeValidableDef as VueTypeValidableDef_2 } from 'vue-types';
 import { WritableComputedRef } from 'vue';
 
+export declare interface AnswerCardLaunchBaseProps {
+    answerCardTarget: AnswerCard;
+    canStart?: boolean;
+    cantStartTips?: string;
+    defaultLimitTimeAnswer?: boolean;
+    defaultLimitDuration?: number;
+}
+
 export declare const AnswerCardLaunchDetail: DefineComponent<    {
 answerCardTarget: VueTypeValidableDef<AnswerCard, ValidatorFunction<AnswerCard>> & {
 required: true;
@@ -65,10 +84,10 @@ default: number;
 }, {
 refreshDetail: () => Promise<void>;
 }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
-input: (_value: boolean) => void;
-stop: (_questionId: string) => void;
-close: () => void;
-start: (_questionId: string) => void;
+input: (arg: boolean) => void;
+stop: (arg: string) => void;
+close: (arg?: void | undefined) => void;
+start: (arg: string) => void;
 }, string, Readonly<ExtractPropTypes<    {
 answerCardTarget: VueTypeValidableDef<AnswerCard, ValidatorFunction<AnswerCard>> & {
 required: true;
@@ -117,26 +136,19 @@ default: number;
 }>>, {
 questionId: string;
 defaultLimitTimeAnswer: boolean;
+value: boolean;
 canStart: boolean;
 cantStartTips: string;
 defaultLimitDuration: number;
-value: boolean;
 launchStatus: string;
 launchSubmittedCount: number;
 }>;
 
-declare type AnswerCardLaunchDetailEmit = {
-    (event: "input", value: boolean): void;
-    (event: "close"): void;
-    (event: "stop", questionId: string): void;
-    (event: "start", questionId: string): void;
-};
-
-export declare const answerCardLaunchDetailEmits: {
-    input: (_value: boolean) => boolean;
-    close: () => boolean;
-    stop: (_questionId: string) => boolean;
-    start: (_questionId: string) => boolean;
+export declare const answerCardLaunchDetailEmits: () => {
+    input: EmitFuncType<boolean>;
+    close: EmitFuncType<void>;
+    stop: EmitFuncType<string>;
+    start: EmitFuncType<string>;
 };
 
 export declare const answerCardLaunchDetailProps: () => {
@@ -196,6 +208,26 @@ export declare const answerCardLaunchDetailProps: () => {
     };
 };
 
+export declare interface AnswerCardLaunchEndPayload {
+    questionId: string;
+    question?: QuestionContent;
+    total: number;
+    optionCounts: number[];
+}
+
+export declare interface AnswerCardLaunchEventPayload {
+    source?: 'pc' | 'mobile' | 'external';
+    target?: 'pc' | 'mobile' | 'all';
+    reason?: AnswerCardLaunchRefreshReason;
+    questionId?: string;
+    templateId?: string;
+}
+
+export declare interface AnswerCardLaunchExportPayload {
+    questionId: string;
+    url?: string;
+}
+
 export declare const AnswerCardLaunchList: DefineComponent<    {
 answerCardTarget: VueTypeValidableDef<AnswerCard, ValidatorFunction<AnswerCard>> & {
 required: true;
@@ -220,12 +252,22 @@ default: number;
 } & {
 default: number;
 };
+answerContentBlankEnabled: VueTypeValidableDef<boolean, ValidatorFunction<boolean>> & {
+default: boolean;
+} & {
+default: boolean;
+};
+checkDefaultBadwordEnabled: VueTypeValidableDef<boolean, ValidatorFunction<boolean>> & {
+default: boolean;
+} & {
+default: boolean;
+};
 }, {
 refreshList: () => Promise<void>;
 getCardById: typeof getCardById;
 }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
-"view-detail": (_card: LaunchCardItem) => void;
-refresh: (_list: LaunchCardItem[]) => void;
+"view-detail": (arg: LaunchCardItem) => void;
+refresh: (arg: LaunchCardItem[]) => void;
 }, string, Readonly<ExtractPropTypes<    {
 answerCardTarget: VueTypeValidableDef<AnswerCard, ValidatorFunction<AnswerCard>> & {
 required: true;
@@ -250,21 +292,28 @@ default: number;
 } & {
 default: number;
 };
+answerContentBlankEnabled: VueTypeValidableDef<boolean, ValidatorFunction<boolean>> & {
+default: boolean;
+} & {
+default: boolean;
+};
+checkDefaultBadwordEnabled: VueTypeValidableDef<boolean, ValidatorFunction<boolean>> & {
+default: boolean;
+} & {
+default: boolean;
+};
 }>>, {
 defaultLimitTimeAnswer: boolean;
 canStart: boolean;
 cantStartTips: string;
 defaultLimitDuration: number;
+answerContentBlankEnabled: boolean;
+checkDefaultBadwordEnabled: boolean;
 }>;
 
-declare type AnswerCardLaunchListEmit = {
-    (event: 'view-detail', card: LaunchCardItem): void;
-    (event: 'refresh', list: LaunchCardItem[]): void;
-};
-
-export declare const answerCardLaunchListEmits: {
-    'view-detail': (_card: LaunchCardItem) => boolean;
-    refresh: (_list: LaunchCardItem[]) => boolean;
+export declare const answerCardLaunchListEmits: () => {
+    'view-detail': EmitFuncType<LaunchCardItem>;
+    refresh: EmitFuncType<LaunchCardItem[]>;
 };
 
 export declare const answerCardLaunchListProps: () => {
@@ -291,6 +340,16 @@ export declare const answerCardLaunchListProps: () => {
     } & {
         default: number;
     };
+    answerContentBlankEnabled: VueTypeValidableDef_2<boolean, ValidatorFunction<boolean>> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    checkDefaultBadwordEnabled: VueTypeValidableDef_2<boolean, ValidatorFunction<boolean>> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
 };
 
 export declare const AnswerCardLaunchPanel: DefineComponent<    {
@@ -321,6 +380,16 @@ default: number;
 } & {
 default: number;
 };
+answerContentBlankEnabled: VueTypeValidableDef<boolean, ValidatorFunction<boolean>> & {
+default: boolean;
+} & {
+default: boolean;
+};
+checkDefaultBadwordEnabled: VueTypeValidableDef<boolean, ValidatorFunction<boolean>> & {
+default: boolean;
+} & {
+default: boolean;
+};
 }, {
 openPanel: () => void;
 refreshCardList: typeof refreshCardList;
@@ -329,8 +398,8 @@ openDetail: (question: LaunchCardItem | string, mode?: LaunchDetailMode) => void
 openQuick: () => void;
 closePanel: () => void;
 }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
-input: (_value: boolean) => void;
-close: () => void;
+input: (arg: boolean) => void;
+close: (arg?: void | undefined) => void;
 }, string, Readonly<ExtractPropTypes<    {
 value: {
 type: BooleanConstructor;
@@ -359,23 +428,49 @@ default: number;
 } & {
 default: number;
 };
+answerContentBlankEnabled: VueTypeValidableDef<boolean, ValidatorFunction<boolean>> & {
+default: boolean;
+} & {
+default: boolean;
+};
+checkDefaultBadwordEnabled: VueTypeValidableDef<boolean, ValidatorFunction<boolean>> & {
+default: boolean;
+} & {
+default: boolean;
+};
 }>>, {
 defaultLimitTimeAnswer: boolean;
+value: boolean;
 canStart: boolean;
 cantStartTips: string;
 defaultLimitDuration: number;
-value: boolean;
+answerContentBlankEnabled: boolean;
+checkDefaultBadwordEnabled: boolean;
 }>;
 
-declare type AnswerCardLaunchPanelEmit = {
-    (event: 'input', value: boolean): void;
-    (event: 'close'): void;
+export declare const answerCardLaunchPanelEmits: () => {
+    input: EmitFuncType<boolean>;
+    close: EmitFuncType<void>;
 };
 
-export declare const answerCardLaunchPanelEmits: {
-    input: (_value: boolean) => boolean;
-    close: () => boolean;
-};
+export declare interface AnswerCardLaunchPanelExpose {
+    openPanel(options?: {
+        questionId?: string;
+    }): void;
+    closePanel(): void;
+    refreshQuestionList(reason?: AnswerCardLaunchRefreshReason): Promise<void>;
+    refreshTemplateList(reason?: AnswerCardLaunchRefreshReason): Promise<void>;
+    openQuickAnswer(): void;
+    openTemplateManager(): void;
+    selectQuestion(questionId: string): void;
+}
+
+export declare interface AnswerCardLaunchPanelProps extends AnswerCardLaunchBaseProps {
+    value?: boolean;
+    initialQuestion?: QuestionContent | null;
+    answerContentBlankEnabled?: boolean;
+    checkDefaultBadwordEnabled?: boolean;
+}
 
 export declare const answerCardLaunchPanelProps: () => {
     /** 面板显隐（v-model）。 */
@@ -406,6 +501,16 @@ export declare const answerCardLaunchPanelProps: () => {
     } & {
         default: number;
     };
+    answerContentBlankEnabled: VueTypeValidableDef_2<boolean, ValidatorFunction<boolean>> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    checkDefaultBadwordEnabled: VueTypeValidableDef_2<boolean, ValidatorFunction<boolean>> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
 };
 
 export declare const answerCardLaunchProps: () => {
@@ -437,6 +542,18 @@ export declare const answerCardLaunchProps: () => {
     } & {
         default: number;
     };
+    /** 是否启用旧数据空题干/空选项兼容。 */
+    answerContentBlankEnabled: VueTypeValidableDef_2<boolean, ValidatorFunction<boolean>> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    /** 是否开启默认严禁词校验。 */
+    checkDefaultBadwordEnabled: VueTypeValidableDef_2<boolean, ValidatorFunction<boolean>> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
 };
 
 export declare const AnswerCardLaunchQuick: DefineComponent<    {
@@ -464,9 +581,9 @@ default: boolean;
 default: boolean;
 };
 }, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
-input: (_value: boolean) => void;
-close: () => void;
-sent: (_questionId: string) => void;
+input: (arg: boolean) => void;
+close: (arg?: void | undefined) => void;
+sent: (arg: string) => void;
 }, string, Readonly<ExtractPropTypes<    {
 answerCardTarget: VueTypeValidableDef<AnswerCard, ValidatorFunction<AnswerCard>> & {
 required: true;
@@ -493,9 +610,9 @@ default: boolean;
 };
 }>>, {
 defaultLimitTimeAnswer: boolean;
+value: boolean;
 canStart: boolean;
 cantStartTips: string;
-value: boolean;
 }>;
 
 export declare const AnswerCardLaunchQuickDetail: DefineComponent<    {
@@ -541,10 +658,10 @@ default: boolean;
 }, {
 refreshDetail: () => Promise<void>;
 }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
-input: (_value: boolean) => void;
-stop: (_questionId: string) => void;
-close: () => void;
-start: (_questionId: string) => void;
+input: (arg: boolean) => void;
+stop: (arg: string) => void;
+close: (arg?: void | undefined) => void;
+start: (arg: string) => void;
 }, string, Readonly<ExtractPropTypes<    {
 answerCardTarget: VueTypeValidableDef<AnswerCard, ValidatorFunction<AnswerCard>> & {
 required: true;
@@ -588,25 +705,18 @@ default: boolean;
 }>>, {
 questionId: string;
 defaultLimitTimeAnswer: boolean;
+value: boolean;
 canStart: boolean;
 cantStartTips: string;
-value: boolean;
 launchStatus: string;
 launchSubmittedCount: number;
 }>;
 
-declare type AnswerCardLaunchQuickDetailEmit = {
-    (event: 'input', value: boolean): void;
-    (event: 'close'): void;
-    (event: 'stop', questionId: string): void;
-    (event: 'start', questionId: string): void;
-};
-
-export declare const answerCardLaunchQuickDetailEmits: {
-    input: (_value: boolean) => boolean;
-    close: () => boolean;
-    stop: (_questionId: string) => boolean;
-    start: (_questionId: string) => boolean;
+export declare const answerCardLaunchQuickDetailEmits: () => {
+    input: EmitFuncType<boolean>;
+    close: EmitFuncType<void>;
+    stop: EmitFuncType<string>;
+    start: EmitFuncType<string>;
 };
 
 export declare const answerCardLaunchQuickDetailProps: () => {
@@ -660,17 +770,16 @@ export declare const answerCardLaunchQuickDetailProps: () => {
     };
 };
 
-declare type AnswerCardLaunchQuickEmit = {
-    (event: 'input', value: boolean): void;
-    (event: 'sent', questionId: string): void;
-    (event: 'close'): void;
+export declare const answerCardLaunchQuickEmits: () => {
+    input: EmitFuncType<boolean>;
+    sent: EmitFuncType<string>;
+    close: EmitFuncType<void>;
 };
 
-export declare const answerCardLaunchQuickEmits: {
-    input: (_value: boolean) => boolean;
-    sent: (_questionId: string) => boolean;
-    close: () => boolean;
-};
+export declare interface AnswerCardLaunchQuickProps extends AnswerCardLaunchBaseProps {
+    value?: boolean;
+    checkDefaultBadwordEnabled?: boolean;
+}
 
 export declare const answerCardLaunchQuickProps: () => {
     /** 答题卡 SDK 实例。 */
@@ -703,6 +812,47 @@ export declare const answerCardLaunchQuickProps: () => {
     };
 };
 
+export declare type AnswerCardLaunchRefreshReason = 'import' | 'delete' | 'apply' | 'save' | 'socket' | 'manual';
+
+export declare interface AnswerCardLaunchStartPayload {
+    questionId: string;
+    question: QuestionContent;
+    isAgain: boolean;
+    isQuickQuestion: boolean;
+}
+
+export declare interface AnswerCardLaunchStopPayload {
+    questionId: string;
+    question?: QuestionContent;
+    total: number;
+    optionCounts: number[];
+}
+
+declare interface AnswerCardQuestionOptionViewModel {
+    optionId: string;
+    content: string;
+    tips: string;
+    scoreValue: string;
+}
+
+declare interface AnswerCardQuestionViewModel {
+    questionId: string;
+    type: QuestionType;
+    stem: string;
+    options: AnswerCardQuestionOptionViewModel[];
+    answerOptionIds: string[];
+    isQuickQuestion: boolean;
+    status?: QuestionContent['status'];
+}
+
+export declare interface AnswerCardTemplateItemData {
+    templateId: string;
+    name: string;
+    status: 'error' | 'unused' | 'used';
+    isDefault: boolean;
+    questionCount?: number;
+}
+
 export declare const AnswerCardTemplateList: DefineComponent<    {
 answerCardTarget: VueTypeValidableDef<AnswerCard, ValidatorFunction<AnswerCard>> & {
 required: true;
@@ -710,22 +860,17 @@ required: true;
 }, {
 refreshList: () => Promise<void>;
 }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
-refresh: () => void;
-applied: (_templateId: string) => void;
+refresh: (arg?: void | undefined) => void;
+applied: (arg: string) => void;
 }, string, Readonly<ExtractPropTypes<    {
 answerCardTarget: VueTypeValidableDef<AnswerCard, ValidatorFunction<AnswerCard>> & {
 required: true;
 };
 }>>, {}>;
 
-declare type AnswerCardTemplateListEmit = {
-    (event: 'applied', templateId: string): void;
-    (event: 'refresh'): void;
-};
-
-export declare const answerCardTemplateListEmits: {
-    applied: (_templateId: string) => boolean;
-    refresh: () => boolean;
+export declare const answerCardTemplateListEmits: () => {
+    applied: EmitFuncType<string>;
+    refresh: EmitFuncType<void>;
 };
 
 export declare const answerCardTemplateListProps: () => {
@@ -788,6 +933,11 @@ isSentResult?: boolean | undefined;
 } | undefined;
 }[]>;
 
+declare type EditorQuestionNode = Omit<QuestionNode, 'type' | 'options'> & {
+    type: QuestionNodeTypeValue;
+    options: QuestionDocumentOption[];
+};
+
 export declare function formatQuestionTitle(question: Pick<QuestionContent, 'name' | 'type'>): string;
 
 declare function getCardById(questionId: string): LaunchCard | undefined;
@@ -796,6 +946,8 @@ export declare function getQuestionLaunchStatus(question: Pick<QuestionContent,
 
 export declare function getQuestionTypeLabel(type: QuestionType): string;
 
+declare function isQuestionTypeWithRightAnswer(type: QuestionType): boolean;
+
 declare type LaunchCard = (typeof cardList.value)[number];
 
 export declare interface LaunchCardItem {
@@ -827,6 +979,8 @@ export declare const LaunchQuestionType: {
     readonly Radio: QuestionType;
     /** 多选题 */
     readonly CheckBox: QuestionType;
+    /** 评星题 */
+    readonly Star: QuestionType;
     /** 评分题 */
     readonly Score: QuestionType;
     /** 问答题 */
@@ -847,6 +1001,271 @@ export declare enum LaunchStatus {
     Send = "send"
 }
 
+declare function openTemplateManager(): void;
+
+export declare const PcAnswerCardLaunchPanel: DefineComponent<    {
+value: VueTypeValidableDef<boolean, ValidatorFunction<boolean>> & {
+default: boolean;
+} & {
+default: boolean;
+};
+initialQuestion: VueTypeValidableDef<QuestionContent, ValidatorFunction<QuestionContent>>;
+answerCardTarget: VueTypeValidableDef<AnswerCard, ValidatorFunction<AnswerCard>> & {
+required: true;
+};
+canStart: VueTypeValidableDef<boolean, ValidatorFunction<boolean>> & {
+default: boolean;
+} & {
+default: boolean;
+};
+cantStartTips: VueTypeValidableDef<string, ValidatorFunction<string>> & {
+default: string;
+} & {
+default: string;
+};
+defaultLimitTimeAnswer: VueTypeValidableDef<boolean, ValidatorFunction<boolean>> & {
+default: boolean;
+} & {
+default: boolean;
+};
+defaultLimitDuration: VueTypeValidableDef<number, ValidatorFunction<number>> & {
+default: number;
+} & {
+default: number;
+};
+answerContentBlankEnabled: VueTypeValidableDef<boolean, ValidatorFunction<boolean>> & {
+default: boolean;
+} & {
+default: boolean;
+};
+checkDefaultBadwordEnabled: VueTypeValidableDef<boolean, ValidatorFunction<boolean>> & {
+default: boolean;
+} & {
+default: boolean;
+};
+}, {
+openPanel: (options?: {
+questionId?: string;
+}) => void;
+closePanel: () => void;
+refreshQuestionList: (reason?: AnswerCardLaunchRefreshReason) => Promise<void>;
+refreshTemplateList: (_reason?: AnswerCardLaunchRefreshReason) => Promise<void>;
+openQuickAnswer: () => void;
+openTemplateManager: typeof openTemplateManager;
+selectQuestion: (questionId: string) => Promise<void>;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+input: (arg: boolean) => void;
+stop: (arg: AnswerCardLaunchStopPayload) => void;
+close: (arg?: void | undefined) => void;
+start: (arg: AnswerCardLaunchStartPayload) => void;
+ended: (arg: AnswerCardLaunchEndPayload) => void;
+export: (arg: AnswerCardLaunchExportPayload) => void;
+}, string, Readonly<ExtractPropTypes<    {
+value: VueTypeValidableDef<boolean, ValidatorFunction<boolean>> & {
+default: boolean;
+} & {
+default: boolean;
+};
+initialQuestion: VueTypeValidableDef<QuestionContent, ValidatorFunction<QuestionContent>>;
+answerCardTarget: VueTypeValidableDef<AnswerCard, ValidatorFunction<AnswerCard>> & {
+required: true;
+};
+canStart: VueTypeValidableDef<boolean, ValidatorFunction<boolean>> & {
+default: boolean;
+} & {
+default: boolean;
+};
+cantStartTips: VueTypeValidableDef<string, ValidatorFunction<string>> & {
+default: string;
+} & {
+default: string;
+};
+defaultLimitTimeAnswer: VueTypeValidableDef<boolean, ValidatorFunction<boolean>> & {
+default: boolean;
+} & {
+default: boolean;
+};
+defaultLimitDuration: VueTypeValidableDef<number, ValidatorFunction<number>> & {
+default: number;
+} & {
+default: number;
+};
+answerContentBlankEnabled: VueTypeValidableDef<boolean, ValidatorFunction<boolean>> & {
+default: boolean;
+} & {
+default: boolean;
+};
+checkDefaultBadwordEnabled: VueTypeValidableDef<boolean, ValidatorFunction<boolean>> & {
+default: boolean;
+} & {
+default: boolean;
+};
+}>>, {
+defaultLimitTimeAnswer: boolean;
+value: boolean;
+canStart: boolean;
+cantStartTips: string;
+defaultLimitDuration: number;
+answerContentBlankEnabled: boolean;
+checkDefaultBadwordEnabled: boolean;
+}>;
+
+export declare const pcAnswerCardLaunchPanelEmits: () => {
+    input: EmitFuncType<boolean>;
+    close: EmitFuncType<void>;
+    start: EmitFuncType<AnswerCardLaunchStartPayload>;
+    stop: EmitFuncType<AnswerCardLaunchStopPayload>;
+    ended: EmitFuncType<AnswerCardLaunchEndPayload>;
+    export: EmitFuncType<AnswerCardLaunchExportPayload>;
+};
+
+export declare const pcAnswerCardLaunchPanelProps: () => {
+    /** 面板显隐（v-model）。 */
+    value: VueTypeValidableDef_2<boolean, ValidatorFunction<boolean>> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    /** 打开时初始选中的题目。 */
+    initialQuestion: VueTypeValidableDef_2<QuestionContent, ValidatorFunction<QuestionContent>>;
+    answerCardTarget: VueTypeValidableDef_2<AnswerCard, ValidatorFunction<AnswerCard>> & {
+        required: true;
+    };
+    canStart: VueTypeValidableDef_2<boolean, ValidatorFunction<boolean>> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    cantStartTips: VueTypeValidableDef_2<string, ValidatorFunction<string>> & {
+        default: string;
+    } & {
+        default: string;
+    };
+    defaultLimitTimeAnswer: VueTypeValidableDef_2<boolean, ValidatorFunction<boolean>> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    defaultLimitDuration: VueTypeValidableDef_2<number, ValidatorFunction<number>> & {
+        default: number;
+    } & {
+        default: number;
+    };
+    answerContentBlankEnabled: VueTypeValidableDef_2<boolean, ValidatorFunction<boolean>> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+    checkDefaultBadwordEnabled: VueTypeValidableDef_2<boolean, ValidatorFunction<boolean>> & {
+        default: boolean;
+    } & {
+        default: boolean;
+    };
+};
+
+export declare const PcAnswerCardQuickAnswer: DefineComponent<    {
+value: VueTypeValidableDef<boolean, ValidatorFunction<boolean>> & {
+default: boolean;
+} & {
+default: boolean;
+};
+answerCardTarget: VueTypeValidableDef<AnswerCard, ValidatorFunction<AnswerCard>> & {
+required: true;
+};
+canStart: VueTypeValidableDef<boolean, ValidatorFunction<boolean>> & {
+default: boolean;
+} & {
+default: boolean;
+};
+cantStartTips: VueTypeValidableDef<string, ValidatorFunction<string>> & {
+default: string;
+} & {
+default: string;
+};
+defaultLimitTimeAnswer: VueTypeValidableDef<boolean, ValidatorFunction<boolean>> & {
+default: boolean;
+} & {
+default: boolean;
+};
+defaultLimitDuration: VueTypeValidableDef<number, ValidatorFunction<number>> & {
+default: number;
+} & {
+default: number;
+};
+answerContentBlankEnabled: VueTypeValidableDef<boolean, ValidatorFunction<boolean>> & {
+default: boolean;
+} & {
+default: boolean;
+};
+checkDefaultBadwordEnabled: VueTypeValidableDef<boolean, ValidatorFunction<boolean>> & {
+default: boolean;
+} & {
+default: boolean;
+};
+}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+input: (arg: boolean) => void;
+stop: (arg: AnswerCardLaunchStopPayload) => void;
+close: (arg?: void | undefined) => void;
+start: (arg: AnswerCardLaunchStartPayload) => void;
+ended: (arg: AnswerCardLaunchEndPayload) => void;
+export: (arg: AnswerCardLaunchExportPayload) => void;
+}, string, Readonly<ExtractPropTypes<    {
+value: VueTypeValidableDef<boolean, ValidatorFunction<boolean>> & {
+default: boolean;
+} & {
+default: boolean;
+};
+answerCardTarget: VueTypeValidableDef<AnswerCard, ValidatorFunction<AnswerCard>> & {
+required: true;
+};
+canStart: VueTypeValidableDef<boolean, ValidatorFunction<boolean>> & {
+default: boolean;
+} & {
+default: boolean;
+};
+cantStartTips: VueTypeValidableDef<string, ValidatorFunction<string>> & {
+default: string;
+} & {
+default: string;
+};
+defaultLimitTimeAnswer: VueTypeValidableDef<boolean, ValidatorFunction<boolean>> & {
+default: boolean;
+} & {
+default: boolean;
+};
+defaultLimitDuration: VueTypeValidableDef<number, ValidatorFunction<number>> & {
+default: number;
+} & {
+default: number;
+};
+answerContentBlankEnabled: VueTypeValidableDef<boolean, ValidatorFunction<boolean>> & {
+default: boolean;
+} & {
+default: boolean;
+};
+checkDefaultBadwordEnabled: VueTypeValidableDef<boolean, ValidatorFunction<boolean>> & {
+default: boolean;
+} & {
+default: boolean;
+};
+}>>, {
+defaultLimitTimeAnswer: boolean;
+value: boolean;
+canStart: boolean;
+cantStartTips: string;
+defaultLimitDuration: number;
+answerContentBlankEnabled: boolean;
+checkDefaultBadwordEnabled: boolean;
+}>;
+
+export declare type PcAnswerCardViewState = 'idle' | 'preview' | 'creating' | 'editing' | 'saving' | 'starting' | 'running' | 'stopping' | 'ended' | 'managing-template' | 'importing' | 'exporting';
+
+export { PlatformQuestionnaireItemData }
+
+export { PlatformQuestionnairePageContentData }
+
+export { PlatformQuestionnairePreviewQuestionData }
+
 export declare enum QuickDetailStatus {
     Ongoing = "ongoing",
     Ended = "ended"
@@ -882,11 +1301,13 @@ export declare function useAnswerCardLaunchBase(options: {
     cantStartTips: string;
     defaultLimitTimeAnswer: boolean;
     defaultLimitDuration: number;
+    answerContentBlankEnabled: boolean;
+    checkDefaultBadwordEnabled: boolean;
 };
 
 export declare const useAnswerCardLaunchDetail: (options: {
     props: VueProps<typeof answerCardLaunchDetailProps>;
-    emit: AnswerCardLaunchDetailEmit;
+    emit: VueEmit<typeof answerCardLaunchDetailEmits>;
 }) => {
     visible: WritableComputedRef<boolean>;
     loading: Ref<boolean>;
@@ -915,7 +1336,7 @@ export declare const useAnswerCardLaunchDetail: (options: {
 
 export declare const useAnswerCardLaunchList: (options: {
     props: VueProps<typeof answerCardLaunchListProps>;
-    emit: AnswerCardLaunchListEmit;
+    emit: VueEmit<typeof answerCardLaunchListEmits>;
 }) => {
     loading: Ref<boolean>;
     actionQuestionId: Ref<string>;
@@ -965,7 +1386,7 @@ export declare const useAnswerCardLaunchList: (options: {
 
 export declare const useAnswerCardLaunchPanel: (options: {
     props: VueProps<typeof answerCardLaunchPanelProps>;
-    emit: AnswerCardLaunchPanelEmit;
+    emit: VueEmit<typeof answerCardLaunchPanelEmits>;
 }) => {
     visible: WritableComputedRef<boolean>;
     activeTab: Ref<LaunchPanelTab>;
@@ -986,7 +1407,7 @@ export declare const useAnswerCardLaunchPanel: (options: {
 
 export declare const useAnswerCardLaunchQuick: (options: {
     props: VueProps<typeof answerCardLaunchQuickProps>;
-    emit: AnswerCardLaunchQuickEmit;
+    emit: VueEmit<typeof answerCardLaunchQuickEmits>;
 }) => {
     visible: WritableComputedRef<boolean>;
     sending: Ref<boolean>;
@@ -1001,7 +1422,7 @@ export declare const useAnswerCardLaunchQuick: (options: {
 
 export declare const useAnswerCardLaunchQuickDetail: (options: {
     props: VueProps<typeof answerCardLaunchQuickDetailProps>;
-    emit: AnswerCardLaunchQuickDetailEmit;
+    emit: VueEmit<typeof answerCardLaunchQuickDetailEmits>;
 }) => {
     visible: WritableComputedRef<boolean>;
     loading: Ref<boolean>;
@@ -1019,7 +1440,7 @@ export declare const useAnswerCardLaunchQuickDetail: (options: {
 
 export declare const useAnswerCardTemplateList: (options: {
     props: VueProps<typeof answerCardTemplateListProps>;
-    emit: AnswerCardTemplateListEmit;
+    emit: VueEmit<typeof answerCardTemplateListEmits>;
 }) => {
     loading: Ref<boolean>;
     applyingTemplateId: Ref<string>;
@@ -1038,4 +1459,273 @@ export declare const useAnswerCardTemplateList: (options: {
     applyTemplate: (template: TemplateItemData) => Promise<void>;
 };
 
+export declare const usePcAnswerCardLaunchPanel: (options: {
+    props: VueProps<typeof pcAnswerCardLaunchPanelProps>;
+    emit: VueEmit<typeof pcAnswerCardLaunchPanelEmits>;
+}) => {
+    visible: WritableComputedRef<boolean>;
+    viewState: Ref<PcAnswerCardViewState>;
+    loadingQuestions: Ref<boolean>;
+    loadingTemplates: Ref<boolean>;
+    actionLoading: Ref<boolean>;
+    questionList: Ref<    {
+    question: {
+    status?: QuestionStatus | undefined;
+    options: string[];
+    tips?: string[] | undefined;
+    questionId: string;
+    name: string;
+    type: QuestionType;
+    isQuickQuestion: boolean;
+    answer: string;
+    };
+    status: LaunchCardStatus;
+    submittedCount: number;
+    isSentResult: boolean;
+    statistics?: {
+    total: number;
+    correctCount: number;
+    faultUser: {
+    avatar: string;
+    nick: string;
+    timestamp: number;
+    userid: string;
+    }[];
+    rightUser: {
+    avatar: string;
+    nick: string;
+    timestamp: number;
+    userid: string;
+    }[];
+    options: {
+    count: number;
+    percent?: string | undefined;
+    }[];
+    isSentResult?: boolean | undefined;
+    } | undefined;
+    }[]>;
+    templateListScrollRef: Ref<HTMLElement | undefined>;
+    filteredQuestionList: ComputedRef<    {
+    question: {
+    status?: QuestionStatus | undefined;
+    options: string[];
+    tips?: string[] | undefined;
+    questionId: string;
+    name: string;
+    type: QuestionType;
+    isQuickQuestion: boolean;
+    answer: string;
+    };
+    status: LaunchCardStatus;
+    submittedCount: number;
+    isSentResult: boolean;
+    statistics?: {
+    total: number;
+    correctCount: number;
+    faultUser: {
+    avatar: string;
+    nick: string;
+    timestamp: number;
+    userid: string;
+    }[];
+    rightUser: {
+    avatar: string;
+    nick: string;
+    timestamp: number;
+    userid: string;
+    }[];
+    options: {
+    count: number;
+    percent?: string | undefined;
+    }[];
+    isSentResult?: boolean | undefined;
+    } | undefined;
+    }[]>;
+    templateList: Ref<AnswerCardTemplateItemData[]>;
+    currentTemplateId: Ref<string>;
+    selectedQuestionId: Ref<string>;
+    selectedQuestion: ComputedRef<    {
+    status?: QuestionStatus | undefined;
+    options: string[];
+    tips?: string[] | undefined;
+    questionId: string;
+    name: string;
+    type: QuestionType;
+    isQuickQuestion: boolean;
+    answer: string;
+    } | undefined>;
+    selectedCard: ComputedRef<    {
+    question: {
+    status?: QuestionStatus | undefined;
+    options: string[];
+    tips?: string[] | undefined;
+    questionId: string;
+    name: string;
+    type: QuestionType;
+    isQuickQuestion: boolean;
+    answer: string;
+    };
+    status: LaunchCardStatus;
+    submittedCount: number;
+    isSentResult: boolean;
+    statistics?: {
+    total: number;
+    correctCount: number;
+    faultUser: {
+    avatar: string;
+    nick: string;
+    timestamp: number;
+    userid: string;
+    }[];
+    rightUser: {
+    avatar: string;
+    nick: string;
+    timestamp: number;
+    userid: string;
+    }[];
+    options: {
+    count: number;
+    percent?: string | undefined;
+    }[];
+    isSentResult?: boolean | undefined;
+    } | undefined;
+    } | undefined>;
+    searchKeyword: Ref<string>;
+    editorDraft: Ref<AnswerCardQuestionViewModel | undefined>;
+    editorValidationMessage: ComputedRef<string>;
+    editorQuestionFieldTips: ComputedRef<    {
+    [x: string]: {
+    title: string;
+    };
+    } | {
+    [x: string]: {
+    options: {
+    [x: string]: string;
+    };
+    };
+    }>;
+    editorQuestionNodes: WritableComputedRef<EditorQuestionNode[]>;
+    questionValidationVersion: Ref<number>;
+    selectedQuestionNodePreview: ComputedRef<QuestionNode_2 | undefined>;
+    templateManagerVisible: Ref<boolean>;
+    platformQuestionnaireVisible: Ref<boolean>;
+    loadingPlatformQuestionnaires: Ref<boolean>;
+    platformQuestionnaireKeyword: Ref<string>;
+    platformQuestionnairePageContent: Ref<    {
+    pageNumber: number;
+    pageSize: number;
+    totalItems: number;
+    totalPages: number;
+    contents: {
+    questionnaireId: string;
+    userId: string;
+    name: string;
+    questionCount: number;
+    createdAt?: string | undefined;
+    creator?: string | undefined;
+    questions: {
+    questionId?: string | undefined;
+    title: string;
+    type?: string | undefined;
+    typeName?: string | undefined;
+    optionCount: number;
+    }[];
+    }[];
+    }>;
+    quickVisible: Ref<boolean>;
+    downloadRecordsVisible: Ref<boolean>;
+    limitTimeEnabled: Ref<boolean>;
+    limitDuration: Ref<number>;
+    hasOngoing: ComputedRef<boolean>;
+    currentStatistics: ComputedRef<    {
+    total: number;
+    correctCount: number;
+    faultUser: {
+    avatar: string;
+    nick: string;
+    timestamp: number;
+    userid: string;
+    }[];
+    rightUser: {
+    avatar: string;
+    nick: string;
+    timestamp: number;
+    userid: string;
+    }[];
+    options: {
+    count: number;
+    percent?: string | undefined;
+    }[];
+    isSentResult?: boolean | undefined;
+    } | undefined>;
+    currentCorrectCount: ComputedRef<number>;
+    timedOngoing: ComputedRef<boolean>;
+    remainingSeconds: Ref<number>;
+    averageScoreText: ComputedRef<string>;
+    canEditSelectedQuestion: ComputedRef<boolean>;
+    canAddOption: ComputedRef<boolean>;
+    isQuestionTypeWithRightAnswer: typeof isQuestionTypeWithRightAnswer;
+    formatQuestionTitle: typeof formatQuestionTitle;
+    getQuestionTypeLabel: typeof getQuestionTypeLabel;
+    openPanel: (options?: {
+        questionId?: string;
+    }) => void;
+    closePanel: () => void;
+    openQuickAnswer: () => void;
+    closeQuickAnswer: () => void;
+    openDownloadRecords: () => void;
+    closeDownloadRecords: () => void;
+    openTemplateManager: () => void;
+    closeTemplateManager: () => void;
+    openPlatformQuestionnairePopup: () => void;
+    closePlatformQuestionnairePopup: () => void;
+    changePlatformQuestionnairePage: (pageContent: PlatformQuestionnairePageContentData_2) => void;
+    addPlatformQuestionnaire: (item: PlatformQuestionnaireItemData_2) => Promise<void>;
+    refreshQuestionList: (reason?: AnswerCardLaunchRefreshReason) => Promise<void>;
+    refreshTemplateList: (_reason?: AnswerCardLaunchRefreshReason) => Promise<void>;
+    refreshPlatformQuestionnaireList: (pageContent?: {
+        pageNumber: number;
+        pageSize: number;
+        totalItems: number;
+        totalPages: number;
+        contents: {
+            questionnaireId: string;
+            userId: string;
+            name: string;
+            questionCount: number;
+            createdAt?: string | undefined;
+            creator?: string | undefined;
+            questions: {
+                questionId?: string | undefined;
+                title: string;
+                type?: string | undefined;
+                typeName?: string | undefined;
+                optionCount: number;
+            }[];
+        }[];
+    }) => Promise<void>;
+    selectQuestion: (questionId: string) => Promise<void>;
+    createQuestion: (type?: QuestionType) => Promise<void>;
+    editSelectedQuestion: () => void;
+    cancelEdit: () => void;
+    updateDraftType: (type: QuestionType) => void;
+    updateDraftStem: (value: string) => void;
+    updateDraftOption: (optionId: string, patch: Partial<AnswerCardQuestionViewModel["options"][number]>) => void;
+    addDraftOption: (afterIndex?: number) => void;
+    removeDraftOption: (optionId: string) => void;
+    toggleDraftAnswer: (optionId: string) => void;
+    saveDraft: () => Promise<void>;
+    deleteSelectedQuestion: () => Promise<void>;
+    startSelectedQuestion: (isAgain?: boolean) => Promise<void>;
+    stopSelectedQuestion: () => Promise<void>;
+    sendSelectedResult: () => Promise<void>;
+    exportSelectedResult: () => void;
+    applyTemplate: (template: AnswerCardTemplateItemData) => Promise<void>;
+    deleteTemplate: (template: AnswerCardTemplateItemData) => Promise<void>;
+    downloadTemplate: (templateId?: string) => Promise<void>;
+    uploadTemplate: (file: File, templateId?: string) => Promise<boolean>;
+    getTemplateStatusText: (template: AnswerCardTemplateItemData) => string;
+    getQuestionNodePreview: () => EditorQuestionNode | undefined;
+};
+
 export { }