@persei/perseed-api 4.34.5 → 4.34.6

package/dist/index.d.ts

@@ -0,0 +1,2541 @@
+import { AjvValidator } from 'objection';
+import { default as default_2 } from 'objection';
+import { i18n } from 'i18next';
+import { Knex } from 'knex';
+import { Model } from 'objection';
+import { NumberQueryBuilder } from 'objection';
+import { QueryBuilder } from 'objection';
+import { RelationType } from 'objection';
+import { Request as Request_2 } from 'express';
+import { TFunction } from 'i18next';
+import { Transaction } from 'objection';
+
+declare class AbstractDisplayer extends BaseModel {
+    reference?: SubformReference;
+    crf_name: string;
+    user_ip?: string;
+    creation_user?: number;
+    creation_time: string;
+    mod_user: number;
+    mod_time: string;
+    static getModel(ctx: RequestContext): typeof AbstractDisplayer;
+    static get QueryBuilder(): typeof CustomQueryBuilder;
+    static get uidRefProp(): null;
+    static get dbRefProp(): null;
+    getString(value: any): any;
+    getNumber(value: any): any;
+    $beforeDelete(queryContext: any): Promise<void>;
+    $afterInsert(queryContext: any): Promise<void>;
+    $afterUpdate(opt: any, queryContext: any): Promise<void>;
+    $afterSave(queryContext: any, inserting: any, old: any): Promise<any>;
+    toIdRefResponse(): IdRefForm;
+    getPatientId(): number;
+}
+
+export declare type AggFunction = 'avg' | 'count' | 'max' | 'min' | 'sum';
+
+export declare enum ApiAction {
+    QUESTIONNAIRE_CREATE = "questionnaire.create",
+    CRF_CREATE = "crf.create",
+    CRF_UPDATE = "crf.update",
+    CRF_DELETE = "crf.delete",
+    EXTERNAL_API_CALL = "external_api_call"
+}
+
+declare interface ApiActionContextData {
+    ctx?: RequestContext;
+    requestContextData?: RequestContextData;
+    current: Record<string, unknown>;
+    old?: Record<string, unknown> | null;
+    patient?: AbstractDisplayer;
+    projectId?: number;
+}
+
+/**
+ * App font factor
+ */
+export declare type AppFontFactor = number;
+
+export declare const AUDIT_FLAGS: {
+    added: string;
+    edited: string;
+    deleted: string;
+};
+
+/**
+ * Global authentication security definition
+ */
+export declare interface AuthenticationSecurityDefinition {
+    mfaMethods?: MFAMethod[];
+    required?: boolean;
+    default?: MFAMethodCode;
+}
+
+declare type BaseApiServicePayload = {
+    ctx?: RequestContext;
+} & Partial<ApiActionContextData>;
+
+declare class BaseModel extends Model {
+    id: number;
+    static createValidator(): AjvValidator;
+    static get modelPaths(): string[];
+    $parseJson(json: any, _opt: any): any;
+}
+
+declare interface BaseWidget {
+    size?: number | ColProps;
+}
+
+declare interface CacheOptions {
+    enabled: boolean;
+    requestDependent: boolean;
+    serializable: boolean;
+    ecosystemDependent: boolean;
+    projectDependent: boolean;
+    userDependent: boolean;
+    patientDependent: boolean;
+    tags: Record<string, any>;
+}
+
+declare class Clinic extends BaseModel {
+    name: string;
+    country: string;
+    city: string;
+    address: string;
+    contact: string;
+    owner_id: number | null;
+    location_data: string;
+    zip_code: string;
+    logo: string;
+    userClinic?: UserClinic[];
+    static get tableName(): string;
+    static get jsonSchema(): {
+        type: string;
+        properties: {
+            id: {
+                type: string;
+            };
+            name: {
+                type: string;
+                maxLength: number;
+            };
+            country: {
+                type: string;
+                maxLength: number;
+            };
+            city: {
+                type: string;
+                maxLength: number;
+            };
+            address: {
+                type: string;
+                maxLength: number;
+            };
+            contact: {
+                type: string;
+                maxLength: number;
+            };
+            owner_id: {
+                oneOf: {
+                    type: string;
+                }[];
+            };
+            location_data: {
+                type: string;
+            };
+            zip_code: {
+                type: string;
+                maxLength: number;
+            };
+            logo: {
+                type: string;
+                maxLength: number;
+            };
+        };
+    };
+    static get relationMappings(): {
+        userClinic: {
+            relation: default_2.RelationType;
+            modelClass: string;
+            join: {
+                from: string;
+                to: string;
+            };
+        };
+    };
+    static getModel(ctx: NoUserRequestContext): typeof Clinic;
+    static getAll(ctx: RequestContext, valuesToSelect?: ClinicQuery['select'], whereStatement?: ClinicQuery['where']): Promise<ClinicQuery>;
+    static insert(ctx: RequestContext, data: default_2.PartialModelObject<Clinic>): Promise<number>;
+    static checkIfClinicExists(ctx: RequestContext, clinicId: number): Promise<boolean>;
+    static getClinicsMap(ctx: RequestContext): Promise<{}>;
+}
+
+declare type ClinicQuery = default_2.QueryBuilder<Clinic, Clinic[]>;
+
+export declare interface ColProps {
+    flex?: FlexType;
+    span?: ColSpanType;
+    order?: ColSpanType;
+    offset?: ColSpanType;
+    push?: ColSpanType;
+    pull?: ColSpanType;
+    xs?: ColSpanType | ColSize;
+    sm?: ColSpanType | ColSize;
+    md?: ColSpanType | ColSize;
+    lg?: ColSpanType | ColSize;
+    xl?: ColSpanType | ColSize;
+    xxl?: ColSpanType | ColSize;
+    prefixCls?: string;
+}
+
+export declare interface ColSize {
+    flex?: FlexType;
+    span?: ColSpanType;
+    order?: ColSpanType;
+    offset?: ColSpanType;
+    push?: ColSpanType;
+    pull?: ColSpanType;
+}
+
+export declare type ColSpanType = number | string;
+
+export declare interface ConditionExpression {
+    [field: string]: ConditionValue;
+}
+
+export declare interface ConditionOperator {
+    AND?: Conditions[];
+    OR?: Conditions[];
+    NOT?: Conditions[];
+    JQ?: string;
+}
+
+export declare type Conditions = ConditionExpression | ConditionOperator;
+
+export declare enum ConditionsFormat {
+    JSON_LOGIC = "jsonLogic",
+    CUSTOM = "custom"
+}
+
+/**
+ * Importing the types from json-logic-js makes the process of generating schema.json fails so we use any instead
+ */
+export declare type ConditionsRules = Conditions | any;
+
+export declare interface ConditionValue {
+    equal?: string | number | boolean;
+    not_equal?: string | number | boolean;
+    contains?: string;
+    not_contains?: string;
+    greater_than?: string | number;
+    less_than?: string | number;
+    empty?: string | number | boolean;
+    not_empty?: string | number | boolean;
+    parseValue?: boolean;
+    operator?: 'AND' | 'OR';
+}
+
+declare class ConsentGeneral extends BaseModel {
+    name: string;
+    project_id: number;
+    clinic_id: number | null;
+    title: string;
+    subtitle: string;
+    consent_text_title: string;
+    consent_text: string;
+    timestamp: string;
+    group_meta: ConsentGroupMeta[];
+    static get tableName(): string;
+    static get jsonSchema(): {
+        type: string;
+        properties: {
+            id: {
+                type: string;
+                maxLength: number;
+            };
+            name: {
+                type: string;
+                maxLength: number;
+            };
+            project_id: {
+                type: string;
+                maxLength: number;
+            };
+            clinic_id: {
+                oneOf: {
+                    type: string;
+                }[];
+                maxLength: number;
+            };
+            title: {
+                type: string;
+            };
+            subtitle: {
+                type: string;
+            };
+            consent_text_title: {
+                type: string;
+            };
+            consent_text: {
+                type: string;
+            };
+            timestamp: {
+                type: string;
+                format: string;
+            };
+        };
+        additionalProperties: boolean;
+    };
+    static get relationMappings(): {
+        group_meta: {
+            relation: RelationType;
+            modelClass: string;
+            join: {
+                from: string;
+                to: string;
+            };
+        };
+    };
+    orderConsent(): void;
+}
+
+declare class ConsentGroupMeta extends BaseModel {
+    consent_general_id: number;
+    header: string;
+    footer: string;
+    order: number;
+    timestamp: string;
+    meta: ConsentMeta[];
+    static get tableName(): string;
+    static get jsonSchema(): {
+        type: string;
+        properties: {
+            id: {
+                type: string;
+                maxLength: number;
+            };
+            consent_general_id: {
+                type: string;
+                maxLength: number;
+            };
+            header: {
+                type: string;
+            };
+            footer: {
+                type: string;
+            };
+            order: {
+                type: string;
+                maxLength: number;
+            };
+            timestamp: {
+                type: string;
+                format: string;
+            };
+        };
+        additionalProperties: boolean;
+    };
+    static get relationMappings(): {
+        meta: {
+            relation: RelationType;
+            modelClass: string;
+            join: {
+                from: string;
+                to: string;
+            };
+        };
+    };
+}
+
+declare class ConsentMeta extends BaseModel {
+    consent_group_meta_id: number;
+    specific_consent: string;
+    order: number;
+    required: number;
+    timestamp: string;
+    static get tableName(): string;
+    static get jsonSchema(): {
+        type: string;
+        properties: {
+            id: {
+                type: string;
+                maxLength: number;
+            };
+            consent_group_meta_id: {
+                type: string;
+                maxLength: number;
+            };
+            specific_consent: {
+                type: string;
+            };
+            order: {
+                type: string;
+                maxLength: number;
+            };
+            required: {
+                type: string;
+                maxLength: number;
+            };
+            timestamp: {
+                type: string;
+                format: string;
+            };
+        };
+        additionalProperties: boolean;
+    };
+}
+
+export declare const CORE: {
+    CREATION_TIME: string;
+    CREATION_USER: string;
+    CRF_NAME: string;
+    CRF_STATUS: string;
+    HOSPITAL: string;
+    HOSPITAL_STATUS: string;
+    ID: string;
+    LOCK_STATE: string;
+    LOCK_USER: string;
+    LOCK_DATE: string;
+    MODIFICATION_TIME: string;
+    MODIFICATION_USER: string;
+    PATIENT_ID: string;
+    PATIENT_NUMBER: string;
+    PATIENT_NUMBER_STATUS: string;
+    RECORD_ID: string;
+    SIGNATURE_DATE: string;
+    SIGNATURE_STATE: string;
+    SIGNATURE_USER: string;
+    STATUS: string;
+    USER_IP: string;
+    DATE_OF_QUESTIONNAIRE: string;
+    TIME_OF_QUESTIONNAIRE: string;
+    VERSION: string;
+    REFERENCE: string;
+    SUBFORM_ID: string;
+};
+
+export declare interface CreateDashboardPayload {
+    title: string;
+    active?: boolean;
+    config?: DashboardConfig;
+    icon?: string | null;
+    weight?: number;
+}
+
+export declare interface CreateFormPayload extends BaseApiServicePayload {
+    formName: string;
+    patientId: number;
+    fullBody: any;
+    method?: string;
+    token?: string;
+    qInfoId?: number;
+}
+
+export declare interface CreateQuestionnairePayload {
+    patientId?: number;
+    type: 'unique' | 'periodic';
+    date: string;
+    untilDate?: string;
+    formName: string;
+}
+
+export declare interface CreateTriggerPayload {
+    notified_about: NotifiedAboutType;
+    text_content?: string;
+    configuration?: NotificationConfigurationConf;
+}
+
+declare class CustomQueryBuilder<M extends Model = Model, R = M[]> extends QueryBuilder<M, R> {
+    delete(): this;
+    nativeDelete(): NumberQueryBuilder<this>;
+}
+
+export declare interface DashboardConfig {
+    widgets?: Widget[];
+}
+
+export declare enum DashboardWidgetType {
+    VALUECARD = "ValueCard",
+    SECTIONCARD = "SectionCard",
+    PATIENTLIST = "PatientList"
+}
+
+/**
+ * Any changes here may need changes in Caaring-js packages/perseed-react-ui-components/src/dashboards/types.ts
+ */
+export declare enum DataLoaderType {
+    OUTCOMES = "outcomes"
+}
+
+export declare const DATE_FORMAT = "YYYY-MM-DD";
+
+export declare const DATE_TYPE: string[];
+
+export declare const DATETIME_SHORT_FORMAT = "YYYY-MM-DD HH:mm";
+
+export declare const DEFAULT_CONFIGURATION_PATIENT_LIST: {
+    id: string;
+    name: string;
+    type: string;
+    label: string;
+    required: string;
+    crf_name: string;
+    status: string;
+}[];
+
+export declare interface DeleteFormPayload extends BaseApiServicePayload {
+    formId: number;
+    formName: string;
+}
+
+export declare const DYNAMIC_FILE_VALID_FORMATS: {
+    1: string[];
+    2: string[];
+    3: string[];
+    4: string[];
+    5: string[];
+};
+
+declare type EcosystemUsers = {
+    ecosystem: string;
+    id: number;
+    password: string;
+    username: string;
+    email: string;
+    loginId: string;
+    displayName: string;
+    label: string;
+    type: string;
+    tz: string;
+};
+
+export declare const EXCLUDE_FIELDS: string[];
+
+declare class ExternalDisplayerCrf extends BaseModel {
+    crf_name: string;
+    patient_id: number;
+    external_form_id: number;
+    external_project_id: number;
+    static get tableName(): string;
+    static get jsonSchema(): {
+        type: string;
+        properties: {
+            id: {
+                type: string;
+                maxLength: number;
+            };
+            crf_name: {
+                type: string;
+                maxLength: number;
+            };
+            patient_id: {
+                type: string;
+                maxLength: number;
+            };
+            external_form_id: {
+                type: string;
+                maxLength: number;
+            };
+            external_project_id: {
+                type: string;
+                maxLength: number;
+            };
+        };
+        additionalProperties: boolean;
+    };
+    static getModelByPool(projectPool: default_2.TransactionOrKnex): typeof ExternalDisplayerCrf;
+    static insert(ctx: RequestContext, data: default_2.PartialModelObject<ExternalDisplayerCrf>): Promise<number>;
+}
+
+declare class ExternalPatientProject extends BaseModel {
+    project_id: number;
+    patient_id: number;
+    external_project_id?: number;
+    external_patient_id?: number;
+    projectCrfs: ExternalDisplayerCrf[];
+    projectFields: ExternalProjectFields;
+    static get tableName(): string;
+    static get jsonSchema(): {
+        type: string;
+        properties: {
+            project_id: {
+                type: string;
+                maxLength: number;
+            };
+            patient_id: {
+                type: string;
+                maxLength: number;
+            };
+            external_project_id: {
+                oneOf: {
+                    type: string;
+                }[];
+                default: null;
+                maxLength: number;
+            };
+            external_patient_id: {
+                oneOf: {
+                    type: string;
+                }[];
+                default: null;
+                maxLength: number;
+            };
+        };
+        additionalProperties: boolean;
+    };
+    static get relationMappings(): {
+        projectFields: {
+            relation: default_2.RelationType;
+            modelClass: string;
+            join: {
+                from: string;
+                to: string;
+            };
+        };
+        projectCrfs: {
+            relation: default_2.RelationType;
+            modelClass: string;
+            join: {
+                from: string;
+                to: string;
+            };
+        };
+    };
+    static getModelByPool(projectPool: default_2.TransactionOrKnex): typeof ExternalPatientProject;
+    static getExternalValues(projectPool: default_2.TransactionOrKnex, projectId: number, patientId: number): Promise<ExternalPatientProject[]>;
+    getExternalFormId(formName: string, formId: number): number | null;
+}
+
+declare class ExternalProjectFields extends BaseModel {
+    project_id: number;
+    fields: string;
+    static get tableName(): string;
+    static get jsonSchema(): {
+        type: string;
+        properties: {
+            id: {
+                type: string;
+                maxLength: number;
+            };
+            project_id: {
+                type: string;
+                maxLength: number;
+            };
+            fields: {
+                type: string;
+            };
+        };
+        additionalProperties: boolean;
+    };
+    static getModel(projectPool: default_2.TransactionOrKnex): typeof ExternalProjectFields;
+}
+
+export declare const FIELD_NAMES: {
+    DECIMAL_NAME: string;
+    INTEGER_NAME: string;
+    MULTIPLE_SELECTION_NAME: string;
+    SELECTION_NAME: string;
+    DYNAMIC_SELECTION_NAME: string;
+    DATE_NAME: string;
+    HEADER_NAME: string;
+    SUBHEADER_NAME: string;
+    WARNING_NAME: string;
+    SUBFORM_NAME: string;
+    MEMO_NAME: string;
+    TEXT_NAME: string;
+    TEXT_AREA_NAME: string;
+    YES_NO_NAME: string;
+    TIME_NAME: string;
+    LINK_HREF_NAME: string;
+    COUNTRY_NAME: string;
+    HOSPITAL_NAME: string;
+    USERS_NAME: string;
+    DYNAMIC_FILE_NAME: string;
+    DYNAMIC_LINK_HREF_NAME: string;
+    SCAN_CODE_NAME: string;
+    PARAGRAPH_NAME: string;
+    FILE_NAME: string;
+};
+
+export declare const FIELD_NAMES_MAP: () => {};
+
+export declare const FIELD_STATUS: {
+    filled: string;
+    unk: string;
+    na: string;
+    nd: string;
+};
+
+/**
+ * @deprecated Use STATUS_SUFFIX instead
+ * @type {string}
+ */
+export declare const FIELD_SUFFIX = "_status";
+
+export declare const FIELDS: {
+    DECIMAL: number;
+    INTEGER: number;
+    MULTIPLE_SELECTION: number;
+    SELECTION: number;
+    DYNAMIC_SELECTION: number;
+    DATE: number;
+    HEADER: number;
+    SUBHEADER: number;
+    WARNING: number;
+    SUBFORM: number;
+    MEMO: number;
+    TEXT: number;
+    TEXT_AREA: number;
+    YES_NO: number;
+    TIME: number;
+    LINK_HREF: number;
+    COUNTRY: number;
+    HOSPITAL: number;
+    USERS: number;
+    DYNAMIC_FILE: number;
+    DYNAMIC_LINK_HREF: number;
+    SCAN_CODE: number;
+    PARAGRAPH: number;
+    FILE: number;
+};
+
+export declare interface FilterParams {
+    conditions?: Record<string, unknown>;
+    relatedData?: {
+        join?: string[];
+    };
+}
+
+export declare type FlexType = number | 'none' | 'auto' | string;
+
+export declare const FORM_NAMES: {
+    PATIENT: string;
+    SEPARATOR: string;
+};
+
+export declare const FORM_SUFFIX: {
+    AUDIT: string;
+};
+
+export declare const FORM_TYPES: {
+    STANDARD: number;
+    FOLLOW_UP: number;
+    ADVERSE_EVENT: number;
+    QUESTIONNAIRE: number;
+    STUDY: number;
+};
+
+export declare type GenericBooleanSetting = boolean;
+
+export declare interface GenericWidgetDataLoader {
+    type: DataLoaderType;
+    params: Record<string, any>;
+}
+
+export declare function getIntrospectionSchema(t: TFunction): IntrospectionSchema;
+
+export declare const HREF_TYPE: {
+    NEW_WINDOW: string;
+    EMBEDDED_HTML: string;
+};
+
+export declare interface I18nTextLocales {
+    [locale: string]: string;
+    default: string;
+}
+
+export declare type I18nTextTranslation = I18nTextLocales | string;
+
+declare interface IdRefForm {
+    syncId?: number;
+    id: number;
+}
+
+export declare interface IntrospectionField {
+    name: string;
+    type: IntrospectionSchemaType;
+    options?: {
+        value: string;
+        title: string;
+    }[];
+    label: string;
+}
+
+export declare interface IntrospectionOption {
+    value: string;
+    label: string;
+}
+
+export declare interface IntrospectionSchema {
+    models: Record<string, IntrospectionSchemaModel>;
+    externalApis?: {
+        value: string;
+        label: string;
+        methods?: string | string[];
+    }[];
+}
+
+export declare interface IntrospectionSchemaModel {
+    label: string;
+    fields: IntrospectionField[];
+    relations?: IntrospectionOption[];
+    canJoinPatient?: boolean;
+}
+
+export declare enum IntrospectionSchemaType {
+    TEXT = "text",
+    DATE = "date",
+    TIME = "time",
+    BOOLEAN = "boolean",
+    NUMBER = "number",
+    SELECT = "select",
+    MULTISELECT = "multiselect"
+}
+
+export declare const isNotStatusField: (fieldName: any) => boolean;
+
+declare interface LoadPatientDataType {
+    join?: string[];
+    where: Record<string, string> | 'auto';
+}
+
+export declare const META_NAMES: {
+    DEPENDENT_SOURCE: string;
+    ENCRYPTED: string;
+    ENCRYPTED_LEVEL: string;
+    EXTERNAL_SHARING: string;
+    SHOW_EMBEDDED_PDF: string;
+    HIDDEN: string;
+    IS_CRF_MAIN_FIELD: string;
+    MIN_VALUE: string;
+    MIN_VALUE_VALIDATION: string;
+    MAX_VALUE: string;
+    MAX_VALUE_VALIDATION: string;
+    NEXT_FORM: string;
+    MULTIPLE: string;
+    ORDER: string;
+    READ_ONLY: string;
+    REQUIRED: string;
+    REQUIRED_TYPE: string;
+    SELECTION_VALUE: string;
+    SELECTION_VALUE_SLIDER: string;
+    SOURCE_FIELD: string;
+    TYPE: string;
+    TYPE_QUESTIONARY: string;
+    QUESTION_DAYS: string;
+    QUESTION_TIME: string;
+    QUESTION_HOURS: string;
+    QUESTION_MINUTES: string;
+    REMINDER_DAYS: string;
+    REMINDER_HOURS: string;
+    REMINDER_MINUTES: string;
+    REMINDER_SUBJECT: string;
+    REMINDER_MESSAGE: string;
+    MAX_NUMBER_REMINDER: string;
+    NUMBER_QUESTION_PAGE: string;
+    UNTIL: string;
+    NUMBER_OF_QUESTIONAIRES: string;
+    QUESTION_COMMENTS: string;
+    TYPE_OF_QUESTIONNAIRE: string;
+    HISTORY_OF_QUESTIONNAIRE: string;
+    HISTORY: string;
+    CRF_HISTORY: string;
+    PROCEDURE_CONDITION: string;
+    HREF_VALUE: string;
+    HREF_TYPE: string;
+    SIZE: string;
+    FILE_TYPE: string;
+    INPUT_TYPE: string;
+    PARAGRAPH_CONTENT: string;
+    FILE_VALUE: string;
+    WINDOW_REFERENCE: string;
+    START_DATE_DAYS: string;
+    HAS_DEFAULT_VALUE: string;
+    SPECIFIC_VALUE: string;
+    DEFAULT_VALUE: string;
+    UNIQUE: string;
+    HELP: string;
+    SELECTOR_TYPE: string;
+    SLIDER_SELECTOR: string;
+    SLIDER_SCALE_ORIENTATION: string;
+    UNTIL_DATE: string;
+    PAGE_BREAK: string;
+    WINDOW_BEFORE: string;
+    WINDOW_AFTER: string;
+    WINDOW_PERIOD: string;
+};
+
+export declare const META_RESTRICTION: {
+    STRICT: string;
+    FLEXIBLE: string;
+};
+
+export declare const META_STATUS: {
+    ACTIVE: string;
+};
+
+export declare interface MFALoginData {
+    type: MFAMethodCode;
+    value: string;
+}
+
+/**
+ * MFA method definition and configuration
+ */
+export declare interface MFAMethod {
+    code: MFAMethodCode;
+}
+
+/**
+ * Available MFA methods
+ */
+export declare type MFAMethodCode = 'sms' | 'email';
+
+declare type ModelName = string;
+
+export declare const MULTIPLE_SELECTION_SEPARATOR = "~";
+
+export declare const MYSQL_DATE_FORMAT = "YYYY-MM-DD";
+
+export declare const MYSQL_DATETIME_FORMAT = "YYYY-MM-DD HH:mm:ss";
+
+export declare const NO_FILL_STATUS: string[];
+
+export declare interface NotificationConfigurationConf {
+    conditions?: ConditionsRules;
+    join?: string[];
+    load_patient?: LoadPatientDataType;
+    action?: ApiAction;
+    conditionsFormat?: ConditionsFormat;
+}
+
+export declare type NotifiedAboutType = `model_${ModelName}` | `model_displayer_${ModelName}` | `model_${ModelName}_${TriggerAction}` | `model_displayer_${ModelName}_${TriggerAction}`;
+
+declare type NoUserRequestContext = Omit<RequestContext, 'userId' | 'patientId' | 'ip' | 'user' | 'userLanguage' | 'coreProfiling' | 'userRole' | 'loginId'>;
+
+export declare const NUMBER_TYPE: string[];
+
+export declare const OBJECT_TYPE: string[];
+
+declare type Optional<T, K extends keyof T> = Pick<Partial<T>, K> & Omit<T, K>;
+
+/**
+ * Any changes here may need changes in Caaring-js packages/perseed-api-client/src/PerseedApiClient.ts
+ */
+export declare type OrderDir = 'asc' | 'desc';
+
+export declare type Outcome = OutcomeDateGroup & {
+    name: string;
+    identifier: string;
+    from: string;
+    to: string;
+    value: number;
+};
+
+export declare type OutcomeDateField = `${OutcomesDateFields}.${OutcomesDateFunctions}`;
+
+export declare interface OutcomeDateGroup {
+    [dateGroup: string]: string;
+}
+
+export declare type OutcomesDateFields = 'from' | 'to';
+
+export declare type OutcomesDateFunctions = 'date' | 'day' | 'dayname' | 'dayofmonth' | 'dayofweek' | 'dayofyear' | 'hour' | 'minute' | 'month' | 'monthname' | 'time' | 'second' | 'week' | 'weekday' | 'weekofyear' | 'year' | 'yearweek';
+
+export declare type OutcomesGroupBy = 'name' | 'identifier' | 'value' | OutcomesDateFields | OutcomeDateField;
+
+export declare interface OutcomesParams {
+    ecosystem: string;
+    projectName: string;
+    clinicId?: number;
+    name: string | string[];
+    identifier?: string | string[];
+    from?: string;
+    to?: string;
+    datesContained?: boolean;
+    aggType?: AggFunction;
+    groupBy?: OutcomesGroupBy | OutcomesGroupBy[];
+    limit?: number;
+    orderBy?: string;
+    orderDir?: OrderDir;
+}
+
+export declare interface PatientListProps {
+    loadUserProfiles?: boolean;
+    loadAdherence?: boolean;
+    extraFields?: string[];
+    loadPushTokens?: boolean;
+    loadUserAccessData?: boolean;
+    programId?: number | null;
+    prevAdherenceDays?: number | null;
+    filter?: FilterParams;
+}
+
+declare class Profiling extends BaseModel {
+    name: string;
+    description: string;
+    timestamp: string;
+    project_id: number | null;
+    profile_type: string | null;
+    parent_id: number | null;
+    seedPrivileges: SeedPrivilege[];
+    enabledCrfs?: ProfilingEnableCp;
+    addRepeatCrfs?: ProfilingAddRepeatCrf[];
+    deleteRepeatCrfs?: ProfilingDeleteRepeatCrf[];
+    privilegesDenied?: ProfilingPrivilegeDenied[];
+    profilingSelections?: ProfilingSelected[];
+    static get tableName(): string;
+    static get jsonSchema(): {
+        type: string;
+        properties: {
+            id: {
+                type: string;
+                maxLength: number;
+            };
+            name: {
+                type: string;
+                maxLength: number;
+            };
+            description: {
+                type: string;
+            };
+            timestamp: {
+                type: string;
+                format: string;
+            };
+            project_id: {
+                oneOf: {
+                    type: string;
+                }[];
+                default: null;
+                maxLength: number;
+            };
+            profile_type: {
+                oneOf: {
+                    type: string;
+                }[];
+                default: null;
+                maxLength: number;
+            };
+            parent_id: {
+                oneOf: {
+                    type: string;
+                }[];
+                default: null;
+                maxLength: number;
+            };
+        };
+        additionalProperties: boolean;
+    };
+    static get relationMappings(): {
+        seedPrivileges: {
+            relation: RelationType;
+            modelClass: string;
+            join: {
+                from: string;
+                through: {
+                    from: string;
+                    to: string;
+                };
+                to: string;
+            };
+        };
+        addRepeatCrfs: {
+            relation: RelationType;
+            modelClass: string;
+            join: {
+                from: string;
+                to: string;
+            };
+        };
+        deleteRepeatCrfs: {
+            relation: RelationType;
+            modelClass: string;
+            join: {
+                from: string;
+                to: string;
+            };
+        };
+        enabledCrfs: {
+            relation: RelationType;
+            modelClass: string;
+            join: {
+                from: string;
+                to: string;
+            };
+        };
+        privilegesDenied: {
+            relation: RelationType;
+            modelClass: string;
+            join: {
+                from: string;
+                to: string;
+            };
+        };
+        profilingSelections: {
+            relation: RelationType;
+            modelClass: string;
+            join: {
+                from: string;
+                to: string;
+            };
+        };
+    };
+    static getModel(ctx: RequestContext): typeof Profiling;
+    static getFirstProProfilingId(ctx: RequestContext, projectId: number): Promise<number | undefined>;
+    isProProfiling(seedPrivileges: SeedPrivilege[]): boolean;
+    static hasAddPatient(seedPrivilegeName: string): boolean;
+    static hasConfigNotifications(seedPrivilegeName: string): boolean;
+    static hasManageUsers(seedPrivilegeName: string): boolean;
+    static hasCoreProUserSensitiveInfo(seedPrivilegeName: string): boolean;
+    static hasUsersManagementOrganization(seedPrivilegeName: string): boolean;
+    static hasAllowToControl(seedPrivilegeName: string): boolean;
+    static hasOnlyUpdatePatientsApiPermission(seedPrivilegeName: string): boolean;
+    static hasUploadDocumentsPermission(seedPrivilegeName: string): boolean;
+    static hasDeleteDocumentsPermission(seedPrivilegeName: string): boolean;
+    static hasDownloadDocumentsPermission(seedPrivilegeName: string): boolean;
+    static hasDisplayPatientListPrivilege(seedPrivilegeName: string): boolean;
+    hasManageUsersPrivilege(): boolean;
+    hasCoreProUserSensitiveInfoPrivilege(): boolean;
+    hasUserManagementMyOrganizationsPrivilege(): boolean;
+    hasAllowControlProfilesPrivilege(): boolean;
+    hasDeletePatientPrivilege(): boolean;
+    hasFullDeletePatientPrivilege(): boolean;
+    hasAddRepeatableCrfPrivilege(): boolean;
+    hasDeleteRepeatableCrfPrivilege(): boolean;
+    hasEnableCpPrivilege(): boolean;
+    hasNotificationLogPrivilege(): boolean;
+    hasMyNotificationLogPrivilege(): boolean;
+    hasAllPatientListPrivilege(): boolean;
+    hasOnlyMyPatients(): boolean;
+    hasConnectorAddCpPrivilege(): boolean;
+    hasConnectorAddCrfPrivilege(): boolean;
+    hasConnectorAddFieldPrivilege(): boolean;
+    hasRawExportPrivilege(): boolean;
+    hasExportConfigurationsExplicitAccessOnlyPrivilege(): boolean;
+    static checkIfProfilingExists(ctx: RequestContext, profilingId?: number): Promise<boolean>;
+    isPro(): boolean;
+    isNonPro(): boolean;
+    hasEnabledForm(formName: any): boolean;
+    hasAddRepeatCrf(formName: any): boolean;
+    hasDeleteRepeatCrf(formName: any): boolean;
+    hasViewPermission(formName: any): boolean;
+}
+
+declare class ProfilingAddRepeatCrf extends BaseModel {
+    profiling_id: number;
+    crf_name: string;
+    static get tableName(): string;
+    static get jsonSchema(): {
+        type: string;
+        properties: {
+            id: {
+                type: string;
+            };
+            profiling_id: {
+                type: string;
+            };
+            crf_name: {
+                type: string;
+            };
+        };
+    };
+    static getModel(ctx: RequestContext): typeof ProfilingAddRepeatCrf;
+}
+
+declare class ProfilingDeleteRepeatCrf extends BaseModel {
+    profiling_id: number;
+    crf_name: string;
+    static get tableName(): string;
+    static get jsonSchema(): {
+        type: string;
+        properties: {
+            id: {
+                type: string;
+            };
+            profiling_id: {
+                type: string;
+            };
+            crf_name: {
+                type: string;
+            };
+        };
+    };
+    static getModel(ctx: RequestContext): typeof ProfilingDeleteRepeatCrf;
+}
+
+declare class ProfilingEnableCp extends BaseModel {
+    profiling_id: number;
+    cp: string;
+    crfs: string;
+    static get tableName(): string;
+    static get jsonSchema(): {
+        type: string;
+        properties: {
+            id: {
+                type: string;
+            };
+            profiling_id: {
+                type: string;
+            };
+            cp: {
+                type: string;
+            };
+            crfs: {
+                type: string;
+            };
+        };
+    };
+    static getModel(ctx: RequestContext): typeof ProfilingEnableCp;
+}
+
+declare class ProfilingPrivilegeDenied extends BaseModel {
+    profiling_id: number;
+    crf_name: string;
+    permission_name: string;
+    static get tableName(): string;
+    static get jsonSchema(): {
+        type: string;
+        properties: {
+            id: {
+                type: string;
+            };
+            profiling_id: {
+                type: string;
+            };
+            crf_name: {
+                type: string;
+            };
+            permission_name: {
+                type: string;
+            };
+        };
+    };
+    static getModel(ctx: RequestContext): typeof ProfilingPrivilegeDenied;
+}
+
+declare class ProfilingSelected extends BaseModel {
+    profiling_id: number | null;
+    profiling_selected_id: number | null;
+    static get tableName(): string;
+    static get jsonSchema(): {
+        type: string;
+        properties: {
+            id: {
+                type: string;
+                maxLength: number;
+            };
+            profiling_id: {
+                oneOf: {
+                    type: string;
+                }[];
+                maxLength: number;
+            };
+            profiling_selected_id: {
+                oneOf: {
+                    type: string;
+                }[];
+                maxLength: number;
+            };
+        };
+        additionalProperties: boolean;
+    };
+    static getModel(ctx: RequestContext): typeof ProfilingSelected;
+}
+
+declare class Project extends BaseModel {
+    ecosystem: number;
+    user_id: number;
+    user_mode: string;
+    name: string;
+    label: string;
+    description: string;
+    database_name: string;
+    hostname: string;
+    username: string;
+    password: string;
+    database_name_training: string;
+    hostname_training: string;
+    username_training: string;
+    password_training: string;
+    database_name_production: string;
+    hostname_production: string;
+    username_production: string;
+    password_production: string;
+    mobile_customization: number;
+    mobile_description: string;
+    mobile_icon: string;
+    mobile_splash: string;
+    contact_phone: string;
+    external_ecosystem_name: string | null;
+    clinics: Clinic[];
+    static get tableName(): string;
+    static get jsonSchema(): {
+        type: string;
+        required: string[];
+        properties: {
+            id: {
+                type: string;
+            };
+            ecosystem: {
+                type: string;
+            };
+            user_id: {
+                type: string;
+            };
+            user_mode: {
+                type: string;
+                maxLength: number;
+            };
+            name: {
+                type: string;
+                maxLength: number;
+            };
+            label: {
+                type: string;
+                maxLength: number;
+            };
+            description: {
+                type: string;
+            };
+            database_name: {
+                type: string;
+                maxLength: number;
+            };
+            hostname: {
+                type: string;
+                maxLength: number;
+            };
+            username: {
+                type: string;
+                maxLength: number;
+            };
+            password: {
+                type: string;
+                maxLength: number;
+            };
+            database_name_training: {
+                type: string;
+                maxLength: number;
+            };
+            hostname_training: {
+                type: string;
+                maxLength: number;
+            };
+            username_training: {
+                type: string;
+                maxLength: number;
+            };
+            password_training: {
+                type: string;
+                maxLength: number;
+            };
+            database_name_production: {
+                type: string;
+                maxLength: number;
+            };
+            hostname_production: {
+                type: string;
+                maxLength: number;
+            };
+            username_production: {
+                type: string;
+                maxLength: number;
+            };
+            password_production: {
+                type: string;
+                maxLength: number;
+            };
+            mobile_customization: {
+                type: string;
+            };
+            mobile_description: {
+                type: string;
+            };
+            mobile_icon: {
+                type: string;
+                maxLength: number;
+            };
+            mobile_splash: {
+                type: string;
+                maxLength: number;
+            };
+            contact_phone: {
+                type: string;
+                maxLength: number;
+            };
+            external_ecosystem_name: {
+                oneOf: {
+                    type: string;
+                }[];
+                default: null;
+                maxLength: number;
+            };
+        };
+    };
+    static get relationMappings(): {
+        clinics: {
+            relation: default_2.RelationType;
+            modelClass: string;
+            join: {
+                from: string;
+                through: {
+                    from: string;
+                    to: string;
+                };
+                to: string;
+            };
+        };
+    };
+    static getModel(ctx: RequestContext): typeof Project;
+    static getModelByPool(ecosystemPool: default_2.TransactionOrKnex): typeof Project;
+    static checkIfProjectExists(ctx: RequestContext, projectId: number): Promise<boolean>;
+    static getProjectIdByName(ctxOrEcosystemPool: RequestContext | default_2.TransactionOrKnex, projectName: string): Promise<number | undefined>;
+    static getProjectIdByNameOrFail(ctx: RequestContext, projectName?: string | null): Promise<number>;
+    static getProjectName(ctx: RequestContext, projectId: number): Promise<string | undefined>;
+    static getExternalEcosystemName(ctx: RequestContext, projectId: number): Promise<string | null | undefined>;
+    static getProjectLabel(ctx: RequestContext, projectName: string): Promise<string | undefined>;
+}
+
+declare enum QuestionnaireInfoUpdateMode {
+    START_OVER = 0,
+    RESUME = 1
+}
+
+declare interface QuestionnaireInfoUpdateOptions {
+    defaultMode: QuestionnaireInfoUpdateMode;
+    referenceFieldIdModes?: {
+        [key: string]: QuestionnaireInfoUpdateMode;
+    };
+}
+
+/**
+ * req.body object mfa validation
+ */
+export declare interface ReqBodyWithMFA {
+    mfa?: MFALoginData;
+    [key: string]: any;
+}
+
+declare class RequestCache_2 {
+    cache: Record<string, any>;
+    cacheHits: Record<string, number>;
+    redisCacheHits: Record<string, number>;
+    nodeCacheHits: Record<string, number>;
+    ctx: RequestContext;
+    constructor(ctx: RequestContext);
+    get ecosystem(): string | null | undefined;
+    get project(): string | null | undefined;
+    get userId(): number | undefined;
+    get patientId(): number | undefined;
+    /**
+     * Merge options
+     * @param {object} options
+     * @return {*&{projectDependent: boolean, patientDependent: boolean, userDependent: boolean, requestDependent: boolean, serializable: boolean, ecosystemDependent: boolean}}
+     */
+    getOptions(options: any): CacheOptions;
+    /**
+     * @param {string} key
+     * @param {object} options
+     * @return {string}
+     */
+    getCacheKey(key: any, options: any): string;
+    getTagsWithDependencyTags(options: CacheOptions): {
+        [x: string]: any;
+    };
+    /**
+     * Add an item to the cache
+     * @param {string} key
+     * @param {any} value
+     * @param {any} opt
+     * @return {any}
+     */
+    add<T = any>(key: string, value: T, opt?: Partial<CacheOptions>): T;
+    addToLocal<T>(key: any, value: any, tags?: {}, options?: Partial<CacheOptions>): T;
+    addToRedis(key: any, value: any, tags?: {}, options?: Partial<CacheOptions>): any;
+    _addToRequestCache(key: any, value: any): void;
+    _addToRedisCache(key: any, value: any, tags: any): void;
+    _addToNodeCache(key: any, value: any, tags: any): void;
+    /**
+     * Get an item from the cache
+     * @param {string} key
+     * @param {any} defaultValue
+     * @param {any} options
+     * @return {any}
+     */
+    get(key: any, defaultValue?: null, options?: Partial<CacheOptions>): Promise<any>;
+    /**
+     * Return cached value from local node cache
+     * This function is used in not async environments
+     * @param key
+     * @param defaultValue
+     * @param options
+     * @return {null|*}
+     */
+    getFromLocal<T = any>(key: any, defaultValue?: T | null, options?: Partial<CacheOptions>): T | null;
+    /**
+     * Return cached value from local node cache
+     * This function is used in not async environments
+     * @param key
+     * @param defaultValue
+     * @param options
+     * @return {null|*}
+     */
+    getFromRequest(key: any, defaultValue?: null, options?: Partial<CacheOptions>): any;
+    getFromRedis(key: any, defaultValue?: null, options?: Partial<CacheOptions>): any;
+    _getFromRequestCache(key: any): any;
+    _getFromRedisCache(key: any): Promise<any>;
+    _getFromNodeCache(key: any): any;
+    clearDesigner(crf: any): void;
+    clearForm(crf: any, id: any): void;
+}
+
+declare class RequestContext implements RequestContextData {
+    ecosystemName?: string | null;
+    projectName?: string | null;
+    userId?: number;
+    patientId?: number;
+    ip?: string;
+    cache: RequestCache_2;
+    loginId?: string;
+    user?: User;
+    userLanguage?: string;
+    ecosystemPool?: Knex;
+    projectPool?: Knex;
+    perseedPool?: Knex;
+    ecosystemTrx?: Transaction;
+    tz: string;
+    reqId?: string;
+    i18n: i18n;
+    projectTrx?: Transaction;
+    projectTrxPile: Transaction[];
+    ecosystemTrxPile: Transaction[];
+    coreProfiling?: 'NonPRO' | 'PRO';
+    userRole?: string;
+    projectId?: number;
+    ecosystemId?: number;
+    /**
+     * Compatibility prop, should be removed in the future
+     */
+    params: {
+        ecosystemName?: string | null;
+        projectName?: string | null;
+    };
+    static create(data: RequestContextData): Promise<RequestContext>;
+    static createFromRequest(req: Request_2): Promise<RequestContext>;
+    static getRequestDataWithUser(req: Optional<Request_2, 'ctx'>, u: Partial<UserData>): RequestContextData;
+    static getRequestData(req: Optional<Request_2, 'ctx'>): Partial<RequestContextData>;
+    getStaticRequestDataWithUser(u: EcosystemUsers): {
+        ecosystemName: string | null;
+        projectName?: string | null | undefined;
+        loginId: string;
+        userId: number;
+        userLanguage?: string | undefined;
+        ip?: string | undefined;
+        tz: string;
+        i18n?: i18n | undefined;
+        reqId?: string | undefined;
+    };
+    getStaticRequestData(): Partial<RequestContextData>;
+    private constructor();
+    private init;
+    updateContextData(data: Partial<RequestContextData>): Promise<void>;
+    get userType(): string | undefined;
+    get acceptLanguage(): string;
+    getRequestContextData(): RequestContextData;
+    cloneWithData(data: Partial<RequestContextData>): Promise<RequestContext>;
+    get t(): TFunction<["translation", ...string[]], undefined>;
+    getProjectPool(): Knex;
+    getEcosystemPool(): Knex;
+    getPerseedPool(): Knex;
+    getUserId(): number;
+    getUser(throwException?: true): User;
+    getUser(throwException: false): User | undefined;
+    getProjectName(): string;
+    getProjectId(): number;
+    getEcosystemName(): string;
+    getEcosystemId(): number;
+    getPatientId(): number;
+}
+
+declare interface RequestContextData {
+    ecosystemName?: string | null;
+    projectName?: string | null;
+    loginId?: string;
+    userId?: number;
+    userLanguage?: string;
+    ip?: string;
+    tz: string;
+    i18n?: i18n;
+    reqId?: string;
+}
+
+declare class Role extends BaseModel {
+    roleId: string;
+    parent_id: number;
+    static get tableName(): string;
+    static get jsonSchema(): {
+        type: string;
+        properties: {
+            id: {
+                type: string;
+            };
+            roleId: {
+                type: string;
+            };
+            parent_id: {
+                type: string;
+            };
+        };
+    };
+    static getModel(ctx: RequestContext): typeof Role;
+    static getIdByRoleId(ctx: RequestContext, roleId: string): Promise<number | undefined>;
+}
+
+export declare interface SectionCardProps {
+    icon: string;
+    background?: string;
+    titleBackground?: string;
+    title: I18nTextTranslation;
+    widgets: Widget[];
+}
+
+/**
+ * Seed Privilege constants
+ */
+declare const SEED_PRIVILEGE: {
+    readonly ADD_PATIENT: "add_patient";
+    readonly ADD_REPEATABLE_CRF: "add_repeat_crf";
+    readonly ADVANCED_FILTER: "advanced_filter";
+    readonly ALL_PATIENT_LIST: "all_patient_list";
+    readonly ALLOW_TO_CONTROL_THESE_PROFILES: "core_control_profile";
+    readonly CONNECTOR_ADD_CP: "connector_add_cp";
+    readonly CONNECTOR_ADD_CRF: "connector_add_crf";
+    readonly CONNECTOR_ADD_FIELD: "connector_add_field";
+    readonly CORE_NOT_ALLOW_ACCESS_SENSITIVE_INFO: "core_not_allow_access_sensitive_info";
+    readonly CORE_NOTIFICATION_LOG: "core_notification_log";
+    readonly CORE_NOTIFICATION_MY_LOG: "core_notification_my_log";
+    readonly DELETE_PATIENT: "delete_patient";
+    readonly FULL_DELETE_PATIENT: "full_delete_patient";
+    readonly DELETE_REPEATABLE_CRF: "delete_crf";
+    readonly EXPORT_ANONYMIZED: "export_anonymized";
+    readonly ENABLE_CP: "enable_cp";
+    readonly EXPORT_MY_HOSPITALS: "export_my_hospitals";
+    readonly EXPORT_NOT_ALLOW_ACCESS_SENSITIVE_INFO: "export_not_allow_access_sensitive_info";
+    readonly EXPORT_USER_TIMESTAMP: "export_user_timestamp";
+    readonly EXPORT_RAW: "export_raw";
+    readonly FILTER_ALL: "filter_all";
+    readonly FILTER_MY_HOSPITALS: "filter_my_hospitals";
+    readonly MANAGE_USERS: "core_manage_user";
+    readonly CORE_PRO_USER_SENSITIVE_INFO: "core_pro_user_sensitive_info";
+    readonly NOTIFICATIONS: "core_notification_seed";
+    readonly ONLY_MY_PATIENTS: "only_my_patients";
+    readonly ONLY_UPDATE_PATIENTS_API: "only_update_patients";
+    readonly PRO_USER: "core_pro_user";
+    readonly USERS_MANAGEMENT_FOR_MY_ORGANIZATIONS: "core_manage_user_hospital";
+    readonly UPLOAD_DOCUMENTS: "add";
+    readonly DELETE_DOCUMENTS: "delete";
+    readonly READ_DOCUMENTS: "read";
+    readonly DISPLAY_PATIENT_LIST: "advanced_patient_list";
+    readonly EXPORT_CONFIGURATION_EXPLICIT_ACCESS: "export_configurations_explicit_access_only";
+    readonly FOLLOWUP_DASHBOARD: "followup_dashboard";
+    readonly TRIGGERS_MANAGEMENT: "triggers_management";
+};
+
+declare type SEED_PRIVILEGE_Keys = keyof typeof SEED_PRIVILEGE;
+
+declare type SEED_PRIVILEGES = typeof SEED_PRIVILEGE[SEED_PRIVILEGE_Keys];
+
+declare class SeedPrivilege extends BaseModel {
+    seed_id: number;
+    name: string;
+    label: string;
+    description: string;
+    timestamp: string;
+    controller: string;
+    action: string;
+    param: string;
+    is_relate_extra_control: number;
+    static get tableName(): string;
+    static get jsonSchema(): {
+        type: string;
+        properties: {
+            id: {
+                type: string;
+                maxLength: number;
+            };
+            seed_id: {
+                type: string;
+                maxLength: number;
+            };
+            name: {
+                type: string;
+                maxLength: number;
+            };
+            label: {
+                type: string;
+                maxLength: number;
+            };
+            description: {
+                type: string;
+            };
+            timestamp: {
+                type: string;
+                format: string;
+            };
+            controller: {
+                type: string;
+                maxLength: number;
+            };
+            action: {
+                type: string;
+                maxLength: number;
+            };
+            param: {
+                type: string;
+                maxLength: number;
+            };
+            is_relate_extra_control: {
+                type: string;
+                maxLength: number;
+            };
+        };
+        additionalProperties: boolean;
+    };
+    static getModel(ctx: RequestContext): typeof SeedPrivilege;
+    isDeletePatient(): boolean;
+    isFullDeletePatient(): boolean;
+    isAddRepeatableCrf(): boolean;
+    isDeleteRepeatableCrf(): boolean;
+    isEnableCp(): boolean;
+    isShowAllNotificationsInLog(): boolean;
+    isShowOnlyMyNotificationsInLog(): boolean;
+    isAllPatientList(): boolean;
+    isOnlyMyPatients(): boolean;
+    isManageUsers(): boolean;
+    isCoreProUserSensitiveInfo(): boolean;
+    isUserManagementMyOrganizations(): boolean;
+    isAllowControlProfiles(): boolean;
+    isConnectorAddCp(): boolean;
+    isConnectorAddCrf(): boolean;
+    isConnectorAddField(): boolean;
+    isExportRaw(): boolean;
+    isExportConfigurationsExplicitAccessOnly(): boolean;
+}
+
+export declare const SELECTOR_TYPE: {
+    SLIDER: string;
+    DROPDOWN: string;
+    RADIO_BUTTON: string;
+    CHECK_BOX: string;
+};
+
+declare interface SettingResponse {
+    id: number;
+    name: string;
+    value: UserSettingValue;
+    device_id?: string | null;
+    project_name?: string | null;
+    ecosystem_name?: string | null;
+}
+
+export declare const SHORT_TIME_FORMAT = "HH:mm";
+
+export declare const SLIDER_SCALE_ORIENTATION_TYPE: {
+    [x: string]: string;
+};
+
+export declare const SLIDER_SCALE_TYPE: {
+    HORIZONTAL: string;
+    VERTICAL: string;
+};
+
+export declare const SLIDER_SELECTOR_TYPE: {
+    [x: string]: string;
+};
+
+export declare const SLIDER_TYPE: {
+    STARS: string;
+    SCALE_RATING: string;
+    IMAGES: string;
+};
+
+export declare const STATUS_FIELD_REGEXP: RegExp;
+
+export declare const STATUS_SUFFIX = "_status";
+
+declare class SubformReference extends BaseModel {
+    crf_name: string;
+    subform: number;
+    record_id: number;
+    subform_id: number;
+    reference: number;
+    static get tableName(): string;
+    static get jsonSchema(): {
+        type: string;
+        properties: {
+            id: {
+                type: string;
+            };
+            crf_name: {
+                type: string;
+            };
+            subform: {
+                type: string;
+            };
+            record_id: {
+                type: string;
+            };
+            subform_id: {
+                type: string;
+            };
+            reference: {
+                type: string;
+            };
+        };
+    };
+    static getModelByPool(projectPool: default_2.TransactionOrKnex): typeof SubformReference;
+    static getModel(ctx: RequestContext): typeof SubformReference;
+    static getSubformRef(ctx: RequestContext, recordId: number | null, reference: number, subform: number, crfName: string): Promise<SubformReference | undefined>;
+    $beforeInsert(queryContext: any): Promise<void>;
+}
+
+export declare const TIME_FORMAT = "HH:mm:ss";
+
+export declare const TIME_SCHEMA = "^[0-1][0-9]:[0-5][0-9]$|^[0-2][0-3]:[0-5][0-9]$";
+
+export declare enum TriggerAction {
+    CREATION = "creation",
+    UPDATE = "update"
+}
+
+export declare type UpdateDashboardPayload = Partial<CreateDashboardPayload>;
+
+export declare interface UpdateFormPayload extends BaseApiServicePayload {
+    formName: string;
+    body: any;
+    formId: number;
+    token?: string;
+    options?: QuestionnaireInfoUpdateOptions;
+    method?: string;
+}
+
+export declare type UpdateTriggerPayload = Partial<CreateTriggerPayload>;
+
+declare class User extends BaseModel {
+    username?: string;
+    created_user?: number;
+    created_mode?: string;
+    mod_user?: number;
+    mod_time?: string;
+    email?: string;
+    password: string;
+    displayName?: string;
+    blocked: number;
+    timestamp: string;
+    state?: number;
+    new_register?: string;
+    password_changed_date?: string;
+    token?: string;
+    type?: string;
+    expiry_date?: string;
+    allow_upload: number;
+    allow_change_color: number;
+    clinic_request: string;
+    favourite: string;
+    last_access?: string;
+    temporary_password: string;
+    currentFailedCount?: number;
+    token_date?: string;
+    clinics?: Clinic[];
+    projects?: Project[];
+    patients?: UserPatient[];
+    profile?: UserProfile;
+    role?: Role;
+    profilings?: Profiling[];
+    _clinicsNotRepeated?: Clinic[];
+    static get tableName(): string;
+    static get jsonSchema(): {
+        type: string;
+        properties: {
+            id: {
+                type: string;
+                maxLength: number;
+            };
+            username: {
+                oneOf: {
+                    type: string;
+                }[];
+                default: null;
+                maxLength: number;
+            };
+            created_user: {
+                oneOf: {
+                    type: string;
+                }[];
+                default: null;
+                maxLength: number;
+            };
+            created_mode: {
+                oneOf: {
+                    type: string;
+                }[];
+                default: null;
+                maxLength: number;
+            };
+            mod_user: {
+                oneOf: {
+                    type: string;
+                }[];
+                default: null;
+                maxLength: number;
+            };
+            mod_time: {
+                oneOf: ({
+                    type: string;
+                    format?: undefined;
+                } | {
+                    type: string;
+                    format: string;
+                })[];
+                default: null;
+            };
+            email: {
+                oneOf: {
+                    type: string;
+                }[];
+                default: null;
+                maxLength: number;
+            };
+            password: {
+                type: string;
+                default: string;
+                maxLength: number;
+            };
+            displayName: {
+                oneOf: {
+                    type: string;
+                }[];
+                default: null;
+                maxLength: number;
+            };
+            blocked: {
+                type: string;
+                default: number;
+                enum: number[];
+            };
+            timestamp: {
+                type: string;
+                format: string;
+            };
+            state: {
+                oneOf: {
+                    type: string;
+                }[];
+                default: null;
+                maxLength: number;
+            };
+            new_register: {
+                oneOf: {
+                    type: string;
+                }[];
+                default: null;
+                maxLength: number;
+            };
+            password_changed_date: {
+                oneOf: ({
+                    type: string;
+                    format: string;
+                } | {
+                    type: string;
+                    format?: undefined;
+                })[];
+                default: null;
+            };
+            token: {
+                oneOf: {
+                    type: string;
+                }[];
+                default: null;
+                maxLength: number;
+            };
+            type: {
+                oneOf: {
+                    type: string;
+                }[];
+                default: null;
+                maxLength: number;
+            };
+            expiry_date: {
+                oneOf: ({
+                    type: string;
+                    format?: undefined;
+                } | {
+                    type: string;
+                    format: string;
+                })[];
+                default: null;
+            };
+            allow_upload: {
+                type: string;
+                default: number;
+                enum: number[];
+            };
+            allow_change_color: {
+                type: string;
+                default: number;
+                enum: number[];
+            };
+            clinic_request: {
+                type: string;
+            };
+            favourite: {
+                type: string;
+            };
+            last_access: {
+                oneOf: {
+                    type: string;
+                }[];
+                default: null;
+            };
+            temporary_password: {
+                type: string;
+            };
+            currentFailedCount: {
+                oneOf: {
+                    type: string;
+                }[];
+                default: null;
+                maxLength: number;
+            };
+            token_date: {
+                oneOf: ({
+                    type: string;
+                    format?: undefined;
+                } | {
+                    type: string;
+                    format: string;
+                })[];
+                default: null;
+            };
+        };
+        additionalProperties: boolean;
+    };
+    static get relationMappings(): {
+        clinics: {
+            relation: default_2.RelationType;
+            modelClass: string;
+            join: {
+                from: string;
+                through: {
+                    from: string;
+                    to: string;
+                };
+                to: string;
+            };
+        };
+        projects: {
+            relation: default_2.RelationType;
+            modelClass: string;
+            join: {
+                from: string;
+                through: {
+                    from: string;
+                    to: string;
+                };
+                to: string;
+            };
+        };
+        patients: {
+            relation: default_2.RelationType;
+            modelClass: string;
+            join: {
+                from: string;
+                to: string;
+            };
+        };
+        profile: {
+            relation: default_2.RelationType;
+            modelClass: string;
+            join: {
+                from: string;
+                to: string;
+            };
+        };
+        role: {
+            relation: default_2.RelationType;
+            modelClass: string;
+            join: {
+                from: string;
+                through: {
+                    from: string;
+                    to: string;
+                };
+                to: string;
+            };
+        };
+        profilings: {
+            relation: default_2.RelationType;
+            modelClass: string;
+            join: {
+                from: string;
+                through: {
+                    from: string;
+                    to: string;
+                };
+                to: string;
+            };
+        };
+    };
+    static getModel(ctx: RequestContext): typeof User;
+    static getModelByPool(ecosystemPool: default_2.TransactionOrKnex): typeof User;
+    static getUser(ctx: RequestContext, userId: number): Promise<User | undefined>;
+    static fetchAll(ecosystemPool: default_2.TransactionOrKnex, userId: number, page: number, perPage: number): default_2.QueryBuilder<User, default_2.Page<User>>;
+    static fetchAllForProjects(ecosystemPool: default_2.TransactionOrKnex, projects: number[], userId: number, page: number, perPage: number): default_2.QueryBuilder<User, default_2.Page<User>>;
+    static fetchAllForProjectsAndOrganizations(ecosystemPool: default_2.TransactionOrKnex, clinics: number[], userId: number, page: number, perPage: number): default_2.QueryBuilder<User, default_2.Page<User>>;
+    /**
+     * @param userId
+     * @returns {Promise<User>}
+     */
+    static getScopes(ecosystemPool: default_2.TransactionOrKnex, userId: number): Promise<User | undefined>;
+    static getUserByEmail(ecosystemPool: default_2.TransactionOrKnex, email: string): Promise<User | undefined>;
+    static insert(ctx: RequestContext, data: default_2.PartialModelObject<User>): Promise<number>;
+    static patch(ctx: RequestContext, data: default_2.PartialModelObject<User>, id: number): Promise<User>;
+    static checkIfIdExists(ctx: RequestContext, userId: number): Promise<boolean>;
+    static checkIfEmailExists(ctx: RequestContext, email: string, returnId?: boolean): Promise<number | boolean>;
+    static checkIfUsernameExists(ctx: RequestContext, username: string, returnId?: boolean): Promise<number | boolean>;
+    static getUserPassword(ctx: RequestContext, userId: number): Promise<string | null>;
+    static setUserNewPassword(ctx: RequestContext, userId: number, newPassword: string): Promise<boolean>;
+    static activateAccount(ctx: RequestContext, userId: number, username: string, password: string): Promise<User>;
+    static logAccess(ctx: RequestContext, userId: number, checkPrevValue?: boolean): Promise<void>;
+    static logFailedLogin(ecosystemPool: default_2.TransactionOrKnex, userId: number): Promise<User[]>;
+    static resetCurrentFailedCount(ecosystemPool: default_2.TransactionOrKnex, userId: number): Promise<number>;
+    getCrfFilter(projectName: string): string[] | null;
+    getClinics(): Clinic[];
+    checkIfAccountIsActivated(activationToken: string): boolean;
+    checkCreateUserPermissions(selectedProfilingId: any, projectId: any, clinicsIds: any): boolean | undefined;
+    isMobileLogged(ecosystemPool: default_2.TransactionOrKnex, userId: number): Promise<boolean>;
+    hasStatusPermissions(projectName: string, clinics: Clinic[], profilingId: number): boolean;
+    hasConnectorAddPermissions(projectName: string): boolean | undefined;
+    checkUserManagementMyOrganizationsPermissions(projectName: string, clinics: Clinic[]): boolean;
+    checkAllowControlProfilesPermissions(projectName: string, profilingId: number): boolean;
+    checkAddPatientPermissions(projectId: number): boolean;
+    checkConfigNotificationsPermissions(projectId: number): boolean;
+    checkDisplayPatientListPermissions(projectId: number): boolean;
+    checkOnlyUpdatePatientsPermissions(projectName: string): boolean;
+    static checkUploadDocumentsPermissions(projectId: number, profilings: Profiling[]): boolean;
+    static checkDeleteDocumentsPermissions(projectId: number, profilings: Profiling[]): boolean;
+    static checkDownloadDocumentsPermissions(projectId: number, profilings: Profiling[]): boolean;
+    checkPermission(ctx: RequestContext, privilege: SEED_PRIVILEGES): boolean;
+    checkUserProject(projectId: number): boolean;
+    isPerseedAdmin(): boolean;
+    isEcosystemAdmin(): boolean;
+    isAdmin(): boolean;
+    getProject(projectName: string): Project | undefined;
+    getProjectId(ctx: RequestContext): Promise<number | undefined>;
+    hasProjectAccessByName(projectName: string): boolean;
+    getProfiling(projectName: string): Profiling | undefined;
+    isNonPro(projectName: string): boolean;
+    isPro(projectName: string): boolean;
+    hasEnabledForm(projectName: string, formName: string): boolean;
+    canViewForm(projectName: string, formName: string): boolean | undefined;
+    canDeletePatient(projectName: string): boolean | undefined;
+    canFullDeletePatient(projectName: string): boolean | undefined;
+    canAddRepeatCrf(projectName: string, formName: string): boolean;
+    canDeleteRepeatCrf(projectName: string, formName: string): boolean;
+    canSeeAllPatients(projectName: string): boolean | undefined;
+    canOnlySeeOwnPatients(projectName: string): boolean | undefined;
+    hasClinicAccess(clinicId: string): boolean;
+    getPatient(projectName: string): UserPatient | null | undefined;
+    getPatientId(projectName: string): number | null | undefined;
+    hasProjectClinicAccess(projectName: string, clinicId?: string | null): boolean | "" | null | undefined;
+    getProjectClinicsAssociated(projectName: string): Clinic[];
+    callConnector(ctx: RequestContext, body: any, token: string, method: string, project: ExternalPatientProject, PATH: string, formName: string, subformFieldName?: string): Promise<any>;
+    getConsent(ecosystemPool: default_2.TransactionOrKnex, projectName: string, returnArray: false): Promise<ConsentGeneral>;
+    getConsent(ecosystemPool: default_2.TransactionOrKnex, projectName: string, returnArray: true): Promise<ConsentGeneral[]>;
+    fillConsent(ecosystemPool: default_2.TransactionOrKnex, projectName: string, userConsent: any, t: TFunction): Promise<void>;
+    isLegalAccessAllowed(ecosystemPool: default_2.TransactionOrKnex, projectName: string): Promise<boolean>;
+    isConsentFilled(ecosystemPool: default_2.TransactionOrKnex, projectName: string): Promise<boolean>;
+}
+
+declare class UserClinic extends BaseModel {
+    user_id?: number;
+    clinic_id?: number;
+    project_id?: number;
+    static get tableName(): string;
+    static get jsonSchema(): {
+        type: string;
+        properties: {
+            id: {
+                type: string;
+            };
+            user_id: {
+                oneOf: {
+                    type: string;
+                }[];
+                default: null;
+                maxLength: number;
+            };
+            clinic_id: {
+                oneOf: {
+                    type: string;
+                }[];
+                default: null;
+                maxLength: number;
+            };
+            project_id: {
+                oneOf: {
+                    type: string;
+                }[];
+                default: null;
+                maxLength: number;
+            };
+        };
+        additionalProperties: boolean;
+    };
+    static getModel(ctx: RequestContext): typeof UserClinic;
+    static insert(ctx: RequestContext, data: default_2.PartialModelObject<UserClinic>): Promise<number>;
+    static getUserClinicId(ctx: RequestContext, userId: number, projectId: number): Promise<number[]>;
+    static checkUserClinic(ctx: RequestContext, userId: number, projectId: number, clinicsIds: number[]): Promise<any>;
+}
+
+declare interface UserData {
+    language?: string;
+    userId: number;
+    userName: string;
+    ecosystem: string;
+    email: string;
+    loginId: string;
+    displayName: string;
+    userType: string;
+    ecosystemLabel: string;
+    tz: string;
+    settings?: SettingResponse[];
+}
+
+declare class UserMobileApp extends BaseModel {
+    user_id: number;
+    device_id?: string;
+    device_token?: string;
+    token?: string;
+    created_at: string;
+    updated_at?: string;
+    static get tableName(): string;
+    static get jsonSchema(): {
+        type: string;
+        properties: {
+            id: {
+                type: string;
+                maxLength: number;
+            };
+            user_id: {
+                type: string;
+                maxLength: number;
+            };
+            device_id: {
+                oneOf: {
+                    type: string;
+                }[];
+            };
+            device_token: {
+                oneOf: {
+                    type: string;
+                }[];
+            };
+            token: {
+                oneOf: {
+                    type: string;
+                }[];
+            };
+            created_at: {
+                type: string;
+                format: string;
+            };
+            updated_at: {
+                oneOf: ({
+                    type: string;
+                    format?: undefined;
+                } | {
+                    type: string;
+                    format: string;
+                })[];
+                default: null;
+            };
+        };
+        additionalProperties: boolean;
+    };
+    static getModel(ecosystemPool: default_2.TransactionOrKnex): typeof UserMobileApp;
+    static get(ecosystemPool: default_2.TransactionOrKnex, userId: number): Promise<UserMobileApp | undefined>;
+}
+
+declare class UserPatient extends BaseModel {
+    user_id?: number;
+    patient_id?: number;
+    project_id?: number;
+    patient_number: string;
+    projects?: Project;
+    user?: User | null;
+    user_profile: UserProfile;
+    user_mobile?: UserMobileApp[];
+    static get tableName(): string;
+    static get jsonSchema(): {
+        type: string;
+        properties: {
+            id: {
+                type: string;
+            };
+            user_id: {
+                oneOf: {
+                    type: string;
+                }[];
+            };
+            patient_id: {
+                oneOf: {
+                    type: string;
+                }[];
+            };
+            project_id: {
+                oneOf: {
+                    type: string;
+                }[];
+            };
+            patient_number: {
+                type: string;
+                maxLength: number;
+            };
+        };
+    };
+    static get relationMappings(): {
+        projects: {
+            relation: default_2.RelationType;
+            modelClass: string;
+            join: {
+                from: string;
+                to: string;
+            };
+        };
+        user: {
+            relation: default_2.RelationType;
+            modelClass: string;
+            join: {
+                from: string;
+                to: string;
+            };
+        };
+        user_profile: {
+            relation: default_2.RelationType;
+            modelClass: string;
+            join: {
+                from: string;
+                to: string;
+            };
+        };
+        user_mobile: {
+            relation: default_2.RelationType;
+            modelClass: string;
+            join: {
+                from: string;
+                to: string;
+            };
+        };
+    };
+    static getModel(ctx: RequestContext): typeof UserPatient;
+    static getModelByPool(ecosystemPool: default_2.TransactionOrKnex): typeof UserPatient;
+    static insert(ctx: RequestContext, data: default_2.PartialModelObject<UserPatient>): Promise<number>;
+}
+
+declare class UserProfile extends BaseModel {
+    user_id?: number;
+    name?: string;
+    surname?: string;
+    address?: string;
+    phone?: string;
+    image?: string;
+    birthday?: string;
+    company?: string;
+    company_localtion?: string;
+    position?: string;
+    description?: string;
+    language?: string;
+    training_password?: string;
+    demo_accepted?: number;
+    user_accepted?: number;
+    accepted_date?: string;
+    tzname?: string;
+    location?: string | null;
+    static get tableName(): string;
+    static get virtualAttributes(): string[];
+    static get jsonSchema(): {
+        type: string;
+        properties: {
+            id: {
+                type: string;
+                maxLength: number;
+            };
+            user_id: {
+                oneOf: {
+                    type: string;
+                }[];
+                maxLength: number;
+            };
+            name: {
+                oneOf: {
+                    type: string;
+                }[];
+                maxLength: number;
+            };
+            surname: {
+                oneOf: {
+                    type: string;
+                }[];
+                maxLength: number;
+            };
+            address: {
+                oneOf: {
+                    type: string;
+                }[];
+                default: null;
+                maxLength: number;
+            };
+            phone: {
+                oneOf: {
+                    type: string;
+                }[];
+                default: null;
+                maxLength: number;
+            };
+            image: {
+                oneOf: {
+                    type: string;
+                }[];
+                default: null;
+                maxLength: number;
+            };
+            birthday: {
+                oneOf: ({
+                    type: string;
+                    format: string;
+                } | {
+                    type: string;
+                    format?: undefined;
+                })[];
+                default: null;
+            };
+            company: {
+                oneOf: {
+                    type: string;
+                }[];
+                default: null;
+                maxLength: number;
+            };
+            company_localtion: {
+                oneOf: {
+                    type: string;
+                }[];
+                default: null;
+                maxLength: number;
+            };
+            position: {
+                oneOf: {
+                    type: string;
+                }[];
+                default: null;
+                maxLength: number;
+            };
+            description: {
+                oneOf: {
+                    type: string;
+                }[];
+                default: null;
+                maxLength: number;
+            };
+            language: {
+                oneOf: {
+                    type: string;
+                }[];
+                default: string;
+                maxLength: number;
+            };
+            training_password: {
+                oneOf: {
+                    type: string;
+                }[];
+                default: null;
+                maxLength: number;
+            };
+            demo_accepted: {
+                type: string;
+                default: number;
+                minimum: number;
+                maximum: number;
+            };
+            user_accepted: {
+                type: string;
+                default: number;
+                minimum: number;
+                maximum: number;
+            };
+            accepted_date: {
+                oneOf: ({
+                    type: string;
+                    format?: undefined;
+                } | {
+                    type: string;
+                    format: string;
+                })[];
+                default: null;
+            };
+            tzname: {
+                oneOf: {
+                    type: string;
+                }[];
+                maxLength: number;
+            };
+        };
+        additionalProperties: boolean;
+    };
+    get acceptLanguage(): string | null;
+    static getModel(ctx: RequestContext): typeof UserProfile;
+    static getModelByPool(ecosystemPool: default_2.TransactionOrKnex): typeof UserProfile;
+    static insert(ctx: RequestContext, data: default_2.PartialModelObject<UserProfile>): Promise<number>;
+    static checkIfUserIdExists(ctx: RequestContext, userId: number): Promise<boolean>;
+}
+
+declare type UserSettingValue = string | number | boolean | Record<string, string | number> | string[] | number[];
+
+export declare interface ValueCardProps {
+    title: I18nTextTranslation;
+    icon: string;
+    text: I18nTextTranslation;
+    subtext?: I18nTextTranslation;
+    titleTextColor?: string;
+    bodyTextColor?: string;
+    data?: Record<string, any>;
+    dataLoader?: WidgetDataLoader<WidgetOutcomesDataLoader>;
+}
+
+export declare type Widget = BaseWidget & ({
+    type: DashboardWidgetType.SECTIONCARD;
+    params: SectionCardProps;
+} | {
+    type: DashboardWidgetType.VALUECARD;
+    params: ValueCardProps;
+} | {
+    type: DashboardWidgetType.PATIENTLIST;
+    params: PatientListProps;
+});
+
+export declare type WidgetDataLoader<T> = T extends {
+    type: infer Type;
+    params: infer Params;
+} ? {
+    type: Type;
+    params: Params;
+} : never;
+
+export declare interface WidgetOutcomesDataLoader {
+    type: DataLoaderType.OUTCOMES;
+    params: OutcomesParams;
+}
+
+export { }