web-core-tcm 0.0.30 → 0.0.34

package/dist/src/api/algorithm/alova/implement/comprehensiveAlgorithm.d.ts

@@ -0,0 +1,7 @@
+import { ComprehensiveAlgorithm } from '../..';
+export declare class AlovaComprehensiveAlgorithm implements ComprehensiveAlgorithm {
+    comprehensiveDeepSeekR1Algorithm(data: object): Promise<Response>;
+    comprehensiveDeepSeekV3Algorithm(data: object): Promise<Response>;
+    comprehensiveQwenAlgorithm(data: object): Promise<Response>;
+    doctorSceneTextAnalysis(data: object): Promise<Response>;
+}

package/dist/src/api/algorithm/alova/implement/comprehensiveAlgorithm.js

@@ -0,0 +1,31 @@
+import { comprehensiveAlgorithmService as t } from "../index.js";
+import "../../comprehensiveAlgorithm.js";
+import "../../inquiriesAlgorithm.js";
+import "../../inspectionsAlgorithm.js";
+import "../../lisemsAlgorithm.js";
+import "../../pulsationsAlgorithm.js";
+class h {
+  comprehensiveDeepSeekR1Algorithm(e) {
+    return t.Post("/千问大模型分析", e, {
+      timeout: 3e4
+    }).send();
+  }
+  comprehensiveDeepSeekV3Algorithm(e) {
+    return t.Post("/DeepSeekV3大模型分析", e, {
+      timeout: 3e4
+    }).send();
+  }
+  comprehensiveQwenAlgorithm(e) {
+    return t.Post("/DeepSeekR1大模型分析", e, {
+      timeout: 3e5
+    }).send();
+  }
+  doctorSceneTextAnalysis(e) {
+    return t.Post("/医生场景文本", e, {
+      timeout: 3e5
+    }).send();
+  }
+}
+export {
+  h as AlovaComprehensiveAlgorithm
+};

package/dist/src/api/algorithm/alova/implement/index.d.ts

@@ -0,0 +1,5 @@
+export * from './comprehensiveAlgorithm';
+export * from './inquiriesAlgorithm';
+export * from './inspectionsAlgorithm';
+export * from './lisemsAlgorithm';
+export * from './pulsationsAlgorithm';

package/dist/src/api/algorithm/alova/implement/inquiriesAlgorithm.d.ts

@@ -0,0 +1,16 @@
+import { InquiriesAlgorithm } from '../..';
+export declare class AlovaInquiriesAlgorithm implements InquiriesAlgorithm {
+    complaintsRecognition(symptomDescription: string): Promise<string[]>;
+    complaintsDialog(body: object): Promise<{
+        reply: string;
+        positive_symptom: string[];
+    }>;
+    complaintsView(params: string): Promise<{
+        symptoms: string[];
+    }>;
+    complaintsSearch(data: string): Promise<string[]>;
+    complaintsChoose(body: object): Promise<{
+        status: string;
+        data: [];
+    }>;
+}

package/dist/src/api/algorithm/alova/implement/inquiriesAlgorithm.js

@@ -0,0 +1,26 @@
+import { inquiriesAlgorithmService as t } from "../index.js";
+import "../../comprehensiveAlgorithm.js";
+import "../../inquiriesAlgorithm.js";
+import "../../inspectionsAlgorithm.js";
+import "../../lisemsAlgorithm.js";
+import "../../pulsationsAlgorithm.js";
+class l {
+  complaintsRecognition(o) {
+    return t.Post("/主诉/识别", { symptomDescription: o }).send();
+  }
+  complaintsDialog(o) {
+    return t.Post("/主诉/对话", o).send();
+  }
+  complaintsView(o) {
+    return t.Post("/主诉/视图", { params: o }).send();
+  }
+  complaintsSearch(o) {
+    return t.Post("/主诉/搜索", { data: o }).send();
+  }
+  complaintsChoose(o) {
+    return t.Post("/主诉/选择", o).send();
+  }
+}
+export {
+  l as AlovaInquiriesAlgorithm
+};

package/dist/src/api/algorithm/alova/implement/inspectionsAlgorithm.d.ts

@@ -0,0 +1,5 @@
+import { InspectionsAlgorithm } from '../..';
+export declare class AlovaInspectionsAlgorithm implements InspectionsAlgorithm {
+    static tongueAnalyze(images: FormData): Promise<JSON>;
+    static faceAnalyze(images: FormData): Promise<JSON>;
+}

package/dist/src/api/algorithm/alova/implement/inspectionsAlgorithm.js

@@ -0,0 +1,21 @@
+import { inspectionAlgorithmService as o } from "../index.js";
+import "../../comprehensiveAlgorithm.js";
+import "../../inquiriesAlgorithm.js";
+import "../../inspectionsAlgorithm.js";
+import "../../lisemsAlgorithm.js";
+import "../../pulsationsAlgorithm.js";
+class a {
+  static tongueAnalyze(t) {
+    return o.Post("/舌象", t, {
+      timeout: 3e4
+    }).send();
+  }
+  static faceAnalyze(t) {
+    return o.Post("/面象", t, {
+      timeout: 3e4
+    }).send();
+  }
+}
+export {
+  a as AlovaInspectionsAlgorithm
+};

package/dist/src/api/algorithm/alova/implement/lisemsAlgorithm.d.ts

@@ -0,0 +1,5 @@
+import { LisemsAlgorithm } from '../..';
+export declare class AlovaLisemsAlgorithm implements LisemsAlgorithm {
+    analysisLisems(body: object): Promise<JSON>;
+    getFrequencyDomainDiagram(body: number[]): Promise<string>;
+}

package/dist/src/api/algorithm/alova/implement/lisemsAlgorithm.js

@@ -0,0 +1,26 @@
+import { lisemsAlgorithmService as o } from "../index.js";
+import "../../comprehensiveAlgorithm.js";
+import "../../inquiriesAlgorithm.js";
+import "../../inspectionsAlgorithm.js";
+import "../../lisemsAlgorithm.js";
+import "../../pulsationsAlgorithm.js";
+class p {
+  analysisLisems(r) {
+    return o.Post("/特征参数", r, {
+      transform(t) {
+        return t.json();
+      }
+    }).send();
+  }
+  getFrequencyDomainDiagram(r) {
+    return o.Post("/频域图", JSON.stringify(r), {
+      async transform(t) {
+        const s = await t.blob();
+        return URL.createObjectURL(s);
+      }
+    }).send();
+  }
+}
+export {
+  p as AlovaLisemsAlgorithm
+};

package/dist/src/api/algorithm/alova/implement/pulsationsAlgorithm.d.ts

@@ -0,0 +1,7 @@
+import { PulsationsAlgorithm } from '../..';
+export declare class AlovaPulsationsAlgorithm implements PulsationsAlgorithm {
+    pulsationPreprocessing(pulsation: object): Promise<{
+        [key: string]: number[];
+    }>;
+    pulsationAnalysis(pulsation: object): Promise<JSON>;
+}

package/dist/src/api/algorithm/alova/implement/pulsationsAlgorithm.js

@@ -0,0 +1,19 @@
+import { pulsationsAlgorithmService as t } from "../index.js";
+import "../../comprehensiveAlgorithm.js";
+import "../../inquiriesAlgorithm.js";
+import "../../inspectionsAlgorithm.js";
+import "../../lisemsAlgorithm.js";
+import "../../pulsationsAlgorithm.js";
+class l {
+  pulsationPreprocessing(o) {
+    return t.Post("/预处理", o, {}).send();
+  }
+  pulsationAnalysis(o) {
+    return t.Post("/特征参数", o, {
+      timeout: 3e4
+    }).send();
+  }
+}
+export {
+  l as AlovaPulsationsAlgorithm
+};

package/dist/src/api/algorithm/alova/index.d.ts

@@ -0,0 +1,6 @@
+export * from './implement';
+export declare const inspectionAlgorithmService: import('alova').Alova<import('alova').AlovaGenerics<any, any, import('alova/fetch').FetchRequestInit, Response, Headers, import('alova').AlovaDefaultCacheAdapter, import('alova').AlovaDefaultCacheAdapter, import('alova').StatesExport<any>>>;
+export declare const inquiriesAlgorithmService: import('alova').Alova<import('alova').AlovaGenerics<any, any, import('alova/fetch').FetchRequestInit, Response, Headers, import('alova').AlovaDefaultCacheAdapter, import('alova').AlovaDefaultCacheAdapter, import('alova').StatesExport<any>>>;
+export declare const lisemsAlgorithmService: import('alova').Alova<import('alova').AlovaGenerics<any, any, import('alova/fetch').FetchRequestInit, Response, Headers, import('alova').AlovaDefaultCacheAdapter, import('alova').AlovaDefaultCacheAdapter, import('alova').StatesExport<any>>>;
+export declare const pulsationsAlgorithmService: import('alova').Alova<import('alova').AlovaGenerics<any, any, import('alova/fetch').FetchRequestInit, Response, Headers, import('alova').AlovaDefaultCacheAdapter, import('alova').AlovaDefaultCacheAdapter, import('alova').StatesExport<any>>>;
+export declare const comprehensiveAlgorithmService: import('alova').Alova<import('alova').AlovaGenerics<any, any, import('alova/fetch').FetchRequestInit, Response, Headers, import('alova').AlovaDefaultCacheAdapter, import('alova').AlovaDefaultCacheAdapter, import('alova').StatesExport<any>>>;

package/dist/src/api/algorithm/alova/index.js

@@ -0,0 +1,47 @@
+import { createAlova as e } from "../../../../node_modules/alova/dist/alova.esm.js";
+import { getServiceEndpoint as t, ServiceType as r } from "../../config/index.js";
+import o from "../../../../node_modules/alova/dist/adapter/fetch.esm.js";
+import "../comprehensiveAlgorithm.js";
+import "../inquiriesAlgorithm.js";
+import "../inspectionsAlgorithm.js";
+import "../lisemsAlgorithm.js";
+import "../pulsationsAlgorithm.js";
+import { responded as i } from "../../config/alova/index.js";
+const A = e({
+  baseURL: t(r.InspectionsAlgorithm),
+  timeout: 3e4,
+  cacheFor: null,
+  requestAdapter: o(),
+  responded: i
+}), g = e({
+  baseURL: t(r.InquiriesAlgorithm),
+  timeout: 3e4,
+  cacheFor: null,
+  requestAdapter: o(),
+  responded: i
+}), v = e({
+  baseURL: t(r.LisemsAlgorithm),
+  timeout: 3e4,
+  cacheFor: null,
+  requestAdapter: o(),
+  responded: i
+}), d = e({
+  baseURL: t(r.PulsationsAlgorithm),
+  timeout: 3e4,
+  cacheFor: null,
+  requestAdapter: o(),
+  responded: i
+}), q = e({
+  baseURL: t(r.ComprehensiveAlgorithm),
+  timeout: 3e4,
+  cacheFor: null,
+  requestAdapter: o(),
+  responded: i
+});
+export {
+  q as comprehensiveAlgorithmService,
+  g as inquiriesAlgorithmService,
+  A as inspectionAlgorithmService,
+  v as lisemsAlgorithmService,
+  d as pulsationsAlgorithmService
+};

package/dist/src/api/algorithm/comprehensiveAlgorithm.d.ts

@@ -1,4 +1,11 @@
-export declare const comprehensiveQwenAlgorithm: (data: object) => import('alova').Method<import('alova').RespondedAlovaGenerics<import('alova').AlovaGenerics<any, any, import('alova/fetch').FetchRequestInit, Response, Headers, import('alova').AlovaDefaultCacheAdapter, import('alova').AlovaDefaultCacheAdapter, import('alova').StatesExport<any>>, Response, unknown>>;
-export declare const comprehensiveDeepSeekV3Algorithm: (data: object) => import('alova').Method<import('alova').RespondedAlovaGenerics<import('alova').AlovaGenerics<any, any, import('alova/fetch').FetchRequestInit, Response, Headers, import('alova').AlovaDefaultCacheAdapter, import('alova').AlovaDefaultCacheAdapter, import('alova').StatesExport<any>>, Response, unknown>>;
-export declare const comprehensiveDeepSeekR1Algorithm: (data: object) => import('alova').Method<import('alova').RespondedAlovaGenerics<import('alova').AlovaGenerics<any, any, import('alova/fetch').FetchRequestInit, Response, Headers, import('alova').AlovaDefaultCacheAdapter, import('alova').AlovaDefaultCacheAdapter, import('alova').StatesExport<any>>, Response, unknown>>;
-export declare const doctorSceneTextAnalysis: (data: object) => import('alova').Method<import('alova').RespondedAlovaGenerics<import('alova').AlovaGenerics<any, any, import('alova/fetch').FetchRequestInit, Response, Headers, import('alova').AlovaDefaultCacheAdapter, import('alova').AlovaDefaultCacheAdapter, import('alova').StatesExport<any>>, Response, unknown>>;
+import { BaseObject } from '../patient';
+import { IBuilder } from 'builder-pattern';
+export declare abstract class ComprehensiveAlgorithm extends BaseObject {
+    static _default: typeof ComprehensiveAlgorithm;
+    static builder(): IBuilder<unknown>;
+    static default(): typeof ComprehensiveAlgorithm;
+    static comprehensiveQwenAlgorithm(data: object): Promise<Response>;
+    static comprehensiveDeepSeekV3Algorithm(data: object): Promise<Response>;
+    static comprehensiveDeepSeekR1Algorithm(data: object): Promise<Response>;
+    static doctorSceneTextAnalysis(data: object): Promise<Response>;
+}

package/dist/src/api/algorithm/comprehensiveAlgorithm.js

@@ -1,16 +1,28 @@
-import { comprehensiveAlgorithmService as o } from "./index.js";
-const i = (e) => o.Post("/千问大模型分析", e, {
-  timeout: 3e4
-}), m = (e) => o.Post("/DeepSeekV3大模型分析", e, {
-  timeout: 3e4
-}), s = (e) => o.Post("/DeepSeekR1大模型分析", e, {
-  timeout: 3e5
-}), r = (e) => o.Post("/医生场景文本", e, {
-  timeout: 3e5
-});
+import { BaseObject as r } from "../core/core.js";
+import { Builder as i } from "../../../node_modules/builder-pattern/dist/index.js";
+import "../../../node_modules/pinyin/lib/esm/pinyin.js";
+import "../patient/alova/index.js";
+class t extends r {
+  static _default = t;
+  static builder() {
+    return i(this._default);
+  }
+  static default() {
+    return t;
+  }
+  static comprehensiveQwenAlgorithm(e) {
+    return this.default().comprehensiveQwenAlgorithm(e);
+  }
+  static comprehensiveDeepSeekV3Algorithm(e) {
+    return this.default().comprehensiveDeepSeekV3Algorithm(e);
+  }
+  static comprehensiveDeepSeekR1Algorithm(e) {
+    return this.default().comprehensiveDeepSeekR1Algorithm(e);
+  }
+  static doctorSceneTextAnalysis(e) {
+    return this.default().doctorSceneTextAnalysis(e);
+  }
+}
 export {
-  s as comprehensiveDeepSeekR1Algorithm,
-  m as comprehensiveDeepSeekV3Algorithm,
-  i as comprehensiveQwenAlgorithm,
-  r as doctorSceneTextAnalysis
+  t as ComprehensiveAlgorithm
 };

package/dist/src/api/algorithm/index.d.ts

@@ -1,8 +1,4 @@
-export declare const inspectionAlgorithmService: import('alova').Alova<import('alova').AlovaGenerics<any, any, import('alova/fetch').FetchRequestInit, Response, Headers, import('alova').AlovaDefaultCacheAdapter, import('alova').AlovaDefaultCacheAdapter, import('alova').StatesExport<any>>>;
-export declare const inquiriesAlgorithmService: import('alova').Alova<import('alova').AlovaGenerics<any, any, import('alova/fetch').FetchRequestInit, Response, Headers, import('alova').AlovaDefaultCacheAdapter, import('alova').AlovaDefaultCacheAdapter, import('alova').StatesExport<any>>>;
-export declare const lisemsAlgorithmService: import('alova').Alova<import('alova').AlovaGenerics<any, any, import('alova/fetch').FetchRequestInit, Response, Headers, import('alova').AlovaDefaultCacheAdapter, import('alova').AlovaDefaultCacheAdapter, import('alova').StatesExport<any>>>;
-export declare const pulsationsAlgorithmService: import('alova').Alova<import('alova').AlovaGenerics<any, any, import('alova/fetch').FetchRequestInit, Response, Headers, import('alova').AlovaDefaultCacheAdapter, import('alova').AlovaDefaultCacheAdapter, import('alova').StatesExport<any>>>;
-export declare const comprehensiveAlgorithmService: import('alova').Alova<import('alova').AlovaGenerics<any, any, import('alova/fetch').FetchRequestInit, Response, Headers, import('alova').AlovaDefaultCacheAdapter, import('alova').AlovaDefaultCacheAdapter, import('alova').StatesExport<any>>>;
+export * from './alova';
 export * from './comprehensiveAlgorithm';
 export * from './inquiriesAlgorithm';
 export * from './inspectionsAlgorithm';

package/dist/src/api/algorithm/index.js

@@ -1,62 +1,28 @@
-import { createAlova as e } from "../../../node_modules/alova/dist/alova.esm.js";
-import o from "../../../node_modules/alova/dist/adapter/fetch.esm.js";
-import { responded as r } from "../config/alova/index.js";
-import { getServiceEndpoint as t, ServiceType as i } from "../config/index.js";
-import { comprehensiveDeepSeekR1Algorithm as v, comprehensiveDeepSeekV3Algorithm as S, comprehensiveQwenAlgorithm as d, doctorSceneTextAnalysis as f } from "./comprehensiveAlgorithm.js";
-import { complaintsChoose as x, complaintsDialog as y, complaintsRecognition as F, complaintsSearch as L, complaintsView as R } from "./inquiriesAlgorithm.js";
-import { faceAnalyze as D, tongueAnalyze as U } from "./inspectionsAlgorithm.js";
-import { analysisLisems as w, getFrequencyDomainDiagram as z } from "./lisemsAlgorithm.js";
-import { pulsationAnalysis as I, pulsationPreprocessing as P } from "./pulsationsAlgorithm.js";
-const a = e({
-  baseURL: t(i.InspectionsAlgorithm),
-  timeout: 3e4,
-  cacheFor: null,
-  requestAdapter: o(),
-  responded: r
-}), l = e({
-  baseURL: t(i.InquiriesAlgorithm),
-  timeout: 3e4,
-  cacheFor: null,
-  requestAdapter: o(),
-  responded: r
-}), p = e({
-  baseURL: t(i.LisemsAlgorithm),
-  timeout: 3e4,
-  cacheFor: null,
-  requestAdapter: o(),
-  responded: r
-}), h = e({
-  baseURL: t(i.PulsationsAlgorithm),
-  timeout: 3e4,
-  cacheFor: null,
-  requestAdapter: o(),
-  responded: r
-}), u = e({
-  baseURL: t(i.ComprehensiveAlgorithm),
-  timeout: 3e4,
-  cacheFor: null,
-  requestAdapter: o(),
-  responded: r
-});
+import { comprehensiveAlgorithmService as i, inquiriesAlgorithmService as e, inspectionAlgorithmService as m, lisemsAlgorithmService as t, pulsationsAlgorithmService as l } from "./alova/index.js";
+import { ComprehensiveAlgorithm as A } from "./comprehensiveAlgorithm.js";
+import { InquiriesAlgorithm as p } from "./inquiriesAlgorithm.js";
+import { InspectionsAlgorithm as n } from "./inspectionsAlgorithm.js";
+import { LisemsAlgorithm as f } from "./lisemsAlgorithm.js";
+import { PulsationsAlgorithm as c } from "./pulsationsAlgorithm.js";
+import { AlovaComprehensiveAlgorithm as u } from "./alova/implement/comprehensiveAlgorithm.js";
+import { AlovaInquiriesAlgorithm as I } from "./alova/implement/inquiriesAlgorithm.js";
+import { AlovaInspectionsAlgorithm as C } from "./alova/implement/inspectionsAlgorithm.js";
+import { AlovaLisemsAlgorithm as P } from "./alova/implement/lisemsAlgorithm.js";
+import { AlovaPulsationsAlgorithm as d } from "./alova/implement/pulsationsAlgorithm.js";
 export {
-  w as analysisLisems,
-  x as complaintsChoose,
-  y as complaintsDialog,
-  F as complaintsRecognition,
-  L as complaintsSearch,
-  R as complaintsView,
-  u as comprehensiveAlgorithmService,
-  v as comprehensiveDeepSeekR1Algorithm,
-  S as comprehensiveDeepSeekV3Algorithm,
-  d as comprehensiveQwenAlgorithm,
-  f as doctorSceneTextAnalysis,
-  D as faceAnalyze,
-  z as getFrequencyDomainDiagram,
-  l as inquiriesAlgorithmService,
-  a as inspectionAlgorithmService,
-  p as lisemsAlgorithmService,
-  I as pulsationAnalysis,
-  P as pulsationPreprocessing,
-  h as pulsationsAlgorithmService,
-  U as tongueAnalyze
+  u as AlovaComprehensiveAlgorithm,
+  I as AlovaInquiriesAlgorithm,
+  C as AlovaInspectionsAlgorithm,
+  P as AlovaLisemsAlgorithm,
+  d as AlovaPulsationsAlgorithm,
+  A as ComprehensiveAlgorithm,
+  p as InquiriesAlgorithm,
+  n as InspectionsAlgorithm,
+  f as LisemsAlgorithm,
+  c as PulsationsAlgorithm,
+  i as comprehensiveAlgorithmService,
+  e as inquiriesAlgorithmService,
+  m as inspectionAlgorithmService,
+  t as lisemsAlgorithmService,
+  l as pulsationsAlgorithmService
 };

package/dist/src/api/algorithm/inquiriesAlgorithm.d.ts

@@ -1,13 +1,20 @@
-export declare const complaintsRecognition: (symptomDescription: string) => import('alova').Method<import('alova').RespondedAlovaGenerics<import('alova').AlovaGenerics<any, any, import('alova/fetch').FetchRequestInit, Response, Headers, import('alova').AlovaDefaultCacheAdapter, import('alova').AlovaDefaultCacheAdapter, import('alova').StatesExport<any>>, string[], unknown>>;
-export declare const complaintsDialog: (body: object) => import('alova').Method<import('alova').RespondedAlovaGenerics<import('alova').AlovaGenerics<any, any, import('alova/fetch').FetchRequestInit, Response, Headers, import('alova').AlovaDefaultCacheAdapter, import('alova').AlovaDefaultCacheAdapter, import('alova').StatesExport<any>>, {
-    reply: string;
-    positive_symptom: string[];
-}, unknown>>;
-export declare const complaintsView: (params: string) => import('alova').Method<import('alova').RespondedAlovaGenerics<import('alova').AlovaGenerics<any, any, import('alova/fetch').FetchRequestInit, Response, Headers, import('alova').AlovaDefaultCacheAdapter, import('alova').AlovaDefaultCacheAdapter, import('alova').StatesExport<any>>, {
-    symptoms: string[];
-}, unknown>>;
-export declare const complaintsSearch: (data: string) => import('alova').Method<import('alova').RespondedAlovaGenerics<import('alova').AlovaGenerics<any, any, import('alova/fetch').FetchRequestInit, Response, Headers, import('alova').AlovaDefaultCacheAdapter, import('alova').AlovaDefaultCacheAdapter, import('alova').StatesExport<any>>, string[], unknown>>;
-export declare const complaintsChoose: (body: object) => import('alova').Method<import('alova').RespondedAlovaGenerics<import('alova').AlovaGenerics<any, any, import('alova/fetch').FetchRequestInit, Response, Headers, import('alova').AlovaDefaultCacheAdapter, import('alova').AlovaDefaultCacheAdapter, import('alova').StatesExport<any>>, {
-    status: string;
-    data: [];
-}, unknown>>;
+import { IBuilder } from 'builder-pattern';
+import { BaseObject } from '../core/core';
+export declare abstract class InquiriesAlgorithm extends BaseObject {
+    static _default: typeof InquiriesAlgorithm;
+    static builder(): IBuilder<unknown>;
+    static default(): typeof InquiriesAlgorithm;
+    static complaintsRecognition(symptomDescription: string): Promise<string[]>;
+    static complaintsDialog(body: object): Promise<{
+        reply: string;
+        positive_symptom: string[];
+    }>;
+    static complaintsView(params: string): Promise<{
+        symptoms: string[];
+    }>;
+    static complaintsSearch(data: string): Promise<string[]>;
+    static complaintsChoose(body: object): Promise<{
+        status: string;
+        data: [];
+    }>;
+}

package/dist/src/api/algorithm/inquiriesAlgorithm.js

@@ -1,9 +1,29 @@
-import { inquiriesAlgorithmService as t } from "./index.js";
-const i = (o) => t.Post("/主诉/识别", { symptomDescription: o }), c = (o) => t.Post("/主诉/对话", o), n = (o) => t.Post("/主诉/视图", { params: o }), e = (o) => t.Post("/主诉/搜索", { data: o }), m = (o) => t.Post("/主诉/选择", o);
+import { Builder as a } from "../../../node_modules/builder-pattern/dist/index.js";
+import { BaseObject as e } from "../core/core.js";
+class i extends e {
+  static _default = i;
+  static builder() {
+    return a(this._default);
+  }
+  static default() {
+    return this._default;
+  }
+  static complaintsRecognition(t) {
+    return this.default().complaintsRecognition(t);
+  }
+  static complaintsDialog(t) {
+    return this.default().complaintsDialog(t);
+  }
+  static complaintsView(t) {
+    return this.default().complaintsView(t);
+  }
+  static complaintsSearch(t) {
+    return this.default().complaintsSearch(t);
+  }
+  static complaintsChoose(t) {
+    return this.default().complaintsChoose(t);
+  }
+}
 export {
-  m as complaintsChoose,
-  c as complaintsDialog,
-  i as complaintsRecognition,
-  e as complaintsSearch,
-  n as complaintsView
+  i as InquiriesAlgorithm
 };

package/dist/src/api/algorithm/inspectionsAlgorithm.d.ts

@@ -1,2 +1,9 @@
-export declare const tongueAnalyze: (images: FormData) => import('alova').Method<import('alova').RespondedAlovaGenerics<import('alova').AlovaGenerics<any, any, import('alova/fetch').FetchRequestInit, Response, Headers, import('alova').AlovaDefaultCacheAdapter, import('alova').AlovaDefaultCacheAdapter, import('alova').StatesExport<any>>, JSON, unknown>>;
-export declare const faceAnalyze: (images: FormData) => import('alova').Method<import('alova').RespondedAlovaGenerics<import('alova').AlovaGenerics<any, any, import('alova/fetch').FetchRequestInit, Response, Headers, import('alova').AlovaDefaultCacheAdapter, import('alova').AlovaDefaultCacheAdapter, import('alova').StatesExport<any>>, JSON, unknown>>;
+import { BaseObject } from '../core/core';
+import { IBuilder } from 'builder-pattern';
+export declare abstract class InspectionsAlgorithm extends BaseObject {
+    static _default: typeof InspectionsAlgorithm;
+    static builder(): IBuilder<unknown>;
+    static default(): typeof InspectionsAlgorithm;
+    static tongueAnalyze(images: FormData): Promise<JSON>;
+    static faceAnalyze(images: FormData): Promise<JSON>;
+}

package/dist/src/api/algorithm/inspectionsAlgorithm.js

@@ -1,10 +1,20 @@
-import { inspectionAlgorithmService as e } from "./index.js";
-const i = (t) => e.Post("/舌象", t, {
-  timeout: 3e4
-}), n = (t) => e.Post("/面象", t, {
-  timeout: 3e4
-});
+import { BaseObject as a } from "../core/core.js";
+import { Builder as r } from "../../../node_modules/builder-pattern/dist/index.js";
+class e extends a {
+  static _default = e;
+  static builder() {
+    return r(this._default);
+  }
+  static default() {
+    return this._default;
+  }
+  static tongueAnalyze(t) {
+    return this.default().tongueAnalyze(t);
+  }
+  static faceAnalyze(t) {
+    return this.default().faceAnalyze(t);
+  }
+}
 export {
-  n as faceAnalyze,
-  i as tongueAnalyze
+  e as InspectionsAlgorithm
 };

package/dist/src/api/algorithm/lisemsAlgorithm.d.ts

@@ -1,2 +1,9 @@
-export declare const analysisLisems: (body: object) => import('alova').Method<import('alova').RespondedAlovaGenerics<import('alova').AlovaGenerics<any, any, import('alova/fetch').FetchRequestInit, Response, Headers, import('alova').AlovaDefaultCacheAdapter, import('alova').AlovaDefaultCacheAdapter, import('alova').StatesExport<any>>, JSON, Response>>;
-export declare const getFrequencyDomainDiagram: (body: number[]) => import('alova').Method<import('alova').RespondedAlovaGenerics<import('alova').AlovaGenerics<any, any, import('alova/fetch').FetchRequestInit, Response, Headers, import('alova').AlovaDefaultCacheAdapter, import('alova').AlovaDefaultCacheAdapter, import('alova').StatesExport<any>>, string, Response>>;
+import { BaseObject } from '../core/core';
+import { IBuilder } from 'builder-pattern';
+export declare abstract class LisemsAlgorithm extends BaseObject {
+    static _default: typeof LisemsAlgorithm;
+    static builder(): IBuilder<unknown>;
+    static default(): typeof LisemsAlgorithm;
+    static analysisLisems(body: object): Promise<JSON>;
+    static getFrequencyDomainDiagram(body: number[]): Promise<string>;
+}

package/dist/src/api/algorithm/lisemsAlgorithm.js

@@ -1,15 +1,20 @@
-import { lisemsAlgorithmService as s } from "./index.js";
-const n = (r) => s.Post("/特征参数", r, {
-  transform(t) {
-    return t.json();
+import { BaseObject as a } from "../core/core.js";
+import { Builder as i } from "../../../node_modules/builder-pattern/dist/index.js";
+class e extends a {
+  static _default = e;
+  static builder() {
+    return i(this._default);
   }
-}), a = (r) => s.Post("/频域图", JSON.stringify(r), {
-  async transform(t) {
-    const o = await t.blob();
-    return URL.createObjectURL(o);
+  static default() {
+    return e;
   }
-});
+  static analysisLisems(t) {
+    return this.default().analysisLisems(t);
+  }
+  static getFrequencyDomainDiagram(t) {
+    return this.default().getFrequencyDomainDiagram(t);
+  }
+}
 export {
-  n as analysisLisems,
-  a as getFrequencyDomainDiagram
+  e as LisemsAlgorithm
 };

package/dist/src/api/algorithm/pulsationsAlgorithm.d.ts

@@ -1,4 +1,11 @@
-export declare const pulsationPreprocessing: (pulsation: object) => import('alova').Method<import('alova').RespondedAlovaGenerics<import('alova').AlovaGenerics<any, any, import('alova/fetch').FetchRequestInit, Response, Headers, import('alova').AlovaDefaultCacheAdapter, import('alova').AlovaDefaultCacheAdapter, import('alova').StatesExport<any>>, {
-    [key: string]: number[];
-}, unknown>>;
-export declare const pulsationAnalysis: (pulsation: object) => import('alova').Method<import('alova').RespondedAlovaGenerics<import('alova').AlovaGenerics<any, any, import('alova/fetch').FetchRequestInit, Response, Headers, import('alova').AlovaDefaultCacheAdapter, import('alova').AlovaDefaultCacheAdapter, import('alova').StatesExport<any>>, JSON, unknown>>;
+import { IBuilder } from 'builder-pattern';
+import { BaseObject } from '../core/core';
+export declare abstract class PulsationsAlgorithm extends BaseObject {
+    static _default: typeof PulsationsAlgorithm;
+    static builder(): IBuilder<unknown>;
+    static default(): typeof PulsationsAlgorithm;
+    static pulsationPreprocessing(pulsation: object): Promise<{
+        [key: string]: number[];
+    }>;
+    static pulsationAnalysis(pulsation: object): Promise<JSON>;
+}

package/dist/src/api/algorithm/pulsationsAlgorithm.js

@@ -1,8 +1,20 @@
-import { pulsationsAlgorithmService as s } from "./index.js";
-const i = (o) => s.Post("/预处理", o, {}), e = (o) => s.Post("/特征参数", o, {
-  timeout: 3e4
-});
+import { Builder as e } from "../../../node_modules/builder-pattern/dist/index.js";
+import { BaseObject as i } from "../core/core.js";
+class s extends i {
+  static _default = s;
+  static builder() {
+    return e(this._default);
+  }
+  static default() {
+    return s;
+  }
+  static pulsationPreprocessing(t) {
+    return this.default().pulsationPreprocessing(t);
+  }
+  static pulsationAnalysis(t) {
+    return this.default().pulsationAnalysis(t);
+  }
+}
 export {
-  e as pulsationAnalysis,
-  i as pulsationPreprocessing
+  s as PulsationsAlgorithm
 };

package/dist/src/api/check/alova/index.js

@@ -3,7 +3,7 @@ import o from "../../../../node_modules/alova/dist/adapter/fetch.esm.js";
 import { createApis as r, mountApis as t, withConfigType as p } from "./createApis.js";
 import { responded as i, onAuthRequired as a } from "../../config/alova/index.js";
 import { getServiceEndpoint as m, ServiceType as n } from "../../config/index.js";
-import "../../patient/core.js";
+import "../../core/core.js";
 import "../../../../node_modules/pinyin/lib/esm/pinyin.js";
 import "../../prescription/alova/index.js";
 const s = e({