@awell-health/ui-library 0.1.33

package/dist/types/types/generated/types-orchestration.d.ts

@@ -0,0 +1,1874 @@
+export declare type Maybe<T> = T | null;
+export declare type InputMaybe<T> = Maybe<T>;
+export declare type Exact<T extends {
+    [key: string]: unknown;
+}> = {
+    [K in keyof T]: T[K];
+};
+export declare type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]?: Maybe<T[SubKey]>;
+};
+export declare type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]: Maybe<T[SubKey]>;
+};
+export declare type Scalars = {
+    ID: string;
+    String: string;
+    Boolean: boolean;
+    Int: number;
+    Float: number;
+    SafeDate: any;
+};
+export declare type ActionPayload = Payload & {
+    __typename?: 'ActionPayload';
+    calculationId: Scalars['String'];
+    code: Scalars['String'];
+    success: Scalars['Boolean'];
+};
+export declare enum ActionType {
+    ApiCall = "API_CALL",
+    ApiCallGraphql = "API_CALL_GRAPHQL",
+    Calculation = "CALCULATION",
+    Checklist = "CHECKLIST",
+    ClinicalNote = "CLINICAL_NOTE",
+    Form = "FORM",
+    Message = "MESSAGE",
+    Plugin = "PLUGIN",
+    PushToEmr = "PUSH_TO_EMR"
+}
+export declare type ActivitiesPayload = Payload & {
+    __typename?: 'ActivitiesPayload';
+    activities: Array<Activity>;
+    code: Scalars['String'];
+    metadata?: Maybe<ActivityMetadata>;
+    pagination?: Maybe<PaginationOutput>;
+    sorting?: Maybe<SortingOutput>;
+    success: Scalars['Boolean'];
+};
+export declare type Activity = {
+    __typename?: 'Activity';
+    action: ActivityAction;
+    container_name?: Maybe<Scalars['String']>;
+    context?: Maybe<PathwayContext>;
+    date: Scalars['String'];
+    form?: Maybe<Form>;
+    form_display_mode?: Maybe<FormDisplayMode>;
+    icon_url?: Maybe<Scalars['String']>;
+    id: Scalars['ID'];
+    indirect_object?: Maybe<ActivityObject>;
+    isUserActivity: Scalars['Boolean'];
+    label?: Maybe<ActivityLabel>;
+    object: ActivityObject;
+    public?: Maybe<Scalars['Boolean']>;
+    reference_id: Scalars['String'];
+    resolution?: Maybe<ActivityResolution>;
+    session_id?: Maybe<Scalars['String']>;
+    stakeholders?: Maybe<Array<ActivityObject>>;
+    status: ActivityStatus;
+    stream_id: Scalars['String'];
+    sub_activities: Array<SubActivity>;
+    subject: ActivitySubject;
+    track?: Maybe<ActivityTrack>;
+};
+export declare enum ActivityAction {
+    Activate = "ACTIVATE",
+    Added = "ADDED",
+    Assigned = "ASSIGNED",
+    Complete = "COMPLETE",
+    Computed = "COMPUTED",
+    Delegated = "DELEGATED",
+    Deliver = "DELIVER",
+    Discarded = "DISCARDED",
+    Failed = "FAILED",
+    FailedToSend = "FAILED_TO_SEND",
+    Generated = "GENERATED",
+    IsWaitingOn = "IS_WAITING_ON",
+    Postponed = "POSTPONED",
+    Processed = "PROCESSED",
+    Read = "READ",
+    Remind = "REMIND",
+    Reported = "REPORTED",
+    Scheduled = "SCHEDULED",
+    Send = "SEND",
+    Skipped = "SKIPPED",
+    Stopped = "STOPPED",
+    Submitted = "SUBMITTED"
+}
+export declare type ActivityLabel = {
+    __typename?: 'ActivityLabel';
+    color: Scalars['String'];
+    id?: Maybe<Scalars['String']>;
+    text: Scalars['String'];
+};
+export declare type ActivityMetadata = {
+    __typename?: 'ActivityMetadata';
+    stakeholders?: Maybe<Array<ActivityObject>>;
+};
+export declare type ActivityObject = {
+    __typename?: 'ActivityObject';
+    email?: Maybe<Scalars['String']>;
+    id: Scalars['String'];
+    name: Scalars['String'];
+    preferred_language?: Maybe<Scalars['String']>;
+    type: ActivityObjectType;
+};
+export declare enum ActivityObjectType {
+    Action = "ACTION",
+    ApiCall = "API_CALL",
+    Calculation = "CALCULATION",
+    Checklist = "CHECKLIST",
+    ClinicalNote = "CLINICAL_NOTE",
+    EmrReport = "EMR_REPORT",
+    EmrRequest = "EMR_REQUEST",
+    EvaluatedRule = "EVALUATED_RULE",
+    Form = "FORM",
+    Message = "MESSAGE",
+    Pathway = "PATHWAY",
+    Patient = "PATIENT",
+    Plugin = "PLUGIN",
+    PluginAction = "PLUGIN_ACTION",
+    Reminder = "REMINDER",
+    Stakeholder = "STAKEHOLDER",
+    Step = "STEP",
+    Track = "TRACK",
+    User = "USER"
+}
+export declare enum ActivityResolution {
+    Failure = "FAILURE",
+    Success = "SUCCESS"
+}
+export declare enum ActivityStatus {
+    Active = "ACTIVE",
+    Canceled = "CANCELED",
+    Done = "DONE",
+    Failed = "FAILED"
+}
+export declare type ActivitySubject = {
+    __typename?: 'ActivitySubject';
+    id?: Maybe<Scalars['String']>;
+    name: Scalars['String'];
+    type: ActivitySubjectType;
+};
+export declare enum ActivitySubjectType {
+    ApiCall = "API_CALL",
+    Awell = "AWELL",
+    Plugin = "PLUGIN",
+    Stakeholder = "STAKEHOLDER",
+    User = "USER"
+}
+export declare type ActivityTrack = {
+    __typename?: 'ActivityTrack';
+    id?: Maybe<Scalars['String']>;
+    title: Scalars['String'];
+};
+export declare type AddTrackInput = {
+    pathway_id: Scalars['String'];
+    track_id: Scalars['String'];
+};
+export declare type AddTrackPayload = Payload & {
+    __typename?: 'AddTrackPayload';
+    code: Scalars['String'];
+    success: Scalars['Boolean'];
+};
+export declare type Address = {
+    __typename?: 'Address';
+    city?: Maybe<Scalars['String']>;
+    country?: Maybe<Scalars['String']>;
+    state?: Maybe<Scalars['String']>;
+    street?: Maybe<Scalars['String']>;
+    zip?: Maybe<Scalars['String']>;
+};
+export declare type AddressInput = {
+    city?: InputMaybe<Scalars['String']>;
+    country?: InputMaybe<Scalars['String']>;
+    state?: InputMaybe<Scalars['String']>;
+    street?: InputMaybe<Scalars['String']>;
+    zip?: InputMaybe<Scalars['String']>;
+};
+export declare type Answer = {
+    __typename?: 'Answer';
+    question_id: Scalars['String'];
+    value: Scalars['String'];
+    value_type: DataPointValueType;
+};
+export declare type AnswerInput = {
+    question_id: Scalars['String'];
+    value: Scalars['String'];
+};
+export declare type ApiCall = {
+    __typename?: 'ApiCall';
+    created_at: Scalars['String'];
+    id: Scalars['ID'];
+    request: ApiCallRequest;
+    responses: Array<ApiCallResponse>;
+    status: ApiCallStatus;
+    title: Scalars['String'];
+};
+export declare type ApiCallHeader = {
+    __typename?: 'ApiCallHeader';
+    key: Scalars['String'];
+    value: Scalars['String'];
+};
+export declare type ApiCallPayload = Payload & {
+    __typename?: 'ApiCallPayload';
+    api_call: ApiCall;
+    code: Scalars['String'];
+    success: Scalars['Boolean'];
+};
+export declare type ApiCallRequest = {
+    __typename?: 'ApiCallRequest';
+    body?: Maybe<Scalars['String']>;
+    endpoint: Scalars['String'];
+    headers: Array<ApiCallHeader>;
+    method: ApiCallRequestMethod;
+};
+export declare enum ApiCallRequestMethod {
+    Get = "GET",
+    Post = "POST"
+}
+export declare type ApiCallResponse = {
+    __typename?: 'ApiCallResponse';
+    body: Scalars['String'];
+    date: Scalars['String'];
+    status: Scalars['Float'];
+};
+export declare enum ApiCallStatus {
+    Failed = "Failed",
+    InProgress = "InProgress",
+    Pending = "Pending",
+    PermanentlyFailed = "PermanentlyFailed",
+    Skipped = "Skipped",
+    Success = "Success"
+}
+export declare type ApiCallsPayload = Payload & {
+    __typename?: 'ApiCallsPayload';
+    api_calls: Array<ApiCall>;
+    code: Scalars['String'];
+    success: Scalars['Boolean'];
+};
+export declare type ApiPathwayContext = {
+    __typename?: 'ApiPathwayContext';
+    id: Scalars['String'];
+    pathway_definition_id: Scalars['String'];
+    patient_id?: Maybe<Scalars['String']>;
+    start_date?: Maybe<Scalars['String']>;
+};
+export declare type AuditTrail = {
+    __typename?: 'AuditTrail';
+    date: Scalars['SafeDate'];
+    user_email?: Maybe<Scalars['String']>;
+    user_id: Scalars['String'];
+};
+export declare type BaselineDataPoint = {
+    __typename?: 'BaselineDataPoint';
+    definition: DataPointDefinition;
+    value?: Maybe<Scalars['String']>;
+};
+export declare type BaselineInfoInput = {
+    data_point_definition_id: Scalars['String'];
+    value: Scalars['String'];
+};
+export declare type BaselineInfoPayload = Payload & {
+    __typename?: 'BaselineInfoPayload';
+    baselineDataPoints: Array<BaselineDataPoint>;
+    code: Scalars['String'];
+    success: Scalars['Boolean'];
+};
+export declare enum BooleanOperator {
+    And = "AND",
+    Or = "OR"
+}
+export declare type BrandingSettings = {
+    __typename?: 'BrandingSettings';
+    accent_color?: Maybe<Scalars['String']>;
+    hosted_page_auto_progress?: Maybe<Scalars['Boolean']>;
+    hosted_page_autosave?: Maybe<Scalars['Boolean']>;
+    hosted_page_title?: Maybe<Scalars['String']>;
+    logo_url?: Maybe<Scalars['String']>;
+};
+export declare type CalculationResultsPayload = Payload & {
+    __typename?: 'CalculationResultsPayload';
+    code: Scalars['String'];
+    result: Array<SingleCalculationResult>;
+    success: Scalars['Boolean'];
+};
+export declare type CancelScheduledTracksInput = {
+    ids: Array<Scalars['String']>;
+};
+export declare type CancelScheduledTracksPayload = Payload & {
+    __typename?: 'CancelScheduledTracksPayload';
+    code: Scalars['String'];
+    success: Scalars['Boolean'];
+    unscheduled_ids: Array<Scalars['String']>;
+};
+export declare type Checklist = {
+    __typename?: 'Checklist';
+    items: Array<Scalars['String']>;
+    title: Scalars['String'];
+};
+export declare type ChecklistPayload = Payload & {
+    __typename?: 'ChecklistPayload';
+    checklist?: Maybe<Checklist>;
+    code: Scalars['String'];
+    success: Scalars['Boolean'];
+};
+export declare type ClinicalNotePayload = Payload & {
+    __typename?: 'ClinicalNotePayload';
+    clinical_note: GeneratedClinicalNote;
+    code: Scalars['String'];
+    success: Scalars['Boolean'];
+};
+export declare type CompleteExtensionActivityInput = {
+    activity_id: Scalars['String'];
+    data_points: Array<ExtensionDataPointInput>;
+};
+export declare type CompleteExtensionActivityPayload = Payload & {
+    __typename?: 'CompleteExtensionActivityPayload';
+    activity: Activity;
+    code: Scalars['String'];
+    success: Scalars['Boolean'];
+};
+export declare type Condition = {
+    __typename?: 'Condition';
+    id: Scalars['ID'];
+    operand?: Maybe<Operand>;
+    operator?: Maybe<ConditionOperator>;
+    reference?: Maybe<Scalars['String']>;
+    reference_key?: Maybe<Scalars['String']>;
+};
+export declare enum ConditionOperandType {
+    Boolean = "BOOLEAN",
+    DataPoint = "DATA_POINT",
+    DataSource = "DATA_SOURCE",
+    Number = "NUMBER",
+    NumbersArray = "NUMBERS_ARRAY",
+    String = "STRING"
+}
+export declare enum ConditionOperator {
+    Contains = "CONTAINS",
+    DoesNotContain = "DOES_NOT_CONTAIN",
+    IsAnyOf = "IS_ANY_OF",
+    IsEmpty = "IS_EMPTY",
+    IsEqualTo = "IS_EQUAL_TO",
+    IsGreaterThan = "IS_GREATER_THAN",
+    IsGreaterThanOrEqualTo = "IS_GREATER_THAN_OR_EQUAL_TO",
+    IsInRange = "IS_IN_RANGE",
+    IsLessThan = "IS_LESS_THAN",
+    IsLessThanOrEqualTo = "IS_LESS_THAN_OR_EQUAL_TO",
+    IsNoneOf = "IS_NONE_OF",
+    IsNotEmpty = "IS_NOT_EMPTY",
+    IsNotEqualTo = "IS_NOT_EQUAL_TO",
+    IsNotTrue = "IS_NOT_TRUE",
+    IsToday = "IS_TODAY",
+    IsTrue = "IS_TRUE"
+}
+export declare type CreatePatientInput = {
+    address?: InputMaybe<AddressInput>;
+    birth_date?: InputMaybe<Scalars['String']>;
+    email?: InputMaybe<Scalars['String']>;
+    first_name?: InputMaybe<Scalars['String']>;
+    last_name?: InputMaybe<Scalars['String']>;
+    mobile_phone?: InputMaybe<Scalars['String']>;
+    national_registry_number?: InputMaybe<Scalars['String']>;
+    patient_code?: InputMaybe<Scalars['String']>;
+    phone?: InputMaybe<Scalars['String']>;
+    preferred_language?: InputMaybe<Scalars['String']>;
+    sex?: InputMaybe<Sex>;
+};
+export declare type CreatePatientPayload = Payload & {
+    __typename?: 'CreatePatientPayload';
+    code: Scalars['String'];
+    patient?: Maybe<User>;
+    success: Scalars['Boolean'];
+};
+export declare type DataPointDefinition = {
+    __typename?: 'DataPointDefinition';
+    category: DataPointSourceType;
+    id: Scalars['ID'];
+    key: Scalars['String'];
+    metadata?: Maybe<Array<DataPointMetaDataItem>>;
+    optional?: Maybe<Scalars['Boolean']>;
+    pii?: Maybe<Scalars['Boolean']>;
+    possibleValues?: Maybe<Array<DataPointPossibleValue>>;
+    range?: Maybe<Range>;
+    source_definition_id: Scalars['String'];
+    title: Scalars['String'];
+    unit?: Maybe<Scalars['String']>;
+    valueType: DataPointValueType;
+};
+export declare type DataPointInput = {
+    data_point_definition_id: Scalars['String'];
+    value: Scalars['String'];
+};
+export declare type DataPointMetaDataItem = {
+    __typename?: 'DataPointMetaDataItem';
+    key: Scalars['String'];
+    value: Scalars['String'];
+};
+export declare type DataPointPossibleValue = {
+    __typename?: 'DataPointPossibleValue';
+    label?: Maybe<Scalars['String']>;
+    value: Scalars['String'];
+};
+export declare enum DataPointSourceType {
+    ApiCall = "API_CALL",
+    ApiCallStatus = "API_CALL_STATUS",
+    Calculation = "CALCULATION",
+    ExtensionAction = "EXTENSION_ACTION",
+    ExtensionWebhook = "EXTENSION_WEBHOOK",
+    Form = "FORM",
+    Pathway = "PATHWAY",
+    PatientProfile = "PATIENT_PROFILE",
+    Step = "STEP",
+    Track = "TRACK"
+}
+export declare enum DataPointValueType {
+    Boolean = "BOOLEAN",
+    Date = "DATE",
+    Number = "NUMBER",
+    NumbersArray = "NUMBERS_ARRAY",
+    String = "STRING",
+    Telephone = "TELEPHONE"
+}
+export declare type DateFilter = {
+    gte?: InputMaybe<Scalars['String']>;
+    lte?: InputMaybe<Scalars['String']>;
+};
+export declare type DeletePathwayInput = {
+    pathway_id: Scalars['String'];
+};
+export declare type DeletePatientInput = {
+    patient_id: Scalars['String'];
+};
+export declare type Element = {
+    __typename?: 'Element';
+    activity_type?: Maybe<ActionType>;
+    context: PathwayContext;
+    end_date?: Maybe<Scalars['String']>;
+    id: Scalars['ID'];
+    label?: Maybe<ActivityLabel>;
+    name: Scalars['String'];
+    parent_id?: Maybe<Scalars['ID']>;
+    stakeholders: Array<ElementStakeholder>;
+    start_date: Scalars['String'];
+    status: ElementStatus;
+    type: ElementType;
+};
+export declare type ElementStakeholder = {
+    __typename?: 'ElementStakeholder';
+    id: Scalars['ID'];
+    name?: Maybe<Scalars['String']>;
+};
+export declare enum ElementStatus {
+    Active = "ACTIVE",
+    Discarded = "DISCARDED",
+    Done = "DONE",
+    Postponed = "POSTPONED",
+    Scheduled = "SCHEDULED",
+    Stopped = "STOPPED"
+}
+export declare enum ElementType {
+    Action = "ACTION",
+    Pathway = "PATHWAY",
+    Step = "STEP",
+    Track = "TRACK",
+    Trigger = "TRIGGER"
+}
+export declare type ElementsPayload = Payload & {
+    __typename?: 'ElementsPayload';
+    code: Scalars['String'];
+    elements: Array<Element>;
+    success: Scalars['Boolean'];
+};
+export declare type EmptyPayload = Payload & {
+    __typename?: 'EmptyPayload';
+    code: Scalars['String'];
+    success: Scalars['Boolean'];
+};
+export declare type EmrReport = {
+    __typename?: 'EmrReport';
+    id: Scalars['ID'];
+    message_html: Scalars['String'];
+    metadata?: Maybe<Array<EmrReportMetadataField>>;
+};
+export declare type EmrReportMetadataField = {
+    __typename?: 'EmrReportMetadataField';
+    id: Scalars['ID'];
+    label: Scalars['String'];
+    value?: Maybe<Scalars['String']>;
+};
+export declare type EmrReportPayload = Payload & {
+    __typename?: 'EmrReportPayload';
+    code: Scalars['String'];
+    report?: Maybe<EmrReport>;
+    success: Scalars['Boolean'];
+};
+export declare type EvaluateFormRulesInput = {
+    answers: Array<AnswerInput>;
+    form_id: Scalars['String'];
+};
+export declare type EvaluateFormRulesPayload = Payload & {
+    __typename?: 'EvaluateFormRulesPayload';
+    code: Scalars['String'];
+    results: Array<QuestionRuleResult>;
+    success: Scalars['Boolean'];
+};
+export declare type ExtensionActionField = {
+    __typename?: 'ExtensionActionField';
+    id: Scalars['ID'];
+    label: Scalars['String'];
+    type: ExtensionActionFieldType;
+    value: Scalars['String'];
+};
+export declare enum ExtensionActionFieldType {
+    Boolean = "BOOLEAN",
+    Date = "DATE",
+    Html = "HTML",
+    Json = "JSON",
+    Numeric = "NUMERIC",
+    String = "STRING",
+    Text = "TEXT"
+}
+export declare type ExtensionActivityRecord = {
+    __typename?: 'ExtensionActivityRecord';
+    activity_id: Scalars['String'];
+    data_points: Array<ExtensionDataPoint>;
+    date: Scalars['String'];
+    fields: Array<ExtensionActionField>;
+    id: Scalars['ID'];
+    pathway_id: Scalars['String'];
+    plugin_action_key: Scalars['String'];
+    plugin_key: Scalars['String'];
+    settings?: Maybe<Array<PluginActionSettingsProperty>>;
+};
+export declare type ExtensionActivityRecordPayload = Payload & {
+    __typename?: 'ExtensionActivityRecordPayload';
+    code: Scalars['String'];
+    record: ExtensionActivityRecord;
+    success: Scalars['Boolean'];
+};
+export declare type ExtensionDataPoint = {
+    __typename?: 'ExtensionDataPoint';
+    label: Scalars['String'];
+    value: Scalars['String'];
+};
+export declare type ExtensionDataPointInput = {
+    key: Scalars['String'];
+    value: Scalars['String'];
+};
+export declare type FilterActivitiesParams = {
+    action?: InputMaybe<StringArrayFilter>;
+    activity_status?: InputMaybe<StringArrayFilter>;
+    activity_type?: InputMaybe<StringArrayFilter>;
+    pathway_definition_id?: InputMaybe<StringArrayFilter>;
+    pathway_status?: InputMaybe<StringArrayFilter>;
+    patient_id?: InputMaybe<TextFilterEquals>;
+    stakeholders?: InputMaybe<StringArrayFilter>;
+};
+export declare type FilterPathwayDataPointDefinitionsParams = {
+    category?: InputMaybe<StringArrayFilter>;
+    value_type?: InputMaybe<StringArrayFilter>;
+};
+export declare type FilterPathwayDefinitionsParams = {
+    search?: InputMaybe<TextFilterContains>;
+};
+export declare type FilterPathways = {
+    pathway_definition_id?: InputMaybe<IdFilter>;
+    patient_id?: InputMaybe<StringArrayFilter>;
+    release_id?: InputMaybe<StringArrayFilter>;
+    start_date?: InputMaybe<DateFilter>;
+    status?: InputMaybe<StringArrayFilter>;
+    version?: InputMaybe<NumberArrayFilter>;
+};
+export declare type FilterPatientPathways = {
+    status: StringArrayFilter;
+};
+export declare type FilterPatients = {
+    name?: InputMaybe<TextFilter>;
+    national_registry_number?: InputMaybe<TextFilterEquals>;
+    patient_code?: InputMaybe<TextFilterEquals>;
+    profile_id?: InputMaybe<StringArrayFilter>;
+    search?: InputMaybe<TextFilterContains>;
+};
+export declare type Form = {
+    __typename?: 'Form';
+    definition_id: Scalars['String'];
+    id: Scalars['ID'];
+    key: Scalars['String'];
+    metadata?: Maybe<Scalars['String']>;
+    questions: Array<Question>;
+    release_id: Scalars['String'];
+    title: Scalars['String'];
+    trademark?: Maybe<Scalars['String']>;
+};
+export declare enum FormDisplayMode {
+    Conversational = "CONVERSATIONAL",
+    Regular = "REGULAR"
+}
+export declare type FormPayload = Payload & {
+    __typename?: 'FormPayload';
+    code: Scalars['String'];
+    form?: Maybe<Form>;
+    success: Scalars['Boolean'];
+};
+export declare type FormResponse = {
+    __typename?: 'FormResponse';
+    answers: Array<Answer>;
+};
+export declare type FormResponsePayload = Payload & {
+    __typename?: 'FormResponsePayload';
+    code: Scalars['String'];
+    response: FormResponse;
+    success: Scalars['Boolean'];
+};
+export declare type FormattedText = {
+    __typename?: 'FormattedText';
+    content: TranslatedText;
+    format: Scalars['String'];
+};
+export declare type FormsPayload = Payload & {
+    __typename?: 'FormsPayload';
+    code: Scalars['String'];
+    forms?: Maybe<Array<Form>>;
+    success: Scalars['Boolean'];
+};
+export declare type GeneratedClinicalNote = {
+    __typename?: 'GeneratedClinicalNote';
+    context: Array<GeneratedClinicalNoteContextField>;
+    id: Scalars['ID'];
+    narratives: Array<GeneratedClinicalNoteNarrative>;
+};
+export declare type GeneratedClinicalNoteContextField = {
+    __typename?: 'GeneratedClinicalNoteContextField';
+    key: Scalars['String'];
+    value: Scalars['String'];
+};
+export declare type GeneratedClinicalNoteNarrative = {
+    __typename?: 'GeneratedClinicalNoteNarrative';
+    body: Scalars['String'];
+    id: Scalars['ID'];
+    key: Scalars['String'];
+    title: Scalars['String'];
+};
+export declare type HostedSession = {
+    __typename?: 'HostedSession';
+    cancel_url?: Maybe<Scalars['String']>;
+    id: Scalars['ID'];
+    pathway_id: Scalars['String'];
+    stakeholder: HostedSessionStakeholder;
+    status: HostedSessionStatus;
+    success_url?: Maybe<Scalars['String']>;
+};
+export declare type HostedSessionActivitiesPayload = Payload & {
+    __typename?: 'HostedSessionActivitiesPayload';
+    activities: Array<Activity>;
+    code: Scalars['String'];
+    success: Scalars['Boolean'];
+};
+export declare type HostedSessionPayload = Payload & {
+    __typename?: 'HostedSessionPayload';
+    branding?: Maybe<BrandingSettings>;
+    code: Scalars['String'];
+    session: HostedSession;
+    success: Scalars['Boolean'];
+};
+export declare type HostedSessionStakeholder = {
+    __typename?: 'HostedSessionStakeholder';
+    id: Scalars['ID'];
+    name: Scalars['String'];
+    type: HostedSessionStakeholderType;
+};
+export declare enum HostedSessionStakeholderType {
+    Patient = "PATIENT",
+    Stakeholder = "STAKEHOLDER"
+}
+export declare enum HostedSessionStatus {
+    Active = "ACTIVE",
+    Completed = "COMPLETED",
+    Expired = "EXPIRED"
+}
+export declare type IdFilter = {
+    eq?: InputMaybe<Scalars['String']>;
+};
+export declare type MarkMessageAsReadInput = {
+    activity_id: Scalars['String'];
+};
+export declare type MarkMessageAsReadPayload = Payload & {
+    __typename?: 'MarkMessageAsReadPayload';
+    activity: Activity;
+    code: Scalars['String'];
+    success: Scalars['Boolean'];
+};
+export declare type Message = {
+    __typename?: 'Message';
+    attachments?: Maybe<Array<MessageAttachment>>;
+    body: Scalars['String'];
+    format: MessageFormat;
+    id: Scalars['ID'];
+    subject?: Maybe<Scalars['String']>;
+};
+export declare type MessageAttachment = {
+    __typename?: 'MessageAttachment';
+    id: Scalars['ID'];
+    name: Scalars['String'];
+    type: MessageAttachmentType;
+    url: Scalars['String'];
+};
+export declare enum MessageAttachmentType {
+    File = "FILE",
+    Link = "LINK",
+    Video = "VIDEO"
+}
+export declare enum MessageFormat {
+    Html = "HTML",
+    Slate = "SLATE"
+}
+export declare type MessagePayload = Payload & {
+    __typename?: 'MessagePayload';
+    code: Scalars['String'];
+    message?: Maybe<Message>;
+    success: Scalars['Boolean'];
+};
+export declare type Mutation = {
+    __typename?: 'Mutation';
+    addTrack: AddTrackPayload;
+    completeExtensionActivity: CompleteExtensionActivityPayload;
+    createPatient: CreatePatientPayload;
+    deletePathway: EmptyPayload;
+    deletePatient: EmptyPayload;
+    evaluateFormRules: EvaluateFormRulesPayload;
+    markMessageAsRead: MarkMessageAsReadPayload;
+    requestPatientDemographics: PatientDemographicsPayload;
+    retryActivity: EmptyPayload;
+    retryAllApiCalls: EmptyPayload;
+    retryAllFailedApiCalls: EmptyPayload;
+    retryAllFailedWebhookCalls: EmptyPayload;
+    retryAllFailedWebhookCallsForPathwayDefinition: EmptyPayload;
+    retryAllWebhookCalls: EmptyPayload;
+    retryApiCall: RetryApiCallPayload;
+    retryPushToEmr: EmptyPayload;
+    retryWebhookCall: RetryWebhookCallPayload;
+    saveBaselineInfo: EmptyPayload;
+    scheduleTrack: ScheduleTrackPayload;
+    startHostedActivitySession: StartHostedActivitySessionPayload;
+    startHostedActivitySessionViaHostedPagesLink: StartHostedActivitySessionPayload;
+    startHostedPathwaySession: StartHostedPathwaySessionPayload;
+    startHostedPathwaySessionFromLink: StartHostedPathwaySessionFromLinkPayload;
+    startPathway: StartPathwayPayload;
+    stopPathway: EmptyPayload;
+    stopTrack: StopTrackPayload;
+    submitChecklist: SubmitChecklistPayload;
+    submitFormResponse: SubmitFormResponsePayload;
+    unscheduleTracks: CancelScheduledTracksPayload;
+    updateBaselineInfo: EmptyPayload;
+    updatePatient: UpdatePatientPayload;
+    updatePatientDemographicsQuery: UpdatePatientDemographicsQueryPayload;
+    updatePatientLanguage: UpdatePatientLanguagePayload;
+};
+export declare type MutationAddTrackArgs = {
+    input: AddTrackInput;
+};
+export declare type MutationCompleteExtensionActivityArgs = {
+    input: CompleteExtensionActivityInput;
+};
+export declare type MutationCreatePatientArgs = {
+    input?: InputMaybe<CreatePatientInput>;
+    mycare?: InputMaybe<MyCareOptions>;
+};
+export declare type MutationDeletePathwayArgs = {
+    input: DeletePathwayInput;
+};
+export declare type MutationDeletePatientArgs = {
+    input: DeletePatientInput;
+};
+export declare type MutationEvaluateFormRulesArgs = {
+    input: EvaluateFormRulesInput;
+};
+export declare type MutationMarkMessageAsReadArgs = {
+    input: MarkMessageAsReadInput;
+};
+export declare type MutationRequestPatientDemographicsArgs = {
+    input: PatientDemographicsInput;
+};
+export declare type MutationRetryActivityArgs = {
+    input: RetryActivityInput;
+};
+export declare type MutationRetryAllApiCallsArgs = {
+    input: RetryAllApiCallsInput;
+};
+export declare type MutationRetryAllFailedApiCallsArgs = {
+    input: RetryAllFailedApiCallsInput;
+};
+export declare type MutationRetryAllFailedWebhookCallsArgs = {
+    input: RetryAllFailedWebhookCallsInput;
+};
+export declare type MutationRetryAllFailedWebhookCallsForPathwayDefinitionArgs = {
+    input: RetryAllFailedWebhookCallsForPathwayDefinitionInput;
+};
+export declare type MutationRetryAllWebhookCallsArgs = {
+    input: RetryAllWebhookCallsInput;
+};
+export declare type MutationRetryApiCallArgs = {
+    input: RetryApiCallInput;
+};
+export declare type MutationRetryPushToEmrArgs = {
+    input: RetryPushToEmrInput;
+};
+export declare type MutationRetryWebhookCallArgs = {
+    input: RetryWebhookCallInput;
+};
+export declare type MutationSaveBaselineInfoArgs = {
+    input: SaveBaselineInfoInput;
+};
+export declare type MutationScheduleTrackArgs = {
+    input: ScheduleTrackInput;
+};
+export declare type MutationStartHostedActivitySessionArgs = {
+    input: StartHostedActivitySessionInput;
+};
+export declare type MutationStartHostedActivitySessionViaHostedPagesLinkArgs = {
+    input: StartHostedActivitySessionViaHostedPagesLinkInput;
+};
+export declare type MutationStartHostedPathwaySessionArgs = {
+    input: StartHostedPathwaySessionInput;
+};
+export declare type MutationStartHostedPathwaySessionFromLinkArgs = {
+    input: StartHostedPathwaySessionFromLinkInput;
+};
+export declare type MutationStartPathwayArgs = {
+    input: StartPathwayInput;
+};
+export declare type MutationStopPathwayArgs = {
+    input: StopPathwayInput;
+};
+export declare type MutationStopTrackArgs = {
+    input: StopTrackInput;
+};
+export declare type MutationSubmitChecklistArgs = {
+    input: SubmitChecklistInput;
+};
+export declare type MutationSubmitFormResponseArgs = {
+    input: SubmitFormResponseInput;
+};
+export declare type MutationUnscheduleTracksArgs = {
+    input: CancelScheduledTracksInput;
+};
+export declare type MutationUpdateBaselineInfoArgs = {
+    input: UpdateBaselineInfoInput;
+};
+export declare type MutationUpdatePatientArgs = {
+    input: UpdatePatientInput;
+};
+export declare type MutationUpdatePatientDemographicsQueryArgs = {
+    input: UpdatePatientDemographicsQueryInput;
+};
+export declare type MutationUpdatePatientLanguageArgs = {
+    input: UpdatePatientLanguageInput;
+};
+export declare type MyCareOptions = {
+    password?: InputMaybe<Scalars['String']>;
+};
+export declare type NumberArrayFilter = {
+    in?: InputMaybe<Array<Scalars['Float']>>;
+};
+export declare type Operand = {
+    __typename?: 'Operand';
+    type: ConditionOperandType;
+    value: Scalars['String'];
+};
+export declare type Option = {
+    __typename?: 'Option';
+    id: Scalars['ID'];
+    label: Scalars['String'];
+    value: Scalars['Float'];
+};
+export declare type OrchestrationFact = {
+    __typename?: 'OrchestrationFact';
+    content: Array<Scalars['String']>;
+    date: Scalars['String'];
+    level: Scalars['String'];
+    pathway_id: Scalars['String'];
+};
+export declare type OrchestrationFactsPayload = Payload & {
+    __typename?: 'OrchestrationFactsPayload';
+    code: Scalars['String'];
+    facts: Array<OrchestrationFact>;
+    pagination?: Maybe<PaginationOutput>;
+    sorting?: Maybe<SortingOutput>;
+    success: Scalars['Boolean'];
+};
+export declare type OrchestrationFactsPromptPayload = Payload & {
+    __typename?: 'OrchestrationFactsPromptPayload';
+    code: Scalars['String'];
+    response: Scalars['String'];
+    success: Scalars['Boolean'];
+};
+export declare type PaginationOutput = {
+    __typename?: 'PaginationOutput';
+    count?: Maybe<Scalars['Float']>;
+    offset?: Maybe<Scalars['Float']>;
+    total_count?: Maybe<Scalars['Float']>;
+};
+export declare type PaginationParams = {
+    count: Scalars['Float'];
+    offset: Scalars['Float'];
+};
+export declare type Pathway = {
+    __typename?: 'Pathway';
+    activities: Array<Activity>;
+    complete_date?: Maybe<Scalars['SafeDate']>;
+    dashboards?: Maybe<PathwayDashboard>;
+    id: Scalars['ID'];
+    pathway_definition_id: Scalars['String'];
+    patient: User;
+    patient_id: Scalars['String'];
+    release_id: Scalars['String'];
+    start_date?: Maybe<Scalars['SafeDate']>;
+    status: PathwayStatus;
+    status_explanation?: Maybe<Scalars['String']>;
+    stop_date?: Maybe<Scalars['SafeDate']>;
+    swimlanes: Swimlanes;
+    title: Scalars['String'];
+    tracks: Array<Track>;
+    version?: Maybe<Scalars['Float']>;
+};
+export declare type PathwayContext = {
+    __typename?: 'PathwayContext';
+    action_id?: Maybe<Scalars['String']>;
+    instance_id: Scalars['String'];
+    pathway_id: Scalars['String'];
+    step_id?: Maybe<Scalars['String']>;
+    track_id?: Maybe<Scalars['String']>;
+};
+export declare type PathwayDashboard = {
+    __typename?: 'PathwayDashboard';
+    cumulio_auth_id: Scalars['String'];
+    cumulio_auth_token: Scalars['String'];
+    dashboard_ids: Array<Scalars['String']>;
+};
+export declare type PathwayDataPointDefinitionsPayload = Payload & {
+    __typename?: 'PathwayDataPointDefinitionsPayload';
+    code: Scalars['String'];
+    data_point_definitions: Array<DataPointDefinition>;
+    success: Scalars['Boolean'];
+};
+export declare type PathwayDefinitionDetails = {
+    __typename?: 'PathwayDefinitionDetails';
+    active_careflows?: Maybe<Scalars['Float']>;
+    completed_careflows?: Maybe<Scalars['Float']>;
+    stopped_careflows?: Maybe<Scalars['Float']>;
+    total_careflows?: Maybe<Scalars['Float']>;
+    total_patients?: Maybe<Scalars['Float']>;
+};
+export declare type PathwayFactsFilters = {
+    date?: InputMaybe<DateFilter>;
+    keyword?: InputMaybe<Scalars['String']>;
+    pathway_id: Scalars['String'];
+};
+export declare type PathwayPayload = Payload & {
+    __typename?: 'PathwayPayload';
+    code: Scalars['String'];
+    pathway?: Maybe<Pathway>;
+    success: Scalars['Boolean'];
+};
+export declare enum PathwayStatus {
+    Active = "active",
+    Completed = "completed",
+    MissingBaselineInfo = "missing_baseline_info",
+    Starting = "starting",
+    Stopped = "stopped"
+}
+export declare type PathwaySummary = {
+    __typename?: 'PathwaySummary';
+    complete_date?: Maybe<Scalars['SafeDate']>;
+    id: Scalars['ID'];
+    pathway_definition_id?: Maybe<Scalars['String']>;
+    patient_id?: Maybe<Scalars['String']>;
+    start_date?: Maybe<Scalars['SafeDate']>;
+    status: PathwayStatus;
+    status_explanation?: Maybe<Scalars['String']>;
+    stop_date?: Maybe<Scalars['SafeDate']>;
+    title: Scalars['String'];
+    version?: Maybe<Scalars['Float']>;
+};
+export declare type PathwaysPayload = Payload & {
+    __typename?: 'PathwaysPayload';
+    code: Scalars['String'];
+    pagination?: Maybe<PaginationOutput>;
+    pathways: Array<PathwaySummary>;
+    sorting?: Maybe<SortingOutput>;
+    success: Scalars['Boolean'];
+};
+export declare type PatientDemographicsInput = {
+    patient_identifier: Scalars['String'];
+};
+export declare type PatientDemographicsPayload = Payload & {
+    __typename?: 'PatientDemographicsPayload';
+    code: Scalars['String'];
+    entry?: Maybe<Array<UserProfile>>;
+    query_id: Scalars['String'];
+    status: Scalars['String'];
+    success: Scalars['Boolean'];
+    total?: Maybe<Scalars['Float']>;
+};
+export declare type PatientDemographicsQueryConfigurationPayload = {
+    __typename?: 'PatientDemographicsQueryConfigurationPayload';
+    input_box_text?: Maybe<Scalars['String']>;
+    is_enabled: Scalars['Boolean'];
+};
+export declare type PatientPathway = {
+    __typename?: 'PatientPathway';
+    active_activities?: Maybe<Scalars['Float']>;
+    baseline_info?: Maybe<Array<BaselineDataPoint>>;
+    complete_date?: Maybe<Scalars['String']>;
+    failed_activities?: Maybe<Scalars['Float']>;
+    id: Scalars['ID'];
+    latest_activity_date?: Maybe<Scalars['String']>;
+    latest_activity_title?: Maybe<Scalars['String']>;
+    latest_activity_type?: Maybe<Scalars['String']>;
+    pathway_definition_id: Scalars['String'];
+    release_id: Scalars['String'];
+    status: PathwayStatus;
+    status_explanation?: Maybe<Scalars['String']>;
+    stop_date?: Maybe<Scalars['String']>;
+    title: Scalars['String'];
+    total_activities?: Maybe<Scalars['Float']>;
+    version?: Maybe<Scalars['Float']>;
+};
+export declare type PatientPathwaysPayload = Payload & {
+    __typename?: 'PatientPathwaysPayload';
+    code: Scalars['String'];
+    patientPathways: Array<PatientPathway>;
+    success: Scalars['Boolean'];
+};
+export declare type PatientPayload = Payload & {
+    __typename?: 'PatientPayload';
+    code: Scalars['String'];
+    patient?: Maybe<User>;
+    success: Scalars['Boolean'];
+};
+export declare type PatientProfileInput = {
+    address?: InputMaybe<AddressInput>;
+    birth_date?: InputMaybe<Scalars['String']>;
+    email?: InputMaybe<Scalars['String']>;
+    first_name?: InputMaybe<Scalars['String']>;
+    last_name?: InputMaybe<Scalars['String']>;
+    mobile_phone?: InputMaybe<Scalars['String']>;
+    national_registry_number?: InputMaybe<Scalars['String']>;
+    patient_code?: InputMaybe<Scalars['String']>;
+    phone?: InputMaybe<Scalars['String']>;
+    preferred_language?: InputMaybe<Scalars['String']>;
+    sex?: InputMaybe<Sex>;
+};
+export declare type PatientsPayload = Payload & {
+    __typename?: 'PatientsPayload';
+    code: Scalars['String'];
+    pagination: PaginationOutput;
+    patients: Array<User>;
+    sorting: SortingOutput;
+    success: Scalars['Boolean'];
+};
+export declare type Payload = {
+    code: Scalars['String'];
+    success: Scalars['Boolean'];
+};
+export declare type PhoneConfig = {
+    __typename?: 'PhoneConfig';
+    available_countries?: Maybe<Array<Scalars['String']>>;
+    default_country?: Maybe<Scalars['String']>;
+};
+export declare type PluginActionSettingsProperty = {
+    __typename?: 'PluginActionSettingsProperty';
+    key: Scalars['String'];
+    label: Scalars['String'];
+    value: Scalars['String'];
+};
+export declare type PublishedPathwayDefinition = {
+    __typename?: 'PublishedPathwayDefinition';
+    active_activities?: Maybe<Scalars['Float']>;
+    all?: Maybe<PathwayDefinitionDetails>;
+    cancelled_activities?: Maybe<Scalars['Float']>;
+    created?: Maybe<AuditTrail>;
+    dataPointDefinitions: Array<DataPointDefinition>;
+    data_point_definitions?: Maybe<Array<DataPointDefinition>>;
+    failed_activities?: Maybe<Scalars['Float']>;
+    id: Scalars['ID'];
+    last_updated?: Maybe<AuditTrail>;
+    latest?: Maybe<PathwayDefinitionDetails>;
+    patients_with_pending_activities?: Maybe<Scalars['Float']>;
+    release_date?: Maybe<Scalars['String']>;
+    release_id?: Maybe<Scalars['String']>;
+    stakeholders_with_pending_activities_list?: Maybe<Array<Scalars['String']>>;
+    title: Scalars['String'];
+    total_activities?: Maybe<Scalars['Float']>;
+    total_patients?: Maybe<Scalars['Float']>;
+    total_stakeholders?: Maybe<Scalars['Float']>;
+    track_definitions?: Maybe<Array<Track>>;
+    version?: Maybe<Scalars['Float']>;
+};
+export declare type PublishedPathwayDefinitionsPayload = Payload & {
+    __typename?: 'PublishedPathwayDefinitionsPayload';
+    code: Scalars['String'];
+    pagination?: Maybe<PaginationOutput>;
+    publishedPathwayDefinitions: Array<PublishedPathwayDefinition>;
+    sorting?: Maybe<SortingOutput>;
+    success: Scalars['Boolean'];
+};
+export declare type Query = {
+    __typename?: 'Query';
+    activities: ActivitiesPayload;
+    adHocTracksByPathway: TracksPayload;
+    adHocTracksByRelease: TracksPayload;
+    apiCall: ApiCallPayload;
+    apiCalls: ApiCallsPayload;
+    baselineInfo: BaselineInfoPayload;
+    calculationAction: ActionPayload;
+    calculationResults: CalculationResultsPayload;
+    checklist: ChecklistPayload;
+    clinicalNote: ClinicalNotePayload;
+    emrReport: EmrReportPayload;
+    extensionActivityRecord: ExtensionActivityRecordPayload;
+    filterStakeholders: StakeholdersPayload;
+    form: FormPayload;
+    formResponse: FormResponsePayload;
+    forms: FormsPayload;
+    getOrchestrationFactsFromPrompt: OrchestrationFactsPromptPayload;
+    getStatusForPublishedPathwayDefinitions: PublishedPathwayDefinitionsPayload;
+    hostedSession: HostedSessionPayload;
+    hostedSessionActivities: HostedSessionActivitiesPayload;
+    message: MessagePayload;
+    myActivities: ActivitiesPayload;
+    myPathways: PathwaysPayload;
+    myPendingActivities: ActivitiesPayload;
+    pathway: PathwayPayload;
+    pathwayActivities: ActivitiesPayload;
+    pathwayDataPointDefinitions: PathwayDataPointDefinitionsPayload;
+    pathwayElements: ElementsPayload;
+    pathwayFacts: OrchestrationFactsPayload;
+    pathwayStepActivities: ActivitiesPayload;
+    pathways: PathwaysPayload;
+    patient: PatientPayload;
+    patientDemographicsQueryConfiguration: PatientDemographicsQueryConfigurationPayload;
+    patientPathways: PatientPathwaysPayload;
+    patients: PatientsPayload;
+    publishedPathwayDefinitions: PublishedPathwayDefinitionsPayload;
+    publishedPathwayDefinitionsDashboard: PublishedPathwayDefinitionsPayload;
+    scheduledSteps: ScheduledStepsPayload;
+    scheduledTracksForPathway: ScheduledTracksPayload;
+    searchPatientsByNationalRegistryNumber: SearchPatientsPayload;
+    searchPatientsByPatientCode: SearchPatientsPayload;
+    stakeholdersByDefinitionIds: StakeholdersPayload;
+    stakeholdersByPathwayDefinitionIds: StakeholdersPayload;
+    stakeholdersByReleaseIds: StakeholdersPayload;
+    webhookCall: WebhookCallPayload;
+    webhookCalls: WebhookCallsPayload;
+    webhookCallsForPathwayDefinition: WebhookCallsPayload;
+    webhookCallsForTenant: WebhookCallsPayload;
+    whoami: UserPayload;
+};
+export declare type QueryActivitiesArgs = {
+    filters?: InputMaybe<FilterActivitiesParams>;
+    pagination?: InputMaybe<PaginationParams>;
+    sorting?: InputMaybe<SortingParams>;
+};
+export declare type QueryAdHocTracksByPathwayArgs = {
+    pathway_id: Scalars['String'];
+};
+export declare type QueryAdHocTracksByReleaseArgs = {
+    release_id: Scalars['String'];
+};
+export declare type QueryApiCallArgs = {
+    id: Scalars['String'];
+};
+export declare type QueryApiCallsArgs = {
+    pathway_id: Scalars['String'];
+};
+export declare type QueryBaselineInfoArgs = {
+    pathway_id: Scalars['String'];
+};
+export declare type QueryCalculationActionArgs = {
+    id: Scalars['String'];
+};
+export declare type QueryCalculationResultsArgs = {
+    activity_id: Scalars['String'];
+    pathway_id: Scalars['String'];
+};
+export declare type QueryChecklistArgs = {
+    id: Scalars['String'];
+};
+export declare type QueryClinicalNoteArgs = {
+    id: Scalars['String'];
+};
+export declare type QueryEmrReportArgs = {
+    id: Scalars['String'];
+};
+export declare type QueryExtensionActivityRecordArgs = {
+    id: Scalars['String'];
+};
+export declare type QueryFilterStakeholdersArgs = {
+    pathway_definition_ids?: InputMaybe<Array<Scalars['String']>>;
+    release_ids?: InputMaybe<Array<Scalars['String']>>;
+    stakeholder_definition_ids?: InputMaybe<Array<Scalars['String']>>;
+};
+export declare type QueryFormArgs = {
+    id: Scalars['String'];
+};
+export declare type QueryFormResponseArgs = {
+    activity_id: Scalars['String'];
+    pathway_id: Scalars['String'];
+};
+export declare type QueryFormsArgs = {
+    pathway_definition_id: Scalars['String'];
+    release_id?: InputMaybe<Scalars['String']>;
+};
+export declare type QueryGetOrchestrationFactsFromPromptArgs = {
+    pathway_id: Scalars['String'];
+    prompt: Scalars['String'];
+};
+export declare type QueryHostedSessionActivitiesArgs = {
+    only_stakeholder_activities?: InputMaybe<Scalars['Boolean']>;
+};
+export declare type QueryMessageArgs = {
+    id: Scalars['String'];
+};
+export declare type QueryMyActivitiesArgs = {
+    pathway_id: Scalars['String'];
+};
+export declare type QueryPathwayArgs = {
+    id: Scalars['String'];
+};
+export declare type QueryPathwayActivitiesArgs = {
+    pathway_id: Scalars['String'];
+};
+export declare type QueryPathwayDataPointDefinitionsArgs = {
+    filters?: InputMaybe<FilterPathwayDataPointDefinitionsParams>;
+    pathway_definition_id?: InputMaybe<Scalars['String']>;
+    release_id: Scalars['String'];
+};
+export declare type QueryPathwayElementsArgs = {
+    pathway_id: Scalars['String'];
+};
+export declare type QueryPathwayFactsArgs = {
+    filters: PathwayFactsFilters;
+    pagination?: InputMaybe<PaginationParams>;
+    sorting?: InputMaybe<SortingParams>;
+};
+export declare type QueryPathwayStepActivitiesArgs = {
+    pathway_id: Scalars['String'];
+    step_id: Scalars['String'];
+};
+export declare type QueryPathwaysArgs = {
+    filters?: InputMaybe<FilterPathways>;
+    pagination?: InputMaybe<PaginationParams>;
+    sorting?: InputMaybe<SortingParams>;
+};
+export declare type QueryPatientArgs = {
+    id: Scalars['String'];
+};
+export declare type QueryPatientPathwaysArgs = {
+    filters?: InputMaybe<FilterPatientPathways>;
+    patient_id: Scalars['String'];
+};
+export declare type QueryPatientsArgs = {
+    filters?: InputMaybe<FilterPatients>;
+    pagination?: InputMaybe<PaginationParams>;
+    sorting?: InputMaybe<SortingParams>;
+};
+export declare type QueryPublishedPathwayDefinitionsDashboardArgs = {
+    filters?: InputMaybe<FilterPathwayDefinitionsParams>;
+    pagination?: InputMaybe<PaginationParams>;
+    sorting?: InputMaybe<SortingParams>;
+};
+export declare type QueryScheduledStepsArgs = {
+    pathway_id: Scalars['String'];
+};
+export declare type QueryScheduledTracksForPathwayArgs = {
+    pathway_id: Scalars['String'];
+};
+export declare type QuerySearchPatientsByNationalRegistryNumberArgs = {
+    national_registry_number: Scalars['String'];
+};
+export declare type QuerySearchPatientsByPatientCodeArgs = {
+    patient_code: Scalars['String'];
+};
+export declare type QueryStakeholdersByDefinitionIdsArgs = {
+    stakeholder_definition_ids: Array<Scalars['String']>;
+};
+export declare type QueryStakeholdersByPathwayDefinitionIdsArgs = {
+    pathway_definition_ids: Array<Scalars['String']>;
+};
+export declare type QueryStakeholdersByReleaseIdsArgs = {
+    release_ids: Array<Scalars['String']>;
+};
+export declare type QueryWebhookCallArgs = {
+    webhook_call_id: Scalars['String'];
+};
+export declare type QueryWebhookCallsArgs = {
+    pathway_id: Scalars['String'];
+};
+export declare type QueryWebhookCallsForPathwayDefinitionArgs = {
+    pathway_definition_id: Scalars['String'];
+};
+export declare type Question = {
+    __typename?: 'Question';
+    dataPointValueType?: Maybe<DataPointValueType>;
+    definition_id: Scalars['String'];
+    id: Scalars['ID'];
+    key: Scalars['String'];
+    metadata?: Maybe<Scalars['String']>;
+    options?: Maybe<Array<Option>>;
+    questionConfig?: Maybe<QuestionConfig>;
+    questionType?: Maybe<QuestionType>;
+    rule?: Maybe<Rule>;
+    title: Scalars['String'];
+    userQuestionType?: Maybe<UserQuestionType>;
+};
+export declare type QuestionConfig = {
+    __typename?: 'QuestionConfig';
+    mandatory: Scalars['Boolean'];
+    phone?: Maybe<PhoneConfig>;
+    recode_enabled?: Maybe<Scalars['Boolean']>;
+    slider?: Maybe<SliderConfig>;
+    use_select?: Maybe<Scalars['Boolean']>;
+};
+export declare type QuestionResponseInput = {
+    question_id: Scalars['String'];
+    value: Scalars['String'];
+};
+export declare type QuestionRuleResult = {
+    __typename?: 'QuestionRuleResult';
+    question_id: Scalars['String'];
+    rule_id: Scalars['String'];
+    satisfied: Scalars['Boolean'];
+};
+export declare enum QuestionType {
+    Input = "INPUT",
+    MultipleChoice = "MULTIPLE_CHOICE",
+    NoInput = "NO_INPUT"
+}
+export declare type Range = {
+    __typename?: 'Range';
+    max?: Maybe<Scalars['Float']>;
+    min?: Maybe<Scalars['Float']>;
+};
+export declare type RetryActivityInput = {
+    activity_id: Scalars['String'];
+};
+export declare type RetryAllApiCallsInput = {
+    pathway_id: Scalars['String'];
+};
+export declare type RetryAllFailedApiCallsInput = {
+    pathway_id: Scalars['String'];
+};
+export declare type RetryAllFailedWebhookCallsForPathwayDefinitionInput = {
+    pathway_definition_id: Scalars['String'];
+};
+export declare type RetryAllFailedWebhookCallsInput = {
+    pathway_id: Scalars['String'];
+};
+export declare type RetryAllWebhookCallsInput = {
+    pathway_id: Scalars['String'];
+};
+export declare type RetryApiCallInput = {
+    api_call_id: Scalars['String'];
+};
+export declare type RetryApiCallPayload = Payload & {
+    __typename?: 'RetryApiCallPayload';
+    api_call: ApiCall;
+    code: Scalars['String'];
+    success: Scalars['Boolean'];
+};
+export declare type RetryPushToEmrInput = {
+    activity_id: Scalars['String'];
+};
+export declare type RetryWebhookCallInput = {
+    webhook_call_id: Scalars['String'];
+};
+export declare type RetryWebhookCallPayload = Payload & {
+    __typename?: 'RetryWebhookCallPayload';
+    code: Scalars['String'];
+    success: Scalars['Boolean'];
+    webhook_call: WebhookCall;
+};
+export declare type Rule = {
+    __typename?: 'Rule';
+    boolean_operator: BooleanOperator;
+    conditions: Array<Condition>;
+    definition_id?: Maybe<Scalars['String']>;
+    id: Scalars['ID'];
+};
+export declare type SaveBaselineInfoInput = {
+    baseline_info: Array<BaselineInfoInput>;
+    pathway_id: Scalars['String'];
+};
+export declare type ScheduleTrackInput = {
+    cancel_any_scheduled?: InputMaybe<Scalars['Boolean']>;
+    pathway_id: Scalars['String'];
+    scheduled_date: Scalars['String'];
+    track_id: Scalars['String'];
+};
+export declare type ScheduleTrackPayload = Payload & {
+    __typename?: 'ScheduleTrackPayload';
+    code: Scalars['String'];
+    id: Scalars['String'];
+    success: Scalars['Boolean'];
+};
+export declare type ScheduledStepsPayload = Payload & {
+    __typename?: 'ScheduledStepsPayload';
+    code: Scalars['String'];
+    steps: Array<Element>;
+    success: Scalars['Boolean'];
+};
+export declare type ScheduledTrack = {
+    __typename?: 'ScheduledTrack';
+    created_by_user_id: Scalars['String'];
+    created_date: Scalars['String'];
+    id: Scalars['ID'];
+    modified_date?: Maybe<Scalars['String']>;
+    pathway_id: Scalars['String'];
+    release_id: Scalars['String'];
+    scheduled_date: Scalars['String'];
+    status: Scalars['String'];
+    tenant_id: Scalars['String'];
+    title: Scalars['String'];
+    track_definition_id: Scalars['String'];
+};
+export declare type ScheduledTracksPayload = Payload & {
+    __typename?: 'ScheduledTracksPayload';
+    code: Scalars['String'];
+    scheduled_tracks: Array<ScheduledTrack>;
+    success: Scalars['Boolean'];
+};
+export declare type SearchPatientsPayload = Payload & {
+    __typename?: 'SearchPatientsPayload';
+    code: Scalars['String'];
+    patients: Array<User>;
+    success: Scalars['Boolean'];
+};
+export declare enum Sex {
+    Female = "FEMALE",
+    Male = "MALE",
+    NotKnown = "NOT_KNOWN"
+}
+export declare type SingleCalculationResult = {
+    __typename?: 'SingleCalculationResult';
+    status?: Maybe<Scalars['String']>;
+    subresult_id: Scalars['String'];
+    unit?: Maybe<Scalars['String']>;
+    value: Scalars['String'];
+    value_type?: Maybe<DataPointValueType>;
+};
+export declare type SliderConfig = {
+    __typename?: 'SliderConfig';
+    display_marks: Scalars['Boolean'];
+    is_value_tooltip_on: Scalars['Boolean'];
+    max: Scalars['Float'];
+    max_label: Scalars['String'];
+    min: Scalars['Float'];
+    min_label: Scalars['String'];
+    show_min_max_values: Scalars['Boolean'];
+    step_value: Scalars['Float'];
+};
+export declare type SortingOutput = {
+    __typename?: 'SortingOutput';
+    direction: Scalars['String'];
+    field: Scalars['String'];
+};
+export declare type SortingParams = {
+    direction: Scalars['String'];
+    field: Scalars['String'];
+};
+export declare type Stakeholder = {
+    __typename?: 'Stakeholder';
+    clinical_app_role: StakeholderClinicalAppRole;
+    definition_id: Scalars['String'];
+    id: Scalars['ID'];
+    label: StakeholderLabel;
+    release_id: Scalars['String'];
+    version: Scalars['Float'];
+};
+export declare enum StakeholderClinicalAppRole {
+    Caregiver = "CAREGIVER",
+    Patient = "PATIENT",
+    Physician = "PHYSICIAN"
+}
+export declare type StakeholderLabel = {
+    __typename?: 'StakeholderLabel';
+    en: Scalars['String'];
+};
+export declare type StakeholdersPayload = Payload & {
+    __typename?: 'StakeholdersPayload';
+    code: Scalars['String'];
+    stakeholders: Array<Stakeholder>;
+    success: Scalars['Boolean'];
+};
+export declare type StartHostedActivitySessionInput = {
+    cancel_url?: InputMaybe<Scalars['String']>;
+    language?: InputMaybe<Scalars['String']>;
+    pathway_id: Scalars['String'];
+    stakeholder_id: Scalars['String'];
+    success_url?: InputMaybe<Scalars['String']>;
+};
+export declare type StartHostedActivitySessionPayload = Payload & {
+    __typename?: 'StartHostedActivitySessionPayload';
+    code: Scalars['String'];
+    language?: Maybe<Scalars['String']>;
+    session_id: Scalars['String'];
+    session_url: Scalars['String'];
+    success: Scalars['Boolean'];
+};
+export declare type StartHostedActivitySessionViaHostedPagesLinkInput = {
+    hosted_pages_link_id: Scalars['String'];
+};
+export declare type StartHostedPathwaySessionFromLinkInput = {
+    id: Scalars['String'];
+};
+export declare type StartHostedPathwaySessionFromLinkPayload = Payload & {
+    __typename?: 'StartHostedPathwaySessionFromLinkPayload';
+    code: Scalars['String'];
+    session_url: Scalars['String'];
+    success: Scalars['Boolean'];
+};
+export declare type StartHostedPathwaySessionInput = {
+    cancel_url?: InputMaybe<Scalars['String']>;
+    data_points?: InputMaybe<Array<DataPointInput>>;
+    language?: InputMaybe<Scalars['String']>;
+    pathway_definition_id: Scalars['String'];
+    patient_id?: InputMaybe<Scalars['String']>;
+    success_url?: InputMaybe<Scalars['String']>;
+};
+export declare type StartHostedPathwaySessionPayload = Payload & {
+    __typename?: 'StartHostedPathwaySessionPayload';
+    code: Scalars['String'];
+    pathway_id: Scalars['String'];
+    session_id: Scalars['String'];
+    session_url: Scalars['String'];
+    stakeholder: HostedSessionStakeholder;
+    success: Scalars['Boolean'];
+};
+export declare type StartPathwayInput = {
+    data_points?: InputMaybe<Array<DataPointInput>>;
+    pathway_definition_id: Scalars['String'];
+    patient_id: Scalars['String'];
+};
+export declare type StartPathwayPayload = Payload & {
+    __typename?: 'StartPathwayPayload';
+    code: Scalars['String'];
+    pathway_id: Scalars['String'];
+    stakeholders: Array<Stakeholder>;
+    success: Scalars['Boolean'];
+};
+export declare type StopPathwayInput = {
+    pathway_id: Scalars['String'];
+    reason?: InputMaybe<Scalars['String']>;
+};
+export declare type StopTrackInput = {
+    pathway_id: Scalars['String'];
+    track_id: Scalars['String'];
+};
+export declare type StopTrackPayload = Payload & {
+    __typename?: 'StopTrackPayload';
+    code: Scalars['String'];
+    success: Scalars['Boolean'];
+    track: Element;
+};
+export declare type StringArrayFilter = {
+    in?: InputMaybe<Array<Scalars['String']>>;
+};
+export declare type SubActivity = {
+    __typename?: 'SubActivity';
+    action: ActivityAction;
+    date: Scalars['String'];
+    error?: Maybe<Scalars['String']>;
+    error_category?: Maybe<Scalars['String']>;
+    id: Scalars['String'];
+    object?: Maybe<ActivityObject>;
+    subject: ActivitySubject;
+    text?: Maybe<TranslatedText>;
+};
+export declare type SubmitChecklistInput = {
+    activity_id: Scalars['String'];
+};
+export declare type SubmitChecklistPayload = Payload & {
+    __typename?: 'SubmitChecklistPayload';
+    activity: Activity;
+    code: Scalars['String'];
+    success: Scalars['Boolean'];
+};
+export declare type SubmitFormResponseInput = {
+    activity_id: Scalars['String'];
+    response: Array<QuestionResponseInput>;
+};
+export declare type SubmitFormResponsePayload = Payload & {
+    __typename?: 'SubmitFormResponsePayload';
+    activity: Activity;
+    code: Scalars['String'];
+    success: Scalars['Boolean'];
+};
+export declare type Subscription = {
+    __typename?: 'Subscription';
+    activityCompleted: Activity;
+    activityCreated: Activity;
+    activityUpdated: Activity;
+    apiCallCreated: ApiCall;
+    apiCallUpdated: ApiCall;
+    elementCompleted: Element;
+    elementCreated: Element;
+    elementUpdated: Element;
+    pathwayUpdated: Pathway;
+    sessionActivityCompleted: Activity;
+    sessionActivityCreated: Activity;
+    sessionActivityUpdated: Activity;
+    sessionCompleted: HostedSession;
+    sessionExpired: HostedSession;
+    webhookCallCreated: WebhookCall;
+    webhookCallUpdated: WebhookCall;
+};
+export declare type SubscriptionActivityCompletedArgs = {
+    only_patient_activities?: InputMaybe<Scalars['Boolean']>;
+    pathway_id?: InputMaybe<Scalars['String']>;
+};
+export declare type SubscriptionActivityCreatedArgs = {
+    only_patient_activities?: InputMaybe<Scalars['Boolean']>;
+    pathway_id?: InputMaybe<Scalars['String']>;
+};
+export declare type SubscriptionActivityUpdatedArgs = {
+    only_patient_activities?: InputMaybe<Scalars['Boolean']>;
+    pathway_id?: InputMaybe<Scalars['String']>;
+};
+export declare type SubscriptionApiCallCreatedArgs = {
+    pathway_id: Scalars['String'];
+};
+export declare type SubscriptionApiCallUpdatedArgs = {
+    pathway_id: Scalars['String'];
+};
+export declare type SubscriptionElementCompletedArgs = {
+    element_type?: InputMaybe<ElementType>;
+    pathway_id: Scalars['String'];
+};
+export declare type SubscriptionElementCreatedArgs = {
+    element_type?: InputMaybe<ElementType>;
+    pathway_id: Scalars['String'];
+};
+export declare type SubscriptionElementUpdatedArgs = {
+    element_type?: InputMaybe<ElementType>;
+    pathway_id: Scalars['String'];
+};
+export declare type SubscriptionPathwayUpdatedArgs = {
+    id: Scalars['ID'];
+};
+export declare type SubscriptionSessionActivityCompletedArgs = {
+    only_stakeholder_activities?: InputMaybe<Scalars['Boolean']>;
+};
+export declare type SubscriptionSessionActivityCreatedArgs = {
+    only_stakeholder_activities?: InputMaybe<Scalars['Boolean']>;
+};
+export declare type SubscriptionSessionActivityUpdatedArgs = {
+    only_stakeholder_activities?: InputMaybe<Scalars['Boolean']>;
+};
+export declare type SubscriptionWebhookCallCreatedArgs = {
+    pathway_id: Scalars['String'];
+};
+export declare type SubscriptionWebhookCallUpdatedArgs = {
+    pathway_id: Scalars['String'];
+};
+export declare type Swimlane = {
+    __typename?: 'Swimlane';
+    id: Scalars['ID'];
+    title: Scalars['String'];
+};
+export declare type SwimlaneItem = {
+    __typename?: 'SwimlaneItem';
+    category: SwimlaneItemCategory;
+    column_index: Scalars['Float'];
+    date?: Maybe<Scalars['SafeDate']>;
+    documentation?: Maybe<FormattedText>;
+    id: Scalars['ID'];
+    info?: Maybe<Scalars['String']>;
+    lane_id: Scalars['ID'];
+    row_index: Scalars['Float'];
+    title: Scalars['String'];
+    track_id?: Maybe<Scalars['ID']>;
+    type: SwimlaneItemType;
+};
+export declare enum SwimlaneItemCategory {
+    Action = "ACTION",
+    PathwayEnd = "PATHWAY_END",
+    PathwayStart = "PATHWAY_START",
+    Step = "STEP",
+    Track = "TRACK",
+    TrackEnd = "TRACK_END",
+    TrackStart = "TRACK_START"
+}
+export declare enum SwimlaneItemType {
+    Active = "active",
+    Completed = "completed",
+    Pending = "pending",
+    Possible = "possible"
+}
+export declare type SwimlaneLink = {
+    __typename?: 'SwimlaneLink';
+    destination_id: Scalars['ID'];
+    id: Scalars['ID'];
+    origin_id: Scalars['ID'];
+};
+export declare type Swimlanes = {
+    __typename?: 'Swimlanes';
+    items: Array<SwimlaneItem>;
+    lanes: Array<Swimlane>;
+    links: Array<SwimlaneLink>;
+};
+export declare type Tenant = {
+    __typename?: 'Tenant';
+    accent_color: Scalars['String'];
+    hosted_page_title: Scalars['String'];
+    is_default: Scalars['Boolean'];
+    logo_path: Scalars['String'];
+    name: Scalars['String'];
+};
+export declare type TextFilter = {
+    contains?: InputMaybe<Scalars['String']>;
+    eq?: InputMaybe<Scalars['String']>;
+};
+export declare type TextFilterContains = {
+    contains?: InputMaybe<Scalars['String']>;
+};
+export declare type TextFilterEquals = {
+    eq?: InputMaybe<Scalars['String']>;
+};
+export declare type Track = {
+    __typename?: 'Track';
+    can_trigger_manually?: Maybe<Scalars['Boolean']>;
+    id: Scalars['ID'];
+    release_id?: Maybe<Scalars['String']>;
+    title: Scalars['String'];
+};
+export declare type TracksPayload = Payload & {
+    __typename?: 'TracksPayload';
+    code: Scalars['String'];
+    success: Scalars['Boolean'];
+    tracks: Array<Track>;
+};
+export declare type TranslatedText = {
+    __typename?: 'TranslatedText';
+    en?: Maybe<Scalars['String']>;
+};
+export declare type UpdateBaselineInfoInput = {
+    baseline_info: Array<BaselineInfoInput>;
+    pathway_id: Scalars['String'];
+};
+export declare type UpdatePatientDemographicsQueryInput = {
+    created_patient_entry_index: Scalars['Float'];
+    created_patient_id: Scalars['String'];
+    query_id: Scalars['String'];
+};
+export declare type UpdatePatientDemographicsQueryPayload = Payload & {
+    __typename?: 'UpdatePatientDemographicsQueryPayload';
+    code: Scalars['String'];
+    created_patient_entry_index: Scalars['Float'];
+    created_patient_id: Scalars['String'];
+    success: Scalars['Boolean'];
+};
+export declare type UpdatePatientInput = {
+    patient_id: Scalars['String'];
+    profile: PatientProfileInput;
+};
+export declare type UpdatePatientLanguageInput = {
+    preferred_language: Scalars['String'];
+};
+export declare type UpdatePatientLanguagePayload = Payload & {
+    __typename?: 'UpdatePatientLanguagePayload';
+    code: Scalars['String'];
+    success: Scalars['Boolean'];
+    user?: Maybe<User>;
+};
+export declare type UpdatePatientPayload = Payload & {
+    __typename?: 'UpdatePatientPayload';
+    code: Scalars['String'];
+    patient?: Maybe<User>;
+    success: Scalars['Boolean'];
+};
+export declare type User = {
+    __typename?: 'User';
+    id: Scalars['ID'];
+    profile?: Maybe<UserProfile>;
+    tenant: Tenant;
+    tenant_id: Scalars['String'];
+};
+export declare type UserPayload = Payload & {
+    __typename?: 'UserPayload';
+    code: Scalars['String'];
+    success: Scalars['Boolean'];
+    user: User;
+};
+export declare type UserProfile = {
+    __typename?: 'UserProfile';
+    address?: Maybe<Address>;
+    birth_date?: Maybe<Scalars['String']>;
+    email?: Maybe<Scalars['String']>;
+    first_name?: Maybe<Scalars['String']>;
+    last_name?: Maybe<Scalars['String']>;
+    mobile_phone?: Maybe<Scalars['String']>;
+    name?: Maybe<Scalars['String']>;
+    national_registry_number?: Maybe<Scalars['String']>;
+    patient_code?: Maybe<Scalars['String']>;
+    phone?: Maybe<Scalars['String']>;
+    preferred_language?: Maybe<Scalars['String']>;
+    sex?: Maybe<Sex>;
+};
+export declare enum UserQuestionType {
+    Date = "DATE",
+    Description = "DESCRIPTION",
+    LongText = "LONG_TEXT",
+    MultipleChoice = "MULTIPLE_CHOICE",
+    MultipleChoiceGrid = "MULTIPLE_CHOICE_GRID",
+    MultipleSelect = "MULTIPLE_SELECT",
+    Number = "NUMBER",
+    ShortText = "SHORT_TEXT",
+    Signature = "SIGNATURE",
+    Slider = "SLIDER",
+    Telephone = "TELEPHONE",
+    YesNo = "YES_NO"
+}
+export declare type WebhookCall = {
+    __typename?: 'WebhookCall';
+    created_at: Scalars['String'];
+    event_type: Scalars['String'];
+    id: Scalars['ID'];
+    pathway?: Maybe<ApiPathwayContext>;
+    request: WebhookCallRequest;
+    responses: Array<WebhookCallResponse>;
+    status: Scalars['String'];
+    webhook_id: Scalars['String'];
+    webhook_name: Scalars['String'];
+};
+export declare type WebhookCallHeader = {
+    __typename?: 'WebhookCallHeader';
+    key: Scalars['String'];
+    value: Scalars['String'];
+};
+export declare type WebhookCallPayload = Payload & {
+    __typename?: 'WebhookCallPayload';
+    code: Scalars['String'];
+    success: Scalars['Boolean'];
+    webhook_call: WebhookCall;
+};
+export declare type WebhookCallRequest = {
+    __typename?: 'WebhookCallRequest';
+    body: Scalars['String'];
+    endpoint: Scalars['String'];
+    headers: Array<WebhookCallHeader>;
+    method: Scalars['String'];
+};
+export declare type WebhookCallResponse = {
+    __typename?: 'WebhookCallResponse';
+    body: Scalars['String'];
+    date: Scalars['String'];
+    status: Scalars['Float'];
+};
+export declare type WebhookCallsPayload = Payload & {
+    __typename?: 'WebhookCallsPayload';
+    code: Scalars['String'];
+    success: Scalars['Boolean'];
+    webhook_calls: Array<WebhookCall>;
+};