/**
 * This type represents all the patient profile kind
 */
export declare type ProfileKind = 'myself' | 'child' | 'other';
/**
 * this type is done as an example on how to add another data kind
 */
export declare type OtherKind = 'otherKindOfType';
/**
 * This type represents all the kind a data that can define `ChoiceInputData` (`OtherKind` is here only as an example on how to add a new kind)
 */
export declare type AllChoiceInputDataKind = ProfileKind | OtherKind;
/**
 * This interface represents a `StateTrigger` on selected profile kind
 */
export interface ProfileTrigger {
    kind: 'profileTrigger';
    value: ProfileKind;
}
/**
 * This interface is meant as an example of another kind of `StateTrigger`
 */
export interface OtherTrigger {
    kind: 'otherTrigger';
    field1: number;
    field2: string;
}
/**
 * This type represents all the state triggers that are defined.
 *
 * A state trigger is triggered onto app states. In other words, it is for triggers that cannot be defined thanks to pure workflow answers.
 */
export declare type StateTrigger = ProfileTrigger | OtherTrigger;
export interface IndexedData<T> {
    [key: string]: T;
}
export declare type SelectedAnswerData = string | string[];
export declare type SelectedAnswersData = IndexedData<SelectedAnswerData>[];
/**
 * Tracking between the selected answers and the previous ones (if exist)
 */
export interface PreviousAnswerData<T = (SelectedAnswerData | WorkflowUploadedImage[])> {
    /**
     * The answer from the previous consultation
    */
    previousAnswer: T;
    /**
     * The timestamp of when the previous answer was entered
     */
    timestamp?: Date;
    /**
     * Whether the value from the current answer and the previous answer has changed
     */
    changed: boolean;
}
export declare type PreviousAnswersData = IndexedData<PreviousAnswerData>[];
export interface ChoiceInputData {
    text: string;
    className?: string;
    order?: number;
    /** If defined, the choice input contains a kind that can be used into app. For instance, to check if a specific `kind` of answer has been selected */
    kind?: AllChoiceInputDataKind;
}
export interface RadioInputIconOptionsData {
    variant: 'icon';
    icon: string;
}
export interface RadioInputData extends ChoiceInputData {
    options?: RadioInputIconOptionsData;
}
export interface RadioCardInputData extends RadioInputData {
    bodyText: string;
}
export interface LanguagePickerData extends ChoiceInputData {
    flag: string;
    locale: string;
}
export interface TileRadioData extends ChoiceInputData {
    fullText?: string;
    image?: string;
    description?: string;
}
export declare enum InputApplyFunctions {
    AllUpperCase = "AllUpperCase",
    AllLowerCase = "AllLowerCase",
    AllAlphabetical = "AllAlphabetical",
    AllAlphanumeric = "AllAlphanumeric",
    NoSpaces = "NoSpaces"
}
export interface EntryData {
    id?: number;
    label?: string;
    inputApply?: InputApplyFunctions | InputApplyFunctions[];
    hideLabel?: boolean;
    minorLabel?: string;
    summaryLabel?: string;
    summaryHidden?: boolean;
    className?: string;
    /**
     * This field represents a list of `selectedAnswers` that must be set for this entry to be displayed using the followng logical combination of rules:
     *
     * #### Single string
     *
     * ```
     * // Required: rule1
     * rules: rule1
     * ```
     *
     * #### Array of strings (AND is applied between statements):
     *
     * ```
     * // Required: rule1 AND rule2
     * rules: [ rule1, rule2 ]
     * ```
     *
     * #### Array of arrays of strings (OR is applied between inner arrays. AND is applied between inner arrays statements)
     *
     * ```
     * // Required: rule1 OR rule2
     * rules: [
     *   [ rule1 ],
     *   [ rule2 ]
     * ]
     *
     * // Required: rule1 OR (rule2 AND rule3)
     * rules: [
     *   [ rule1 ],
     *   [ rule2, rule3 ]
     * ]
     *
     * // THIS IS FORBIDDEN
     * rules: [
     *   rule1, // <-- THIS IS FORBIDDEN. Instead use [ rule1 ]
     *   [ rule2, rule3 ]
     * ]
     * ```
     */
    triggers?: string[][] | string[] | string;
    /**
     * This field represents a list of `StateTrigger` that must be fulfilled for this entry to be displayed.
     */
    stateTriggers?: StateTrigger[];
    componentKind?: string;
    message?: string;
}
export interface SlideData {
    header: string;
    body: string;
    image?: {
        src: string;
        alt: string;
    };
    icon?: string;
}
export declare enum MetadataCategory {
    ChildPersonal = "ChildPersonal",
    Consultation = "Consultation",
    Refill = "Refill",
    DataRetrieval = "DataRetrieval",
    Followup = "Followup",
    Recovery = "Recovery",
    Medical = "Medical",
    OtherPersonal = "OtherPersonal",
    Personal = "Personal",
    Preference = "Preference",
    Prescription = "Prescription",
    Raw = "Raw"
}
/**
 * This interface describes all images-alias question kind options
 */
export interface ImagesAliasQuestionOptions {
    /**
     * Comma separated list of accepted formats. Will be given to the input html element.
     * Use same format as described [here](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#accept)
     */
    accept?: string;
    /**
     * Should allow multiple uploads or not
     */
    multiple?: boolean;
    /**
     * Should display photo guide instructions or not
     */
    photoGuide?: boolean;
}
export interface GenericQuestionData<T, A = IndexedData<ChoiceInputData>, O = undefined> extends EntryData {
    kind: T;
    metaCategory: MetadataCategory;
    answers?: A;
    formValidation?: any[];
    placeholder?: string;
    defaultValue?: any;
    value?: string;
    /**
     * Options to forward to the workflow component
     */
    options?: O;
    messages?: string;
    /**
     * Overrides the read only ability of the question's answer
     * populated by extended workflow feature
     */
    readOnly?: boolean;
    /**
     * Overrides the fillable default of the question's answer
     * populated by extended workflow feature
     */
    defaultEmpty?: boolean;
}
export interface GroupedGenericQuestionData<T, A = IndexedData<ChoiceInputData>> extends GenericQuestionData<T, A> {
    inline?: boolean;
    inlineLabel?: boolean;
    order?: number;
}
export declare type QuestionData = GenericQuestionData<'title' | 'paragraph' | 'checkbox', void> | GenericQuestionData<'text' | 'text-area' | 'date' | 'number' | 'images' | 'body-parts' | 'pharmacy-picker' | 'online-pharmacy-picker' | 'place-address'> | GenericQuestionData<'images-alias', IndexedData<ChoiceInputData>, ImagesAliasQuestionOptions> | GenericQuestionData<'checkbox-group' | 'hair-loss-frontal' | 'select' | 'multiple' | 'text-select-group', IndexedData<ChoiceInputData>> | GroupedGenericQuestionData<'radio' | 'hair-selector-women' | 'hair-selector-men' | 'hair-loss-stage' | 'hair-loss-other', IndexedData<RadioInputData>> | GroupedGenericQuestionData<'radio-card' | 'profile-selector', IndexedData<RadioCardInputData>> | GroupedGenericQuestionData<'language-picker', IndexedData<LanguagePickerData>> | GroupedGenericQuestionData<'tile-radio', IndexedData<TileRadioData>>;
export interface FieldData {
    type: 'field';
    className?: string;
    id: string;
}
export interface FieldGroupData {
    type: 'field-group';
    className?: string;
    fieldsAndGroups: (FieldData | FieldGroupData)[];
    name?: string;
    inline?: boolean;
    fullWidth?: boolean;
}
export interface WorkflowPageData {
    className?: string;
    groups?: FieldGroupData[];
    highlightMsg?: string;
    questions: IndexedData<QuestionData>;
    title?: string;
    triggers?: string[];
    /**
     * This field represents a list of `ids` which will be spliced from the workflow groups and inserted into a designated location
     */
    prioritizeIds?: string[];
}
export interface WorkflowData {
    createdAt: string;
    culDeSacs: EntryData[];
    id: string;
    locale?: string;
    pages: WorkflowPageData[];
    summaryImageFieldName?: string;
    summarySymptomsFieldName?: string;
    selectedAnswers?: SelectedAnswersData;
    previousAnswers?: PreviousAnswersData;
    serviceImage?: string;
    walkthroughSlides?: SlideData[];
    /**
     * (optional) the service name this workflow provides
     */
    serviceName?: string;
    /**
     * (optional) the description of the service this workflow provides
     */
    serviceDescription?: string;
    /**
     * (optional) These are the plan uuids that will be defaulted and shown at payment plan selection
    */
    startingPlanIds?: number[];
    /**
     * (optional) rules to hide certain payment plans (`startingPlanIds`) depending on the workflow answers
     */
    hidePlanRules?: HidePlanRule[];
    /**
     * (optional) extension of another workflow referenced by uuid
     */
    extendingWorkflow?: string;
    /**
     * (optional) the extending referenced workflows `createdAt` timestamp
     */
    extendingWorkflowTimestamp?: string;
    /**
     * (optional) rules for the extension of another workflow
     */
    extendingRules?: IndexedData<WorkflowExtendingRules>;
}
export interface WorkflowExtendingRules {
    /**
     * Whether the field becomes read only in the extended workflow
     */
    readOnly?: boolean;
    /**
     * Whether the field becomes deselected/empty by default in the extended workflow
     */
    defaultEmpty?: boolean;
    /**
     * Whether the field should be removed altogether in the extended workflow
     */
    remove?: boolean;
    /**
     * Overrides the label of the original question
     */
    label?: string;
}
export interface HidePlanRule {
    /**
     * the stripe plan id from the practice service
     */
    idPlan: string;
    /**
     * Questions to apply yup rules on in, if rules are met then hide the plan
     */
    rules: QuestionHidePlanRule[] | QuestionHidePlanRule[][];
}
export interface QuestionHidePlanRule {
    /**
     * the id of the question to check the rule on
     */
    questionId: string;
    /**
     * a collection of yup validated rules (same exact syntax we used for the workflow formValidation field, please reuse same functions)
     */
    yupRuleValueToHide: any;
}
/**
 * This interface describes an upload of an image (could be a picture, a pdf, a text file, etc.)
 */
export interface WorkflowUploadedImage {
    /**
     * Depending on the driver used by WorkflowInput:
     * - 'indexdb': will fetch the image in IndexDB with this id
     * - 'vault': will fetch the image in the vault with this id
     */
    idbId?: string;
    /**
     * The name of the image
     */
    name: string;
    /**
     * the image data (could be a picture, a pdf, a text file, etc.)
     */
    imageData?: string;
}
/**
 * This interface describes a workflow prepared and ready to be sent to vault
 */
export interface PopulatedWorkflowField {
    previousAnswer?: PreviousAnswerData;
    answer?: SelectedAnswerData | WorkflowUploadedImage[];
    displayedAnswer?: any;
    kind: string;
}
export interface PopulatedWorkflowData {
    workflowId: string;
    workflowCreatedAt: string;
    locale?: string;
    fields: Record<string, PopulatedWorkflowField>;
}