import React$1, { ReactElement, DependencyList, MouseEventHandler, CSSProperties, ReactNode, Ref } from 'react';
import { AsthmaActionPlanManagerPreviewState } from './components/asthma/components/AsthmaActionPlanManager/AsthmaActionPlanManager.previewData.ts';
import { AsthmaAirQualitiesPreviewState } from './components/asthma/components/AsthmaAirQualities/AsthmaAirQualities.previewData.ts';
export { AsthmaAirQualitiesPreviewState } from './components/asthma/components/AsthmaAirQualities/AsthmaAirQualities.previewData.ts';
import { AsthmaBiometricsPreviewState } from './components/asthma/components/AsthmaBiometrics/AsthmaBiometrics.previewData.ts';
export { AsthmaBiometricsPreviewState } from './components/asthma/components/AsthmaBiometrics/AsthmaBiometrics.previewData.ts';
import { AsthmaControlCalendarPreviewState } from './components/asthma/components/AsthmaControlCalendar/AsthmaControlCalendar.previewData.ts';
export { AsthmaControlCalendarPreviewState } from './components/asthma/components/AsthmaControlCalendar/AsthmaControlCalendar.previewData.ts';
import { ParticipantInfo, Guid, DataCollectionSettings, SupportedDeviceDataV2DataType, EventName, DeviceDataNamespace, DeviceDataV2Namespace, StatusBarStyle, ExternalAccount, Notification, SurveyTask, ConnectExternalAccountOptions, ExternalAccountStatus, InboxItemType, InboxItemStatus, SortOrder, InboxItemSortColumn, InboxItem, NotificationType, ExternalAccountProvider, SurveyAnswer, SurveyTaskStatus, InboxMessage, InboxResource, InboxSurvey, DeviceInfo, DeviceDataPoint } from '@careevolution/mydatahelps-js';
import { AsthmaControlStatusHeaderPreviewState } from './components/asthma/components/AsthmaControlStatusHeader/AsthmaControlStatusHeader.previewData.ts';
import { AsthmaLogEntryDetailsPreviewState } from './components/asthma/components/AsthmaLogEntryDetails/AsthmaLogEntryDetails.previewData.ts';
export { AsthmaLogEntryDetailsPreviewState } from './components/asthma/components/AsthmaLogEntryDetails/AsthmaLogEntryDetails.previewData.ts';
import { AsthmaLogEntryHeaderPreviewState } from './components/asthma/components/AsthmaLogEntryHeader/AsthmaLogEntryHeader.previewData.ts';
import { AsthmaProviderReportPreviewState } from './components/asthma/components/AsthmaProviderReport/AsthmaProviderReport.previewData.ts';
export { AsthmaProviderReportPreviewState } from './components/asthma/components/AsthmaProviderReport/AsthmaProviderReport.previewData.ts';
import { AsthmaLogEntryEditorViewPreviewState } from './components/asthma/views/AsthmaLogEntryEditorView/AsthmaLogEntryEditorView.previewData.ts';
export { AsthmaLogEntryEditorViewPreviewState } from './components/asthma/views/AsthmaLogEntryEditorView/AsthmaLogEntryEditorView.previewData.ts';
import * as _langchain_core_tools from '@langchain/core/tools';
import { StructuredTool } from '@langchain/core/tools';
import { DocumentLibraryPreviewPreviewState } from './components/container/DocumentLibraryPreview/DocumentLibraryPreview.previewData.ts';
import { GlucoseChartPreviewState } from './components/container/GlucoseChart/GlucoseChart.previewData.ts';
import { GlucoseDayCoordinatorPreviewState } from './components/container/GlucoseDayCoordinator/GlucoseDayCoordinator.previewData.ts';
export { GlucoseDayCoordinatorPreviewState } from './components/container/GlucoseDayCoordinator/GlucoseDayCoordinator.previewData.ts';
import { IconDefinition as IconDefinition$1 } from '@fortawesome/fontawesome-common-types';
import { GoalPreviewState } from './components/container/Goal/Goal.previewData.ts';
export { GoalPreviewState } from './components/container/Goal/Goal.previewData.ts';
import { InboxItemListPreviewState } from './components/container/InboxItemList/InboxItemList.previewData.ts';
export { InboxItemListPreviewState } from './components/container/InboxItemList/InboxItemList.previewData.ts';
import { IconDefinition } from '@fortawesome/fontawesome-svg-core';
import { MealCoordinatorPreviewState } from './components/container/MealCoordinator/MealCoordinator.previewData.ts';
export { MealCoordinatorPreviewState } from './components/container/MealCoordinator/MealCoordinator.previewData.ts';
import { MealEditorPreviewState } from './components/container/MealEditor/MealEditor.previewData.ts';
export { MealEditorPreviewState } from './components/container/MealEditor/MealEditor.previewData.ts';
import { AxisDomain } from 'recharts/types/util/types';
import { Duration } from 'date-fns';
import { ResourceListPreviewState } from './components/presentational/ResourceList/ResourceList.previewData.ts';
export { ResourceListPreviewState } from './components/presentational/ResourceList/ResourceList.previewData.ts';
import { DocumentDetailViewPreviewState } from './components/view/DocumentDetailView/DocumentDetailView.previewData.ts';
import { DocumentLibraryViewPreviewState } from './components/view/DocumentLibraryView/DocumentLibraryView.previewData.ts';
import { Locale } from 'date-fns/locale';
import { z } from 'zod';

interface AsthmaActionPlanManagerProps {
    previewState?: AsthmaActionPlanManagerPreviewState;
    learnMoreUrl: string;
    editActionPlanSurveyName: string;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
declare function export_default$1X(props: AsthmaActionPlanManagerProps): React$1.JSX.Element;

interface AsthmaAirQualitiesProps {
    previewState?: 'loading' | AsthmaAirQualitiesPreviewState;
    editZipCodesSurveyName?: string;
    airQualityUrl: string;
    date?: Date;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
declare function export_default$1W(props: AsthmaAirQualitiesProps): React$1.JSX.Element;

interface AsthmaAlertTakeoverNoticeProps {
    previewState?: 'loading' | 'loaded';
    message: string;
    logEntrySurveyName: string;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
declare function export_default$1V(props: AsthmaAlertTakeoverNoticeProps): React$1.JSX.Element;

interface AsthmaAlertTakeoverTriggerProps {
    previewState?: boolean;
    heartAndLungsUrl: string;
    activityUrl: string;
    sleepUrl: string;
    airQualityUrl: string;
    alertTakeoverUrl: string;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
declare function export_default$1U(props: AsthmaAlertTakeoverTriggerProps): null;

interface AsthmaBiometricsProps {
    previewState?: 'loading' | AsthmaBiometricsPreviewState;
    heartAndLungsUrl: string;
    activityUrl: string;
    sleepUrl: string;
    date?: Date;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
declare function export_default$1T(props: AsthmaBiometricsProps): React$1.JSX.Element;

type AsthmaControlCalendarVariant = 'compact' | 'verbose';
interface AsthmaControlCalendarProps {
    previewState?: AsthmaControlCalendarPreviewState;
    dayViewUrl: string;
    intervalStart?: Date;
    variant?: AsthmaControlCalendarVariant;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
declare function export_default$1S(props: AsthmaControlCalendarProps): React$1.JSX.Element;

type AsthmaParticipantMode = 'Self' | 'Caregiver';
declare class AsthmaParticipant {
    participantInfo: ParticipantInfo;
    constructor(participantInfo: ParticipantInfo);
    getId(): Guid;
    getFirstName(): string;
    hasPairedDevice(): boolean;
    hasEstablishedBaseline(): boolean;
    getHomeAirQualityZipCode(): string;
    getWorkAirQualityZipCode(): string;
    getActionPlanTaskRunUUID(): string;
    getAlertTakeover(): string | undefined;
    getParticipantMode(): AsthmaParticipantMode;
    getCareRecipientName(): string | undefined;
    getDaytimeRestingHeartRateBaseline(): number | undefined;
    getNighttimeRestingHeartRateBaseline(): number | undefined;
    getRespiratoryRateBaseline(): number | undefined;
    getStepsBaseline(): number | undefined;
    getSleepDisturbancesBaseline(): number | undefined;
    getDaytimeBloodOxygenLevelBaseline(): number | undefined;
    getNighttimeBloodOxygenLevelBaseline(): number | undefined;
    private hasEstablishedBaselineByType;
    private getBaseline;
    private getCustomFieldValue;
}
type AsthmaControlStatus = 'no-data' | 'not-controlled' | 'controlled' | 'not-determined';
interface AsthmaControlState {
    status: AsthmaControlStatus;
    symptomDaysPast7?: number;
    nighttimeAwakeningDaysPast7?: number;
    limitedActivityDaysPast7?: number;
    inhalerUseDaysPast7?: number;
}
type AsthmaDataStatus = 'not-configured' | 'not-found' | 'not-determined' | 'establishing' | 'offline' | 'in-range' | 'out-of-range';
type AsthmaBiometricType = 'daytime-resting-heart-rate' | 'nighttime-resting-heart-rate' | 'respiratory-rate' | 'steps' | 'sleep-disturbances' | 'daytime-blood-oxygen-level' | 'nighttime-blood-oxygen-level';
interface AsthmaBiometric {
    type: AsthmaBiometricType;
    status: AsthmaDataStatus;
    value?: number;
}
type AsthmaAirQualityType = 'work' | 'home';
type AsthmaAirQualityDescription = 'unhealthy' | 'very unhealthy' | 'hazardous';
interface AsthmaAirQuality {
    type: AsthmaAirQualityType;
    status: AsthmaDataStatus;
    value?: number;
    description?: AsthmaAirQualityDescription;
}
type AsthmaSymptomLevel = 'none' | 'mild' | 'moderate' | 'severe';
type AsthmaSymptom = 'Difficulty breathing' | 'Wheezing' | 'Coughing' | 'Chest tightness or pressure';
type AsthmaImpact = 'Wake up at night' | 'Limit your daily activity' | 'Use your rescue inhaler';
type AsthmaTrigger = 'Cold/viral illness' | 'Animal exposure' | 'Seasonal allergens/pollen' | 'Exercise' | 'Smoke (tobacco or wood burning)' | 'Extreme weather changes' | 'Air pollution' | 'Strong smells' | 'Chemicals/cleaning supplies' | 'Dust' | 'Mold' | 'Dust mites' | 'Rodents' | 'Cockroaches' | 'Taken a NSAID (non-steroidal anti-inflammatory drugs including aspirin and ibuprofen)' | 'Taken a beta blocker' | 'Had heartburn' | 'Drank red wine' | 'Tried any new foods' | 'Cooked without a fan or open window' | 'Had a pet sleep in your bed' | 'Burned incense or a candle';
interface AsthmaLogEntry {
    identifier: string;
    symptomLevel: AsthmaSymptomLevel;
    symptoms: AsthmaSymptom[];
    impacts: AsthmaImpact[];
    triggers: AsthmaTrigger[];
}
interface AsthmaActionPlan {
    id: string;
    url: string;
}

interface AsthmaControlStatusHeaderProps {
    previewState?: 'loading' | AsthmaControlStatusHeaderPreviewState;
    participant: AsthmaParticipant;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
declare function export_default$1R(props: AsthmaControlStatusHeaderProps): React$1.JSX.Element | null;

interface AsthmaLogEntryDetailsProps {
    previewState?: 'loading' | AsthmaLogEntryDetailsPreviewState;
    date: Date;
    logTodayEntrySurveyName: string;
    logYesterdayEntrySurveyName: string;
    editLogEntryUrl: string;
    infoUrl: string;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
declare function export_default$1Q(props: AsthmaLogEntryDetailsProps): React$1.JSX.Element;

interface AsthmaLogEntryHeaderProps {
    previewState?: 'loading' | AsthmaLogEntryHeaderPreviewState;
    logTodayEntrySurveyName: string;
    logYesterdayEntrySurveyName: string;
    dayViewUrl: string;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
declare function export_default$1P(props: AsthmaLogEntryHeaderProps): React$1.JSX.Element | null;

interface AsthmaPostEnrollmentSurveyTriggerProps {
    previewState?: boolean;
    postEnrollmentSurveyName: string;
    postEnrollmentMobileSurveyName: string;
    logTodayEntrySurveyName: string;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
declare function export_default$1O(props: AsthmaPostEnrollmentSurveyTriggerProps): null;

interface AsthmaProviderReportProps {
    previewState?: AsthmaProviderReportPreviewState;
    logEntrySurveyName: string;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
declare function export_default$1N(props: AsthmaProviderReportProps): React$1.JSX.Element;

type ColorDefinition = string | {
    lightMode?: string;
    darkMode?: string;
};
declare function resolveColor(colorScheme: "light" | "dark", colorDefinition?: ColorDefinition): string | undefined;
declare function getColorFromAssortment(index: number): string;

interface ActionProps {
    title?: string;
    titleIcon?: ReactElement;
    icon?: ReactElement;
    subtitle?: string;
    onClick?: Function;
    children?: React$1.ReactNode;
    className?: string;
    indicatorIcon?: IconDefinition;
    indicator?: ReactElement;
    indicatorValue?: string;
    indicatorPosition?: "default" | "topRight";
    bottomBorder?: boolean;
    innerRef?: React$1.Ref<HTMLDivElement>;
    titleColor?: ColorDefinition;
    subtitleColor?: ColorDefinition;
    renderAs?: "div" | "button";
}
declare function Action(props: ActionProps): React$1.JSX.Element;

interface ActivityMeterProps {
    label: string;
    value: string;
    icon: ReactElement;
    fillPercent: number;
    averageFillPercent: number;
    color: ColorDefinition;
    message?: string;
    className?: string;
    innerRef?: React$1.Ref<HTMLDivElement>;
    thresholdLabel?: string;
}
declare function ActivityMeter(props: ActivityMeterProps): React$1.JSX.Element;

declare enum DailyDataType {
    AppleHealthDistanceWalkingRunning = "AppleHealthDistanceWalkingRunning",
    AppleHealthEstimatedAppleWatchWearTime = "AppleHealthEstimatedAppleWatchWearTime",
    AppleHealthFlightsClimbed = "AppleHealthFlightsClimbed",
    AppleHealthHeartRateRange = "AppleHealthHeartRateRange",
    AppleHealthHrv = "AppleHealthHrv",
    AppleHealthMaxHeartRate = "AppleHealthMaxHeartRate",
    AppleHealthMindfulMinutes = "AppleHealthMindfulMinutes",
    AppleHealthRestingHeartRate = "AppleHealthRestingHeartRate",
    AppleHealthSleepMinutes = "AppleHealthSleepMinutes",
    AppleHealthRemSleepMinutes = "AppleHealthSleepRemMinutes",
    AppleHealthDeepSleepMinutes = "AppleHealthSleepDeepMinutes",
    AppleHealthCoreSleepMinutes = "AppleHealthSleepCoreMinutes",
    AppleHealthInBedMinutes = "AppleHealthInBedMinutes",
    AppleHealthStandMinutes = "AppleHealthStandMinutes",
    AppleHealthSteps = "AppleHealthSteps",
    AppleHealthStepsWhileWearingDevice = "AppleHealthStepsWhileWearingDevice",
    AppleHealthTherapyMinutes = "AppleHealthTherapyMinutes",
    AppleHealthWalkingHeartRateAverage = "AppleHealthWalkingHeartRateAverage",
    AppleHealthActiveEnergyBurned = "AppleHealthActiveEnergyBurned",
    AppleHealthNumberOfAlcoholicBeverages = "AppleHealthNumberOfAlcoholicBeverages",
    FitbitSedentaryMinutes = "FitbitSedentaryMinutes",
    FitbitActiveMinutes = "FitbitActiveMinutes",
    FitbitLightlyActiveMinutes = "FitbitLightlyActiveMinutes",
    FitbitFairlyActiveMinutes = "FitbitFairlyActiveMinutes",
    FitbitVeryActiveMinutes = "FitbitVeryActiveMinutes",
    FitbitBreathingRate = "FitbitBreathingRate",
    FitbitCaloriesBurned = "FitbitCaloriesBurned",
    FitbitRestingCaloriesBurned = "FitbitRestingCaloriesBurned",
    FitbitActiveCaloriesBurned = "FitbitActiveCaloriesBurned",
    FitbitElevatedHeartRateMinutes = "FitbitElevatedHeartRateMinutes",
    FitbitFatBurnHeartRateMinutes = "FitbitFatBurnHeartRateMinutes",
    FitbitCardioHeartRateMinutes = "FitbitCardioHeartRateMinutes",
    FitbitPeakHeartRateMinutes = "FitbitPeakHeartRateMinutes",
    FitbitFloors = "FitbitFloors",
    FitbitHrv = "FitbitHrv",
    FitbitRestingHeartRate = "FitbitRestingHeartRate",
    FitbitSleepMinutes = "FitbitSleepMinutes",
    FitbitLightSleepMinutes = "FitbitLightSleepMinutes",
    FitbitRemSleepMinutes = "FitbitRemSleepMinutes",
    FitbitDeepSleepMinutes = "FitbitDeepSleepMinutes",
    FitbitSpO2 = "FitbitSpO2",
    FitbitSteps = "FitbitSteps",
    FitbitWearMinutes = "FitbitWearMinutes",
    GarminSteps = "GarminSteps",
    GarminDistance = "GarminDistance",
    GarminFloors = "GarminFloors",
    GarminActiveMinutes = "GarminActiveMinutes",
    GarminActiveCalories = "GarminActiveCalories",
    GarminRestingCalories = "GarminRestingCalories",
    GarminTotalCalories = "GarminTotalCalories",
    GarminRestingHeartRate = "GarminRestingHeartRate",
    GarminMinHeartRate = "GarminMinHeartRate",
    GarminMaxHeartRate = "GarminMaxHeartRate",
    GarminAverageHeartRate = "GarminAverageHeartRate",
    GarminMaxStressLevel = "GarminMaxStressLevel",
    GarminAverageStressLevel = "GarminAverageStressLevel",
    GarminTotalStressMinutes = "GarminTotalStressMinutes",
    GarminLowStressMinutes = "GarminLowStressMinutes",
    GarminMediumStressMinutes = "GarminMediumStressMinutes",
    GarminHighStressMinutes = "GarminHighStressMinutes",
    GarminTotalSleepMinutes = "GarminTotalSleepMinutes",
    GarminLightSleepMinutes = "GarminLightSleepMinutes",
    GarminDeepSleepMinutes = "GarminDeepSleepMinutes",
    GarminRemSleepMinutes = "GarminRemSleepMinutes",
    GarminAwakeMinutes = "GarminAwakeMinutes",
    GarminSleepScore = "GarminSleepScore",
    GoogleFitMindfulMinutes = "GoogleFitMindfulMinutes",
    GoogleFitSteps = "GoogleFitSteps",
    GoogleFitTherapyMinutes = "GoogleFitTherapyMinutes",
    Steps = "Steps",
    StepsWithGoogleFit = "StepsWithGoogleFit",
    ActiveCaloriesBurned = "ActiveCaloriesBurned",
    RestingHeartRate = "RestingHeartRate",
    SleepMinutes = "SleepMinutes",
    MindfulMinutes = "MindfulMinutes",
    TherapyMinutes = "TherapyMinutes",
    AirQuality = "AirQuality",
    HomeAirQuality = "HomeAirQuality",
    WorkAirQuality = "WorkAirQuality",
    HealthConnectRestingHeartRate = "HealthConnectRestingHeartRate",
    HealthConnectTotalSleepMinutes = "HealthConnectTotalSleepMinutes",
    HealthConnectLightSleepMinutes = "HealthConnectLightSleepMinutes",
    HealthConnectRemSleepMinutes = "HealthConnectRemSleepMinutes",
    HealthConnectDeepSleepMinutes = "HealthConnectDeepSleepMinutes",
    HealthConnectSteps = "HealthConnectSteps",
    HealthConnectDistance = "HealthConnectDistance",
    HealthConnectMaxHeartRate = "HealthConnectMaxHeartRate",
    HealthConnectMinHeartRate = "HealthConnectMinHeartRate",
    HealthConnectActiveCaloriesBurned = "HealthConnectActiveCaloriesBurned",
    HealthConnectTotalCaloriesBurned = "HealthConnectTotalCaloriesBurned",
    HealthConnectTherapyMinutes = "HealthConnectTherapyMinutes",
    HealthConnectMindfulMinutes = "HealthConnectMindfulMinutes",
    OuraSteps = "OuraSteps",
    OuraRestingHeartRate = "OuraRestingHeartRate",
    OuraSleepMinutes = "OuraSleepMinutes",
    OuraActiveCaloriesBurned = "OuraActiveCaloriesBurned"
}
interface DailyDataTypeDefinition {
    dataSource?: "Unified" | "AppleHealth" | "Garmin" | "Fitbit" | "GoogleFit" | "AirQuality" | "Oura" | "HealthConnect";
    type: string;
    dataProvider: DailyDataProvider;
    availabilityCheck: DailyDataAvailabilityCheck;
    labelKey?: string;
    icon: ReactElement;
    formatter: (value: number) => string;
    yAxisConverter?: (value: number) => number;
    previewDataRange: [number, number];
    requiresV2Api?: boolean;
}

interface CombinedDataCollectionSettings {
    settings: DataCollectionSettings;
    deviceDataV2Types: SupportedDeviceDataV2DataType[];
}

type DailyDataQueryResult = {
    [key: string]: number;
};
type DailyDataProvider = (startDate: Date, endDate: Date) => Promise<DailyDataQueryResult>;
type DailyDataAvailabilityCheck = (CombinedDataCollectionSettings: CombinedDataCollectionSettings, modifiedAfter?: Date) => Promise<boolean>;
declare function registerDailyDataProvider(type: string, provider: DailyDataProvider, availabilityCheck: DailyDataAvailabilityCheck): void;
declare function registerDailyDataTypeDefinition(typeDefinition: DailyDataTypeDefinition): void;
declare function checkDailyDataAvailability(type: string, modifiedAfter?: Date): Promise<boolean>;
declare function queryDailyData(type: string, startDate: Date, endDate: Date, preview?: boolean): Promise<DailyDataQueryResult>;
declare function queryPreviewDailyData(type: string, startDate: Date, endDate: Date, fillPercentage?: number): Promise<DailyDataQueryResult>;
declare function getAllDailyDataTypes(): DailyDataTypeDefinition[];
declare function getDailyDataTypeDefinition(type: string): DailyDataTypeDefinition;

declare function supportedLocales(): string[];
/** Gets the currently active locale, accounting for which ones are supported (e.g., en-UK will fall back to just en) */
declare function getCurrentLocale(specifiedLocale?: string): string;
declare function language(key: string, specifiedLocale?: string, args?: {
    [key: string]: string;
}): string;
/** Gets the language code from an ISO locale string (e.g., en-US returns en. */
declare function getLanguageCodeFromIso(locale: string): string;
/** Gets the country code from an ISO locale string (e.g., en-US returns us). */
declare function getCountryCodeFromIso(locale: string): string | undefined;

declare function getIntlLocale(): string;
declare function getDateLocale(): Locale;
/**
 * Uses date-fns format strings.
 * Note that some languages don't treat day/month names as proper nouns, so a string might come
 * back like "27 marzo 2024". The capitalize param lets you auto-capitalize the first letter in case
 * the string is being used like a title/heading.
 */
declare function formatDateForLocale(dateOrDateString: string | Date | undefined, formatString: string, capitalize?: boolean): string;
declare function formatNumberForLocale(value: number | undefined, fractionDigits?: number): string;
/** e.g., 7h 5m */
declare function formatMinutesForLocale(value: number): string;
declare function capitalizeFirstLetterForLocale(str: string): string;

type BasicPointsForBadgesActivityType = "dailyData" | "surveyCompleted" | "connectExternalAccount" | "custom";
interface BasicPointsForBadgesActivity {
    key: string;
    type: BasicPointsForBadgesActivityType;
    points: number;
}
interface BasicPointsForBadgesState {
    badges: number[];
    activityStates: {
        [key: string]: BasicPointsForBadgesActivityState;
    };
}
interface BasicPointsForBadgesActivityState {
    pointsAwarded: number;
}

type ConnectExternalActivityType = "Provider" | "Health Plan" | "Device Manufacturer";
interface ConnectExternalAccountActivity extends BasicPointsForBadgesActivity {
    type: "connectExternalAccount";
    providerCategories: ConnectExternalActivityType[];
}

interface DailyDataActivity extends BasicPointsForBadgesActivity {
    type: "dailyData";
    activationDate: Date;
    awardThreshold: number;
    dailyDataType: string;
}

interface CustomActivity extends BasicPointsForBadgesActivity {
    type: "custom";
    customField: string;
}

interface SurveyCompletionActivity extends BasicPointsForBadgesActivity {
    type: "surveyCompleted";
    surveyName: string;
    limit?: number;
}

declare function getDayKey(date: string | Date): string;

type WeekStartsOn = "Sunday" | "Monday" | "Tuesday" | "Wednesday" | "Thursday" | "Friday" | "Saturday" | "6DaysAgo" | "7DaysAgo";
declare function getWeekStart(weekStartsOn?: WeekStartsOn): Date;
declare function getMonthStart(): Date;
declare function get6MonthStart(): Date;
declare function getDefaultIntervalStart(intervalType: "Week" | "Month" | "6Month", weekStartsOn?: WeekStartsOn): Date;

type BloodPressureDeviceDataSource = 'AppleHealth' | 'GoogleFit' | 'Omron' | 'HealthConnect';
declare function export_default$1M(surveyDataSource?: SurveyBloodPressureDataParameters, bloodPressureDeviceDataSources?: BloodPressureDeviceDataSource[]): Promise<BloodPressureDataPoint[]>;

interface SurveyBloodPressureDataParameters {
    surveyName: string;
    dateResultIdentifier?: string;
    systolicResultIdentifier: string;
    diastolicResultIdentifier: string;
}
interface BloodPressureDataPoint {
    date: Date;
    systolic: number;
    diastolic: number;
}

declare function useInitializeView(initialize: () => void, additionalEvents?: EventName[], dependencies?: DependencyList): void;

interface RelativeActivityQueryResult {
    relativePercent?: number;
    value: number;
    threshold?: number;
}
interface RelativeActivityDataType {
    dailyDataType: string;
    color?: ColorDefinition;
    overThresholdColor?: ColorDefinition;
    threshold?: number | "30DayAverage";
    label?: string;
    icon?: React.ReactElement;
    formatter?: (number: number) => string;
}
declare function queryRelativeActivity(startDate: Date, endDate: Date, dataTypes: RelativeActivityDataType[], preview: boolean): Promise<{
    [key: string]: {
        [key: string]: RelativeActivityQueryResult;
    };
}>;

declare function awardPointsAndBadges(activities: BasicPointsForBadgesActivity[], state: BasicPointsForBadgesState, pointsPerBadge: number, participantInfo: ParticipantInfo): Promise<BasicPointsForBadgesState>;
declare function sumActivityPoints(activityStates: {
    [key: string]: BasicPointsForBadgesActivityState;
}): number;

interface DeviceDataV2QueryFilters {
    dataSource?: Record<string, string>;
}

interface AvailabilityCheckOptions {
    requireAllTypes?: boolean;
    v2QueryFilters?: DeviceDataV2QueryFilters;
}
declare function simpleAvailabilityCheck(namespace: DeviceDataNamespace | DeviceDataV2Namespace, type: string | string[], options?: AvailabilityCheckOptions): DailyDataAvailabilityCheck;

declare const allTypeDefinitions: DailyDataTypeDefinition[];

interface StandardDailyDataTypeDefinition extends DailyDataTypeDefinition {
    color: string;
}
declare const standardDailyDataTypes: StandardDailyDataTypeDefinition[];

interface LineChartOptions {
    lineColor?: string;
    domainMin?: number | "Auto";
}
interface BarChartOptions {
    barColor?: ColorDefinition;
    thresholds?: BarChartThreshold[];
}
interface BarChartThreshold {
    value: number;
    referenceLineColor?: ColorDefinition;
    overThresholdBarColor?: ColorDefinition;
}
interface AreaChartOptions {
    lineColor?: ColorDefinition;
    areaColor?: ColorDefinition;
}
interface ChartSeries {
    dataKey: string;
    color?: ColorDefinition;
}
interface AreaChartSeries extends ChartSeries {
    areaColor?: ColorDefinition;
}
interface TimeSeriesChartContainerOptions {
    height?: string | number;
}
interface TimeSeriesGridOptions {
    hide?: boolean;
}
interface TimeSeriesChartXAxisOptions {
    height?: number | undefined;
    domain?: [number | string, number | string];
    ticks?: (string | number)[];
    tickFormatter?: (value: any, index: number) => string;
}
interface TimeSeriesChartYAxisOptions {
    width?: number;
    domain?: [number | string, number | string];
    ticks?: (string | number)[];
}
type TimeSeriesChartLabel = ReactElement<SVGElement> | ((props: any) => ReactElement<SVGElement>) | boolean | string | number;
type TimeSeriesChartLineDot = ReactElement<SVGElement> | ((props: any) => ReactElement<SVGElement>) | boolean;
interface TimeSeriesChartLineOptions {
    connectNulls?: boolean;
    dot?: TimeSeriesChartLineDot;
    label?: TimeSeriesChartLabel;
    strokeWidth?: number;
    animationDuration?: number;
}
interface TimeSeriesChartOptions {
    containerOptions?: TimeSeriesChartContainerOptions;
    gridOptions?: TimeSeriesGridOptions;
    xAxisOptions?: TimeSeriesChartXAxisOptions;
    yAxisOptions?: TimeSeriesChartYAxisOptions;
}
interface MultiSeriesLineChartOptions extends TimeSeriesChartOptions {
    thresholds?: ChartThreshold[];
    lineOptions?: TimeSeriesChartLineOptions;
}
interface MultiSeriesBarChartOptions extends TimeSeriesChartOptions {
    thresholds?: ChartThreshold[];
}
interface ChartThreshold {
    value: number;
    referenceLineColor?: ColorDefinition;
    overThresholdColor?: ColorDefinition;
}

interface TimeSeriesDataPoint {
    timestamp: number;
    [key: string]: any;
}
interface TimeSeriesChartProps {
    title?: string;
    intervalType?: "Day" | "Week" | "Month" | "6Month" | "Dynamic";
    dynamicIntervalEndType?: "Today" | "Last Reading";
    intervalStart?: Date;
    data?: TimeSeriesDataPoint[];
    expectedDataInterval?: Duration;
    series: ChartSeries[] | AreaChartSeries[];
    chartHasData: boolean;
    tooltip?: ({ active, payload, label }: any) => React$1.JSX.Element | null;
    chartType: "Line" | "Bar" | "Area";
    options?: MultiSeriesLineChartOptions | MultiSeriesBarChartOptions;
    syncId?: string;
    children?: React$1.ReactNode;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
declare function TimeSeriesChart(props: TimeSeriesChartProps): React$1.JSX.Element;

declare function createLineChartDefs(layoutContext: LayoutContext, gradientKey: string, series: ChartSeries[], options: MultiSeriesLineChartOptions | undefined, dataKeys: string[], data: TimeSeriesDataPoint[]): React$1.JSX.Element;
declare function createBarChartDefs(layoutContext: LayoutContext, gradientKey: string, series: ChartSeries[], options?: MultiSeriesBarChartOptions): React$1.JSX.Element;
declare function createAreaChartDefs(layoutContext: LayoutContext, gradientKey: string, series: AreaChartSeries[]): React$1.JSX.Element;

type IntradayHeartRateAggregationOption = "avg" | "min" | "max";
type IntradayHeartRateData = {
    [key: number]: number;
};
declare function export_default$1L(dataSources: DeviceDataV2Namespace[], startDate: Date, endDate: Date, aggregationOption: IntradayHeartRateAggregationOption, aggregationIntervalMinutes: number): Promise<IntradayHeartRateData>;

interface Reading {
    timestamp: Date;
    value: number;
}
interface ReadingRange {
    date: Date;
    min: number;
    max: number;
    average: number;
}
type MealType = 'meal' | 'snack' | 'drink';
declare function getMealTypeDisplayText(mealType: MealType): string;
interface MealItem {
    name: string;
    confidenceScore?: number;
}
interface MealAnalysis$1 {
    timestamp: Date;
    items: MealItem[];
    reviewTimestamp?: Date;
}
interface Meal {
    id: Guid;
    timestamp: Date;
    type: MealType;
    description?: string;
    hasImage?: boolean;
    items?: MealItem[];
    analysis?: MealAnalysis$1;
    archiveTimestamp?: Date;
    created?: Date;
    lastModified?: Date;
}
interface MealReference {
    date: Date;
    id: Guid;
}

declare function getGlucoseReadings(startDate: Date, endDate?: Date, combinedDataCollectionSettings?: CombinedDataCollectionSettings): Promise<Reading[]>;
declare function computeBestFitGlucoseValue(observationDate: Date, readings: Reading[]): number;
declare function computeGlucoseReadingRanges(readings: Reading[]): ReadingRange[];
declare function computeGlucoseReadingRecentAverage(readings: Reading[], endDate: Date, pastDayCount?: number): number | undefined;

declare function getMeals(date: Date): Promise<Meal[]>;
declare function saveMeals(date: Date, meals: Meal[]): Promise<void>;
declare function prepareMealForEditing(meal: Meal): Promise<void>;
declare function getMealToEdit(): Promise<MealReference | undefined>;
declare function uploadMealImageFile(meal: Meal, file: File): Promise<void>;
declare function getMealImageUrls(meals: Meal[]): Promise<Record<string, string>>;

declare function generateGlucose(startDate: Date, endDate?: Date): Promise<Reading[]>;
declare function generateSteps(date: Date): Reading[];
declare function generateSleep(date: Date): Reading[];

declare function getSleepMinutes(date: Date, combinedDataCollectionSettings?: CombinedDataCollectionSettings): Promise<number | undefined>;

declare function getSteps(date: Date, combinedDataCollectionSettings?: CombinedDataCollectionSettings): Promise<Reading[]>;

declare function getStressLevel(date: Date): Promise<number | undefined>;
declare function saveStressLevel(date: Date, stressLevel: number): void;
declare function deleteStressLevel(date: Date): void;

declare function timestampSortAsc(a: {
    timestamp: Date;
}, b: {
    timestamp: Date;
}): number;

declare const PersistParticipantInfoTool: _langchain_core_tools.DynamicStructuredTool<z.ZodObject<{
    demographics: z.ZodOptional<z.ZodObject<{
        email: z.ZodOptional<z.ZodString>;
        mobilePhone: z.ZodOptional<z.ZodString>;
        firstName: z.ZodOptional<z.ZodString>;
        middleName: z.ZodOptional<z.ZodString>;
        lastName: z.ZodOptional<z.ZodString>;
        dateOfBirth: z.ZodOptional<z.ZodString>;
        gender: z.ZodOptional<z.ZodString>;
        preferredLanguage: z.ZodOptional<z.ZodString>;
        street1: z.ZodOptional<z.ZodString>;
        street2: z.ZodOptional<z.ZodString>;
        city: z.ZodOptional<z.ZodString>;
        state: z.ZodOptional<z.ZodString>;
        postalCode: z.ZodOptional<z.ZodString>;
        unsubscribedFromEmails: z.ZodOptional<z.ZodString>;
        unsubscribedFromSms: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        email?: string | undefined;
        mobilePhone?: string | undefined;
        firstName?: string | undefined;
        middleName?: string | undefined;
        lastName?: string | undefined;
        dateOfBirth?: string | undefined;
        gender?: string | undefined;
        preferredLanguage?: string | undefined;
        street1?: string | undefined;
        street2?: string | undefined;
        city?: string | undefined;
        state?: string | undefined;
        postalCode?: string | undefined;
        unsubscribedFromEmails?: string | undefined;
        unsubscribedFromSms?: string | undefined;
    }, {
        email?: string | undefined;
        mobilePhone?: string | undefined;
        firstName?: string | undefined;
        middleName?: string | undefined;
        lastName?: string | undefined;
        dateOfBirth?: string | undefined;
        gender?: string | undefined;
        preferredLanguage?: string | undefined;
        street1?: string | undefined;
        street2?: string | undefined;
        city?: string | undefined;
        state?: string | undefined;
        postalCode?: string | undefined;
        unsubscribedFromEmails?: string | undefined;
        unsubscribedFromSms?: string | undefined;
    }>>;
    customFields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
}, "strip", z.ZodTypeAny, {
    demographics?: {
        email?: string | undefined;
        mobilePhone?: string | undefined;
        firstName?: string | undefined;
        middleName?: string | undefined;
        lastName?: string | undefined;
        dateOfBirth?: string | undefined;
        gender?: string | undefined;
        preferredLanguage?: string | undefined;
        street1?: string | undefined;
        street2?: string | undefined;
        city?: string | undefined;
        state?: string | undefined;
        postalCode?: string | undefined;
        unsubscribedFromEmails?: string | undefined;
        unsubscribedFromSms?: string | undefined;
    } | undefined;
    customFields?: Record<string, string> | undefined;
}, {
    demographics?: {
        email?: string | undefined;
        mobilePhone?: string | undefined;
        firstName?: string | undefined;
        middleName?: string | undefined;
        lastName?: string | undefined;
        dateOfBirth?: string | undefined;
        gender?: string | undefined;
        preferredLanguage?: string | undefined;
        street1?: string | undefined;
        street2?: string | undefined;
        city?: string | undefined;
        state?: string | undefined;
        postalCode?: string | undefined;
        unsubscribedFromEmails?: string | undefined;
        unsubscribedFromSms?: string | undefined;
    } | undefined;
    customFields?: Record<string, string> | undefined;
}>, {
    demographics?: {
        email?: string | undefined;
        mobilePhone?: string | undefined;
        firstName?: string | undefined;
        middleName?: string | undefined;
        lastName?: string | undefined;
        dateOfBirth?: string | undefined;
        gender?: string | undefined;
        preferredLanguage?: string | undefined;
        street1?: string | undefined;
        street2?: string | undefined;
        city?: string | undefined;
        state?: string | undefined;
        postalCode?: string | undefined;
        unsubscribedFromEmails?: string | undefined;
        unsubscribedFromSms?: string | undefined;
    } | undefined;
    customFields?: Record<string, string> | undefined;
}, {
    demographics?: {
        email?: string | undefined;
        mobilePhone?: string | undefined;
        firstName?: string | undefined;
        middleName?: string | undefined;
        lastName?: string | undefined;
        dateOfBirth?: string | undefined;
        gender?: string | undefined;
        preferredLanguage?: string | undefined;
        street1?: string | undefined;
        street2?: string | undefined;
        city?: string | undefined;
        state?: string | undefined;
        postalCode?: string | undefined;
        unsubscribedFromEmails?: string | undefined;
        unsubscribedFromSms?: string | undefined;
    } | undefined;
    customFields?: Record<string, string> | undefined;
}, string>;
declare const QueryAppleHealthWorkoutsTool: _langchain_core_tools.DynamicStructuredTool<z.ZodObject<{
    endDate: z.ZodOptional<z.ZodString>;
    startDate: z.ZodOptional<z.ZodString>;
    pageSize: z.ZodOptional<z.ZodNumber>;
    pageID: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    endDate?: string | undefined;
    startDate?: string | undefined;
    pageSize?: number | undefined;
    pageID?: string | undefined;
}, {
    endDate?: string | undefined;
    startDate?: string | undefined;
    pageSize?: number | undefined;
    pageID?: string | undefined;
}>, {
    endDate?: string | undefined;
    startDate?: string | undefined;
    pageSize?: number | undefined;
    pageID?: string | undefined;
}, {
    endDate?: string | undefined;
    startDate?: string | undefined;
    pageSize?: number | undefined;
    pageID?: string | undefined;
}, string>;
declare const QueryAppleHealthActivitySummariesTool: _langchain_core_tools.DynamicStructuredTool<z.ZodObject<{
    endDate: z.ZodOptional<z.ZodString>;
    startDate: z.ZodOptional<z.ZodString>;
    pageSize: z.ZodOptional<z.ZodNumber>;
    pageID: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    endDate?: string | undefined;
    startDate?: string | undefined;
    pageSize?: number | undefined;
    pageID?: string | undefined;
}, {
    endDate?: string | undefined;
    startDate?: string | undefined;
    pageSize?: number | undefined;
    pageID?: string | undefined;
}>, {
    endDate?: string | undefined;
    startDate?: string | undefined;
    pageSize?: number | undefined;
    pageID?: string | undefined;
}, {
    endDate?: string | undefined;
    startDate?: string | undefined;
    pageSize?: number | undefined;
    pageID?: string | undefined;
}, string>;
declare const QueryNotificationsTool: _langchain_core_tools.DynamicStructuredTool<z.ZodObject<{
    type: z.ZodOptional<z.ZodEnum<["Sms", "Push", "Email"]>>;
    statusCode: z.ZodOptional<z.ZodEnum<["Succeeded", "Unsubscribed", "MissingContactInfo", "NoRegisteredMobileDevice", "NoAssociatedUser", "ServiceError"]>>;
    sentBefore: z.ZodOptional<z.ZodString>;
    sentAfter: z.ZodOptional<z.ZodString>;
    identifier: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    type?: "Sms" | "Push" | "Email" | undefined;
    statusCode?: "Succeeded" | "Unsubscribed" | "MissingContactInfo" | "NoRegisteredMobileDevice" | "NoAssociatedUser" | "ServiceError" | undefined;
    sentBefore?: string | undefined;
    sentAfter?: string | undefined;
    identifier?: string | undefined;
}, {
    type?: "Sms" | "Push" | "Email" | undefined;
    statusCode?: "Succeeded" | "Unsubscribed" | "MissingContactInfo" | "NoRegisteredMobileDevice" | "NoAssociatedUser" | "ServiceError" | undefined;
    sentBefore?: string | undefined;
    sentAfter?: string | undefined;
    identifier?: string | undefined;
}>, {
    type?: "Sms" | "Push" | "Email" | undefined;
    statusCode?: "Succeeded" | "Unsubscribed" | "MissingContactInfo" | "NoRegisteredMobileDevice" | "NoAssociatedUser" | "ServiceError" | undefined;
    sentBefore?: string | undefined;
    sentAfter?: string | undefined;
    identifier?: string | undefined;
}, {
    type?: "Sms" | "Push" | "Email" | undefined;
    statusCode?: "Succeeded" | "Unsubscribed" | "MissingContactInfo" | "NoRegisteredMobileDevice" | "NoAssociatedUser" | "ServiceError" | undefined;
    sentBefore?: string | undefined;
    sentAfter?: string | undefined;
    identifier?: string | undefined;
}, string>;
declare const QuerySurveyAnswersTool: _langchain_core_tools.DynamicStructuredTool<z.ZodObject<{
    surveyResultID: z.ZodOptional<z.ZodString>;
    surveyID: z.ZodOptional<z.ZodString>;
    surveyName: z.ZodOptional<z.ZodString>;
    after: z.ZodOptional<z.ZodString>;
    before: z.ZodOptional<z.ZodString>;
    stepIdentifier: z.ZodOptional<z.ZodString>;
    resultIdentifier: z.ZodOptional<z.ZodString>;
    answer: z.ZodOptional<z.ZodString>;
    pageID: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    after?: string | undefined;
    pageID?: string | undefined;
    surveyResultID?: string | undefined;
    surveyID?: string | undefined;
    surveyName?: string | undefined;
    before?: string | undefined;
    stepIdentifier?: string | undefined;
    resultIdentifier?: string | undefined;
    answer?: string | undefined;
}, {
    after?: string | undefined;
    pageID?: string | undefined;
    surveyResultID?: string | undefined;
    surveyID?: string | undefined;
    surveyName?: string | undefined;
    before?: string | undefined;
    stepIdentifier?: string | undefined;
    resultIdentifier?: string | undefined;
    answer?: string | undefined;
}>, {
    after?: string | undefined;
    pageID?: string | undefined;
    surveyResultID?: string | undefined;
    surveyID?: string | undefined;
    surveyName?: string | undefined;
    before?: string | undefined;
    stepIdentifier?: string | undefined;
    resultIdentifier?: string | undefined;
    answer?: string | undefined;
}, {
    after?: string | undefined;
    pageID?: string | undefined;
    surveyResultID?: string | undefined;
    surveyID?: string | undefined;
    surveyName?: string | undefined;
    before?: string | undefined;
    stepIdentifier?: string | undefined;
    resultIdentifier?: string | undefined;
    answer?: string | undefined;
}, string>;
declare const QueryDeviceDataV2Tool: _langchain_core_tools.DynamicStructuredTool<z.ZodObject<{
    namespace: z.ZodEnum<["Fitbit", "AppleHealth", "Garmin", "Dexcom", "HealthConnect"]>;
    type: z.ZodString;
    observedAfter: z.ZodOptional<z.ZodString>;
    observedBefore: z.ZodOptional<z.ZodString>;
    dataSource: z.ZodOptional<z.ZodObject<{
        sourceName: z.ZodOptional<z.ZodString>;
        sourceIdentifier: z.ZodOptional<z.ZodString>;
        sourceProductType: z.ZodOptional<z.ZodString>;
        sourceOperatingSystemVersion: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        sourceIdentifier?: string | undefined;
        sourceName?: string | undefined;
        sourceProductType?: string | undefined;
        sourceOperatingSystemVersion?: string | undefined;
    }, {
        sourceIdentifier?: string | undefined;
        sourceName?: string | undefined;
        sourceProductType?: string | undefined;
        sourceOperatingSystemVersion?: string | undefined;
    }>>;
    properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
}, "strip", z.ZodTypeAny, {
    type: string;
    namespace: "AppleHealth" | "Garmin" | "Fitbit" | "HealthConnect" | "Dexcom";
    dataSource?: {
        sourceIdentifier?: string | undefined;
        sourceName?: string | undefined;
        sourceProductType?: string | undefined;
        sourceOperatingSystemVersion?: string | undefined;
    } | undefined;
    observedAfter?: string | undefined;
    observedBefore?: string | undefined;
    properties?: Record<string, string> | undefined;
}, {
    type: string;
    namespace: "AppleHealth" | "Garmin" | "Fitbit" | "HealthConnect" | "Dexcom";
    dataSource?: {
        sourceIdentifier?: string | undefined;
        sourceName?: string | undefined;
        sourceProductType?: string | undefined;
        sourceOperatingSystemVersion?: string | undefined;
    } | undefined;
    observedAfter?: string | undefined;
    observedBefore?: string | undefined;
    properties?: Record<string, string> | undefined;
}>, {
    type: string;
    namespace: "AppleHealth" | "Garmin" | "Fitbit" | "HealthConnect" | "Dexcom";
    dataSource?: {
        sourceIdentifier?: string | undefined;
        sourceName?: string | undefined;
        sourceProductType?: string | undefined;
        sourceOperatingSystemVersion?: string | undefined;
    } | undefined;
    observedAfter?: string | undefined;
    observedBefore?: string | undefined;
    properties?: Record<string, string> | undefined;
}, {
    type: string;
    namespace: "AppleHealth" | "Garmin" | "Fitbit" | "HealthConnect" | "Dexcom";
    dataSource?: {
        sourceIdentifier?: string | undefined;
        sourceName?: string | undefined;
        sourceProductType?: string | undefined;
        sourceOperatingSystemVersion?: string | undefined;
    } | undefined;
    observedAfter?: string | undefined;
    observedBefore?: string | undefined;
    properties?: Record<string, string> | undefined;
}, string>;
declare const QueryDeviceDataV2AggregateTool: _langchain_core_tools.DynamicStructuredTool<z.ZodObject<{
    namespace: z.ZodEnum<["Fitbit", "AppleHealth", "Garmin", "Dexcom", "HealthConnect"]>;
    type: z.ZodString;
    observedAfter: z.ZodOptional<z.ZodString>;
    observedBefore: z.ZodOptional<z.ZodString>;
    dataSource: z.ZodOptional<z.ZodObject<{
        sourceName: z.ZodOptional<z.ZodString>;
        sourceIdentifier: z.ZodOptional<z.ZodString>;
        sourceProductType: z.ZodOptional<z.ZodString>;
        sourceOperatingSystemVersion: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        sourceIdentifier?: string | undefined;
        sourceName?: string | undefined;
        sourceProductType?: string | undefined;
        sourceOperatingSystemVersion?: string | undefined;
    }, {
        sourceIdentifier?: string | undefined;
        sourceName?: string | undefined;
        sourceProductType?: string | undefined;
        sourceOperatingSystemVersion?: string | undefined;
    }>>;
    properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
} & {
    intervalAmount: z.ZodNumber;
    intervalType: z.ZodEnum<["Minutes", "Hours", "Days", "Weeks", "Months"]>;
    aggregateFunctions: z.ZodArray<z.ZodEnum<["sum", "avg", "count", "min", "max"]>, "many">;
}, "strip", z.ZodTypeAny, {
    type: string;
    namespace: "AppleHealth" | "Garmin" | "Fitbit" | "HealthConnect" | "Dexcom";
    intervalAmount: number;
    intervalType: "Minutes" | "Hours" | "Days" | "Weeks" | "Months";
    aggregateFunctions: ("max" | "min" | "count" | "sum" | "avg")[];
    dataSource?: {
        sourceIdentifier?: string | undefined;
        sourceName?: string | undefined;
        sourceProductType?: string | undefined;
        sourceOperatingSystemVersion?: string | undefined;
    } | undefined;
    observedAfter?: string | undefined;
    observedBefore?: string | undefined;
    properties?: Record<string, string> | undefined;
}, {
    type: string;
    namespace: "AppleHealth" | "Garmin" | "Fitbit" | "HealthConnect" | "Dexcom";
    intervalAmount: number;
    intervalType: "Minutes" | "Hours" | "Days" | "Weeks" | "Months";
    aggregateFunctions: ("max" | "min" | "count" | "sum" | "avg")[];
    dataSource?: {
        sourceIdentifier?: string | undefined;
        sourceName?: string | undefined;
        sourceProductType?: string | undefined;
        sourceOperatingSystemVersion?: string | undefined;
    } | undefined;
    observedAfter?: string | undefined;
    observedBefore?: string | undefined;
    properties?: Record<string, string> | undefined;
}>, {
    type: string;
    namespace: "AppleHealth" | "Garmin" | "Fitbit" | "HealthConnect" | "Dexcom";
    intervalAmount: number;
    intervalType: "Minutes" | "Hours" | "Days" | "Weeks" | "Months";
    aggregateFunctions: ("max" | "min" | "count" | "sum" | "avg")[];
    dataSource?: {
        sourceIdentifier?: string | undefined;
        sourceName?: string | undefined;
        sourceProductType?: string | undefined;
        sourceOperatingSystemVersion?: string | undefined;
    } | undefined;
    observedAfter?: string | undefined;
    observedBefore?: string | undefined;
    properties?: Record<string, string> | undefined;
}, {
    type: string;
    namespace: "AppleHealth" | "Garmin" | "Fitbit" | "HealthConnect" | "Dexcom";
    intervalAmount: number;
    intervalType: "Minutes" | "Hours" | "Days" | "Weeks" | "Months";
    aggregateFunctions: ("max" | "min" | "count" | "sum" | "avg")[];
    dataSource?: {
        sourceIdentifier?: string | undefined;
        sourceName?: string | undefined;
        sourceProductType?: string | undefined;
        sourceOperatingSystemVersion?: string | undefined;
    } | undefined;
    observedAfter?: string | undefined;
    observedBefore?: string | undefined;
    properties?: Record<string, string> | undefined;
}, string>;
declare const QueryDailySleepTool: _langchain_core_tools.DynamicStructuredTool<z.ZodObject<{
    namespace: z.ZodEnum<["Fitbit", "AppleHealth", "Garmin", "Dexcom", "HealthConnect"]>;
    observedAfter: z.ZodOptional<z.ZodString>;
    observedBefore: z.ZodOptional<z.ZodString>;
    dataSource: z.ZodOptional<z.ZodObject<{
        sourceName: z.ZodOptional<z.ZodString>;
        sourceIdentifier: z.ZodOptional<z.ZodString>;
        sourceProductType: z.ZodOptional<z.ZodString>;
        sourceOperatingSystemVersion: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        sourceIdentifier?: string | undefined;
        sourceName?: string | undefined;
        sourceProductType?: string | undefined;
        sourceOperatingSystemVersion?: string | undefined;
    }, {
        sourceIdentifier?: string | undefined;
        sourceName?: string | undefined;
        sourceProductType?: string | undefined;
        sourceOperatingSystemVersion?: string | undefined;
    }>>;
    properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
} & {
    type: z.ZodString;
}, "strip", z.ZodTypeAny, {
    type: string;
    namespace: "AppleHealth" | "Garmin" | "Fitbit" | "HealthConnect" | "Dexcom";
    dataSource?: {
        sourceIdentifier?: string | undefined;
        sourceName?: string | undefined;
        sourceProductType?: string | undefined;
        sourceOperatingSystemVersion?: string | undefined;
    } | undefined;
    observedAfter?: string | undefined;
    observedBefore?: string | undefined;
    properties?: Record<string, string> | undefined;
}, {
    type: string;
    namespace: "AppleHealth" | "Garmin" | "Fitbit" | "HealthConnect" | "Dexcom";
    dataSource?: {
        sourceIdentifier?: string | undefined;
        sourceName?: string | undefined;
        sourceProductType?: string | undefined;
        sourceOperatingSystemVersion?: string | undefined;
    } | undefined;
    observedAfter?: string | undefined;
    observedBefore?: string | undefined;
    properties?: Record<string, string> | undefined;
}>, {
    type: string;
    namespace: "AppleHealth" | "Garmin" | "Fitbit" | "HealthConnect" | "Dexcom";
    dataSource?: {
        sourceIdentifier?: string | undefined;
        sourceName?: string | undefined;
        sourceProductType?: string | undefined;
        sourceOperatingSystemVersion?: string | undefined;
    } | undefined;
    observedAfter?: string | undefined;
    observedBefore?: string | undefined;
    properties?: Record<string, string> | undefined;
}, {
    type: string;
    namespace: "AppleHealth" | "Garmin" | "Fitbit" | "HealthConnect" | "Dexcom";
    dataSource?: {
        sourceIdentifier?: string | undefined;
        sourceName?: string | undefined;
        sourceProductType?: string | undefined;
        sourceOperatingSystemVersion?: string | undefined;
    } | undefined;
    observedAfter?: string | undefined;
    observedBefore?: string | undefined;
    properties?: Record<string, string> | undefined;
}, string>;
declare const QueryDailyDataTool: _langchain_core_tools.DynamicStructuredTool<z.ZodObject<{
    type: z.ZodString;
    startDate: z.ZodString;
    endDate: z.ZodString;
}, "strip", z.ZodTypeAny, {
    type: string;
    endDate: string;
    startDate: string;
}, {
    type: string;
    endDate: string;
    startDate: string;
}>, {
    type: string;
    endDate: string;
    startDate: string;
}, {
    type: string;
    endDate: string;
    startDate: string;
}, string>;
declare const GetDeviceDataV2AllDataTypesTool: _langchain_core_tools.DynamicStructuredTool<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>, {}, {}, string>;
declare const GetAllDailyDataTypesTool: _langchain_core_tools.DynamicStructuredTool<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>, {}, {}, string>;
declare const GetEhrNewsFeedPageTool: _langchain_core_tools.DynamicStructuredTool<z.ZodObject<{
    feed: z.ZodEnum<["Immunizations", "LabReports", "Procedures", "Reports"]>;
    pageID: z.ZodOptional<z.ZodString>;
    pageDate: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    feed: "Immunizations" | "Procedures" | "Reports" | "LabReports";
    pageID?: string | undefined;
    pageDate?: string | undefined;
}, {
    feed: "Immunizations" | "Procedures" | "Reports" | "LabReports";
    pageID?: string | undefined;
    pageDate?: string | undefined;
}>, {
    feed: "Immunizations" | "Procedures" | "Reports" | "LabReports";
    pageID?: string | undefined;
    pageDate?: string | undefined;
}, {
    feed: "Immunizations" | "Procedures" | "Reports" | "LabReports";
    pageID?: string | undefined;
    pageDate?: string | undefined;
}, string>;
declare const GraphingTool: _langchain_core_tools.DynamicStructuredTool<z.ZodObject<{
    code: z.ZodString;
}, "strip", z.ZodTypeAny, {
    code: string;
}, {
    code: string;
}>, {
    code: string;
}, {
    code: string;
}, string>;
declare const UploadedFileQueryTool: _langchain_core_tools.DynamicStructuredTool<z.ZodObject<{
    category: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    category?: string | undefined;
}, {
    category?: string | undefined;
}>, {
    category?: string | undefined;
}, {
    category?: string | undefined;
}, string>;
declare const GetUploadedFileTool: _langchain_core_tools.DynamicStructuredTool<z.ZodObject<{
    key: z.ZodString;
}, "strip", z.ZodTypeAny, {
    key: string;
}, {
    key: string;
}>, {
    key: string;
}, {
    key: string;
}, string>;
declare const SaveLastGraphTool: _langchain_core_tools.DynamicStructuredTool<z.ZodObject<{
    fileName: z.ZodString;
}, "strip", z.ZodTypeAny, {
    fileName: string;
}, {
    fileName: string;
}>, {
    fileName: string;
}, {
    fileName: string;
}, string>;

declare const Tools_GetAllDailyDataTypesTool: typeof GetAllDailyDataTypesTool;
declare const Tools_GetDeviceDataV2AllDataTypesTool: typeof GetDeviceDataV2AllDataTypesTool;
declare const Tools_GetEhrNewsFeedPageTool: typeof GetEhrNewsFeedPageTool;
declare const Tools_GetUploadedFileTool: typeof GetUploadedFileTool;
declare const Tools_GraphingTool: typeof GraphingTool;
declare const Tools_PersistParticipantInfoTool: typeof PersistParticipantInfoTool;
declare const Tools_QueryAppleHealthActivitySummariesTool: typeof QueryAppleHealthActivitySummariesTool;
declare const Tools_QueryAppleHealthWorkoutsTool: typeof QueryAppleHealthWorkoutsTool;
declare const Tools_QueryDailyDataTool: typeof QueryDailyDataTool;
declare const Tools_QueryDailySleepTool: typeof QueryDailySleepTool;
declare const Tools_QueryDeviceDataV2AggregateTool: typeof QueryDeviceDataV2AggregateTool;
declare const Tools_QueryDeviceDataV2Tool: typeof QueryDeviceDataV2Tool;
declare const Tools_QueryNotificationsTool: typeof QueryNotificationsTool;
declare const Tools_QuerySurveyAnswersTool: typeof QuerySurveyAnswersTool;
declare const Tools_SaveLastGraphTool: typeof SaveLastGraphTool;
declare const Tools_UploadedFileQueryTool: typeof UploadedFileQueryTool;
declare namespace Tools {
  export { Tools_GetAllDailyDataTypesTool as GetAllDailyDataTypesTool, Tools_GetDeviceDataV2AllDataTypesTool as GetDeviceDataV2AllDataTypesTool, Tools_GetEhrNewsFeedPageTool as GetEhrNewsFeedPageTool, Tools_GetUploadedFileTool as GetUploadedFileTool, Tools_GraphingTool as GraphingTool, Tools_PersistParticipantInfoTool as PersistParticipantInfoTool, Tools_QueryAppleHealthActivitySummariesTool as QueryAppleHealthActivitySummariesTool, Tools_QueryAppleHealthWorkoutsTool as QueryAppleHealthWorkoutsTool, Tools_QueryDailyDataTool as QueryDailyDataTool, Tools_QueryDailySleepTool as QueryDailySleepTool, Tools_QueryDeviceDataV2AggregateTool as QueryDeviceDataV2AggregateTool, Tools_QueryDeviceDataV2Tool as QueryDeviceDataV2Tool, Tools_QueryNotificationsTool as QueryNotificationsTool, Tools_QuerySurveyAnswersTool as QuerySurveyAnswersTool, Tools_SaveLastGraphTool as SaveLastGraphTool, Tools_UploadedFileQueryTool as UploadedFileQueryTool };
}

declare function predictableRandomNumber(message: string): Promise<number>;
declare function fnvPredictableRandomNumber(message: string, maxValue?: number): number;

type SingleValueProviderType = 'static integer' | 'random integer' | 'custom field integer' | 'days with data';
declare abstract class SingleValueProvider<T> {
    type: SingleValueProviderType;
    protected constructor(type: SingleValueProviderType);
    abstract getValue(): Promise<T | undefined>;
}
declare class StaticIntegerValueProvider extends SingleValueProvider<number> {
    staticValue: number;
    constructor(staticValue: number);
    getValue(): Promise<number | undefined>;
}
declare class RandomIntegerValueProvider extends SingleValueProvider<number> {
    maxValue: number;
    constructor(maxValue: number);
    getValue(): Promise<number | undefined>;
}
declare class CustomFieldIntegerValueProvider extends SingleValueProvider<number> {
    customField: string;
    constructor(customField: string);
    getValue(): Promise<number | undefined>;
}
declare class DaysWithDataValueProvider extends SingleValueProvider<number> {
    dataType: string;
    daysInPast: number;
    constructor(dataType: string, daysInPast: number);
    getValue(): Promise<number | undefined>;
}
declare const createStaticIntegerValueProvider: (staticValue: number) => StaticIntegerValueProvider;
declare const createRandomIntegerValueProvider: (maxValue: number) => RandomIntegerValueProvider;
declare const createCustomFieldIntegerValueProvider: (customField: string) => CustomFieldIntegerValueProvider;
declare const createDaysWithDataValueProvider: (dataType: string, daysInPast: number) => DaysWithDataValueProvider;

declare function generateSampleData(startDate: Date, endDate: Date, min: number, max: number): DailyDataQueryResult;

interface SurveyDataType {
    surveyName: string;
    stepIdentifier?: string;
    resultIdentifier?: string;
    useEventAsDate?: boolean;
}
declare function isSurveyDataType(dataType: string | SurveyDataType): dataType is SurveyDataType;
declare function getSurveyDataProvider(dataType: SurveyDataType): DailyDataProvider;

interface InsightMatrixValueCalculator {
    calculate: (thresholdDays: string[], values: number[]) => number | undefined;
}
declare const createNonZeroAverageValueInsightMatrixValueCalculator: () => InsightMatrixValueCalculator;
declare const createPercentageOfDaysInsightMatrixValueCalculator: () => InsightMatrixValueCalculator;

interface InsightMatrixValueFormatter {
    format: (value: number) => string;
}
declare const createShrinkThousandsInsightMatrixValueFormatter: () => InsightMatrixValueFormatter;
declare const createMinutesToHoursInsightMatrixValueFormatter: () => InsightMatrixValueFormatter;
declare const createIntegerInsightMatrixValueFormatter: (suffix?: string) => InsightMatrixValueFormatter;

interface InsightMatrixValueEvaluator {
    evaluate: (value: number) => boolean;
}
declare const createMinMaxInsightMatrixValueEvaluator: (minimumGoodValue: number, maximumGoodValue?: number) => InsightMatrixValueEvaluator;

interface InsightMatrixValueThreshold {
    label: string;
    minimumValue?: number;
    maximumValue?: number;
}
declare const NotEnteredThreshold = "Not Entered";
type InsightMatrixThresholdDaysLookup = {
    [key: string]: string[];
};
declare function computeThresholdDays(startDate: Date, endDate: Date, data: InsightMatrixData<InsightMatrixGroupByDataConfiguration>): InsightMatrixThresholdDaysLookup;

interface InsightMatrixDataConfiguration {
    label?: string;
    rawDataType: string | SurveyDataType;
}
interface InsightMatrixGroupByDataConfiguration extends InsightMatrixDataConfiguration {
    thresholds: InsightMatrixValueThreshold[];
}
interface InsightMatrixComparisonDataConfiguration extends InsightMatrixDataConfiguration {
    units?: string;
    valueCalculator: InsightMatrixValueCalculator;
    valueFormatter: InsightMatrixValueFormatter;
    valueEvaluator: InsightMatrixValueEvaluator;
}
interface InsightMatrixDataProvider<T extends InsightMatrixDataConfiguration> {
    configuration: T;
    loadData: DailyDataProvider;
}
interface InsightMatrixData<T extends InsightMatrixDataConfiguration> {
    configuration: T;
    result: DailyDataQueryResult;
}

declare function createThumbnailIfNecessary(file: File, thumbnailSize?: number): Promise<File | undefined>;
declare function stripExifTags(file: File): Promise<File>;

type EhrNewsFeedType = "Immunizations" | "LabReports" | "Procedures" | "Reports";
type EhrNewsFeedEvent = EhrNewsFeedImmunizationModel | EhrNewsFeedReportModel | EhrNewsFeedProcedureModel[] | EhrNewsFeedLabReportModel | EhrNewsFeedClaimProcedureModel[] | EhrNewsFeedClaimServiceModel[];
type EhrNewsFeedEventType = "ProcedureGroup" | "Report" | "Immunization" | "LabReport" | "ClaimProcedureGroup" | "ClaimServiceGroup";
interface EhrNewsFeedCaregiverModel {
    ID: string;
    CaregiverName?: string;
    Specialty?: string;
    Addresses: EhrNewsFeedCaregiverAddressModel[];
    ContactInfos: EhrNewsFeedCaregiverContactInfoModel[];
    Pcp: boolean;
}
interface EhrNewsFeedCaregiverAddressModel {
    Type?: string;
    Street1?: string;
    Street2?: string;
    Street3?: string;
    City?: string;
    County?: string;
    State?: string;
    Zip?: string;
    Country?: string;
}
interface EhrNewsFeedCaregiverContactInfoModel {
    Type?: string;
    Info?: string;
}
interface EhrNewsFeedLabReportModel {
    ID: string;
    ObservationDate: string;
    PlacerOrderNumber?: string;
    FillerOrderNumber?: string;
    AccessionNumber?: string;
    EncounterID?: string;
    LabObservations: EhrNewsFeedLabObservationModel[];
    ReportStatusDate?: string;
    ReportStatus?: string;
    Service: string;
    Comment?: string;
    OrderingCaregiver?: EhrNewsFeedCaregiverModel;
    Location?: string;
    ServiceDefinition?: string;
}
interface EhrNewsFeedLabObservationModel {
    ID: string;
    Type: string;
    Value: string;
    Units?: string;
    Acuity?: string;
    NormalRange?: string;
    Comment?: string;
    AcuityHighlight?: string;
    ObservationDate?: string;
    ObservationResultStatus?: string;
    ObservationResultStatusDate?: string;
    TrendAvailable?: boolean;
    TypeDefinition?: string;
}
interface EhrNewsFeedProcedureModel {
    ID: string;
    Date?: string;
    Procedure: string;
    Type?: string;
    Description?: string;
    Location?: string;
    PerformedByCaregiver?: EhrNewsFeedCaregiverModel;
    VerifiedByCaregiver?: EhrNewsFeedCaregiverModel;
}
interface EhrNewsFeedReportModel {
    ID: string;
    Type: string;
    Format?: string;
    Summary?: string;
    DictatedByCaregiver?: EhrNewsFeedCaregiverModel;
    Content?: string;
    Location?: string;
}
interface EhrNewsFeedClaimServiceModel {
    ID: string;
    Service: string;
    AmountClaimed?: string;
    AmountPaid?: string;
    EndDate?: string;
    StartDate?: string;
    Status?: string;
}
interface EhrNewsFeedClaimProcedureModel {
    ID: string;
    Date?: string;
    Procedure: string;
    Type?: string;
}
interface EhrNewsFeedImmunizationModel {
    ID: string;
    Date?: string;
    MedicationName?: string;
}

declare function tryParseRegex(pattern: string): {
    success: boolean;
    regex: RegExp | undefined;
};

type LibraryDocumentFileType = 'image' | 'pdf';
interface LibraryDocument {
    surveyResultId: string;
    file: string;
    fileType: LibraryDocumentFileType;
    name: string;
    type?: string;
    date?: string;
    notes?: string;
    fileKey?: string;
    fileUrl?: string;
}
interface LibraryDocumentSurveySpecification {
    surveyName: string;
    fileResultIdentifier: string;
    nameResultIdentifier: string;
    typeResultIdentifier: string;
    dateResultIdentifier: string;
    notesResultIdentifier: string;
}
interface AllLibraryDocumentsLoader {
    load: (surveySpecification: LibraryDocumentSurveySpecification, populateFileKeyAndUrl: boolean) => Promise<LibraryDocument[]>;
}
declare function createAllLibraryDocumentsLoader(): AllLibraryDocumentsLoader;
interface SingleLibraryDocumentLoader {
    load: (surveyResultId: string, surveySpecification: LibraryDocumentSurveySpecification) => Promise<LibraryDocument | undefined>;
}
declare function createSingleLibraryDocumentLoader(): SingleLibraryDocumentLoader;
declare function createLibraryDocumentSorter(sortKey: keyof LibraryDocument, sortDirection: 'asc' | 'desc'): (document1: LibraryDocument, document2: LibraryDocument) => number;
declare function formatLibraryDocumentDateAndType(document: LibraryDocument): string;

declare function buildHtmlReport(reportHtml: string, styleElements?: HTMLStyleElement[], additionalCssRules?: string[]): string;
declare function previewHtmlReport(html: string, fileName?: string): void;

interface BasicBadgeProps {
    backgroundColor?: ColorDefinition;
    size?: "xs" | "small" | "xl";
    children?: ReactElement;
}
declare function export_default$1K(props: BasicBadgeProps): React$1.JSX.Element;

type BloodPressureClassification = 'low' | 'normal' | 'elevated' | 'hypertension-stage-1' | 'hypertension-stage-2' | 'hypertensive-crisis';
interface BloodPressureReadingProps {
    systolic: number;
    diastolic: number;
    date: Date;
    onClick?: () => void;
    indicator?: ReactElement;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
/**
 * This component can be used to render a single blood pressure reading.
 */
declare function BloodPressureReading(props: BloodPressureReadingProps): React$1.JSX.Element;

type ButtonVariant = "default" | "subtle" | "light";
interface ButtonProps {
    children?: React$1.ReactNode;
    disabled?: boolean;
    onClick: MouseEventHandler;
    stopPropagation?: boolean;
    className?: string;
    color?: ColorDefinition;
    loading?: boolean;
    variant?: ButtonVariant;
    innerRef?: React$1.Ref<HTMLButtonElement>;
    defaultMargin?: boolean;
    fullWidth?: boolean;
    title?: string;
}
declare function Button(props: ButtonProps): React$1.JSX.Element;

interface CalendarProps {
    month: number;
    year: number;
    dayRenderer(year: number, month: number, day?: number): JSX.Element | null;
    weekStartsOn?: 0 | 1 | 2 | 3 | 4 | 5 | 6;
    className?: string;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
declare function Calendar(props: CalendarProps): React$1.JSX.Element;

interface CalendarDayState {
    label?: string;
    backgroundColor?: ColorDefinition;
    borderColor?: ColorDefinition;
    textColor?: ColorDefinition;
    /**
     * @deprecated - This property has been deprecated and will be removed in a future release.
     *
     * Please specify a streakIdentifier to enable streaking.  The identifier is used to determine
     * when a matching state has been computed for the prior and/or following days which causes a
     * streak to be rendered.
     */
    streak?: boolean;
    streakIdentifier?: string;
    streakColor?: ColorDefinition;
    combineWhenSolo?: boolean;
    style?: CSSProperties;
}
interface CalendarDayStates extends Array<CalendarDayState> {
    displayValue?: string;
    note?: string;
    noteBackgroundColor?: ColorDefinition;
    noteBorderColor?: ColorDefinition;
    noteTextColor?: ColorDefinition;
}
type CalendarDayStateConfiguration = Partial<Record<string, CalendarDayState>>;
interface CalendarDayProps {
    year: number;
    month: number;
    day?: number;
    /**
     * @deprecated - This property has been deprecated and will be removed in a future release.
     *
     * Please use computeStatesForDay instead.
     */
    stateConfiguration?: CalendarDayStateConfiguration;
    /**
     * @deprecated - This property has been deprecated and will be removed in a future release.
     *
     * Please use computeStatesForDay instead.
     */
    computeStateForDay?: (date: Date) => string | undefined;
    computeStatesForDay?: (date: Date) => CalendarDayStates;
    onClick?: (date: Date) => void;
    multiStateStartAngle?: number;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
declare function CalendarDay(props: CalendarDayProps): React$1.JSX.Element;

interface CardProps {
    className?: string;
    children?: React$1.ReactNode;
    allowOverflow?: boolean;
    innerRef?: React$1.Ref<HTMLDivElement>;
    variant?: "default" | "subtle" | "highlight";
    backgroundColor?: ColorDefinition;
    onClick?: () => void;
    style?: React$1.CSSProperties;
}
declare function export_default$1J(props: CardProps): React$1.JSX.Element | null;

interface CardTitleProps {
    title: string;
    onDetailClick?: Function;
    detailLinkText?: string;
    innerRef?: React$1.Ref<HTMLDivElement>;
    color?: ColorDefinition;
}
declare function CardTitle(props: CardTitleProps): React$1.JSX.Element;

type ChatMessageType = "sent" | "received" | "received-image";
interface ChatProps {
    innerRef?: React$1.Ref<HTMLDivElement>;
    messages: ChatMessage[];
    onSendMessage: (newMessage: string) => void;
    loading?: string;
    inputDisabled?: boolean;
    suggestions?: string[];
    onSuggestionSelected?: (suggestion: string) => void;
}
interface ChatMessage {
    icon?: React$1.JSX.Element;
    content: string;
    type: ChatMessageType;
    cssClass?: string;
}
/**
 * Presentational component that can be used to display a conversation between two users, one of which could be an AI Assistant.
 */
declare function Chat(props: ChatProps): React$1.JSX.Element;

interface DateRangeCoordinatorProps {
    initialIntervalStart?: Date;
    intervalType: "Day" | "Week" | "Month" | "6Month";
    weekStartsOn?: WeekStartsOn;
    variant?: "default" | "rounded";
    children?: React$1.ReactNode;
    innerRef?: React$1.Ref<HTMLDivElement>;
    sticky?: boolean;
    useCustomNavigator?: boolean;
}
interface DateRangeContextUpdates {
    intervalStart: Date;
}
interface DateRangeContext {
    intervalType: "Day" | "Week" | "Month" | "6Month";
    intervalStart: Date;
    update: (updates: DateRangeContextUpdates) => void;
}
declare const DateRangeContext: React$1.Context<DateRangeContext | null>;
declare function DateRangeCoordinator(props: DateRangeCoordinatorProps): React$1.JSX.Element | null;

interface DateRangeNavigatorProps {
    intervalType: "Day" | "Week" | "Month" | "6Month";
    intervalStart: Date;
    variant?: "default" | "rounded";
    onIntervalChange(newIntervalStart: Date, newIntervalEnd: Date): void;
    className?: string;
    innerRef?: React$1.Ref<HTMLDivElement>;
    sticky?: boolean;
}
declare function DateRangeNavigator(props: DateRangeNavigatorProps): React$1.JSX.Element;

interface TitleProps {
    color?: ColorDefinition;
    order?: 1 | 2 | 3 | 4 | 5 | 6;
    children?: React$1.ReactNode;
    style?: React$1.CSSProperties;
    className?: string;
    image?: ReactNode;
    autosizeImage?: boolean;
    imageAlignment?: "top" | "left";
    defaultMargin?: boolean;
    innerRef?: React$1.Ref<HTMLDivElement>;
    accessory?: ReactNode;
}
declare function export_default$1I(props: TitleProps): React$1.JSX.Element;

interface DateRangeTitleProps extends TitleProps {
    color?: ColorDefinition;
    order?: 1 | 2 | 3 | 4 | 5 | 6;
    style?: React$1.CSSProperties;
    defaultMargin?: boolean;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
declare function DateRangeTitle(props: DateRangeTitleProps): React$1.JSX.Element;

interface DayTrackerSymbolProps {
    primaryColors: string[];
    secondaryColors: string[];
    className?: string;
    size?: "small" | "large";
    innerRef?: React$1.Ref<HTMLDivElement>;
}
declare function DayTrackerSymbol(props: DayTrackerSymbolProps): React$1.JSX.Element;

interface DiscreteScaleProps {
    tickCount: number;
    minLabel?: string;
    maxLabel?: string;
    value?: number;
    onChange?: (value: number | undefined) => void;
    sliderColor?: ColorDefinition;
    innerRef?: React$1.RefObject<HTMLDivElement>;
}
declare function export_default$1H(props: DiscreteScaleProps): React$1.JSX.Element;

declare function export_default$1G(): React$1.JSX.Element;

interface ClosedInterval {
    values: number[];
}
interface DataPoint {
    dataSet1: ClosedInterval;
    dataSet2: ClosedInterval;
}
interface DumbbellDataPoint {
    dataPoint?: DataPoint;
    xValue: string;
    class?: DumbbellClass;
}
interface Axis {
    yRange: ClosedInterval;
    yIncrement: number;
    xIncrement: number;
}
interface DumbBellChartProps {
    axis: Axis;
    dumbbells: DumbbellDataPoint[];
}
declare enum DumbbellClass {
    "mdhui-dumbbell-in-range" = 0,
    "mdhui-dumbbell-out-of-range" = 1
}
declare function DumbbellChart(props: DumbBellChartProps): React$1.JSX.Element;

interface FaceProps {
    faceValue?: number;
    selected?: boolean;
    onClick?: MouseEventHandler;
    className?: string;
    innerRef?: React$1.Ref<HTMLButtonElement>;
}
declare function Face(props: FaceProps): React$1.JSX.Element;

interface GlucoseStatsProps {
    variant?: 'default' | 'minimal';
    loading: boolean;
    glucoseReadings: Reading[];
    steps: Reading[];
    sleepMinutes: number | undefined;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
declare function export_default$1F(props: GlucoseStatsProps): React$1.JSX.Element;

interface GridProps {
    children?: React$1.ReactNode;
    gap?: number;
    style?: React$1.CSSProperties;
    className?: string;
    defaultMargin?: boolean;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
interface GridColumnProps {
    children?: React$1.ReactNode;
    span: number;
    variant?: "default" | "card";
    innerRef?: React$1.Ref<HTMLDivElement>;
    style?: React$1.CSSProperties;
}
declare function Grid(props: GridProps): React$1.JSX.Element;
declare namespace Grid {
    var Column: (props: GridColumnProps) => React$1.JSX.Element | null;
}

interface HistogramProps {
    entries: {
        label: string;
        color: string;
        value: number;
        onSelect?(): void;
    }[];
    className?: string;
    innerRef?: React$1.Ref<HTMLDivElement>;
    linkColor?: ColorDefinition;
}
declare function Histogram(props: HistogramProps): React$1.JSX.Element;

interface LayoutProps {
    children?: React$1.ReactNode;
    bodyBackgroundColor?: ColorDefinition;
    primaryColor?: ColorDefinition;
    statusBarStyle?: StatusBarStyle;
    className?: string;
    noGlobalStyles?: boolean;
    colorScheme?: "light" | "dark" | "auto";
    flex?: boolean;
    /**
      * @deprecated
      */
    stylesheetPath?: string;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
interface LayoutContext {
    colorScheme: "light" | "dark";
    bodyBackgroundColor: string;
}
declare const LayoutContext: React$1.Context<LayoutContext>;
declare function Layout(props: LayoutProps): React$1.JSX.Element;

interface LoadingIndicatorProps {
    variant?: "default" | "inline";
    color?: string;
    className?: string;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
declare function LoadingIndicator(props: LoadingIndicatorProps): React$1.JSX.Element;

interface MealAnalysisProps {
    variant?: 'worklist';
    meal: Meal;
    onAddItem?: (itemToAdd: string) => void;
    onAddItems?: () => void;
    onReviewItems?: () => void;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
/**
 * This component renders meal analysis details when present on a meal.
 */
declare function MealAnalysis(props: MealAnalysisProps): React$1.JSX.Element | null;

interface MealButtonsProps {
    preview?: boolean;
    autoLaunchEditor?: boolean;
    onEditMeal?: () => void;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
/**
 * This component renders buttons that can be used to quickly add meal log entries.  It can be
 * configured to automatically launch the meal editor when a new meal has been added.  It must
 * be used within a Meal Coordinator.
 */
declare function MealButtons(props: MealButtonsProps): React$1.JSX.Element;

interface MealLogProps {
    preview?: boolean;
    onEditMeal: () => void;
    showMealNumbers?: boolean;
    highlightSelectedMeal?: boolean;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
/**
 * This component renders a daily meal log.  It can be configured to show meal numbers and/or
 * highlight the currently selected meal.  It must be used within a Meal Coordinator.
 */
declare function MealLog(props: MealLogProps): React$1.JSX.Element;

interface MonthlyEventMatrixRow {
    label: string;
    data: boolean[];
    color: ColorDefinition;
}
interface MonthlyEventMatrixProps {
    title?: string;
    rows: MonthlyEventMatrixRow[];
    innerRef?: React$1.Ref<HTMLTableElement>;
    intervalStart: Date;
}
declare function export_default$1E(props: MonthlyEventMatrixProps): React$1.JSX.Element;

interface NavigationBarProps {
    title?: string;
    subtitle?: string;
    showBackButton?: boolean;
    showCloseButton?: boolean;
    children?: React$1.ReactNode;
    closeButtonText?: string;
    backButtonText?: string;
    className?: string;
    variant?: "default" | "compressed" | "compressedModal";
    titleColor?: ColorDefinition;
    subtitleColor?: ColorDefinition;
    buttonColor?: ColorDefinition;
    navigationBarLeft?: React$1.ReactNode;
    navigationBarRight?: React$1.ReactNode;
    backgroundColor?: ColorDefinition;
    onClose?: () => void;
    onBack?: () => void;
    style?: CSSProperties;
}
declare function export_default$1D(props: NavigationBarProps): React$1.JSX.Element;

interface NotesInputProps {
    autoTimestamp?: boolean;
    placeholder?: string;
    onChange(value: string): void;
    value: string;
}
declare function export_default$1C(props: NotesInputProps): React$1.JSX.Element;

interface ProgressBarProps {
    backgroundColor?: ColorDefinition;
    borderColor?: ColorDefinition;
    fillColor?: ColorDefinition;
    fillPercent: number;
    steps?: {
        percent: number;
        icon: ReactElement;
    }[];
    innerRef?: React$1.Ref<HTMLDivElement>;
    defaultMargin?: boolean;
}
declare function ProgressBar(props: ProgressBarProps): React$1.JSX.Element;
declare namespace ProgressBar {
    var defaultProps: {
        backgroundColor: string;
        fillColor: string;
        fillPercent: number;
    };
}

interface ProgressBarStepProps {
    borderColor?: ColorDefinition;
    backgroundColor?: ColorDefinition;
    children?: React$1.ReactNode;
    height: string;
}
declare function ProgressBarStep(props: ProgressBarStepProps): React$1.JSX.Element;

interface ProgressRingProps {
    diameter?: number;
    strokeWidth?: number;
    color?: ColorDefinition;
    incompleteColor?: ColorDefinition;
    percentCompleted?: number;
    animate?: boolean;
    style?: CSSProperties;
    children: ReactNode;
    innerRef?: Ref<HTMLDivElement>;
}
declare function ProgressRing(props: ProgressRingProps): React$1.JSX.Element;

type ResourceImageAlignment = 'left' | 'center' | 'right';
type ResourceButtonVariant = 'button' | 'link';
interface ResourceProps {
    imageUrl?: string;
    title: string;
    subTitle?: string;
    imageAlignment?: ResourceImageAlignment;
    buttonVariant?: ResourceButtonVariant;
    buttonText?: string;
    onClick: () => void;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
declare function export_default$1B(props: ResourceProps): React$1.JSX.Element;

interface ResourceDefinition {
    title: string;
    subTitle?: string;
    url: string;
    imageUrl?: string;
}
interface ResourceListProps {
    previewState?: ResourceListPreviewState;
    resources: ResourceDefinition[];
    onViewResource: (resource: ResourceDefinition) => void;
    emptyText?: string;
    imageAlignment?: ResourceImageAlignment;
    buttonVariant?: ResourceButtonVariant;
    buttonText?: string;
    style?: CSSProperties;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
declare function export_default$1A(props: ResourceListProps): React$1.JSX.Element;

type RotatingComponentInterval = 'day' | 'week' | 'month';
interface RotatingComponentCoordinatorProps {
    interval?: RotatingComponentInterval;
    children: React$1.ReactNode;
    startDate: Date;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
declare function export_default$1z(props: RotatingComponentCoordinatorProps): React$1.JSX.Element;

interface SectionProps {
    children?: React$1.ReactNode;
    className?: string;
    noTopMargin?: boolean;
    innerRef?: React$1.Ref<HTMLDivElement>;
    backgroundColor?: ColorDefinition;
    style?: React$1.CSSProperties;
}
declare function Section(props: SectionProps): React$1.JSX.Element | null;

interface SegmentedControlProps {
    segments: {
        key: string;
        title: string;
    }[];
    selectedSegment?: string;
    onSegmentSelected(segmentKey: string): void;
    className?: string;
    color?: string;
    variant?: "default" | "optionsHorizontal" | "optionsVertical";
    innerRef?: React$1.Ref<HTMLDivElement>;
    style?: React$1.CSSProperties;
}
declare function SegmentedControl(props: SegmentedControlProps): React$1.JSX.Element;

declare function export_default$1y(): React$1.JSX.Element;

interface SingleDataPointProps {
    label: string;
    statusText?: string;
    statusColor?: ColorDefinition;
    value?: string;
    units?: string;
    onClick?: () => void;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
declare function export_default$1x(props: SingleDataPointProps): React$1.JSX.Element;

interface SingleExternalAccountProps {
    externalAccount: ExternalAccount;
    onAccountRemoved: (account: ExternalAccount) => void;
    onReconnectAccount: (account: ExternalAccount) => void;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
declare function SingleExternalAccount(props: SingleExternalAccountProps): React$1.JSX.Element;

interface SingleNotificationProps {
    notification: Notification | null;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
declare function export_default$1w(props: SingleNotificationProps): React$1.JSX.Element;

type SingleSurveyTaskVariant = 'default' | 'expanded';
interface SingleSurveyTaskProps {
    task: SurveyTask;
    onClick: () => void;
    variant?: SingleSurveyTaskVariant;
    descriptionIcon?: IconDefinition$1;
    surveyActive?: boolean;
    surveyBlocked?: boolean;
    buttonColor?: ColorDefinition;
    buttonVariant?: ButtonVariant;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
declare function export_default$1v(props: SingleSurveyTaskProps): React$1.JSX.Element | null;

interface SparkBarChartProps {
    averageFillPercent?: number;
    bars: SparkBarChartBar[];
    innerRef?: React$1.Ref<HTMLDivElement>;
    style?: React$1.CSSProperties;
    gap?: number;
    variant?: "square" | "rounded";
}
interface SparkBarChartBar {
    color: ColorDefinition;
    barFillPercent: number;
    opacity?: number;
}
declare function SparkBarChart(props: SparkBarChartProps): React$1.JSX.Element;

interface SparkRangeChartRange {
    min: number;
    max: number;
    average: number;
    color?: ColorDefinition;
}
interface SparkRangeChartProps {
    domain: [number, number];
    ranges: SparkRangeChartRange[];
    reference?: number;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
declare function export_default$1u(props: SparkRangeChartProps): React$1.JSX.Element;

interface SwitchProps {
    isOn: Boolean;
    onBackgroundColor?: string;
    onValueChanged(value: boolean): void;
    className?: string;
    innerRef?: React$1.Ref<HTMLButtonElement>;
}
declare function Switch(props: SwitchProps): React$1.JSX.Element;

interface StatusBarBackgroundProps {
    color?: string;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
declare function StatusBarBackgroundProps(props: StatusBarBackgroundProps): React$1.JSX.Element;

interface AIAssistantProps {
    innerRef?: React$1.Ref<HTMLDivElement>;
    previewState?: "default";
    debug: boolean;
    additionalInstructions?: string;
    tools?: StructuredTool[];
    appendTools?: boolean;
    baseUrl?: string;
    showSuggestions?: boolean;
}
/**
 * Component that can be used to add the MyDataHelps AI Assistant to your application.
 * The component will use all the allowed viewport vertical space it is given.
*/
declare function AIAssistant(props: AIAssistantProps): React$1.JSX.Element;

interface TermInformationProps {
    previewState?: "default" | "noData";
    term?: TermInformationReference;
    labObservationID?: string;
    openLinksInNewWindow?: boolean;
}
interface TermInformationReference {
    TermFamily: string;
    TermNamespace: string;
    TermCode: string;
}
declare function export_default$1t(props: TermInformationProps): React$1.JSX.Element;

interface AllergiesListProps {
    previewState?: "default";
    onLoadComplete?: () => void;
    onViewTermInfo?: (termInfo: TermInformationReference) => void;
    innerRef?: Ref<HTMLDivElement>;
}
declare function AllergiesList(props: AllergiesListProps): React$1.JSX.Element;

interface AppDownloadProps {
    previewProjectPlatforms?: string[];
    previewDevicePlatform?: string;
    innerRef?: React$1.Ref<HTMLDivElement>;
    title?: string;
    text?: string;
}
declare function export_default$1s(props: AppDownloadProps): React$1.JSX.Element | null;

type AppleHealthRecordsSyncPreviewState = 'wrong platform' | 'disabled' | 'enabled no data yet' | 'enabled no data' | 'enabled with data';
type AppleHealthRecordsStatus = 'enabled' | 'disabled';
interface AppleHealthRecordsSyncProps {
    previewState?: AppleHealthRecordsSyncPreviewState;
    enableAppleHealthRecordsSurvey: string;
    showWhen?: AppleHealthRecordsStatus;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
declare function AppleHealthRecordsSync(props: AppleHealthRecordsSyncProps): React$1.JSX.Element | null;

interface BasicPointsForBadgesProps {
    pointsPerBadge: number;
    activities: BasicPointsForBadgesActivity[];
    previewState?: "default";
    progressBarFillColor?: ColorDefinition;
    pointsLabelColor?: ColorDefinition;
    awardBadgesViewUrl: string;
    showTotalPoints?: boolean;
    customField: string;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
/**
 * Earn points for completing activities. Badges are earned once pointsPerBadge are reached.
 * The progress bar will fill as points are earned. When a badge is earned a celebration step
 * will show and the progress bar will then reset.
 * Activity types supported are Survey Completion, Daily device data like sleep and steps,
 * connecting external accounts like an EHR, Health Plan, or wearable device,
 * and lastly based on the participant's custom field value.
*/
declare function BasicPointsForBadges(props: BasicPointsForBadgesProps): React$1.JSX.Element;

interface BasicBadgesProps {
    badgeCount?: number;
    title?: string;
    pointsForBadgesCustomField?: string;
}
declare function export_default$1r(props: BasicBadgesProps): React$1.JSX.Element | null;

type BloodPressurePreviewState = "Default" | "NoData" | "Loading";
interface BloodPressureVisualizationProps {
    previewState?: BloodPressurePreviewState;
    surveyDataSource?: SurveyBloodPressureDataParameters;
    weekStartsOn?: WeekStartsOn;
    deviceDataSource?: BloodPressureDeviceDataSource[];
    suppressGuidance?: boolean;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
declare function export_default$1q(props: BloodPressureVisualizationProps): React$1.JSX.Element;

interface ConditionsListProps {
    previewState?: "default";
    onLoadComplete?: () => void;
    onViewTermInfo?: (termInfo: TermInformationReference) => void;
    innerRef?: Ref<HTMLDivElement>;
}
declare function ConditionsList(props: ConditionsListProps): React$1.JSX.Element;

type DeviceAccountType = "Fitbit" | "Garmin" | "Dexcom" | "AppleHealth" | "GoogleFit" | "Omron" | "HealthConnect" | "Environmental" | "Oura";
interface ConnectDevicesMenuProps {
    innerRef?: React$1.Ref<HTMLDivElement>;
    accountTypes?: DeviceAccountType[];
    title?: string;
    text?: string;
    previewState?: "iOS" | "Android" | "Web" | "ConnectedStates";
    headerVariant?: "large" | "medium";
    connectExternalAccountOptions?: ConnectExternalAccountOptions;
    enableAppleHealthSurveyName?: string;
    enableGoogleFitSurveyName?: string;
    postalCodeSurveyName?: string;
}
declare function export_default$1p(props: ConnectDevicesMenuProps): React$1.JSX.Element | null;

type ConnectDexcomPreviewState = ExternalAccountStatus | 'notConnected' | 'notEnabled';
interface ConnectDexcomProps {
    title?: string;
    dexcomProviderID?: number;
    previewState?: ConnectDexcomPreviewState;
    disabledBehavior?: 'hide' | 'displayError';
    hideWhenConnected?: boolean;
    connectExternalAccountOptions?: ConnectExternalAccountOptions;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
declare function export_default$1o(props: ConnectDexcomProps): React$1.JSX.Element;

interface ConnectEhrProps {
    applicationUrl?: string;
    previewState?: ConnectEhrPreviewState;
    disabledBehavior?: 'hide' | 'displayError';
    bottomBorder?: boolean;
    innerRef?: React$1.Ref<HTMLDivElement>;
    variant?: "large" | "medium" | "small";
    title?: string;
    notConnectedText?: string;
    connectedText?: string;
    hideWhenConnected?: boolean;
    buttonColor?: ColorDefinition;
    onClick?: () => void;
}
type ConnectEhrPreviewState = "notEnabled" | "enabled" | "enabledConnected" | "enabledNeedsAttention";
declare function export_default$1n(props: ConnectEhrProps): React$1.JSX.Element | null;

interface ConnectFitbitProps {
    title?: string;
    fitbitProviderID?: number;
    previewState?: ConnectFitbitPreviewState;
    disabledBehavior?: 'hide' | 'displayError';
    innerRef?: React$1.Ref<HTMLDivElement>;
    hideWhenConnected?: boolean;
    connectExternalAccountOptions?: ConnectExternalAccountOptions;
}
type ConnectFitbitPreviewState = ExternalAccountStatus | "notConnected" | "notEnabled";
declare function export_default$1m(props: ConnectFitbitProps): React$1.JSX.Element;

interface ConnectGarminProps {
    title?: string;
    garminProviderID?: number;
    previewState?: ConnectGarminPreviewState;
    disabledBehavior?: 'hide' | 'displayError';
    innerRef?: React$1.Ref<HTMLDivElement>;
    hideWhenConnected?: boolean;
    connectExternalAccountOptions?: ConnectExternalAccountOptions;
}
type ConnectGarminPreviewState = ExternalAccountStatus | "notConnected" | "notEnabled";
declare function export_default$1l(props: ConnectGarminProps): React$1.JSX.Element;

interface ConnectOuraProps {
    title?: string;
    ouraProviderID?: number;
    previewState?: ConnectOuraPreviewState;
    disabledBehavior?: 'hide' | 'displayError';
    innerRef?: React$1.Ref<HTMLDivElement>;
    hideWhenConnected?: boolean;
    connectExternalAccountOptions?: ConnectExternalAccountOptions;
}
type ConnectOuraPreviewState = ExternalAccountStatus | "notConnected" | "notEnabled";
declare function export_default$1k(props: ConnectOuraProps): React$1.JSX.Element;

interface DailyDataChartProps {
    title?: string;
    intervalType?: "Week" | "Month";
    weekStartsOn?: WeekStartsOn;
    dailyDataType: string;
    valueConverter?(value: number): number;
    valueFormatter?(value: number): string;
    chartType: "Line" | "Bar" | "Area";
    options?: LineChartOptions | BarChartOptions | AreaChartOptions;
    hideIfNoData?: boolean;
    previewDataProvider?: DailyDataProvider;
    previewState?: "default";
    innerRef?: React$1.Ref<HTMLDivElement>;
}
declare function DailyDataChart(props: DailyDataChartProps): React$1.JSX.Element | null;

interface DailyDataGoalProps {
    previewState?: "Default";
    goal: number;
    dailyDataType: string;
    title: string;
    subtitle?: string;
    date?: Date;
    goalIncompleteColor?: ColorDefinition;
    goalCompleteColor?: ColorDefinition;
    messages?: DailyDataGoalMessage[];
    innerRef?: React$1.Ref<HTMLDivElement>;
    defaultMargin?: boolean;
}
interface DailyDataGoalMessage {
    message: string;
    threshold: number;
}
declare function export_default$1j(props: DailyDataGoalProps): React$1.JSX.Element;

interface DeviceDataMonthChartProps {
    lines: DeviceDataChartLine[];
    month: number;
    year: number;
    syncId?: string;
    title?: string;
    previewState?: DeviceDataMonthChartPreviewState;
    onDataDetected?: Function;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
interface DeviceDataChartLine {
    label: string;
    dailyDataType: string;
    valueConverter?: Function;
    showAverage?: boolean;
}
type DeviceDataMonthChartPreviewState = "WithData" | "NoData" | "Loading";
declare function export_default$1i(props: DeviceDataMonthChartProps): React$1.JSX.Element | null;

interface DeviceDataMonthChartsProps {
    previewState?: DeviceDataMonthChartsPreviewState;
}
type DeviceDataMonthChartsPreviewState = "Default" | "NoData";
declare function export_default$1h(props: DeviceDataMonthChartsProps): React$1.JSX.Element;

interface DocumentLibraryPreviewProps {
    previewState?: 'loading' | DocumentLibraryPreviewPreviewState;
    surveySpecification: LibraryDocumentSurveySpecification;
    documentLibraryViewBaseUrl: string;
    useFullLoadingIndicator?: boolean;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
/**
 * This component acts as an informational CTA to allow participants to open the DocumentLibraryView.
 * When no documents have been uploaded, the CTA shortcuts directly to the document upload survey.
 */
declare function DocumentLibraryPreview(props: DocumentLibraryPreviewProps): React$1.JSX.Element;

interface EhrDownloadButtonProps {
    preview?: boolean;
    variant?: ButtonVariant;
    text?: string;
    reportHtml?: string;
    reportElement?: HTMLElement;
    fileName: string;
    hidden?: boolean;
    prepareForDownload?: () => Promise<void>;
    innerRef?: Ref<HTMLDivElement>;
}
declare function EhrDownloadButton(props: EhrDownloadButtonProps): React$1.JSX.Element;

interface EhrNewsFeedProps {
    previewState?: "default" | "procedures" | "labReports" | "immunizations" | "reports";
    feed: EhrNewsFeedType;
    loadAllPages?: boolean;
    onPageLoaded?: () => void;
    onAllPagesLoaded?: (error?: unknown) => void;
    onEventSelected: (eventReference: EhrNewsFeedEventReference) => void;
    onReportSelected: (reportID: string) => void;
}
interface EhrNewsFeedEventReference {
    feed: EhrNewsFeedType;
    pageId?: string;
    pageDate?: string;
}
declare function EhrNewsFeed(props: EhrNewsFeedProps): React$1.JSX.Element;

interface EhrNewsFeedEventDetailProps {
    feed: EhrNewsFeedType;
    pageId?: string;
    pageDate?: string;
    previewState?: EhrNewsFeedEventType;
    onViewLabObservationTermInfo?: (labObservationID: string) => void;
}
declare function EhrNewsFeedEventDetail(props: EhrNewsFeedEventDetailProps): React$1.JSX.Element;

interface ExternalAccountConnectionAlertProps {
    previewState?: "externalAccountWithIssue" | "externalAccountNoIssue";
    onClick(): void;
    text?: string;
    externalAccountCategories?: string[];
    innerRef?: React$1.Ref<HTMLDivElement>;
}
declare function export_default$1g(props: ExternalAccountConnectionAlertProps): React$1.JSX.Element | null;

interface ExternalAccountListProps {
    externalAccountProviderCategories?: string[];
    previewState?: "default" | "withSuccessor";
    onExternalAccountsLoaded?: (accounts: ExternalAccount[]) => void;
    innerRef?: React$1.Ref<HTMLDivElement>;
    connectExternalAccountOptions?: ConnectExternalAccountOptions;
}
declare function export_default$1f(props: ExternalAccountListProps): React$1.JSX.Element;

interface ExternalAccountsLoadingIndicatorProps {
    previewState?: "externalAccountsFetchingData" | "externalAccountsLoaded";
    externalAccountCategories?: string[];
    innerRef?: React$1.Ref<HTMLDivElement>;
    triggerWebExternalAccountSyncComplete?: boolean;
}
declare function export_default$1e(props: ExternalAccountsLoadingIndicatorProps): React$1.JSX.Element | null;

interface ExternalAccountsPreviewProps {
    excludeProviders?: boolean;
    excludeHealthPlans?: boolean;
    excludeDeviceManufacturers?: boolean;
    applicationUrl?: string;
    previewState?: ExternalAccountsPreviewPreviewState;
    innerRef?: React$1.Ref<HTMLDivElement>;
    onClick?: () => void;
}
type ExternalAccountsPreviewPreviewState = "Default";
declare function export_default$1d(props: ExternalAccountsPreviewProps): React$1.JSX.Element | null;

type ConnectedDevicesPreviewState = "notEnabled" | "notConnected" | "connected";

interface FitbitDevicesProps {
    previewState?: ConnectedDevicesPreviewState;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
declare function export_default$1c(props: FitbitDevicesProps): React$1.JSX.Element;

type MonthChartsPreviewState = "notEnabled" | "notConnected" | "connected";

interface FitbitMonthChartsProps {
    previewState?: MonthChartsPreviewState;
}
declare function export_default$1b(props: FitbitMonthChartsProps): React$1.JSX.Element;

interface GarminDevicesProps {
    previewState?: ConnectedDevicesPreviewState;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
declare function export_default$1a(props: GarminDevicesProps): React$1.JSX.Element;

interface GarminMonthChartsProps {
    previewState?: MonthChartsPreviewState;
}
declare function export_default$19(props: GarminMonthChartsProps): React$1.JSX.Element;

type GlucoseChartVariant = 'default' | 'minimal';
interface GlucoseChartProps {
    previewState?: 'loading' | GlucoseChartPreviewState;
    variant?: GlucoseChartVariant;
    showStats?: boolean;
    glucoseLineColor?: ColorDefinition;
    averageGlucoseLineColor?: ColorDefinition;
    emptyText?: string;
    hideIfNoData?: boolean;
    onClick?: () => void;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
declare function export_default$18(props: GlucoseChartProps): React$1.JSX.Element | null;

interface GlucoseDayCoordinatorProps {
    previewState?: GlucoseDayCoordinatorPreviewState;
    minimumDate?: Date;
    children?: React$1.ReactNode;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
interface GlucoseContext {
    readings?: Reading[];
    recentAverage?: number;
}
declare const GlucoseContext: React$1.Context<GlucoseContext | null>;
declare function export_default$17(props: GlucoseDayCoordinatorProps): React$1.JSX.Element;

interface GoalColorConfiguration {
    statusColor?: ColorDefinition;
    onSegmentColor?: ColorDefinition;
    offSegmentColor?: ColorDefinition;
    iconColor?: ColorDefinition;
    iconBackgroundColor?: ColorDefinition;
}
/**
 * This function lets us distinguish between ColorDefinition values and newer GoalColorConfiguration values, since some properties can be set to either.
 *
 * A key differentiator is whether the lightMode or darkMode properties are present. An empty object ({}) could technically be either one, but we assume
 * it is a GoalColorConfiguration and return true since it functions just fine as a GoalColorConfiguration.
 */
declare function isGoalColorConfiguration(obj: ColorDefinition | GoalColorConfiguration | undefined): obj is GoalColorConfiguration;
interface GoalTarget {
    targetValue: number;
    color?: ColorDefinition;
    inProgressColors?: GoalColorConfiguration;
}
interface GoalProps {
    previewState?: 'loading' | GoalPreviewState;
    variant?: 'verbose' | 'compact';
    label: string;
    description?: string;
    targetValue: number | GoalTarget[];
    maxValue: number;
    valueProvider: SingleValueProvider<number>;
    maxSegments?: number;
    icon?: IconDefinition$1;
    notStartedColor?: ColorDefinition | GoalColorConfiguration;
    inProgressColor?: ColorDefinition | GoalColorConfiguration;
    completedColor?: ColorDefinition | GoalColorConfiguration;
    loadingIndicatorColor?: ColorDefinition;
    progressBarColor?: ColorDefinition;
    progressBarBackgroundColor?: ColorDefinition;
    style?: CSSProperties;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
declare function Goal(props: GoalProps): React$1.JSX.Element;

interface HealthConnectPhrSyncProps {
    showWhen?: "anyPermissionsEnabled" | "noPermissionsEnabled";
    triggerSyncCompleteEvent?: boolean;
    innerRef?: React$1.Ref<HTMLDivElement>;
    previewState?: "permissionsEnabled" | "noPermissionsEnabled" | "running";
}
declare function HealthConnectPhrSync(props: HealthConnectPhrSyncProps): React$1.JSX.Element | null;

type HealthPreviewSectionConcept = "Medications" | "Immunizations" | "Reports" | "Allergies" | "Conditions" | "Procedures";
interface HealthPreviewSectionProps {
    concept: HealthPreviewSectionConcept;
    onClick(): void;
    previewState?: "NoData" | "Default";
    indicatorPosition?: "default" | "topRight";
    innerRef?: React$1.Ref<HTMLDivElement>;
}
/**
 * Display a preview of EHR data for one of the following concepts: Medications, Immunizations, Reports, Allergies, Conditions, Procedures
 * A connection to your EHR provider is required to display the data.
 * Supports an onClick event for customizing when clicking on the arrow indicator
 */
declare function HealthPreviewSection(props: HealthPreviewSectionProps): React$1.JSX.Element | null;

interface InboxItemListProps {
    previewState?: InboxItemListPreviewState;
    title?: string;
    type?: InboxItemType | InboxItemType[];
    status?: InboxItemStatus | InboxItemStatus[];
    category?: string;
    sortOrder?: SortOrder;
    sortColumn?: InboxItemSortColumn;
    endsAfter?: string;
    endsBefore?: string;
    limit?: number;
    messageViewerUrl?: string;
    emptyText?: string;
    showTitleWhenEmpty?: boolean;
    surveyVariant?: InboxSurveyVariant;
    resourceImageAlignment?: ResourceImageAlignment;
    resourceButtonVariant?: ResourceButtonVariant;
    resourceButtonText?: string;
    hideLoadingIndicator?: boolean;
    onItemsLoaded?: (items: InboxItem[]) => void;
    syncOnChanges?: boolean;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
declare function export_default$16(props: InboxItemListProps): React$1.JSX.Element;

interface InboxItemListCoordinatorProps {
    children: React$1.ReactNode;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
declare function export_default$15(props: InboxItemListCoordinatorProps): React$1.JSX.Element;

interface InsightMatrixProps {
    preview?: boolean;
    groupByDataConfiguration: InsightMatrixGroupByDataConfiguration;
    comparisonDataConfigurations: InsightMatrixComparisonDataConfiguration[];
    daysToCompute?: number;
    showUnmatchedThresholds?: boolean;
    groupByHeaderBackgroundColor?: ColorDefinition;
    groupByHeaderTextColor?: ColorDefinition;
    goodValueBackgroundColor?: ColorDefinition;
    goodValueTextColor?: ColorDefinition;
    goodValueIndicator?: IconDefinition;
    otherValueBackgroundColor?: ColorDefinition;
    otherValueTextColor?: ColorDefinition;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
/**
 * The insight matrix component can be used to compare multiple daily survey and daily data values in a tabular format.
 *
 * The group-by data is first grouped by value threshold.  The comparison data are then grouped by the same days in
 * which the group-by data values met each threshold.  This is intended to illustrate what the values from each of the
 * comparison data looked like on the days when the values from the group-by data were within a given threshold (i.e.
 * What did my step count look like when my mood rating was high?).
 */
declare function InsightMatrix(props: InsightMatrixProps): React$1.JSX.Element;

type IntradayHeartRatePreviewState = "Default" | "CompleteDataWithThresholds" | "MissingMidDayDataThresholds" | "PartialDataWithThresholds" | "NoData";
interface IntradayHeartRateChartProps {
    title?: string;
    previewState?: IntradayHeartRatePreviewState;
    dataSources: DeviceDataV2Namespace[];
    aggregationIntervalOption?: IntradayHeartRateAggregationOption;
    aggregationIntervalMinutes: number;
    lineColor?: ColorDefinition;
    thresholds?: ChartThreshold[];
    innerRef?: React$1.Ref<HTMLDivElement>;
    hideIfNoData?: boolean;
}
declare function export_default$14(props: IntradayHeartRateChartProps): React$1.JSX.Element | null;

interface LabResultsBloodTypeProps {
    previewState?: "BloodTypeLabs" | "SingleLabs" | "ManyLabs" | "NoData";
    showDetailedResults?: true | false;
    maximumResults?: number;
    onClick?: () => void;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
declare function export_default$13(props: LabResultsBloodTypeProps): React$1.JSX.Element | null;

interface LabResultsSummaryProps {
    previewState?: "ImportantLabs" | "RecentLabs" | "NoData";
    onClick(): void;
    onViewTermInfo(termInfo: TermInformationReference): void;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
/** Displays participant EHR Lab data. A connection to an EHR provider is required to display the data.
 * Can be configured to show Recent, or Important labs. Important labs can include sparklines.
 * An onClick event is supported for customizing where the user will go when drillin into the full lab report
 * An onViewTermInfo event is supported for customizing what happens when the user clicks on a term information button
*/
declare function LabResultsSummary(props: LabResultsSummaryProps): React$1.JSX.Element | null;

interface LatestBloodPressureReadingProps {
    previewState?: BloodPressureClassification;
    onClick?: () => void;
    indicator?: ReactElement;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
/**
 * This component will load the participant's most recent blood pressure reading from across all
 * available device data sources and render it using a BloodPressureReading component.
 */
declare function LatestBloodPressureReading(props: LatestBloodPressureReadingProps): React$1.JSX.Element | null;

type MealAnalysisPreviewState = 'no meals to review' | 'with meals to review' | 'with meals to review - reloading';

interface MealAnalysisPreviewProps {
    previewState?: 'loading' | MealAnalysisPreviewState;
    variant?: 'compact';
    onReviewAll: () => void;
    onEditMeal: () => void;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
/**
 * This component displays pending meal analyses, allows for one-at-a-time review, and can open a full meal analysis review worklist.
 */
declare function MealAnalysisPreview(props: MealAnalysisPreviewProps): React$1.JSX.Element | null;

interface MealAnalysisWorklistProps {
    previewState?: 'loading' | MealAnalysisPreviewState;
    onEditMeal: () => void;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
/**
 * This component displays the full list of pending meal analyses for review.
 */
declare function MealAnalysisWorklist(props: MealAnalysisWorklistProps): React$1.JSX.Element;

interface MealCoordinatorProps {
    previewState?: 'loading' | MealCoordinatorPreviewState;
    children: React$1.ReactNode;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
interface MealContext {
    loading: boolean;
    meals: Meal[];
    imageUrls: {
        [key: string]: string;
    };
    selectedMeal?: Meal;
    addMeal: (meal: Meal) => Promise<void>;
    saveMeal: (meal: Meal) => Promise<void>;
    onMealClicked: (meal: Meal) => void;
}
declare const MealContext: React$1.Context<MealContext | null>;
/**
 * This component is used to load and coordinate meal data across its meal-aware child components.
 */
declare function MealCoordinator(props: MealCoordinatorProps): React$1.JSX.Element;

interface MealEditorProps {
    previewState?: 'loading' | MealEditorPreviewState;
    onError: () => void;
    onDelete: () => void;
    onSave: () => void;
    onCancel: () => void;
    withImageCapture?: boolean;
    children?: React$1.ReactNode;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
/**
 * This component can be used to edit meal log entries.
 */
declare function MealEditor(props: MealEditorProps): React$1.JSX.Element;

interface MedicationsListProps {
    previewState?: "default";
    onLoadComplete?: () => void;
    onViewTermInfo?: (termInfo: TermInformationReference) => void;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
declare function MedicationsList(props: MedicationsListProps): React$1.JSX.Element;

type MicroTrendPreviewState = 'default' | 'noTrend' | 'noData';
type MicroTrendChartPosition = 'bottom' | 'right';
interface MicroTrendDataType {
    icon?: ReactElement;
    rawDataType: string | SurveyDataType;
    label?: string;
    color?: ColorDefinition;
    threshold?: number | '30DayAverage';
    overThresholdColor?: ColorDefinition;
    formatter?: (number: number) => string;
}

interface MicroTrendProps {
    previewState?: MicroTrendPreviewState | "loading";
    dataType: MicroTrendDataType | RelativeActivityDataType;
    date?: Date;
    hideIfNoRecentData?: boolean;
    chartPosition?: MicroTrendChartPosition | "responsive";
    indicator?: ReactNode;
    onClick?: () => void;
    innerRef?: Ref<HTMLDivElement>;
}
declare function MicroTrend(props: MicroTrendProps): React$1.JSX.Element | null;

interface MostRecentNotificationProps {
    notificationType?: NotificationType;
    notificationIdentifierRegex?: RegExp;
    onViewMore?: Function;
    hideAfterHours?: number;
    previewState?: MostRecentNotificationPreviewState;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
type MostRecentNotificationPreviewState = 'loading' | 'loaded with data' | 'loaded with no data';
declare function export_default$12(props: MostRecentNotificationProps): React$1.JSX.Element;

type NotificationListPreviewState = 'loading' | 'loaded with data' | 'loaded with no data';
interface NotificationListProps {
    previewState?: NotificationListPreviewState;
    notificationType?: NotificationType;
    notificationIdentifierRegex?: RegExp;
    displayLimit?: number;
    hideWhenEmpty?: boolean;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
/**
 * A list of participant notifications.
 *
 * <ul>
 * <li>The list can be filtered by type (i.e. Email/Push/SMS) and/or identifier regex.</li>
 * <li>You can set a limit on the number of displayed notifications.</li>
 * <li>The list can be hidden when there are no notifications.</li>
 * </ul>
 **/
declare function NotificationList(props: NotificationListProps): React$1.JSX.Element | null;

interface PdfPreviewProps {
    url: string | undefined;
    maxHeight: number;
    maxWidth: number;
    style?: CSSProperties;
    onLoad?: () => void;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
/**
 * This component can be used to render a preview of the first page of a PDF.
 */
declare function PdfPreview(props: PdfPreviewProps): React$1.JSX.Element | null;

interface PlatformSpecificContentProps {
    platforms: string[];
    children?: React$1.ReactNode;
    previewDevicePlatform?: string;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
declare function export_default$11(props: PlatformSpecificContentProps): React$1.JSX.Element | null;

interface ProjectHeaderProps {
    previewState?: ProjectHeaderPropsPreviewState;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
type ProjectHeaderPropsPreviewState = "Default";
declare function export_default$10(props: ProjectHeaderProps): React$1.JSX.Element;

interface ProjectSupportProps {
    previewState?: ProjectSupportPropsPreviewState;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
type ProjectSupportPropsPreviewState = "Default";
declare function export_default$$(props: ProjectSupportProps): React$1.JSX.Element | null;

type ProviderSearchPreviewState = 'Default' | 'Searching' | 'Connected Provider' | 'Connected Provider - Unauthorized' | 'Disabled Provider - Same Endpoint' | 'Disabled Provider - Same Managing Org' | 'Disabled Provider - Unavailable';

type ProviderSearchOperatingMode = 'authenticated' | 'unauthenticated';
interface ProviderSearchProps {
    previewState?: ProviderSearchPreviewState;
    /**
     * The mode this provider search should operate in.
     *
     * - The 'authenticated' mode uses delegated APIs to query for providers.  It also queries for existing external accounts.
     * - The 'unauthenticated' mode uses public APIs to query for providers.  It does not attempt to load existing external accounts.
     *
     * The mode defaults to `authenticated` unless specified, or when either of the provider or featured provider public API URLs are specified.
     */
    operatingMode?: ProviderSearchOperatingMode;
    providerCategories?: string[];
    /** Callback function triggered when a provider is selected. If this function is defined it will override the normal action taken when selecting provider.*/
    onProviderSelected?: (provider: ExternalAccountProvider) => void;
    /** Callback function triggered after a provider is connected. */
    onProviderConnected?: (provider: ExternalAccountProvider) => void;
    connectExternalAccountOptions?: ConnectExternalAccountOptions;
    hideRequestProviderButton?: boolean;
    /** URL for the public provider search API. If provided, this endpoint will be used instead of MyDataHelps.getExternalAccountProviders. */
    publicProviderSearchApiUrl?: string;
    /** List of providers to display at the top when no search is active. If populated, disables the dynamic featured provider lookup. */
    featuredProviders?: ExternalAccountProvider[];
    /** The context to use when querying for featured providers.  Only used if featuredProviders is not set. */
    featuredProvidersContext?: string;
    /** URL for the public featured provider API. If provided, this endpoint will be used instead of MyDataHelps.getFeaturedProviders. */
    publicFeaturedProvidersApiUrl?: string;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
/** Supports searching for Providers, and Health Plans for the purpose of connecting to participant data
 */
declare function ProviderSearch(props: ProviderSearchProps): React$1.JSX.Element;

interface RecentDailyDataBarChartProps {
    previewState?: 'loading' | 'loaded without data' | 'loaded with data';
    previewDataProvider?: (start: Date, end: Date) => Promise<DailyDataQueryResult>;
    title: string;
    dailyDataType: string;
    domain?: AxisDomain;
    emptyDomain?: AxisDomain;
    valueConverter?: (rawValue: number) => number;
    valueFormatter?: (value: number) => string;
    highlight?: (rawValue: number) => boolean;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
declare function export_default$_(props: RecentDailyDataBarChartProps): React$1.JSX.Element;

interface RelativeActivityDayCoordinatorProps {
    innerRef?: React$1.Ref<HTMLDivElement>;
    dataTypes: RelativeActivityDataType[];
    previewState?: 'default';
    children?: React$1.ReactNode;
}
declare function RelativeActivityDateRangeCoordinator(props: RelativeActivityDayCoordinatorProps): React$1.JSX.Element;

interface RelativeActivityProps {
    dataTypes?: RelativeActivityDataType[];
    useContext?: boolean;
    previewState?: "Default" | "LimitedData" | "NoData";
    title?: string;
    innerRef?: React$1.Ref<HTMLDivElement>;
    date?: Date;
}
declare function export_default$Z(props: RelativeActivityProps): React$1.JSX.Element | null;

interface RelativeActivityTodayProps {
    dataTypes: RelativeActivityDataType[];
    previewState?: "Default";
    title?: string;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
declare function export_default$Y(props: RelativeActivityTodayProps): React$1.JSX.Element;

type RestingHeartRateCalendarPreviewState = "WithData" | "NoData" | "Loading";
type RestingHeartRateDataSource = "Combined" | "AppleHealth" | "Fitbit" | "Garmin" | "HealthConnect";
interface RestingHeartRateCalendarProps {
    month: number;
    year: number;
    showPreviewData: RestingHeartRateCalendarPreviewState;
    dataTypeSource?: RestingHeartRateDataSource;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
declare function export_default$X(props: RestingHeartRateCalendarProps): React$1.JSX.Element;

type SurveyAnswerChartPreviewState = 'default' | 'no data' | 'with one data point' | 'with one data point in first series' | 'with two data points' | 'with two data points in first series' | 'with two data points in first series with gap' | 'with gap';

interface SurveyAnswerChartSeries extends ChartSeries {
    surveyName?: string | string[];
    stepIdentifier?: string | string[];
    resultIdentifier: string | string[];
    useEventAsDate?: boolean;
}
interface SurveyAnswerAreaChartSeries extends AreaChartSeries {
    surveyName?: string | string[];
    stepIdentifier?: string | string[];
    resultIdentifier: string | string[];
    useEventAsDate?: boolean;
}
interface SurveyAnswerChartProps {
    title?: string;
    intervalType?: 'Week' | 'Month' | '6Month' | 'Dynamic';
    dynamicIntervalEndType?: 'Today' | 'Last Reading';
    weekStartsOn?: WeekStartsOn;
    series: SurveyAnswerChartSeries[] | SurveyAnswerAreaChartSeries[];
    chartType: 'Line' | 'Bar' | 'Area';
    options?: MultiSeriesLineChartOptions | MultiSeriesBarChartOptions;
    expectedDataInterval?: Duration;
    previewDataProvider?: (startDate: Date, endDate: Date) => Promise<SurveyAnswer[][]>;
    previewState?: SurveyAnswerChartPreviewState;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
declare function SurveyAnswerChart(props: SurveyAnswerChartProps): React$1.JSX.Element;

type SurveyTaskListSortBehaviorType = 'alphabetical' | 'dueDate' | 'insertedDate' | 'userDefined' | 'shuffle';
interface SurveyTaskListSortBehavior {
    type: SurveyTaskListSortBehaviorType;
    direction?: SortOrder;
    userDefinedOrder?: string[];
}
interface SurveyTaskListProps {
    status: SurveyTaskStatus;
    limit?: number;
    sequential?: boolean;
    title?: string;
    surveys?: string[];
    category?: string;
    sortBehavior?: SurveyTaskListSortBehavior;
    onDetailLinkClick?: Function;
    previewState?: SurveyTaskListListPreviewState;
    variant?: "noCard" | "singleCard" | "multiCard";
    innerRef?: React$1.Ref<HTMLDivElement>;
    titleColor?: ColorDefinition;
    cardBackgroundColor?: ColorDefinition;
    cardStyle?: React$1.CSSProperties;
    buttonVariant?: ButtonVariant;
    buttonColor?: ColorDefinition;
    hideIfEmpty?: boolean;
    emptyText?: string;
}
type SurveyTaskListListPreviewState = "IncompleteTasks" | "CompleteTasks" | "Empty";
declare function export_default$W(props: SurveyTaskListProps): React$1.JSX.Element | null;

type SeverityCalendarPreviewState = "Default" | "NoData";
interface SeverityCalendarProps {
    surveyName?: string;
    dateRecordedResultIdentifier?: string;
    severityResultIdentifier: string;
    severityValueMapper?: (value: string) => string;
    intervalStart?: Date;
    previewState?: SeverityCalendarPreviewState;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
declare function export_default$V(props: SeverityCalendarProps): React$1.JSX.Element;

type StressLevelPreviewState = 'loading' | 'no data' | 'with data';
interface StressLevelProps {
    previewState?: StressLevelPreviewState;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
declare function export_default$U(props: StressLevelProps): React$1.JSX.Element;

interface UploadedFileActionProps {
    preview?: boolean;
    icon?: ReactElement;
    title?: string;
    titleColor?: ColorDefinition;
    subtitle?: string;
    subtitleColor?: ColorDefinition;
    category?: string;
    fileNamePattern?: string | RegExp;
    trackUsage?: boolean;
    embedded?: boolean;
    viewKey?: string;
    innerRef: Ref<HTMLDivElement>;
}
declare function UploadedFileAction(props: UploadedFileActionProps): React$1.JSX.Element | null;

interface ViewDeviceActivityProps {
    onClick(): void;
    title?: string;
    innerRef?: React$1.Ref<HTMLDivElement>;
    previewState?: "fetchComplete" | "fetchingData";
    buttonColor?: ColorDefinition;
    buttonVariant?: ButtonVariant;
    dataTypes: DailyDataTypeDefinition[];
}
declare function export_default$T(props: ViewDeviceActivityProps): React$1.JSX.Element | null;

type ViewEhrPreviewState = 'notConnected' | 'fetchComplete' | 'fetchingData';
interface ViewEhrProps {
    previewState?: ViewEhrPreviewState;
    title?: string;
    buttonColor?: ColorDefinition;
    buttonVariant?: ButtonVariant;
    onClick: () => void;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
/**
 * The ViewEhr component can be used as a CTA to view EHR records.
 *
 * It will render when the participant has provider and/or health plan external account
 * connections or when they are using Apple Health Reacts or Health Connect PHR.
 */
declare function ViewEhr(props: ViewEhrProps): React$1.JSX.Element | null;

interface WeeklyDayNavigatorProps {
    minimumDate?: Date;
    selectedDate: Date;
    loadData: (startDate: Date, endDate: Date) => Promise<void>;
    dayRenderer: (dayKey: string) => React$1.JSX.Element | null;
    dependencies?: DependencyList;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
declare function export_default$S(props: WeeklyDayNavigatorProps): React$1.JSX.Element;

interface TermInformationButtonProps {
    termInformation?: TermInformationReference;
    onViewTermInfo?: (termInformation: TermInformationReference) => void;
    labObservationID?: string;
    onViewLabObservationTermInfo?: (labObservationID: string) => void;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
declare function TermInformationButton(props: TermInformationButtonProps): React$1.JSX.Element;

interface TextBlockProps {
    children?: React$1.ReactNode;
    className?: string;
    innerRef?: React$1.Ref<HTMLDivElement>;
    color?: ColorDefinition;
    style?: React$1.CSSProperties;
}
declare function export_default$R(props: TextBlockProps): React$1.JSX.Element | null;

interface TrackerItemProps {
    selected: boolean;
    text?: string;
    color: string;
    bordered?: boolean;
    badge?: string;
    onClick?: Function;
    className?: string;
    noBoxShadow?: boolean;
}
declare function TrackerItem(props: TrackerItemProps): React$1.JSX.Element;

interface UnstyledButtonProps {
    onClick: MouseEventHandler;
    stopPropagation?: boolean;
    className?: string;
    children?: React$1.ReactNode;
    title?: string;
    style?: React$1.CSSProperties;
    disabled?: boolean;
    innerRef?: React$1.Ref<HTMLButtonElement>;
}
declare function export_default$Q(props: UnstyledButtonProps): React$1.JSX.Element;

interface ValueSelectorProps {
    title?: string;
    titleColor?: ColorDefinition;
    subtitle?: string;
    subtitleColor?: ColorDefinition;
    values: string[];
    valueBackgroundColor?: ColorDefinition;
    valueTextColor?: ColorDefinition;
    checkboxColor?: ColorDefinition;
    selectedValues?: string[];
    selectedButtonBackgroundColor?: ColorDefinition;
    selectedButtonTextColor?: ColorDefinition;
    selectedCheckboxColor?: ColorDefinition;
    onChange?: (selectedValues: string[]) => void;
    variant?: 'default' | 'checkboxes';
    multiSelect?: boolean;
    preventEmptySelections?: boolean;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
declare function export_default$P(props: ValueSelectorProps): React$1.JSX.Element;

interface ViewHeaderProps {
    title?: string;
    subtitle?: string;
    titleColor?: ColorDefinition;
    subtitleColor?: ColorDefinition;
    action?: React$1.ReactNode;
}
declare function export_default$O(props: ViewHeaderProps): React$1.JSX.Element | null;

interface WeekCalendarProps {
    minimumDate?: Date;
    selectedDate?: Date;
    hideDateLabel?: boolean;
    startDate: Date;
    onDateSelected?(date: Date): void;
    loading: boolean;
    onStartDateChange?(startDate: Date): void;
    dayRenderer(year: number, month: number, day: number, selectedWeek: boolean): JSX.Element | null;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
declare function WeekCalendar(props: WeekCalendarProps): React$1.JSX.Element;

interface InboxCompletedListItemProps {
    name: string;
    status: string;
    onClick?: () => void;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
declare function export_default$N(props: InboxCompletedListItemProps): React$1.JSX.Element;

interface InboxMessageListItemProps {
    message: InboxMessage;
    onClick: () => void;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
declare function export_default$M(props: InboxMessageListItemProps): React$1.JSX.Element | null;

interface InboxResourceListItemProps {
    resource: InboxResource;
    onClick: () => void;
    imageAlignment?: ResourceImageAlignment;
    buttonVariant?: ResourceButtonVariant;
    buttonText?: string;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
declare function export_default$L(props: InboxResourceListItemProps): React$1.JSX.Element | null;

type InboxSurveyVariant = 'default' | 'expanded';
interface InboxSurveyListItemProps {
    survey: InboxSurvey;
    onClick: () => void;
    variant?: InboxSurveyVariant;
    surveyActive?: boolean;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
declare function export_default$K(props: InboxSurveyListItemProps): React$1.JSX.Element | null;

interface AsthmaRecommendedArticleProps {
    previewState?: 'none' | 'default';
    libraryBaseUrl: string;
    logTodayEntrySurveyName: string;
    imageAlignment?: ResourceImageAlignment;
    buttonVariant?: ResourceButtonVariant;
    buttonText?: string;
    style?: React$1.CSSProperties;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
declare function export_default$J(props: AsthmaRecommendedArticleProps): React$1.JSX.Element | null;

declare enum AsthmaDailyDataType {
    Steps = "Asthma.Steps",
    DaytimeRestingHeartRate = "Asthma.DaytimeRestingHeartRate",
    NighttimeRestingHeartRate = "Asthma.NighttimeRestingHeartRate",
    RespiratoryRate = "Asthma.RespiratoryRate",
    DaytimeBloodOxygenLevel = "Asthma.DaytimeBloodOxygenLevel",
    NighttimeBloodOxygenLevel = "Asthma.NighttimeBloodOxygenLevel",
    SleepDisturbances = "Asthma.SleepDisturbances"
}
interface AsthmaDataService {
    loadParticipant(): Promise<AsthmaParticipant>;
    loadDeviceInfo(): Promise<DeviceInfo>;
    loadLogEntries(fromDate?: Date, toDate?: Date): Promise<AsthmaLogEntry[]>;
    loadBiometricsForControlStatus(): Promise<AsthmaBiometric[]>;
    loadBiometricsForDate(date: Date): Promise<AsthmaBiometric[]>;
    loadAirQualitiesForControlStatus(homeAirQualityZipCode: string, workAirQualityZipCode: string): Promise<AsthmaAirQuality[]>;
    loadAirQualitiesForDate(date: Date): Promise<AsthmaAirQuality[]>;
    loadAirQualityDataPoints(fromDate: Date): Promise<DeviceDataPoint[]>;
    saveLogEntry(logEntry: AsthmaLogEntry): Promise<void>;
    loadAlertTakeover(): Promise<DeviceDataPoint | undefined>;
    updateAlertTakeover(dataPoint: DeviceDataPoint, status: string, comment?: string): Promise<void>;
    loadSurveyAnswers(surveyName: string | string[], fromDate?: Date): Promise<SurveyAnswer[]>;
    checkSurveyAnswerExists(surveyName: string | string[]): Promise<boolean>;
    loadAsthmaActionPlan(): Promise<AsthmaActionPlan | undefined>;
}
declare const service: AsthmaDataService;

declare const dateToAsthmaLogEntryIdentifier: (date: Date) => string;
declare const computeAsthmaControlState: (logEntries: AsthmaLogEntry[], date: Date) => AsthmaControlState;
declare const getAsthmaDataStatusText: (status: AsthmaDataStatus) => string;
declare const getAsthmaDataStatusColor: (status: AsthmaDataStatus) => ColorDefinition;
declare const getAsthmaSymptomLevelText: (symptomLevel: AsthmaSymptomLevel) => string;
declare const getAsthmaSymptomLevel: (symptomLevelText: string) => AsthmaSymptomLevel;
declare const getAsthmaSymptomTexts: (symptoms: AsthmaSymptom[] | undefined) => string[];
declare const getAsthmaSymptoms: (symptomTexts: string[]) => AsthmaSymptom[];
declare const getAsthmaImpactTexts: (impacts: AsthmaImpact[] | undefined) => string[];
declare const getAsthmaImpacts: (impactTexts: string[]) => AsthmaImpact[];
declare const getAsthmaTriggerTexts: (triggers: AsthmaTrigger[] | undefined) => string[];
declare const getAsthmaTriggers: (triggerTexts: string[]) => AsthmaTrigger[];
declare const getAsthmaAirQualityDescriptionText: (description: AsthmaAirQualityDescription | undefined) => string | undefined;
declare const isDaytimeRestingHeartRateWithinRange: (baseline: number, rawValue: number) => boolean;
declare const isNighttimeRestingHeartRateWithinRange: (baseline: number, rawValue: number) => boolean;
declare const isRespiratoryRateWithinRange: (baseline: number, rawValue: number) => boolean;
declare const isStepsWithinRange: (baseline: number, rawValue: number) => boolean;
declare const isSleepDisturbancesWithinRange: (baseline: number, rawValue: number) => boolean;
declare const isBloodOxygenLevelWithinRange: (baseline: number, rawValue: number) => boolean;

declare function caregiverVariableLanguage(participant: AsthmaParticipant, key: string): string;

interface AsthmaActionPlanInfoViewProps {
    colorScheme?: 'light' | 'dark' | 'auto';
    libraryBaseUrl: string;
}
declare function AsthmaActionPlanInfoView(props: AsthmaActionPlanInfoViewProps): React$1.JSX.Element;

interface AsthmaActionPlanViewProps {
    colorScheme?: 'light' | 'dark' | 'auto';
    previewState?: AsthmaActionPlanManagerPreviewState;
    learnMoreUrl: string;
    editActionPlanSurveyName: string;
}
declare function export_default$I(props: AsthmaActionPlanViewProps): React$1.JSX.Element;

interface AsthmaActivityViewProps {
    colorScheme?: 'light' | 'dark' | 'auto';
    previewState?: 'default';
    alert?: 'Steps';
    logEntrySurveyName: string;
}
declare function export_default$H(props: AsthmaActivityViewProps): React$1.JSX.Element;

interface AsthmaAirQualityViewProps {
    colorScheme?: 'light' | 'dark' | 'auto';
    previewState?: 'default';
    alert?: 'HomeAirQuality' | 'WorkAirQuality';
    logEntrySurveyName: string;
}
declare function export_default$G(props: AsthmaAirQualityViewProps): React$1.JSX.Element;

interface AsthmaAlertTakeoverViewProps {
    colorScheme?: 'light' | 'dark' | 'auto';
    previewState?: 'default';
    logEntrySurveyName: string;
}
declare function export_default$F(props: AsthmaAlertTakeoverViewProps): React$1.JSX.Element;

interface AsthmaDayViewProps {
    colorScheme?: 'light' | 'dark' | 'auto';
    previewState?: 'loading' | 'default' | 'as caregiver';
    date: Date;
    logTodayEntrySurveyName: string;
    logYesterdayEntrySurveyName: string;
    editLogEntryUrl: string;
    logEntryInfoUrl: string;
    heartAndLungsUrl: string;
    activityUrl: string;
    sleepUrl: string;
    airQualityUrl: string;
}
declare function export_default$E(props: AsthmaDayViewProps): React$1.JSX.Element;

interface AsthmaHeartAndLungsViewProps {
    colorScheme?: 'light' | 'dark' | 'auto';
    previewState?: 'default';
    alert?: 'DaytimeRestingHeartRate' | 'NighttimeRestingHeartRate' | 'RespiratoryRate' | 'DaytimeBloodOxygenLevel' | 'NighttimeBloodOxygenLevel';
    logEntrySurveyName: string;
}
declare function export_default$D(props: AsthmaHeartAndLungsViewProps): React$1.JSX.Element;

interface AsthmaLibraryCategoryViewProps {
    colorScheme?: 'light' | 'dark' | 'auto';
    title: string;
    category: string;
    libraryBaseUrl: string;
}
declare function AsthmaLibraryCategoryView(props: AsthmaLibraryCategoryViewProps): React$1.JSX.Element;

interface AsthmaLogEntryEditorViewProps {
    colorScheme?: 'light' | 'dark' | 'auto';
    previewState?: 'loading' | AsthmaLogEntryEditorViewPreviewState;
    date: Date;
}
declare function export_default$C(props: AsthmaLogEntryEditorViewProps): React$1.JSX.Element | null;

interface AsthmaLogEntryInfoViewProps {
    colorScheme?: 'light' | 'dark' | 'auto';
}
declare function export_default$B(props: AsthmaLogEntryInfoViewProps): React$1.JSX.Element;

interface AsthmaProviderReportViewProps {
    previewState?: AsthmaProviderReportPreviewState;
    logEntrySurveyName: string;
}
declare function export_default$A(props: AsthmaProviderReportViewProps): React$1.JSX.Element;

interface AsthmaSleepViewProps {
    colorScheme?: 'light' | 'dark' | 'auto';
    previewState?: 'default';
    alert?: 'SleepDisturbances';
    logEntrySurveyName: string;
}
declare function export_default$z(props: AsthmaSleepViewProps): React$1.JSX.Element;

interface CelebrationStepProps {
    title?: string;
    text?: string;
    detailText?: string;
    iconUrl?: string;
    imageUrl?: string;
    nextButtonText?: string;
    styles: {
        [key: string]: any;
    };
}
/**
 * A ready-to-use survey step that celebrates with a confetti animation when first opened.
 */
declare function CelebrationStep(props: CelebrationStepProps): React$1.JSX.Element;

/**
 * A celebration step to use within a MyDataHelps survey.
 */
declare function CelebrationStepContainer(): React$1.JSX.Element;

type deviceType = 'Fitbit' | 'Garmin' | 'Omron' | 'Oura';

interface ConnectDeviceAccountStepProps {
    title?: string;
    text?: string;
    deviceType: deviceType;
    providerID: number;
    styles: {
        [key: string]: any;
    };
    onConnect: () => void;
}
/**
 * This survey step can be passed a function used to connect devices.
*/
declare function ConnectDeviceAccountStep(props: ConnectDeviceAccountStepProps): React$1.JSX.Element;

/**
 * This is a survey step component that facilitates connecting a participant's device account.
 * This component is intended to run within a survey for participants to link their device accounts, enabling data synchronization and enhancing user engagement.
 * It ensures that participants can easily connect their device accounts during the survey flow, providing a straightforward step in the data collection process.
 */
declare function ConnectDeviceAccountStepContainer(): React$1.JSX.Element;

interface ConnectEhrStepProps {
    title?: string;
    text?: string;
    nextButtonText?: string;
    nextButtonDisabled?: boolean;
    previewState?: ProviderSearchPreviewState;
    onProviderConnected: (provider: ExternalAccountProvider) => void;
    onNextButtonClick: () => void;
    styles: {
        [key: string]: any;
    };
}
/**
 * A ready-to-use surey step for connecting Providers, and Health Plans
 */
declare function ConnectEhrStep(props: ConnectEhrStepProps): React$1.JSX.Element;

/**
 * A survey step to use within a MyDataHelps survey for connecting Providers, and Health Plans.
 */
declare function ConnectEhrStepContainer(): React$1.JSX.Element;

interface StepElementProps {
    text?: string;
    textAlign?: any;
    color?: string;
    fontSize?: string;
    fontWeight?: string;
}
interface IconElementProps {
    srcUrl?: string;
}

declare function StepDetailText(props: StepElementProps): React$1.JSX.Element | null;

declare function export_default$y(props: IconElementProps): React$1.JSX.Element | null;

declare function export_default$x(props: IconElementProps): React$1.JSX.Element | null;

interface StepLayoutProps {
    children?: React$1.ReactNode;
    className?: string;
}
declare function export_default$w(props: StepLayoutProps): React$1.JSX.Element;

interface StepMarkdownProps {
    text: string;
    inline?: boolean;
}
declare function export_default$v(props: StepMarkdownProps): React$1.JSX.Element;

interface StepNextButtonProps extends StepElementProps {
    backgroundColor: string;
    letterSpacing: string;
    textTransform: string;
    gradient: any;
    disabled?: boolean;
    onClick(): void;
}
declare function export_default$u(props: StepNextButtonProps): React$1.JSX.Element;

declare function export_default$t(props: StepElementProps): React$1.JSX.Element | null;

declare function StepTitle(props: StepElementProps): React$1.JSX.Element | null;

interface YouTubeStepProps {
    title?: string;
    text?: string;
    transcript?: string;
    videoId: string;
    nextButtonText?: string;
    height?: string;
    styles: {
        [key: string]: any;
    };
}
/**
 * This ready-to-use step is for playing YouTube content
 */
declare function YouTubeStep(props: YouTubeStepProps): React$1.JSX.Element;

/**
 * A survey step to use within a MyDataHelps survey for playing YouTube content.
 */
declare function YouTubeStepContainer(): React$1.JSX.Element;

interface SymptomSharkSymptomMatrixProps {
    intervalStart?: Date;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
declare function export_default$s(props: SymptomSharkSymptomMatrixProps): React$1.JSX.Element | null;

interface SymptomSharkCalendarProps {
    intervalStart?: Date;
    onDaySelected(day: Date): void;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
declare function export_default$r(props: SymptomSharkCalendarProps): React$1.JSX.Element;

interface OverallExperienceChartProps {
    intervalStart?: Date;
    showAllDays?: boolean;
    innerRef?: React$1.Ref<HTMLDivElement>;
    variant?: "default" | "monthReport";
}
declare function export_default$q(props: OverallExperienceChartProps): React$1.JSX.Element | null;

type LogEntryIconKey = "star" | "star-o" | "user-md" | "hospital-o" | "ambulance" | "flag" | "moon-o" | "flask" | "bolt" | "question-circle-o" | "thermometer" | "trophy" | "spoon";

interface SymptomSharkDataService {
    getConfiguration(): Promise<SymptomSharkConfiguration>;
    getDailyLogEntries(after?: string, before?: string): Promise<{
        [key: string]: DailyLogEntry;
    }>;
    saveDailyLogEntry(date: string, entry: DailyLogEntry): Promise<any>;
}
interface SymptomSharkConfiguration {
    participantID: Guid;
    symptoms: SymptomConfiguration[];
    treatments: TreatmentConfiguration[];
}
interface SymptomConfiguration {
    id: string;
    color: string;
    name: string;
    severityTracking: 'None' | '3PointScale' | '10PointScale';
    inactive?: boolean;
}
interface TreatmentConfiguration {
    id: string;
    color: string;
    name: string;
    inactive?: boolean;
}
interface DailyLogEntry {
    symptoms: SymptomReference[];
    treatments: TreatmentReference[];
    overallFeeling?: number;
    notes: string;
    icon?: LogEntryIconKey;
}
interface SymptomReference {
    id: string;
    severity?: number;
}
interface TreatmentReference {
    id: string;
}
declare function convertToSymptomSharkConfiguration(info: ParticipantInfo): {
    participantID: Guid;
    symptoms: SymptomConfiguration[];
    treatments: TreatmentConfiguration[];
};

interface SymptomSharkLogEntryProps {
    date: Date;
    logEntry?: DailyLogEntry;
    configuration: SymptomSharkConfiguration;
    onClick?(d: Date): void;
    title?: string;
    subtitle?: string;
    highlight?: boolean;
    noDataMessage?: string;
    highlightedSymptoms?: string[];
    highlightedTreatments?: string[];
    innerRef?: React$1.Ref<HTMLDivElement>;
}
declare function export_default$p(props: SymptomSharkLogEntryProps): React$1.JSX.Element | null;

interface SymptomSharkMonthReportProps {
    includeNotes: boolean;
    includeDailyOverallFeeling: boolean;
    productLogo?: string;
    productName?: string;
    productUrl?: string;
    intervalStart?: Date;
    innerRef?: React$1.Ref<HTMLTableElement>;
}
declare function export_default$o(props: SymptomSharkMonthReportProps): React$1.JSX.Element | null;

interface SymptomSharkNotesTimelineProps {
    intervalStart?: Date;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
declare function export_default$n(props: SymptomSharkNotesTimelineProps): React$1.JSX.Element | null;

interface SymptomTreatmentHistogramsProps {
    intervalStart?: Date;
    onSymptomSelected(symptom: string, intervalStart: Date): void;
    innerRef?: React$1.Ref<HTMLDivElement>;
    linkColor?: ColorDefinition;
}
declare function export_default$m(props: SymptomTreatmentHistogramsProps): React$1.JSX.Element | null;

interface SymptomSeveritySummaryProps {
    symptom: SymptomConfiguration;
    intervalStart?: Date;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
declare function export_default$l(props: SymptomSeveritySummaryProps): React$1.JSX.Element | null;

interface SymptomSeverityChartProps {
    intervalStart?: Date;
    symptom: SymptomConfiguration;
    showAllDays?: boolean;
    innerRef?: React$1.Ref<HTMLDivElement>;
    variant?: "default" | "monthReport";
}
declare function export_default$k(props: SymptomSeverityChartProps): React$1.JSX.Element | null;

interface SymptomTreatmentFiltersProps {
    expandedDropdown: "Symptoms" | "Treatments" | null;
    onExpandedDropdownChange(expandedDropdown: "Symptoms" | "Treatments" | null): void;
    selectedSymptoms: string[];
    selectedTreatments: string[];
    configuration: SymptomSharkConfiguration;
    onSymptomsSelectionChange(symptoms: string[]): void;
    onTreatmentsSelectionChange(treatments: string[]): void;
    innerRef?: React$1.Ref<HTMLDivElement>;
}
declare function export_default$j(props: SymptomTreatmentFiltersProps): React$1.JSX.Element;

interface SymptomSharkLogEntryListProps {
    onDaySelected(d: Date): void;
    previewState?: "default";
    innerRef?: React$1.Ref<HTMLDivElement>;
}
declare function export_default$i(props: SymptomSharkLogEntryListProps): React$1.JSX.Element;

interface SymptomSharkLogTodayProps {
    previewState?: "withLog" | "noLog";
    innerRef?: React$1.Ref<HTMLDivElement>;
    onClick(d: Date): void;
}
declare function export_default$h(props: SymptomSharkLogTodayProps): React$1.JSX.Element | null;

interface SymptomSharkLogEntryEditProps {
    date: Date;
    promptForReviewAfterDays?: number;
    previewState?: "default";
}
declare function export_default$g(props: SymptomSharkLogEntryEditProps): React$1.JSX.Element;

interface SymptomSharkReportBuilderProps {
    productLogo?: string;
    productName?: string;
    productUrl?: string;
    previewState?: "default";
    innerRef?: React$1.Ref<HTMLDivElement>;
}
declare function ReportBuilder(props: SymptomSharkReportBuilderProps): React$1.JSX.Element;

interface SymptomSharkVisualizationCoordinatorProps {
    children: React$1.ReactNode;
    showFilters?: boolean;
    previewState?: "default";
    innerRef?: React$1.Ref<HTMLDivElement>;
}
declare function export_default$f(props: SymptomSharkVisualizationCoordinatorProps): React$1.JSX.Element;

interface CalendarViewProps {
    colorScheme?: "light" | "dark" | "auto";
    onDaySelected(d: Date): void;
    onSymptomSelected(symptom: string, intervalStart: Date): void;
    previewState?: "default";
}
declare function export_default$e(props: CalendarViewProps): React$1.JSX.Element;

interface LogEntryEditViewProps {
    colorScheme?: "light" | "dark" | "auto";
    date: Date;
    promptForReviewAfterDays?: number;
    previewState?: "default";
}
declare function export_default$d(props: LogEntryEditViewProps): React$1.JSX.Element;

interface SymptomSharkReportBuilderViewProps {
    colorScheme?: "light" | "dark" | "auto";
    previewState?: "default";
}
declare function export_default$c(props: SymptomSharkReportBuilderViewProps): React$1.JSX.Element;

interface SymptomDetailViewProps {
    symptomId: string;
    colorScheme?: "light" | "dark" | "auto";
    previewState?: "default";
    initialIntervalStart?: Date;
}
declare function export_default$b(props: SymptomDetailViewProps): React$1.JSX.Element;

interface AllergiesViewProps {
    presentation?: "Push" | "Modal";
    previewState?: "default";
    onViewTermInfo?: (termInfo: TermInformationReference) => void;
    colorScheme?: "auto" | "light" | "dark";
}
/**
 * This view shows a listing of allergies pulled from the connected Providers and Health Plans.
 */
declare function AllergiesView(props: AllergiesViewProps): React$1.JSX.Element;

interface BlankViewProps {
    children?: React$1.ReactNode;
    title?: string;
    subtitle?: string;
    showCloseButton?: boolean;
    showBackButton?: boolean;
    colorScheme?: "auto" | "light" | "dark";
    primaryColor?: ColorDefinition;
    bodyBackgroundColor?: ColorDefinition;
    titleColor?: ColorDefinition;
    subtitleColor?: ColorDefinition;
    navigationBarButtonColor?: ColorDefinition;
    flexLayout?: boolean;
}
declare function export_default$a(props: BlankViewProps): React$1.JSX.Element;

interface ConditionsViewProps {
    presentation?: "Push" | "Modal";
    previewState?: "default";
    onViewTermInfo?: (termInfo: TermInformationReference) => void;
    colorScheme?: "auto" | "light" | "dark";
}
/**
 * This view shows a listing of conditions pulled from the connected Providers and Health Plans.
 */
declare function ConditionsView(props: ConditionsViewProps): React$1.JSX.Element;

interface ConnectDevicesViewProps {
    externalAccountsApplicationUrl: string;
    presentation?: "Modal" | "Push";
    previewState?: "default";
    colorScheme?: "auto" | "light" | "dark";
    enableAppleHealthSurveyName?: string;
    enableGoogleFitSurveyName?: string;
    postalCodeSurveyName?: string;
    deviceActivityViewUrl?: string;
}
declare function ConnectDevicesView(props: ConnectDevicesViewProps): React$1.JSX.Element;

interface ConnectEhrViewProps {
    enableAppleHealthRecordsSurvey?: string;
    externalAccountsApplicationUrl?: string;
    onViewEhr?: () => void;
    excludeProviders?: boolean;
    excludeHealthPlans?: boolean;
    presentation?: "Modal" | "Push";
    preview?: boolean;
    colorScheme?: "auto" | "light" | "dark";
}
/**
 * This view enables participants to connect with their EHR providers and/or health plans.
 */
declare function ConnectEhrView(props: ConnectEhrViewProps): React$1.JSX.Element;

interface DeviceActivityViewProps {
    presentation?: "Modal" | "Push";
    previewState?: "default";
    colorScheme?: "auto" | "light" | "dark";
}
declare function DeviceActivityView(props: DeviceActivityViewProps): React$1.JSX.Element;

interface DeviceDataViewProps {
    preview?: boolean;
    colorScheme?: "auto" | "light" | "dark";
}
/**
 * This view charts a few commonly requested device data types.
 * It includes steps and resting heart rate from Fitbit and Garmin, steps and distance traveled from Apple Health, and steps from Google Fit.
 * It also allows you to manage your device data connections.
 */
declare function DeviceDataView(props: DeviceDataViewProps): React$1.JSX.Element;

interface DocumentDetailViewProps {
    colorScheme?: 'auto' | 'light' | 'dark';
    previewState?: 'loading' | DocumentDetailViewPreviewState;
    surveySpecification: LibraryDocumentSurveySpecification;
    surveyResultId: string;
}
/**
 * This component displays the details for an uploaded document.  Documents can be downloaded/shared or deleted.
 */
declare function DocumentDetailView(props: DocumentDetailViewProps): React$1.JSX.Element;

interface DocumentLibraryViewProps {
    colorScheme?: 'auto' | 'light' | 'dark';
    previewState?: 'loading' | 'reloading' | DocumentLibraryViewPreviewState;
    surveySpecification: LibraryDocumentSurveySpecification;
    documentDetailViewBaseUrl: string;
}
/**
 * This component displays a list of all currently uploaded documents.  New documents can be uploaded and
 * each existing document can be tapped to open the DocumentDetailView.
 */
declare function DocumentLibraryView(props: DocumentLibraryViewProps): React$1.JSX.Element;

interface EhrNewsFeedViewProps {
    feed: EhrNewsFeedType;
    previewState?: "default";
    presentation?: "Push" | "Modal";
    colorScheme?: "auto" | "light" | "dark";
    onEventSelected: (eventReference: EhrNewsFeedEventReference) => void;
    onReportSelected: (reportID: string) => void;
}
/**
 * This view can be configured to display the following news feeds:
 * Procedures, Reports, Lab Results, and Immunizations
 */
declare function EhrNewsFeedView(props: EhrNewsFeedViewProps): React$1.JSX.Element;

interface EhrNewsFeedEventDetailViewProps {
    feed: EhrNewsFeedType;
    pageId?: string;
    pageDate?: string;
    previewState?: EhrNewsFeedEventType;
    onViewLabObservationTermInfo?: (labObservationID: string) => void;
    presentation?: "Push" | "Modal";
    colorScheme?: "auto" | "light" | "dark";
}
declare function EhrNewsFeedEventDetailView(props: EhrNewsFeedEventDetailViewProps): React$1.JSX.Element;

interface ExternalAccountsViewProps {
    excludeProviders?: boolean;
    excludeHealthPlans?: boolean;
    excludeDeviceManufacturers?: boolean;
    presentation?: ViewPresentationType$2;
    previewState?: "default";
    colorScheme?: "auto" | "light" | "dark";
    connectExternalAccountOptions?: ConnectExternalAccountOptions;
}
type ViewPresentationType$2 = "Modal" | "Push";
/**
 * This view provides an overview of the participant's connected Providers, Health Plans, and Devices.
 * It displays the status of each connection and offers the option to reconnect as needed.
 */
declare function ExternalAccountsView(props: ExternalAccountsViewProps): React$1.JSX.Element;

interface FitbitViewProps {
    connectPreview?: ConnectFitbitPreviewState;
    devicesPreview?: ConnectedDevicesPreviewState;
    chartsPreview?: MonthChartsPreviewState;
    colorScheme?: "auto" | "light" | "dark";
}
/**
 * This view shows Fitbit connection status, a list of the participant's Fitbit devices, and 2 line charts showing monthly steps and resting heart rate.
*/
declare function FitbitView(props: FitbitViewProps): React$1.JSX.Element;

interface GarminViewProps {
    connectPreview?: ConnectGarminPreviewState;
    devicesPreview?: ConnectedDevicesPreviewState;
    chartsPreview?: MonthChartsPreviewState;
    garminProviderID?: number;
}
/**
 * This view shows the Garmin connection status, a list of the participant's Garmin devices, and 2 line charts showing monthly steps and resting heart rate.
*/
declare function GarminView(props: GarminViewProps): React$1.JSX.Element;

interface HomeViewProps {
    /**
     * Notification Type to display for the most recent notification
     * @default Push
     * */
    notificationType?: "Sms" | "Push";
    /** Hides the most recent notification after a certain number of hours of it being sent */
    notificationHideAfterHours?: number;
    /** Hide the task due date on displayed tasks */
    hideTaskDueDate?: boolean;
    /** When present, causes the EHR connect widget to display. */
    ehrConnectApplicationUrl?: string;
    notificationsViewUrl?: string;
    tasksViewUrl?: string;
    preview?: boolean;
    colorScheme?: "auto" | "light" | "dark";
}
/**
 * This view includes all the essential features for MDH engagement:
 * It displays a prompt to download the MyDataHelps app, the latest notification,
 * a list of incomplete tasks, options to connect devices and providers/health plans,
 * and support information for the project.
 */
declare function HomeView(props: HomeViewProps): React$1.JSX.Element;

interface HealthAndWellnessViewProps {
    previewState?: "default";
    colorScheme?: "auto" | "light" | "dark";
    connectEhrApplicationUrl: string;
    externalAccountsApplicationUrl: string;
    variant?: "default" | "cardBased";
    onViewLabs?(): void;
    onViewTermInfo?(termInfo: TermInformationReference): void;
    onViewHealthSectionDetails?(concept: HealthPreviewSectionConcept): void;
    presentation?: "Modal" | "Push";
}
/**
 * This view allows the participant to connect to their EHR provider.
 * After establishing the connection, participants can access a comprehensive range of health information, including labs, blood type, medications, immunizations, reports, allergies, conditions, and procedures.
 */
declare function HealthAndWellnessView(props: HealthAndWellnessViewProps): React$1.JSX.Element;

interface MealAnalysisViewProps {
    colorScheme?: 'auto' | 'light' | 'dark';
    previewState?: Parameters<typeof MealAnalysisWorklist>[0]['previewState'];
    mealEditorUrl: string;
}
declare function MealAnalysisView(props: MealAnalysisViewProps): React$1.JSX.Element;

interface MealEditorViewProps {
    colorScheme?: 'auto' | 'light' | 'dark';
    previewState?: 'loading' | MealEditorPreviewState | 'live';
}
declare function export_default$9(props: MealEditorViewProps): React$1.JSX.Element;

interface MedicationsViewProps {
    presentation?: "Push" | "Modal";
    previewState?: "default";
    onViewTermInfo?: (termInfo: TermInformationReference) => void;
    colorScheme?: "auto" | "light" | "dark";
}
/**
 * This view shows a listing of medications pulled from the connected Providers and Health Plans.
 */
declare function MedicationsView(props: MedicationsViewProps): React$1.JSX.Element;

interface NotificationsViewProps {
    notificationType?: NotificationType;
    presentation?: ViewPresentationType$1;
    preview?: boolean;
    colorScheme?: "auto" | "light" | "dark";
}
type ViewPresentationType$1 = "Modal" | "Push";
/**
 * This view shows notifications.
 * It can be configured to show Sms, Push, or Email notifications.
*/
declare function NotificationsView(props: NotificationsViewProps): React$1.JSX.Element;

interface SurveyTasksViewProps {
    hideCompleteTasks?: boolean;
    hideIncompleteTasks?: boolean;
    hideDueDate?: boolean;
    presentation?: ViewPresentationType;
    preview?: boolean;
    colorScheme?: "auto" | "light" | "dark";
}
type ViewPresentationType = "Modal" | "Push";
/**
 * This view displays all tasks.
 * It can be configured to hide completed and incomplete tasks as needed.
 */
declare function SurveyTasksView(props: SurveyTasksViewProps): React$1.JSX.Element;

interface NewBadgeViewProps {
    title?: string;
    text?: string;
    colorScheme?: 'auto' | 'light' | 'dark';
    primaryColor?: ColorDefinition;
    customField: string;
    previewState?: "default";
    showBadgePoints?: boolean;
}
declare function export_default$8(props: NewBadgeViewProps): React$1.JSX.Element | null;

interface NewPointsEntry {
    name: string;
    points: number;
    bonusPoints?: number;
    message?: {
        title: string;
        text: string;
    };
}
interface NewPointsViewProps {
    entries: NewPointsEntry[];
    pointsToNextReward?: number;
    colorScheme?: 'auto' | 'light' | 'dark';
    primaryColor?: ColorDefinition;
    doneButtonText?: string;
}
/**
 * This view displays a summary of new points earned by the participant.
 */
declare function NewPointsView(props: NewPointsViewProps): React$1.JSX.Element;
declare function showNewPoints(props: NewPointsViewProps, url?: string): void;
declare function loadNewPoints(preview?: boolean): Promise<NewPointsViewProps | undefined>;

interface InboxViewProps {
    previewState?: 'default' | 'empty';
    colorScheme?: 'auto' | 'light' | 'dark';
    surveyVariant?: InboxSurveyVariant;
    resourceImageAlignment?: ResourceImageAlignment;
    resourceButtonVariant?: ResourceButtonVariant;
    resourceButtonText?: string;
    messageViewerUrl: string;
    historyViewerUrl: string;
    itemCategory?: string;
}
declare function export_default$7(props: InboxViewProps): React$1.JSX.Element;

interface InboxHistoryViewProps {
    previewState?: 'default';
    colorScheme?: 'light' | 'dark' | 'auto';
    messageViewerUrl: string;
}
declare function export_default$6(props: InboxHistoryViewProps): React$1.JSX.Element;

interface InboxMessageViewProps {
    previewState?: InboxMessage;
    colorScheme?: 'light' | 'dark' | 'auto';
    resourceImageAlignment?: 'left' | 'center' | 'right';
    resourceButtonText?: string;
}
declare function export_default$5(props: InboxMessageViewProps): React$1.JSX.Element;

interface ReportViewProps {
    reportId: string;
    previewState?: "html" | "pdf";
    colorScheme?: "auto" | "light" | "dark";
}
declare function export_default$4(props: ReportViewProps): React$1.JSX.Element;

interface ResourceListViewProps {
    colorScheme?: 'light' | 'dark' | 'auto';
    previewState?: ResourceListPreviewState;
    title: string;
    resources: ResourceDefinition[];
    emptyText?: string;
    resourceImageAlignment?: ResourceImageAlignment;
    resourceButtonVariant?: ResourceButtonVariant;
    resourceButtonText?: string;
}
declare function export_default$3(props: ResourceListViewProps): React$1.JSX.Element;

interface StandaloneHealthAndWellnessViewProps {
    previewState?: "default";
    colorScheme?: "auto" | "light" | "dark";
    connectExternalAccountOptions?: ConnectExternalAccountOptions;
}
declare function export_default$2(props: StandaloneHealthAndWellnessViewProps): React$1.JSX.Element;

interface TermInformationViewProps {
    presentation?: "Push" | "Modal";
    previewState?: "default" | "noData";
    term?: TermInformationReference;
    labObservationID?: string;
    openLinksInNewWindow?: boolean;
    colorScheme?: "auto" | "light" | "dark";
}
declare function export_default$1(props: TermInformationViewProps): React$1.JSX.Element;

declare function export_default(callback: Function, delay: number | null): void;

export { AIAssistant, Action, ActivityMeter, type AllLibraryDocumentsLoader, AllergiesList, AllergiesView, export_default$1s as AppDownload, type AppleHealthRecordsStatus, AppleHealthRecordsSync, type AppleHealthRecordsSyncPreviewState, type AreaChartOptions, type AreaChartSeries, type AsthmaActionPlan, AsthmaActionPlanInfoView, export_default$1X as AsthmaActionPlanManager, export_default$I as AsthmaActionPlanView, export_default$H as AsthmaActivityView, export_default$1W as AsthmaAirQualities, type AsthmaAirQuality, type AsthmaAirQualityDescription, type AsthmaAirQualityType, export_default$G as AsthmaAirQualityView, export_default$1V as AsthmaAlertTakeoverNotice, export_default$1U as AsthmaAlertTakeoverTrigger, export_default$F as AsthmaAlertTakeoverView, type AsthmaBiometric, type AsthmaBiometricType, export_default$1T as AsthmaBiometrics, export_default$1S as AsthmaControlCalendar, type AsthmaControlCalendarVariant, type AsthmaControlState, type AsthmaControlStatus, export_default$1R as AsthmaControlStatusHeader, AsthmaDailyDataType, type AsthmaDataService, type AsthmaDataStatus, export_default$E as AsthmaDayView, export_default$D as AsthmaHeartAndLungsView, type AsthmaImpact, AsthmaLibraryCategoryView, type AsthmaLogEntry, export_default$1Q as AsthmaLogEntryDetails, export_default$C as AsthmaLogEntryEditorView, export_default$1P as AsthmaLogEntryHeader, export_default$B as AsthmaLogEntryInfoView, AsthmaParticipant, type AsthmaParticipantMode, export_default$1O as AsthmaPostEnrollmentSurveyTrigger, export_default$1N as AsthmaProviderReport, export_default$A as AsthmaProviderReportView, export_default$J as AsthmaRecommendedArticle, export_default$z as AsthmaSleepView, type AsthmaSymptom, type AsthmaSymptomLevel, type AsthmaTrigger, type BarChartOptions, type BarChartThreshold, export_default$1K as BasicBadge, export_default$1r as BasicBadges, BasicPointsForBadges, type BasicPointsForBadgesActivity, type BasicPointsForBadgesActivityState, type BasicPointsForBadgesActivityType, export_default$a as BlankView, type BloodPressureClassification, type BloodPressureDataPoint, type BloodPressureDeviceDataSource, BloodPressureReading, export_default$1q as BloodPressureVisualization, Button, Calendar, CalendarDay, type CalendarDayStateConfiguration, export_default$1J as Card, CardTitle, CelebrationStep, CelebrationStepContainer, type ChartSeries, type ChartThreshold, Chat, type ColorDefinition, ConditionsList, ConditionsView, ConnectDeviceAccountStep, ConnectDeviceAccountStepContainer, export_default$1p as ConnectDevicesMenu, ConnectDevicesView, export_default$1o as ConnectDexcom, type ConnectDexcomPreviewState, export_default$1n as ConnectEhr, ConnectEhrStep, ConnectEhrStepContainer, ConnectEhrView, type ConnectExternalAccountActivity, type ConnectExternalActivityType, export_default$1m as ConnectFitbit, export_default$1l as ConnectGarmin, export_default$1k as ConnectOura, type CustomActivity, CustomFieldIntegerValueProvider, type DailyDataActivity, type DailyDataAvailabilityCheck, DailyDataChart, export_default$1j as DailyDataGoal, type DailyDataProvider, type DailyDataQueryResult, DailyDataType, type DailyDataTypeDefinition, type DailyLogEntry, DateRangeContext, DateRangeCoordinator, DateRangeNavigator, DateRangeTitle, DayTrackerSymbol, DaysWithDataValueProvider, DeviceActivityView, type DeviceDataChartLine, export_default$1i as DeviceDataMonthChart, export_default$1h as DeviceDataMonthCharts, DeviceDataView, export_default$1H as DiscreteScale, export_default$1G as Divider, DocumentDetailView, DocumentLibraryPreview, DocumentLibraryView, DumbbellChart, EhrDownloadButton, EhrNewsFeed, type EhrNewsFeedEvent, EhrNewsFeedEventDetail, EhrNewsFeedEventDetailView, type EhrNewsFeedEventReference, type EhrNewsFeedEventType, type EhrNewsFeedType, EhrNewsFeedView, export_default$1g as ExternalAccountConnectionAlert, export_default$1f as ExternalAccountList, export_default$1e as ExternalAccountsLoadingIndicator, export_default$1d as ExternalAccountsPreview, ExternalAccountsView, Face, export_default$1c as FitbitDevices, export_default$1b as FitbitMonthCharts, FitbitView, export_default$1a as GarminDevices, export_default$19 as GarminMonthCharts, GarminView, export_default$18 as GlucoseChart, GlucoseContext, export_default$17 as GlucoseDayCoordinator, export_default$1F as GlucoseStats, Goal, type GoalColorConfiguration, type GoalTarget, Grid, type GridColumnProps, type GridProps, HealthAndWellnessView, HealthConnectPhrSync, HealthPreviewSection, Histogram, HomeView, export_default$N as InboxCompletedListItem, export_default$6 as InboxHistoryView, export_default$16 as InboxItemList, export_default$15 as InboxItemListCoordinator, export_default$M as InboxMessageListItem, export_default$5 as InboxMessageView, export_default$L as InboxResourceListItem, export_default$K as InboxSurveyListItem, type InboxSurveyVariant, export_default$7 as InboxView, InsightMatrix, type InsightMatrixComparisonDataConfiguration, type InsightMatrixData, type InsightMatrixDataConfiguration, type InsightMatrixDataProvider, type InsightMatrixGroupByDataConfiguration, type InsightMatrixValueCalculator, type InsightMatrixValueEvaluator, type InsightMatrixValueFormatter, type InsightMatrixValueThreshold, type IntradayHeartRateAggregationOption, export_default$14 as IntradayHeartRateChart, type IntradayHeartRateData, export_default$13 as LabResultsBloodType, LabResultsSummary, LatestBloodPressureReading, Layout, LayoutContext, type LibraryDocument, type LibraryDocumentFileType, type LibraryDocumentSurveySpecification, type LineChartOptions, LoadingIndicator, type Meal, MealAnalysis, MealAnalysisPreview, MealAnalysisView, MealAnalysisWorklist, MealButtons, MealContext, MealCoordinator, MealEditor, export_default$9 as MealEditorView, MealLog, type MealReference, type MealType, MedicationsList, MedicationsView, MicroTrend, export_default$1E as MonthlyEventMatrix, type MonthlyEventMatrixRow, export_default$12 as MostRecentNotification, type MultiSeriesBarChartOptions, type MultiSeriesLineChartOptions, Tools as MyDataHelpsTools, export_default$1D as NavigationBar, export_default$8 as NewBadgeView, type NewPointsEntry, NewPointsView, type NewPointsViewProps, NotEnteredThreshold, export_default$1C as NotesInput, NotificationList, NotificationsView, PdfPreview, export_default$11 as PlatformSpecificContent, ProgressBar, ProgressBarStep, ProgressRing, export_default$10 as ProjectHeader, export_default$$ as ProjectSupport, ProviderSearch, RandomIntegerValueProvider, type Reading, type ReadingRange, export_default$_ as RecentDailyDataBarChart, export_default$Z as RelativeActivity, type RelativeActivityDataType, RelativeActivityDateRangeCoordinator as RelativeActivityDayCoordinator, type RelativeActivityQueryResult, export_default$Y as RelativeActivityToday, export_default$4 as ReportView, export_default$1B as Resource, type ResourceButtonVariant, type ResourceDefinition, type ResourceImageAlignment, export_default$1A as ResourceList, export_default$3 as ResourceListView, export_default$X as RestingHeartRateCalendar, export_default$1z as RotatingComponentCoordinator, type RotatingComponentInterval, Section, SegmentedControl, export_default$V as SeverityCalendar, export_default$1y as ShinyOverlay, export_default$1x as SingleDataPoint, SingleExternalAccount, type SingleLibraryDocumentLoader, export_default$1w as SingleNotification, export_default$1v as SingleSurveyTask, SingleValueProvider, type SingleValueProviderType, SparkBarChart, type SparkBarChartBar, export_default$1u as SparkRangeChart, type SparkRangeChartRange, export_default$2 as StandaloneHealthAndWellnessView, StaticIntegerValueProvider, StatusBarBackgroundProps as StatusBarBackground, StepDetailText, export_default$x as StepImage, export_default$y as StepImageIcon, export_default$w as StepLayout, export_default$v as StepMarkdown, export_default$u as StepNextButton, export_default$t as StepText, StepTitle, export_default$U as StressLevel, type SurveyAnswerAreaChartSeries, SurveyAnswerChart, type SurveyAnswerChartSeries, type SurveyBloodPressureDataParameters, type SurveyCompletionActivity, type SurveyDataType, export_default$W as SurveyTaskList, type SurveyTaskListSortBehavior, SurveyTasksView, Switch, type SymptomConfiguration, type SymptomReference, export_default$r as SymptomSharkCalendar, export_default$e as SymptomSharkCalendarView, type SymptomSharkConfiguration, type SymptomSharkDataService, export_default$p as SymptomSharkLogEntry, export_default$g as SymptomSharkLogEntryEdit, export_default$d as SymptomSharkLogEntryEditView, export_default$i as SymptomSharkLogEntryList, export_default$h as SymptomSharkLogToday, export_default$o as SymptomSharkMonthReport, export_default$n as SymptomSharkNotesTimeline, export_default$q as SymptomSharkOverallExperienceChart, ReportBuilder as SymptomSharkReportBuilder, export_default$c as SymptomSharkReportBuilderView, export_default$b as SymptomSharkSymptomDetailView, export_default$s as SymptomSharkSymptomMatrix, export_default$k as SymptomSharkSymptomSeverityChart, export_default$l as SymptomSharkSymptomSeveritySummary, export_default$j as SymptomSharkSymptomTreatmentFilters, export_default$m as SymptomSharkSymptomTreatmentHistograms, export_default$f as SymptomSharkVisualizationCoordinator, export_default$1t as TermInformation, TermInformationButton, type TermInformationReference, export_default$1 as TermInformationView, export_default$R as TextBlock, TimeSeriesChart, type TimeSeriesChartContainerOptions, type TimeSeriesChartLabel, type TimeSeriesChartLineDot, type TimeSeriesChartLineOptions, type TimeSeriesChartOptions, type TimeSeriesChartXAxisOptions, type TimeSeriesChartYAxisOptions, type TimeSeriesGridOptions, export_default$1I as Title, TrackerItem, type TreatmentConfiguration, type TreatmentReference, export_default$Q as UnstyledButton, UploadedFileAction, export_default$P as ValueSelector, export_default$T as ViewDeviceActivity, ViewEhr, export_default$O as ViewHeader, WeekCalendar, type WeekStartsOn, export_default$S as WeeklyDayNavigator, YouTubeStep, YouTubeStepContainer, service as asthmaDataService, awardPointsAndBadges, export_default$1M as bloodPressureDataProvider, buildHtmlReport, capitalizeFirstLetterForLocale, caregiverVariableLanguage, checkDailyDataAvailability, export_default$1L as combinedIntradayHeartRateDataProvider, computeAsthmaControlState, computeBestFitGlucoseValue, computeGlucoseReadingRanges, computeGlucoseReadingRecentAverage, computeThresholdDays, convertToSymptomSharkConfiguration, createAllLibraryDocumentsLoader, createAreaChartDefs, createBarChartDefs, createCustomFieldIntegerValueProvider, createDaysWithDataValueProvider, createIntegerInsightMatrixValueFormatter, createLibraryDocumentSorter, createLineChartDefs, createMinMaxInsightMatrixValueEvaluator, createMinutesToHoursInsightMatrixValueFormatter, createNonZeroAverageValueInsightMatrixValueCalculator, createPercentageOfDaysInsightMatrixValueCalculator, createRandomIntegerValueProvider, createShrinkThousandsInsightMatrixValueFormatter, createSingleLibraryDocumentLoader, createStaticIntegerValueProvider, createThumbnailIfNecessary, allTypeDefinitions as dailyDataTypeDefinitions, dateToAsthmaLogEntryIdentifier, deleteStressLevel, fnvPredictableRandomNumber, formatDateForLocale, formatLibraryDocumentDateAndType, formatMinutesForLocale, formatNumberForLocale, generateGlucose, generateSampleData, generateSleep, generateSteps, get6MonthStart, getAllDailyDataTypes, getAsthmaAirQualityDescriptionText, getAsthmaDataStatusColor, getAsthmaDataStatusText, getAsthmaImpactTexts, getAsthmaImpacts, getAsthmaSymptomLevel, getAsthmaSymptomLevelText, getAsthmaSymptomTexts, getAsthmaSymptoms, getAsthmaTriggerTexts, getAsthmaTriggers, getColorFromAssortment, getCountryCodeFromIso, getCurrentLocale, getDailyDataTypeDefinition, getDateLocale, getDayKey, getDefaultIntervalStart, getGlucoseReadings, getIntlLocale, getLanguageCodeFromIso, getMealImageUrls, getMealToEdit, getMealTypeDisplayText, getMeals, getMonthStart, getSleepMinutes, getSteps, getStressLevel, getSurveyDataProvider, getWeekStart, isBloodOxygenLevelWithinRange, isDaytimeRestingHeartRateWithinRange, isGoalColorConfiguration, isNighttimeRestingHeartRateWithinRange, isRespiratoryRateWithinRange, isSleepDisturbancesWithinRange, isStepsWithinRange, isSurveyDataType, language, loadNewPoints, predictableRandomNumber, prepareMealForEditing, previewHtmlReport, queryDailyData, queryPreviewDailyData, queryRelativeActivity, registerDailyDataProvider, registerDailyDataTypeDefinition, resolveColor, saveMeals, saveStressLevel, showNewPoints, simpleAvailabilityCheck, standardDailyDataTypes, stripExifTags, sumActivityPoints, supportedLocales, timestampSortAsc, tryParseRegex, uploadMealImageFile, useInitializeView, export_default as useInterval };