web-core-tcm 0.0.29 → 0.0.34

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({

package/dist/src/api/check/check.d.ts

@@ -1,5 +1,5 @@
 import { Patient } from '../patient/patient';
-import { Page, Tag, NetworkObject, Sequence } from '../patient/core';
+import { Page, Tag, NetworkObject, Sequence } from '../core/core';
 import { CheckState, PaymentState } from './alova/globals';
 import { Metas } from '../patient/meta';
 import { Prescription } from '../prescription/prescription';

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

@@ -1,5 +1,5 @@
 import { Patient as S } from "../patient/patient.js";
-import { NetworkObject as h, Sequence as m, Tag as y } from "../patient/core.js";
+import { NetworkObject as h, Sequence as m, Tag as y } from "../core/core.js";
 import { Metas as n } from "../patient/meta.js";
 import { Prescription as u } from "../prescription/prescription.js";
 import { AlovaPrescription as g } from "../prescription/alova/implement/prescription.js";

package/dist/src/api/{patient → core}/core.d.ts

@@ -1,4 +1,4 @@
-import { AnnotationState, TagState } from './alova/globals';
+import { AnnotationState, TagState } from '../patient/alova/globals';
 import { IBuilder } from 'builder-pattern';
 export declare class Page<T> {
     data: T[];
@@ -8,7 +8,12 @@ export declare class Page<T> {
     pageCount: number;
     isLastPage: boolean;
 }
-declare abstract class NetworkObject {
+export declare abstract class BaseObject {
+    static _default: typeof BaseObject;
+    static builder(): IBuilder<unknown>;
+    static default(): typeof BaseObject;
+}
+declare abstract class NetworkObject extends BaseObject {
     static _default: typeof NetworkObject;
     static builder(): IBuilder<unknown>;
     static default(): typeof NetworkObject;

package/dist/src/api/{patient → core}/core.js

@@ -1,5 +1,5 @@
-import { Builder as i } from "../../../node_modules/builder-pattern/dist/index.js";
-class d {
+import { Builder as n } from "../../../node_modules/builder-pattern/dist/index.js";
+class f {
   data = [];
   total = 0;
   page = 0;
@@ -7,21 +7,30 @@ class d {
   pageCount = 0;
   isLastPage = !1;
 }
-class a {
+class i {
+  static _default = i;
+  static builder() {
+    return n(this._default);
+  }
+  static default() {
+    return i;
+  }
+}
+class a extends i {
   static _default = a;
   static builder() {
-    return i(this._default);
+    return n(this._default);
   }
   static default() {
     return a;
   }
 }
-class r extends a {
+class o extends a {
   value = "";
   actor = "";
   timestamp = "";
   static builder() {
-    return i(r);
+    return n(o);
   }
   constructor(t = "", e = "", s = "") {
     super(), this.value = t, this.actor = e, this.timestamp = s;
@@ -37,12 +46,12 @@ class r extends a {
     };
   }
 }
-class n extends a {
+class r extends a {
   static builder() {
-    return i(n);
+    return n(r);
   }
   static default() {
-    return n;
+    return r;
   }
   key = "";
   annotations = [];
@@ -52,7 +61,7 @@ class n extends a {
   async of(t) {
     this.key = t.key;
     for (const e of t.annotationsState)
-      this.annotations.push(await new r().of(e));
+      this.annotations.push(await new o().of(e));
     return this;
   }
   state() {
@@ -70,9 +79,9 @@ class n extends a {
   static getValueTagSet(t) {
     const e = [];
     return t.forEach((s) => {
-      const h = s.key, c = s.getLastAnnotation().value.slice(0, 10);
+      const c = s.key, l = s.getLastAnnotation().value.slice(0, 10);
       e.find(
-        (o) => o.key == h && o.getLastAnnotation().value.slice(0, 10) == c
+        (u) => u.key == c && u.getLastAnnotation().value.slice(0, 10) == l
       ) || e.push(s);
     }), e;
   }
@@ -80,7 +89,7 @@ class n extends a {
     return this.key = t.key, this.annotations = t.annotations, this;
   }
 }
-class f {
+class p {
   data = [];
   current = {};
   showed = !1;
@@ -101,9 +110,10 @@ class f {
   }
 }
 export {
-  r as Annotation,
+  o as Annotation,
+  i as BaseObject,
   a as NetworkObject,
-  d as Page,
-  f as Sequence,
-  n as Tag
+  f as Page,
+  p as Sequence,
+  r as Tag
 };

package/dist/src/api/device/device.d.ts

@@ -0,0 +1,5 @@
+export function connectToSerialPort(): Promise<boolean>;
+export function getPortInfo(): any;
+export function disconnectToSerialPort(): Promise<void>;
+export function sendText(text: any): Promise<void>;
+export const port: import('vue').Ref<any, any>;

package/dist/src/api/doctor/alova/globals.d.ts

@@ -0,0 +1,542 @@
+import { Alova, AlovaMethodCreateConfig, AlovaGenerics, Method } from 'alova';
+import { $$userConfigMap, alovaInstance } from './index';
+import { default as apiDefinitions } from './apiDefinitions';
+type CollapsedAlova = typeof alovaInstance;
+type UserMethodConfigMap = typeof $$userConfigMap;
+
+type Alova2MethodConfig<Responded> =
+  CollapsedAlova extends Alova<
+    AlovaGenerics<
+      any,
+      any,
+      infer RequestConfig,
+      infer Response,
+      infer ResponseHeader,
+      infer L1Cache,
+      infer L2Cache,
+      infer SE
+    >
+  >
+    ? Omit<
+        AlovaMethodCreateConfig<
+          AlovaGenerics<
+            Responded,
+            any,
+            RequestConfig,
+            Response,
+            ResponseHeader,
+            L1Cache,
+            L2Cache,
+            SE
+          >,
+          any,
+          Responded
+        >,
+        'params'
+      >
+    : never;
+
+// Extract the return type of transform function that define in $$userConfigMap, if it not exists, use the default type.
+type ExtractUserDefinedTransformed<
+  DefinitionKey extends keyof typeof apiDefinitions,
+  Default,
+> = DefinitionKey extends keyof UserMethodConfigMap
+  ? UserMethodConfigMap[DefinitionKey]['transform'] extends (...args: any[]) => any
+    ? Awaited<ReturnType<UserMethodConfigMap[DefinitionKey]['transform']>>
+    : Default
+  : Default;
+type Alova2Method<
+  Responded,
+  DefinitionKey extends keyof typeof apiDefinitions,
+  CurrentConfig extends Alova2MethodConfig<any>,
+> =
+  CollapsedAlova extends Alova<
+    AlovaGenerics<
+      any,
+      any,
+      infer RequestConfig,
+      infer Response,
+      infer ResponseHeader,
+      infer L1Cache,
+      infer L2Cache,
+      infer SE
+    >
+  >
+    ? Method<
+        AlovaGenerics<
+          CurrentConfig extends undefined
+            ? ExtractUserDefinedTransformed<DefinitionKey, Responded>
+            : CurrentConfig['transform'] extends (...args: any[]) => any
+              ? Awaited<ReturnType<CurrentConfig['transform']>>
+              : ExtractUserDefinedTransformed<DefinitionKey, Responded>,
+          any,
+          RequestConfig,
+          Response,
+          ResponseHeader,
+          L1Cache,
+          L2Cache,
+          SE
+        >
+      >
+    : never;
+
+export interface DoctorState {
+  id?: string;
+  name?: string;
+  createdTimestamp?: string;
+  updatedTimestamp?: string;
+  gender?: string;
+  identityNumber?: string;
+  phoneNumber?: string;
+  birthdate?: string;
+}
+export interface QueryDoctorStateByExactMatchRequest {
+  id?: string[];
+  doctorId?: string[];
+  name?: string[];
+  phoneNumber?: string[];
+  gender?: string[];
+  identityNumber?: string[];
+  pageSize?: number;
+  page?: number;
+  startTime?: number;
+  endTime?: number;
+  sort?: string;
+}
+export interface DateDistribute {
+  date?: string;
+  count?: number;
+}
+export interface SortObject {
+  empty?: boolean;
+  sorted?: boolean;
+  unsorted?: boolean;
+}
+export interface PageableObject {
+  offset?: number;
+  sort?: SortObject;
+  pageSize?: number;
+  paged?: boolean;
+  pageNumber?: number;
+  unpaged?: boolean;
+}
+export interface PageDoctorState {
+  totalPages?: number;
+  totalElements?: number;
+  size?: number;
+  content?: DoctorState[];
+  number?: number;
+  sort?: SortObject;
+  first?: boolean;
+  last?: boolean;
+  numberOfElements?: number;
+  pageable?: PageableObject;
+  empty?: boolean;
+}
+declare global {
+  interface doctorApi {
+    doctorStateRestful: {
+      /**
+       * ---
+       *
+       * [GET]
+       *
+       * **path:** /医生/服务/{id}
+       *
+       * ---
+       *
+       * **Path Parameters**
+       * ```ts
+       * type PathParameters = {
+       *   id: string
+       * }
+       * ```
+       *
+       * ---
+       *
+       * **Response**
+       * ```ts
+       * type Response = {
+       *   id?: string
+       *   name?: string
+       *   createdTimestamp?: string
+       *   updatedTimestamp?: string
+       *   gender?: string
+       *   identityNumber?: string
+       *   phoneNumber?: string
+       *   birthdate?: string
+       * }
+       * ```
+       */
+      getDoctorState<
+        Config extends Alova2MethodConfig<DoctorState> & {
+          pathParams: {
+            id: string;
+          };
+        },
+      >(
+        config: Config,
+      ): Alova2Method<DoctorState, 'doctorStateRestful.getDoctorState', Config>;
+      /**
+       * ---
+       *
+       * [PUT]
+       *
+       * **path:** /医生/服务/{id}
+       *
+       * ---
+       *
+       * **Path Parameters**
+       * ```ts
+       * type PathParameters = {
+       *   id: string
+       * }
+       * ```
+       *
+       * ---
+       *
+       * **RequestBody**
+       * ```ts
+       * type RequestBody = {
+       *   id?: string
+       *   name?: string
+       *   createdTimestamp?: string
+       *   updatedTimestamp?: string
+       *   gender?: string
+       *   identityNumber?: string
+       *   phoneNumber?: string
+       *   birthdate?: string
+       * }
+       * ```
+       *
+       * ---
+       *
+       * **Response**
+       * ```ts
+       * type Response = {
+       *   id?: string
+       *   name?: string
+       *   createdTimestamp?: string
+       *   updatedTimestamp?: string
+       *   gender?: string
+       *   identityNumber?: string
+       *   phoneNumber?: string
+       *   birthdate?: string
+       * }
+       * ```
+       */
+      putDoctorState<
+        Config extends Alova2MethodConfig<DoctorState> & {
+          pathParams: {
+            id: string;
+          };
+          data: DoctorState;
+        },
+      >(
+        config: Config,
+      ): Alova2Method<DoctorState, 'doctorStateRestful.putDoctorState', Config>;
+      /**
+       * ---
+       *
+       * [DELETE]
+       *
+       * **path:** /医生/服务/{id}
+       *
+       * ---
+       *
+       * **Path Parameters**
+       * ```ts
+       * type PathParameters = {
+       *   id: string
+       * }
+       * ```
+       *
+       * ---
+       *
+       * **Response**
+       * ```ts
+       * type Response = null
+       * ```
+       */
+      deleteDoctorState<
+        Config extends Alova2MethodConfig<null> & {
+          pathParams: {
+            id: string;
+          };
+        },
+      >(
+        config: Config,
+      ): Alova2Method<null, 'doctorStateRestful.deleteDoctorState', Config>;
+      /**
+       * ---
+       *
+       * [GET]
+       *
+       * **path:** /医生/服务
+       *
+       * ---
+       *
+       * **Query Parameters**
+       * ```ts
+       * type QueryParameters = {
+       *   id?: string
+       *   name?: string
+       *   phoneNumber?: string
+       *   pageSize: number
+       *   page: number
+       * }
+       * ```
+       *
+       * ---
+       *
+       * **Response**
+       * ```ts
+       * type Response = {
+       *   totalPages?: number
+       *   totalElements?: number
+       *   size?: number
+       *   // [items] start
+       *   // [items] end
+       *   content?: Array<{
+       *     id?: string
+       *     name?: string
+       *     createdTimestamp?: string
+       *     updatedTimestamp?: string
+       *     gender?: string
+       *     identityNumber?: string
+       *     phoneNumber?: string
+       *     birthdate?: string
+       *   }>
+       *   number?: number
+       *   sort?: {
+       *     empty?: boolean
+       *     sorted?: boolean
+       *     unsorted?: boolean
+       *   }
+       *   first?: boolean
+       *   last?: boolean
+       *   numberOfElements?: number
+       *   pageable?: {
+       *     offset?: number
+       *     sort?: {
+       *       empty?: boolean
+       *       sorted?: boolean
+       *       unsorted?: boolean
+       *     }
+       *     pageSize?: number
+       *     paged?: boolean
+       *     pageNumber?: number
+       *     unpaged?: boolean
+       *   }
+       *   empty?: boolean
+       * }
+       * ```
+       */
+      queryDoctorState<
+        Config extends Alova2MethodConfig<PageDoctorState> & {
+          params: {
+            id?: string;
+            name?: string;
+            phoneNumber?: string;
+            pageSize: number;
+            page: number;
+          };
+        },
+      >(
+        config: Config,
+      ): Alova2Method<PageDoctorState, 'doctorStateRestful.queryDoctorState', Config>;
+      /**
+       * ---
+       *
+       * [POST]
+       *
+       * **path:** /医生/服务
+       *
+       * ---
+       *
+       * **RequestBody**
+       * ```ts
+       * type RequestBody = {
+       *   id?: string
+       *   name?: string
+       *   createdTimestamp?: string
+       *   updatedTimestamp?: string
+       *   gender?: string
+       *   identityNumber?: string
+       *   phoneNumber?: string
+       *   birthdate?: string
+       * }
+       * ```
+       *
+       * ---
+       *
+       * **Response**
+       * ```ts
+       * type Response = {
+       *   id?: string
+       *   name?: string
+       *   createdTimestamp?: string
+       *   updatedTimestamp?: string
+       *   gender?: string
+       *   identityNumber?: string
+       *   phoneNumber?: string
+       *   birthdate?: string
+       * }
+       * ```
+       */
+      postDoctorState<
+        Config extends Alova2MethodConfig<DoctorState> & {
+          data: DoctorState;
+        },
+      >(
+        config: Config,
+      ): Alova2Method<DoctorState, 'doctorStateRestful.postDoctorState', Config>;
+      /**
+       * ---
+       *
+       * [POST]
+       *
+       * **path:** /医生/服务/精确匹配
+       *
+       * ---
+       *
+       * **RequestBody**
+       * ```ts
+       * type RequestBody = {
+       *   // [items] start
+       *   // [items] end
+       *   id?: string[]
+       *   // [items] start
+       *   // [items] end
+       *   doctorId?: string[]
+       *   // [items] start
+       *   // [items] end
+       *   name?: string[]
+       *   // [items] start
+       *   // [items] end
+       *   phoneNumber?: string[]
+       *   // [items] start
+       *   // [items] end
+       *   gender?: string[]
+       *   // [items] start
+       *   // [items] end
+       *   identityNumber?: string[]
+       *   pageSize?: number
+       *   page?: number
+       *   startTime?: number
+       *   endTime?: number
+       *   sort?: string
+       * }
+       * ```
+       *
+       * ---
+       *
+       * **Response**
+       * ```ts
+       * type Response = {
+       *   totalPages?: number
+       *   totalElements?: number
+       *   size?: number
+       *   // [items] start
+       *   // [items] end
+       *   content?: Array<{
+       *     id?: string
+       *     name?: string
+       *     createdTimestamp?: string
+       *     updatedTimestamp?: string
+       *     gender?: string
+       *     identityNumber?: string
+       *     phoneNumber?: string
+       *     birthdate?: string
+       *   }>
+       *   number?: number
+       *   sort?: {
+       *     empty?: boolean
+       *     sorted?: boolean
+       *     unsorted?: boolean
+       *   }
+       *   first?: boolean
+       *   last?: boolean
+       *   numberOfElements?: number
+       *   pageable?: {
+       *     offset?: number
+       *     sort?: {
+       *       empty?: boolean
+       *       sorted?: boolean
+       *       unsorted?: boolean
+       *     }
+       *     pageSize?: number
+       *     paged?: boolean
+       *     pageNumber?: number
+       *     unpaged?: boolean
+       *   }
+       *   empty?: boolean
+       * }
+       * ```
+       */
+      queryDoctorStateByExactMatch<
+        Config extends Alova2MethodConfig<PageDoctorState> & {
+          data: QueryDoctorStateByExactMatchRequest;
+        },
+      >(
+        config: Config,
+      ): Alova2Method<PageDoctorState, 'doctorStateRestful.queryDoctorStateByExactMatch', Config>;
+      /**
+       * ---
+       *
+       * [GET]
+       *
+       * **path:** /医生/服务/统计/医生/日期
+       *
+       * ---
+       *
+       * **Response**
+       * ```ts
+       * type Response = Array<{
+       *   date?: string
+       *   count?: number
+       * }>
+       * ```
+       */
+      datesOfDoctor<Config extends Alova2MethodConfig<DateDistribute[]>>(
+        config?: Config,
+      ): Alova2Method<DateDistribute[], 'doctorStateRestful.datesOfDoctor', Config>;
+      /**
+       * ---
+       *
+       * [GET]
+       *
+       * **path:** /医生/服务/统计/医生/总数
+       *
+       * ---
+       *
+       * **Response**
+       * ```ts
+       * type Response = number
+       * ```
+       */
+      totalOfDoctor<Config extends Alova2MethodConfig<number>>(
+        config?: Config,
+      ): Alova2Method<number, 'doctorStateRestful.totalOfDoctor', Config>;
+      /**
+       * ---
+       *
+       * [GET]
+       *
+       * **path:** /医生/服务/统计/医生/今日
+       *
+       * ---
+       *
+       * **Response**
+       * ```ts
+       * type Response = number
+       * ```
+       */
+      totalOfDoctorByToday<Config extends Alova2MethodConfig<number>>(
+        config?: Config,
+      ): Alova2Method<number, 'doctorStateRestful.totalOfDoctorByToday', Config>;
+    };
+  }
+
+  var doctorApi: doctorApi;
+}

package/dist/src/api/doctor/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 n, ServiceType as s } from "../../config/index.js";
-import "../../patient/core.js";
+import "../../core/core.js";
 const c = e({
   baseURL: n(s.Doctor),
   requestAdapter: o(),

package/dist/src/api/doctor/doctor.d.ts

@@ -1,4 +1,4 @@
-import { NetworkObject } from '../patient/core';
+import { NetworkObject } from '../core/core';
 import { DoctorState } from './alova/globals';
 import { IBuilder } from 'builder-pattern';
 export declare abstract class Doctor extends NetworkObject {