web-core-tcm 0.0.24 → 0.0.26

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

@@ -0,0 +1,46 @@
+import { Annotation as t, NetworkObject as o, Page as M, Sequence as n, Tag as l } from "./core.js";
+import { AppendixMeta as A, ComplaintMeta as r, ECGMeta as v, FaceMeta as i, ImageMeta as P, ImagesMeta as m, Meta as x, MetaSequence as c, MetaType as f, MetaTypeConfig as g, Metas as s, PCGMeta as C, PPGMeta as u, PulsationMeta as G, SceneMeta as T, TextMeta as S, TongueMeta as I, WavesMeta as d } from "./meta.js";
+import { Patient as y } from "./patient.js";
+import { $$userConfigMap as F, alovaInstance as $ } from "./alova/index.js";
+import { AlovaAppendixMeta as j, AlovaComplaintMeta as k, AlovaECGMeta as w, AlovaFaceMeta as N, AlovaMeta as O, AlovaMetas as W, AlovaPCGMeta as h, AlovaPPGMeta as z, AlovaPulsationMeta as B, AlovaSceneMeta as D, AlovaTongueMeta as H } from "./alova/implement/meta.js";
+import { AlovaPatient as K } from "./alova/implement/patient.js";
+export {
+  F as $$userConfigMap,
+  j as AlovaAppendixMeta,
+  k as AlovaComplaintMeta,
+  w as AlovaECGMeta,
+  N as AlovaFaceMeta,
+  O as AlovaMeta,
+  W as AlovaMetas,
+  h as AlovaPCGMeta,
+  z as AlovaPPGMeta,
+  K as AlovaPatient,
+  B as AlovaPulsationMeta,
+  D as AlovaSceneMeta,
+  H as AlovaTongueMeta,
+  t as Annotation,
+  A as AppendixMeta,
+  r as ComplaintMeta,
+  v as ECGMeta,
+  i as FaceMeta,
+  P as ImageMeta,
+  m as ImagesMeta,
+  x as Meta,
+  c as MetaSequence,
+  f as MetaType,
+  g as MetaTypeConfig,
+  s as Metas,
+  o as NetworkObject,
+  C as PCGMeta,
+  u as PPGMeta,
+  M as Page,
+  y as Patient,
+  G as PulsationMeta,
+  T as SceneMeta,
+  n as Sequence,
+  l as Tag,
+  S as TextMeta,
+  I as TongueMeta,
+  d as WavesMeta,
+  $ as alovaInstance
+};

package/dist/src/api/patient/meta.d.ts

@@ -0,0 +1,238 @@
+import { Page, Sequence, Tag, NetworkObject } from './core';
+import { WaveMap } from '../../proto/types/WaveMap_pb';
+import { MetaState } from './alova/globals';
+import { Image, Images } from '../../proto/types/Images_pb';
+import { Patient } from './patient';
+import { IBuilder } from 'builder-pattern';
+export declare enum MetaType {
+    Pulsation = "pulsation",
+    Tongue = "tongue",
+    Appendix = "appendix",
+    PPG = "ppg",
+    PCG = "pcg",
+    ECG = "ecg",
+    Scene = "scene",
+    Face = "face",
+    Complaint = "complaint",
+    Meta = "meta"
+}
+export declare abstract class Meta extends NetworkObject {
+    static builder(): IBuilder<unknown>;
+    static default(): typeof Meta;
+    id: string;
+    owner: Patient;
+    type: MetaType;
+    tags: Tag[];
+    createdTimestamp: string;
+    updatedTimestamp: string;
+    isSelected: boolean;
+    of(json: MetaState): Promise<this>;
+    state(): MetaState;
+    getTagValue(key: string): string | undefined;
+    putTags(): import('alova').Method<import('alova').AlovaGenerics<MetaState, any, import('alova/fetch').FetchRequestInit, Response, Headers, any, any, any>>;
+    addTag(tag: Tag): import('alova').Method<import('alova').AlovaGenerics<MetaState, any, import('alova/fetch').FetchRequestInit, Response, Headers, any, any, any>>;
+    removeTag(tag: Tag): import('alova').Method<import('alova').AlovaGenerics<MetaState, any, import('alova/fetch').FetchRequestInit, Response, Headers, any, any, any>>;
+    abstract analyze(): Promise<this>;
+    abstract getObject(): Promise<unknown>;
+    abstract get(): Promise<this>;
+    abstract put(): Promise<this>;
+    abstract post(): Promise<this>;
+    abstract delete(): Promise<this>;
+    abstract serialize(object: unknown): ArrayBuffer;
+    abstract deserialize(buffer: ArrayBuffer): unknown;
+    abstract inject(object: unknown): Promise<this>;
+    static queryMetaWithPatient(page: number, pageSize: number, owner?: Patient, type?: string, startTime?: string, endTime?: string, sort?: string, patientName?: string, patientPhoneNumber?: string, patientStartBirthdate?: string, patientEndBirthdate?: string, patientGender?: string, tags?: Tag[]): Promise<Page<Meta>>;
+    static query(page: number, pageSize: number, owner?: Patient, type?: string, startTime?: string, endTime?: string, sort?: string): Promise<Page<Meta>>;
+    static queryMetaStateByExactMatch(id?: string[], owner?: Patient[], type?: string[], pageSize?: number, page?: number, startTime?: string, endTime?: string, sort?: string): Promise<Page<Meta>>;
+}
+export declare abstract class ImageMeta extends Meta {
+    image?: Image;
+    base64Image: string;
+    serialize(): ArrayBuffer;
+    deserialize(buffer: ArrayBuffer): string;
+    inject(buffer: ArrayBuffer): Promise<this>;
+    abstract getObject(): Promise<string>;
+}
+export declare abstract class ImagesMeta extends Meta {
+    images?: Images;
+    base64Images: string[];
+    serialize(): ArrayBuffer;
+    deserialize(buffer: ArrayBuffer): string[];
+    inject(buffers?: ArrayBuffer[]): Promise<this>;
+    abstract getObject(): Promise<string[]>;
+}
+export declare abstract class TextMeta extends Meta {
+    text: string;
+    constructor();
+    serialize(): ArrayBuffer;
+    deserialize(buffer: ArrayBuffer): string;
+    inject(text?: string): Promise<this>;
+    abstract getObject(): Promise<string>;
+}
+export declare abstract class WavesMeta extends Meta {
+    waves: WaveMap | undefined;
+    serialize(): ArrayBuffer;
+    deserialize(buffer: ArrayBuffer): WaveMap;
+    abstract preprocess(origins: {
+        [key: string]: number[];
+    }): Promise<{
+        [key: string]: number[];
+    }>;
+    inject(origins?: {
+        [key: string]: number[];
+    }, smooths?: {
+        [key: string]: number[];
+    }): Promise<this>;
+    abstract getObject(): Promise<WaveMap>;
+}
+export declare abstract class TongueMeta extends ImageMeta {
+    static builder(): IBuilder<TongueMeta>;
+    static default(): typeof TongueMeta;
+    constructor();
+}
+export declare abstract class FaceMeta extends ImageMeta {
+    static builder(): IBuilder<FaceMeta>;
+    static default(): typeof FaceMeta;
+    constructor();
+}
+export declare abstract class SceneMeta extends ImageMeta {
+    static builder(): IBuilder<SceneMeta>;
+    static default(): typeof SceneMeta;
+    constructor();
+}
+export declare abstract class PulsationMeta extends WavesMeta {
+    static builder(): IBuilder<PulsationMeta>;
+    static default(): typeof PulsationMeta;
+    constructor();
+}
+export declare abstract class PPGMeta extends WavesMeta {
+    static builder(): IBuilder<PPGMeta>;
+    static default(): typeof PPGMeta;
+    constructor();
+}
+export declare abstract class PCGMeta extends WavesMeta {
+    static builder(): IBuilder<PCGMeta>;
+    static default(): typeof PCGMeta;
+    constructor();
+}
+export declare abstract class ECGMeta extends WavesMeta {
+    static builder(): IBuilder<ECGMeta>;
+    static default(): typeof ECGMeta;
+    constructor();
+}
+export declare abstract class AppendixMeta extends ImagesMeta {
+    static builder(): IBuilder<AppendixMeta>;
+    static default(): typeof AppendixMeta;
+    constructor();
+}
+export declare abstract class ComplaintMeta extends TextMeta {
+    static builder(): IBuilder<ComplaintMeta>;
+    static default(): typeof ComplaintMeta;
+    constructor();
+}
+export declare class MetaSequence<T extends Meta> extends Sequence<T> {
+    type: MetaType;
+    owner?: Patient;
+    expand: boolean;
+    constructor(type: MetaType, owner?: Patient);
+    init(owner: Patient): void;
+    query(page: number, pageSize: number, startTime?: string, endTime?: string, sort?: string): Promise<Page<Meta>>;
+    append(page: number, pageSize: number, startTime?: string, endTime?: string, sort?: string): Promise<Page<Meta>>;
+    appendMetaWithPatient(page: number, pageSize: number, type?: string, startTime?: string, endTime?: string, sort?: string, name?: string, phoneNumber?: string, startBirthdate?: string, endBirthdate?: string, gender?: string, tags?: Tag[]): Promise<Page<Meta>>;
+}
+export declare const MetaTypeConfig: {
+    face: {
+        type: typeof FaceMeta;
+        name: string;
+        icon: string;
+        color: string;
+    };
+    tongue: {
+        type: typeof TongueMeta;
+        name: string;
+        icon: string;
+        color: string;
+    };
+    complaint: {
+        type: typeof ComplaintMeta;
+        name: string;
+        icon: string;
+        color: string;
+    };
+    pulsation: {
+        type: typeof PulsationMeta;
+        name: string;
+        icon: string;
+        color: string;
+    };
+    ecg: {
+        type: typeof ECGMeta;
+        name: string;
+        icon: string;
+        color: string;
+    };
+    pcg: {
+        type: typeof PCGMeta;
+        name: string;
+        icon: string;
+        color: string;
+    };
+    ppg: {
+        type: typeof PPGMeta;
+        name: string;
+        icon: string;
+        color: string;
+    };
+    scene: {
+        type: typeof SceneMeta;
+        name: string;
+        icon: string;
+        color: string;
+    };
+    appendix: {
+        type: typeof AppendixMeta;
+        name: string;
+        icon: string;
+        color: string;
+    };
+    meta: {
+        type: typeof Meta;
+        name: string;
+        icon: string;
+        color: string;
+    };
+};
+export declare abstract class Metas {
+    static _default: typeof Metas;
+    static builder(): IBuilder<Metas>;
+    static default(): typeof Metas;
+    [MetaType.Face]: MetaSequence<FaceMeta>;
+    [MetaType.Tongue]: MetaSequence<TongueMeta>;
+    [MetaType.Complaint]: MetaSequence<ComplaintMeta>;
+    [MetaType.Pulsation]: MetaSequence<PulsationMeta>;
+    [MetaType.ECG]: MetaSequence<ECGMeta>;
+    [MetaType.PCG]: MetaSequence<PCGMeta>;
+    [MetaType.PPG]: MetaSequence<PPGMeta>;
+    [MetaType.Scene]: MetaSequence<SceneMeta>;
+    [MetaType.Appendix]: MetaSequence<AppendixMeta>;
+    [MetaType.Meta]: MetaSequence<Meta>;
+    faces: MetaSequence<FaceMeta>;
+    tongues: MetaSequence<TongueMeta>;
+    complaints: MetaSequence<ComplaintMeta>;
+    pulsations: MetaSequence<PulsationMeta>;
+    ecgs: MetaSequence<ECGMeta>;
+    pcgs: MetaSequence<PCGMeta>;
+    ppgs: MetaSequence<PPGMeta>;
+    scenes: MetaSequence<SceneMeta>;
+    appendixes: MetaSequence<AppendixMeta>;
+    metas: MetaSequence<Meta>;
+    constructor(metas?: Meta[]);
+    init(owner: Patient): this;
+    query(page: number, pageSize: number, startTime?: string, endTime?: string, sort?: string): Promise<this>;
+    addMetas(metas: Meta[]): this;
+    addMeta(meta: Meta): this;
+    clear(): void;
+    static map(meta: MetaState): Promise<Meta>;
+    static mapText(type: MetaType): string;
+    static standards(): MetaType[];
+}