@icanbwell/bwell-sdk-ts 0.1.2 → 0.2.0

package/dist/graphql/schema.d.ts

@@ -0,0 +1,3542 @@
+/********************************************************************************
+ *
+ * This file was generated by graphql-codegen. We do not track this file in source
+ * control.
+ * @see https://the-guild.dev/graphql/codegen/docs/config-reference/codegen-config
+ *
+ * Do not edit this file. If changes to the GraphQL Schema, queries, or mutations,
+ * they will need to be made in the "graphql" directory at the root of the directory.
+ *
+ * Please keep in mind that all SDK libraries generate code base on the graphql files
+ * so making changes will not just affect the TypesScript SDK.
+ *
+ ********************************************************************************
+ */
+export type Maybe<T> = T | null;
+export type InputMaybe<T> = Maybe<T>;
+export type Exact<T extends {
+    [key: string]: unknown;
+}> = {
+    [K in keyof T]: T[K];
+};
+export type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]?: Maybe<T[SubKey]>;
+};
+export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]: Maybe<T[SubKey]>;
+};
+export type MakeEmpty<T extends {
+    [key: string]: unknown;
+}, K extends keyof T> = {
+    [_ in K]?: never;
+};
+export type Incremental<T> = T | {
+    [P in keyof T]?: P extends ' $fragmentName' | '__typename' ? T[P] : never;
+};
+/** All built-in and custom scalars, mapped to their actual values */
+export type Scalars = {
+    ID: {
+        input: string;
+        output: string;
+    };
+    String: {
+        input: string;
+        output: string;
+    };
+    Boolean: {
+        input: boolean;
+        output: boolean;
+    };
+    Int: {
+        input: number;
+        output: number;
+    };
+    Float: {
+        input: number;
+        output: number;
+    };
+    CODE: {
+        input: any;
+        output: any;
+    };
+    /**
+     * A custom scalar type for search strings, used for string-based search parameters.
+     * scalar SearchString
+     */
+    Date: {
+        input: any;
+        output: any;
+    };
+    /** A date-time string at UTC, such as 2019-12-03T09:54:33Z, compliant with the date-time format. */
+    DateTime: {
+        input: any;
+        output: any;
+    };
+    Error: {
+        input: any;
+        output: any;
+    };
+    Expression: {
+        input: any;
+        output: any;
+    };
+    JSON: {
+        input: any;
+        output: any;
+    };
+    OperationOutcome: {
+        input: any;
+        output: any;
+    };
+    QuestionnaireItemAnswer: {
+        input: any;
+        output: any;
+    };
+    QuestionnaireResponseData: {
+        input: any;
+        output: any;
+    };
+    Time: {
+        input: any;
+        output: any;
+    };
+    /** A custom scalar that handles URI values */
+    URI: {
+        input: any;
+        output: any;
+    };
+    URL: {
+        input: any;
+        output: any;
+    };
+    Uri: {
+        input: any;
+        output: any;
+    };
+    Void: {
+        input: any;
+        output: any;
+    };
+    base64Binary: {
+        input: any;
+        output: any;
+    };
+    canonical: {
+        input: any;
+        output: any;
+    };
+    code: {
+        input: any;
+        output: any;
+    };
+    consentProvision: {
+        input: any;
+        output: any;
+    };
+    /** Represents a string date value in YYYY-MM-DD format */
+    date: {
+        input: any;
+        output: any;
+    };
+    dateTime: {
+        input: any;
+        output: any;
+    };
+    id: {
+        input: any;
+        output: any;
+    };
+    instant: {
+        input: any;
+        output: any;
+    };
+    reference: {
+        input: any;
+        output: any;
+    };
+    schemaProperties: {
+        input: any;
+        output: any;
+    };
+    time: {
+        input: any;
+        output: any;
+    };
+    uiSchema: {
+        input: any;
+        output: any;
+    };
+    uri: {
+        input: any;
+        output: any;
+    };
+    url: {
+        input: any;
+        output: any;
+    };
+};
+export type Activity = {
+    __typename?: 'Activity';
+    detail?: Maybe<Detail>;
+};
+/** Union type for the performer actor which can be a Practitioner or Organization or Patient */
+export type Actor = Organization | Patient | Practitioner;
+export type Address = {
+    __typename?: 'Address';
+    city?: Maybe<Scalars['String']['output']>;
+    country?: Maybe<Scalars['String']['output']>;
+    district?: Maybe<Scalars['String']['output']>;
+    line?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+    postalCode?: Maybe<Scalars['String']['output']>;
+    state?: Maybe<Scalars['String']['output']>;
+    /** Can define enum */
+    text?: Maybe<Scalars['String']['output']>;
+    /** Can define enum */
+    type?: Maybe<Scalars['String']['output']>;
+    /** Follows https://www.hl7.org/fhir/datatypes.html#Address */
+    use?: Maybe<Scalars['String']['output']>;
+};
+export type AddressInput = {
+    city?: InputMaybe<Scalars['String']['input']>;
+    country?: InputMaybe<Scalars['String']['input']>;
+    district?: InputMaybe<Scalars['String']['input']>;
+    extension?: InputMaybe<Array<InputMaybe<ExtensionInput>>>;
+    id?: InputMaybe<Scalars['String']['input']>;
+    line?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
+    postalCode?: InputMaybe<Scalars['String']['input']>;
+    state?: InputMaybe<Scalars['String']['input']>;
+    /** Can define enum */
+    text?: InputMaybe<Scalars['String']['input']>;
+    /** Can define enum */
+    type?: InputMaybe<Scalars['String']['input']>;
+    use?: InputMaybe<Scalars['String']['input']>;
+};
+export declare enum AddressType {
+    Both = "both",
+    Physical = "physical",
+    /** Follows https://www.hl7.org/fhir/valueset-address-type.html */
+    Postal = "postal"
+}
+export declare enum AddressUse {
+    Billing = "billing",
+    /** Follows https://www.hl7.org/fhir/valueset-address-use.html */
+    Home = "home",
+    Old = "old",
+    Temp = "temp",
+    Work = "work"
+}
+export type AllergyIntoleranceGroup = ResourceGroup & {
+    __typename?: 'AllergyIntoleranceGroup';
+    /** Coding representing the kind of allergy intolerances in this composition */
+    coding?: Maybe<Coding>;
+    /** The most recent recorded Allergy criticality code */
+    criticality?: Maybe<Code>;
+    id?: Maybe<Scalars['ID']['output']>;
+    /** Human readable name of the allergy intolerance */
+    name?: Maybe<Scalars['String']['output']>;
+    /** Date first version of the resource instance was recorded */
+    recordedDate?: Maybe<Scalars['DateTime']['output']>;
+    /** Array of AllergyIntolerance id references in the Composition */
+    references?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+    /** Array of Strings representing the source of the data */
+    source?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+};
+export type AllergyIntoleranceGroupQueryRequest = {
+    page?: InputMaybe<Scalars['Int']['input']>;
+    pageSize?: InputMaybe<Scalars['Int']['input']>;
+};
+export type AllergyIntoleranceGroupQueryResults = PagedQueryResults & {
+    __typename?: 'AllergyIntoleranceGroupQueryResults';
+    paging_info?: Maybe<PagingResults>;
+    /** A list of AllergyIntoleranceGroup resources that match the criteria */
+    resources: Array<AllergyIntoleranceGroup>;
+};
+export type AllergyIntoleranceQueryResults = PagedQueryResults & {
+    __typename?: 'AllergyIntoleranceQueryResults';
+    paging_info?: Maybe<PagingResults>;
+    /** A list of AllergyIntolerance resources that meet the search criteria. */
+    resources: Array<AllergyIntoleranceResource>;
+};
+/** The AllergyIntolerance resource type contains details about an allergy or intolerance event. */
+export type AllergyIntoleranceResource = {
+    __typename?: 'AllergyIntoleranceResource';
+    /** Category of the event (e.g., food, medication). */
+    category?: Maybe<Array<Maybe<Code>>>;
+    /** The clinical status of the allergy or intolerance. */
+    clinicalStatus?: Maybe<CodeableConcept>;
+    /** Code that identifies the substance. */
+    code?: Maybe<CodeableConcept>;
+    /** Estimate of the potential clinical harm, or seriousness, of a reaction to an identified substance. */
+    criticality?: Maybe<Code>;
+    /** Unique identifier for the AllergyIntolerance resource. */
+    id: Scalars['ID']['output'];
+    /** Date and time of the last occurrence. */
+    lastOccurrence?: Maybe<Scalars['DateTime']['output']>;
+    /** Metadata about the resource (e.g., tags, security). */
+    meta?: Maybe<Meta>;
+    /** Notes about the allergy intolerance that aren't captured in other fields. */
+    note?: Maybe<Array<Maybe<Annotation>>>;
+    /** Date and time of the onset of the AllergyIntolerance. */
+    onsetDateTime?: Maybe<Scalars['DateTime']['output']>;
+    /** Period over which the AllergyIntolerance was observed. */
+    onsetPeriod?: Maybe<Period>;
+    /** Details about each adverse reaction event. */
+    reaction?: Maybe<Array<Maybe<Reaction>>>;
+    /** Date first version of the resource instance was recorded */
+    recordedDate?: Maybe<Scalars['DateTime']['output']>;
+    /** Assertion about certainty associated with the propensity, or potential risk, of a reaction to the identified substance (including pharmaceutical product). */
+    verificationStatus?: Maybe<CodeableConcept>;
+};
+export type AllergyIntoleranceResponse = AllergyIntoleranceResource;
+export type AllergyIntolerancesRequest = {
+    groupCode?: InputMaybe<SearchToken>;
+    ids?: InputMaybe<Array<Scalars['String']['input']>>;
+    lastUpdated?: InputMaybe<SearchDate>;
+    page?: InputMaybe<Scalars['Int']['input']>;
+    pageSize?: InputMaybe<Scalars['Int']['input']>;
+};
+export type Analytics = {
+    __typename?: 'Analytics';
+    mixPanel: Array<MixPanel>;
+};
+export type Annotation = {
+    __typename?: 'Annotation';
+    /** The name of the person making the annotation. */
+    authorString?: Maybe<Scalars['String']['output']>;
+    /** The content of the annotation. */
+    text?: Maybe<Scalars['String']['output']>;
+    /** The date and time the annotation was made. */
+    time?: Maybe<Scalars['DateTime']['output']>;
+};
+export type AnyResource = Consent;
+export type ApiMap = {
+    __typename?: 'ApiMap';
+    accessToCare: Scalars['String']['output'];
+    config: Scalars['String']['output'];
+    consent: Scalars['String']['output'];
+    default: Scalars['String']['output'];
+    enterprisePerson: Scalars['String']['output'];
+    healthCircle: Scalars['String']['output'];
+    hpTask: Scalars['String']['output'];
+    identityGateway: Scalars['String']['output'];
+    pss: Scalars['String']['output'];
+    rest: Rest;
+    user: Scalars['String']['output'];
+};
+export type Attachment = {
+    __typename?: 'Attachment';
+    contentType?: Maybe<Scalars['String']['output']>;
+    title?: Maybe<Scalars['String']['output']>;
+    url?: Maybe<Scalars['String']['output']>;
+};
+export type AttachmentInput = {
+    contentType?: InputMaybe<Scalars['code']['input']>;
+    creation?: InputMaybe<Scalars['DateTime']['input']>;
+    data?: InputMaybe<Scalars['base64Binary']['input']>;
+    extension?: InputMaybe<Array<InputMaybe<ExtensionInput>>>;
+    hash?: InputMaybe<Scalars['base64Binary']['input']>;
+    id: Scalars['String']['input'];
+    language?: InputMaybe<Scalars['String']['input']>;
+    size?: InputMaybe<Scalars['Int']['input']>;
+    title?: InputMaybe<Scalars['String']['input']>;
+    url?: InputMaybe<Scalars['url']['input']>;
+};
+export type AuthTokens = {
+    __typename?: 'AuthTokens';
+    accessToken: TokenPayload;
+    idToken: TokenPayload;
+    refreshToken: RefreshPayload;
+};
+export type BootstrapConfiguration = {
+    __typename?: 'BootstrapConfiguration';
+    apertureProxyPageUrl: Scalars['String']['output'];
+    apiMap: ApiMap;
+    app: Scalars['String']['output'];
+    awsCognitoClientId: Scalars['String']['output'];
+    awsCognitoRegion: Scalars['String']['output'];
+    awsCognitoUserPoolId: Scalars['String']['output'];
+    baseUrl: Scalars['String']['output'];
+    client: Scalars['String']['output'];
+    clientSlug: Scalars['String']['output'];
+    embeddableConfiguration: EmbeddableConfiguration;
+    environment: Scalars['String']['output'];
+    featureFlagConfiguration: FeatureFlagConfiguration;
+    frontendEnvironment: FrontendEnvironment;
+    googleGeo: GoogleGeo;
+    jwksKid: Scalars['String']['output'];
+    userProfileSvcUrl: Scalars['String']['output'];
+    zendesk: Zendesk;
+};
+export type Bundle = {
+    __typename?: 'Bundle';
+    entry?: Maybe<Array<Maybe<BundleEntry>>>;
+    identifier?: Maybe<Identifier>;
+    link?: Maybe<Array<Maybe<BundleLink>>>;
+    timestamp?: Maybe<Scalars['dateTime']['output']>;
+    total?: Maybe<Scalars['Int']['output']>;
+    type: BundleType;
+};
+export type BundleEntry = {
+    __typename?: 'BundleEntry';
+    fullUrl?: Maybe<Scalars['uri']['output']>;
+    link?: Maybe<Array<Maybe<BundleLink>>>;
+    resource?: Maybe<AnyResource>;
+};
+export type BundleLink = {
+    __typename?: 'BundleLink';
+    relation?: Maybe<Scalars['String']['output']>;
+    url?: Maybe<Scalars['uri']['output']>;
+};
+export declare enum BundleType {
+    Batch = "BATCH",
+    BatchResponse = "BATCH_RESPONSE",
+    Collection = "COLLECTION",
+    Document = "DOCUMENT",
+    History = "HISTORY",
+    Message = "MESSAGE",
+    Searchset = "SEARCHSET",
+    Transaction = "TRANSACTION",
+    TransactionResponse = "TRANSACTION_RESPONSE"
+}
+export type Cache = {
+    __typename?: 'Cache';
+    maxSizeBytes: Scalars['Float']['output'];
+};
+export type CarePlanGroup = ResourceGroup & {
+    __typename?: 'CarePlanGroup';
+    /** Coding representing the kind of care plans in this composition */
+    coding?: Maybe<Coding>;
+    id?: Maybe<Scalars['ID']['output']>;
+    /** Human readable name of the care plan */
+    name?: Maybe<Scalars['String']['output']>;
+    /** A time period with a defined start and end date and time. */
+    period?: Maybe<Period>;
+    /** Array of CarePlan id references in the Composition */
+    references?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+    /** Array of Strings representing the source of the data */
+    source?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+};
+export type CarePlanGroupQueryRequest = {
+    page?: InputMaybe<Scalars['Int']['input']>;
+    pageSize?: InputMaybe<Scalars['Int']['input']>;
+};
+export type CarePlanGroupQueryResults = PagedQueryResults & {
+    __typename?: 'CarePlanGroupQueryResults';
+    paging_info?: Maybe<PagingResults>;
+    resources: Array<CarePlanGroup>;
+};
+export type CarePlanQueryResults = PagedQueryResults & {
+    __typename?: 'CarePlanQueryResults';
+    paging_info?: Maybe<PagingResults>;
+    resources: Array<CarePlanResource>;
+};
+/** Input type defining the parameters that can be used when querying for CarePlan resources. */
+export type CarePlanRequest = {
+    groupCode?: InputMaybe<SearchToken>;
+    ids?: InputMaybe<Array<Scalars['String']['input']>>;
+    lastUpdated?: InputMaybe<SearchDate>;
+    page?: InputMaybe<Scalars['Int']['input']>;
+    pageSize?: InputMaybe<Scalars['Int']['input']>;
+};
+/** The actual CarePlan resource type which contains detailed information about healthcare planning. */
+export type CarePlanResource = {
+    __typename?: 'CarePlanResource';
+    /** Action to occur as part of plan */
+    activity?: Maybe<Array<Maybe<Activity>>>;
+    /** Categories or types of care plans. */
+    category?: Maybe<Array<Maybe<CodeableConcept>>>;
+    /** Date record was first recorded */
+    created?: Maybe<Scalars['DateTime']['output']>;
+    /** The unique identifier for this CarePlan resource. */
+    id: Scalars['ID']['output'];
+    /** Indicates the intent of the CarePlan (e.g., proposal, plan). */
+    intent?: Maybe<Code>;
+    /** Meta information about the CarePlan, like version, tags, etc. */
+    meta?: Maybe<Meta>;
+    /** Comments about the plan */
+    note?: Maybe<Array<Maybe<Annotation>>>;
+    /** The time period the CarePlan covers. */
+    period?: Maybe<Period>;
+    /** The current status of the CarePlan (e.g., active, completed). */
+    status?: Maybe<Code>;
+    /** The patient or group for whom the CarePlan is maintained. */
+    subject?: Maybe<Subject>;
+    /** The human-readable title of the CarePlan. */
+    title?: Maybe<Scalars['String']['output']>;
+};
+export declare enum CategoryCode {
+    DataSharing = "DATA_SHARING",
+    HealthCircleAdolescent = "HEALTH_CIRCLE_ADOLESCENT",
+    HealthCircleMinor = "HEALTH_CIRCLE_MINOR",
+    MobileCommunicationPreferences = "MOBILE_COMMUNICATION_PREFERENCES",
+    PersonalizedHealthOffersAndAds = "PERSONALIZED_HEALTH_OFFERS_AND_ADS",
+    ProaAttestation = "PROA_ATTESTATION",
+    Tos = "TOS"
+}
+export type Client = {
+    config?: InputMaybe<Scalars['String']['input']>;
+    data_sets?: InputMaybe<Array<InputMaybe<DataSets>>>;
+    id?: InputMaybe<ClientId>;
+    name?: InputMaybe<Scalars['String']['input']>;
+    version?: Scalars['Float']['input'];
+};
+export declare enum ClientId {
+    Proa = "proa",
+    Samsung = "samsung"
+}
+export type ClientSlugAndIdentifierInput = {
+    addBwellPatientIfMissing?: InputMaybe<Scalars['Boolean']['input']>;
+    clientSlug: Scalars['String']['input'];
+    identifier: Scalars['String']['input'];
+};
+/** Object containing a FHIR `code` and its corresponding display value */
+export type Code = {
+    __typename?: 'Code';
+    code?: Maybe<Scalars['String']['output']>;
+    display?: Maybe<Scalars['String']['output']>;
+};
+/** Represents concept of code system */
+export type CodeSystemCodeConcept = {
+    __typename?: 'CodeSystemCodeConcept';
+    /** Code that identifies concept */
+    code?: Maybe<Scalars['String']['output']>;
+    /** Text to display to the user */
+    display?: Maybe<Scalars['String']['output']>;
+    /** Property value for the concept */
+    property?: Maybe<Array<CodeSystemProperty>>;
+};
+/** A representation of CodeSystemCodes resource */
+export type CodeSystemCodeResource = {
+    __typename?: 'CodeSystemCodeResource';
+    /** Concepts in the code system */
+    concept?: Maybe<Array<CodeSystemCodeConcept>>;
+    /** Unique identifier of the code system resource */
+    id: Scalars['ID']['output'];
+};
+/** Represents property value of code system */
+export type CodeSystemProperty = {
+    __typename?: 'CodeSystemProperty';
+    /** Reference to CodeSystem.property.code */
+    code?: Maybe<Scalars['String']['output']>;
+    /** Value of the property for the concept */
+    valueString?: Maybe<Scalars['String']['output']>;
+};
+/** A structured set of codes including a text representation. */
+export type CodeableConcept = {
+    __typename?: 'CodeableConcept';
+    /** Follows https://www.hl7.org/fhir/datatypes-definitions.html#CodeableConcept */
+    coding?: Maybe<Array<Maybe<Coding>>>;
+    /** A human-readable representation of the codeable concept. */
+    text?: Maybe<Scalars['String']['output']>;
+};
+/** A structured set of codes including a text representation. */
+export type CodeableConceptInput = {
+    /** List of codings (codes from a coding system). */
+    coding?: InputMaybe<Array<InputMaybe<CodingInput>>>;
+    /** A human-readable representation of the codeable concept. */
+    text?: InputMaybe<Scalars['String']['input']>;
+};
+export type CodeableConcept_Input = {
+    coding?: InputMaybe<Array<InputMaybe<Coding_Input>>>;
+    extension?: InputMaybe<Array<InputMaybe<Extension_Input>>>;
+    id?: InputMaybe<Scalars['String']['input']>;
+    text?: InputMaybe<Scalars['String']['input']>;
+};
+/** A single coding from a coding system. */
+export type Coding = {
+    __typename?: 'Coding';
+    /** Follows https://www.hl7.org/fhir/datatypes.html#Coding */
+    code?: Maybe<Scalars['String']['output']>;
+    /** The human-readable display name for the code. */
+    display?: Maybe<Scalars['String']['output']>;
+    /** The system the code is taken from (e.g., ICD-10). */
+    system?: Maybe<Scalars['String']['output']>;
+};
+/** A single coding from a coding system. */
+export type CodingInput = {
+    /** The actual code from the system. */
+    code?: InputMaybe<Scalars['String']['input']>;
+    /** The human-readable display name for the code. */
+    display?: InputMaybe<Scalars['String']['input']>;
+    /** The system the code is taken from (e.g., ICD-10). */
+    system?: InputMaybe<Scalars['String']['input']>;
+};
+export type Coding_Input = {
+    code?: InputMaybe<Scalars['code']['input']>;
+    display?: InputMaybe<Scalars['String']['input']>;
+    extension?: InputMaybe<Array<InputMaybe<Extension_Input>>>;
+    id?: InputMaybe<Scalars['String']['input']>;
+    system?: InputMaybe<Scalars['uri']['input']>;
+    userSelected?: InputMaybe<Scalars['Boolean']['input']>;
+    version?: InputMaybe<Scalars['String']['input']>;
+};
+export type Component = {
+    __typename?: 'Component';
+    /** The code that categorizes the observation. */
+    code?: Maybe<CodeableConcept>;
+    /** The interpretation of the observation results. */
+    interpretation?: Maybe<Array<Maybe<CodeableConcept>>>;
+    /** Reference ranges for interpreting the observation value. */
+    referenceRange?: Maybe<Array<Maybe<ReferenceRange>>>;
+    /** Various types of values that an Observation can have, only one of these would typically be populated. */
+    value?: Maybe<Value>;
+};
+export type ConditionGroup = ResourceGroup & {
+    __typename?: 'ConditionGroup';
+    /** Coding representing the kind of Conditions in this composition */
+    coding?: Maybe<Coding>;
+    id?: Maybe<Scalars['ID']['output']>;
+    /** Human readable name of the Condition */
+    name?: Maybe<Scalars['String']['output']>;
+    /** Date first version of the resource instance was recorded */
+    recordedDate?: Maybe<Scalars['DateTime']['output']>;
+    /** Array of Condition id references in the Composition */
+    references?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+    /** Array of Strings representing the source of the data */
+    source?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+};
+export type ConditionGroupQueryRequest = {
+    page?: InputMaybe<Scalars['Int']['input']>;
+    pageSize?: InputMaybe<Scalars['Int']['input']>;
+};
+export type ConditionGroupQueryResults = PagedQueryResults & {
+    __typename?: 'ConditionGroupQueryResults';
+    paging_info?: Maybe<PagingResults>;
+    resources: Array<ConditionGroup>;
+};
+export type ConditionQueryResults = PagedQueryResults & {
+    __typename?: 'ConditionQueryResults';
+    paging_info?: Maybe<PagingResults>;
+    resources: Array<ConditionResource>;
+};
+/** Input type for querying Condition resources */
+export type ConditionRequest = {
+    /** Filters conditions based on code */
+    groupCode?: InputMaybe<SearchToken>;
+    ids?: InputMaybe<Array<Scalars['String']['input']>>;
+    /** Filters based on the meta.lastUpdated date of the resource */
+    lastUpdated?: InputMaybe<SearchDate>;
+    /** Page offset */
+    page?: InputMaybe<Scalars['Int']['input']>;
+    /** Count of procedure in one page */
+    pageSize?: InputMaybe<Scalars['Int']['input']>;
+};
+/** A FHIR Condition resource representing a health condition */
+export type ConditionResource = {
+    __typename?: 'ConditionResource';
+    /** The date/time at which the condition resolved or abated, expressed as a string */
+    abatementDateTime?: Maybe<Scalars['DateTime']['output']>;
+    /** The time period over which the abatement occurred */
+    abatementPeriod?: Maybe<Period>;
+    /** A reference to the practitioner involved. */
+    asserter?: Maybe<Practitioner>;
+    /** Anatomical location of the condition. */
+    bodySite?: Maybe<Array<Maybe<CodeableConcept>>>;
+    /** The category of the condition (problem-list item, encounter-diagnosis) */
+    category?: Maybe<Array<Maybe<CodeableConcept>>>;
+    /** The clinical status of the condition (active, remission, etc.) */
+    clinicalStatus?: Maybe<CodeableConcept>;
+    /** The code that identifies the condition (diagnosis, symptom, etc.) */
+    code?: Maybe<CodeableConcept>;
+    /** The unique identifier for this Condition resource */
+    id: Scalars['ID']['output'];
+    /** Meta information about the Condition, like version, tags, etc. */
+    meta?: Maybe<Meta>;
+    /** Any notes or comments about the condition */
+    note?: Maybe<Array<Maybe<Annotation>>>;
+    /** The date/time when the condition began, expressed as a string */
+    onsetDateTime?: Maybe<Scalars['DateTime']['output']>;
+    /** The time period over which the onset occurred */
+    onsetPeriod?: Maybe<Period>;
+    /** The date/time when the condition was first recorded */
+    recordedDate?: Maybe<Scalars['DateTime']['output']>;
+    /** Who recorded the condition */
+    recorder?: Maybe<Recorder>;
+    /** A subjective assessment of the severity of the condition */
+    severity?: Maybe<CodeableConcept>;
+    /** The patient who has the condition */
+    subject?: Maybe<Patient>;
+    /** The verification status to support the clinical status of the condition */
+    verificationStatus?: Maybe<CodeableConcept>;
+};
+export type Connection = {
+    __typename?: 'Connection';
+    category: ConnectionCategory;
+    created: Scalars['DateTime']['output'];
+    id: Scalars['String']['output'];
+    isDirect: Scalars['Boolean']['output'];
+    lastSynced?: Maybe<Scalars['DateTime']['output']>;
+    name: Scalars['String']['output'];
+    status?: Maybe<DataConnectionStatus>;
+    statusUpdated?: Maybe<Scalars['DateTime']['output']>;
+    syncErrors?: Maybe<Array<Coding>>;
+    syncStatus?: Maybe<SyncStatus>;
+    type: DataConnectionType;
+};
+export declare enum ConnectionCategory {
+    Basic = "BASIC",
+    Oauth = "OAUTH"
+}
+export type ConnectionStatusUpdate = {
+    __typename?: 'ConnectionStatusUpdate';
+    status?: Maybe<DataConnectionStatus>;
+    statusUpdated: Scalars['DateTime']['output'];
+};
+export type Consent = DomainResource & Resource & {
+    __typename?: 'Consent';
+    category?: Maybe<Array<CodeableConcept>>;
+    contained?: Maybe<Array<Maybe<Resource>>>;
+    dateTime?: Maybe<Scalars['dateTime']['output']>;
+    extension?: Maybe<Array<Maybe<Extension>>>;
+    id?: Maybe<Scalars['String']['output']>;
+    identifier?: Maybe<Array<Maybe<Identifier>>>;
+    implicitRules?: Maybe<Scalars['String']['output']>;
+    language?: Maybe<Scalars['String']['output']>;
+    meta?: Maybe<Meta>;
+    modifierExtension?: Maybe<Array<Maybe<Extension>>>;
+    organization?: Maybe<Array<Maybe<Reference>>>;
+    patient?: Maybe<Reference>;
+    performer?: Maybe<Array<Maybe<Reference>>>;
+    policy?: Maybe<Array<Maybe<ConsentPolicy>>>;
+    policyRule?: Maybe<CodeableConcept>;
+    provision?: Maybe<ConsentProvision>;
+    resourceType: Scalars['String']['output'];
+    scope: CodeableConcept;
+    source?: Maybe<ConsentSource>;
+    status: Scalars['code']['output'];
+    text?: Maybe<Scalars['String']['output']>;
+    verification?: Maybe<Array<Maybe<ConsentVerification>>>;
+};
+export type ConsentActor = {
+    __typename?: 'ConsentActor';
+    reference?: Maybe<Scalars['reference']['output']>;
+    role?: Maybe<CodeableConcept>;
+};
+export type ConsentActorInput = {
+    reference?: InputMaybe<Scalars['reference']['input']>;
+    role?: InputMaybe<CodeableConceptInput>;
+};
+export type ConsentBundle = {
+    __typename?: 'ConsentBundle';
+    entry?: Maybe<Array<Maybe<ConsentBundleEntry>>>;
+    identifier?: Maybe<Identifier>;
+    link?: Maybe<Array<Maybe<BundleLink>>>;
+    timestamp?: Maybe<Scalars['dateTime']['output']>;
+    total?: Maybe<Scalars['Int']['output']>;
+    type: BundleType;
+};
+export type ConsentBundleEntry = {
+    __typename?: 'ConsentBundleEntry';
+    fullUrl?: Maybe<Scalars['uri']['output']>;
+    link?: Maybe<Array<Maybe<BundleLink>>>;
+    resource?: Maybe<Consent>;
+};
+export type ConsentData = {
+    __typename?: 'ConsentData';
+    meaning: Scalars['code']['output'];
+    reference: Scalars['reference']['output'];
+};
+export type ConsentDataInput = {
+    meaning: Scalars['code']['input'];
+    reference: Scalars['reference']['input'];
+};
+export type ConsentInput = {
+    category?: InputMaybe<Array<CodeableConceptInput>>;
+    dateTime?: InputMaybe<Scalars['dateTime']['input']>;
+    id?: InputMaybe<Scalars['String']['input']>;
+    identifier?: InputMaybe<Array<InputMaybe<IdentifierInput>>>;
+    organization?: InputMaybe<Array<InputMaybe<Consent_ReferenceInput>>>;
+    patient?: InputMaybe<Consent_ReferenceInput>;
+    performer?: InputMaybe<Array<InputMaybe<Consent_ReferenceInput>>>;
+    policy?: InputMaybe<Array<InputMaybe<ConsentPolicyInput>>>;
+    policyRule?: InputMaybe<CodeableConceptInput>;
+    provision: ConsentProvisionInput;
+    source?: InputMaybe<ConsentSourceInput>;
+    status: ConsentStatus;
+    verification?: InputMaybe<Array<InputMaybe<ConsentVerificationInput>>>;
+};
+export type ConsentPolicy = {
+    __typename?: 'ConsentPolicy';
+    authority?: Maybe<Scalars['uri']['output']>;
+    uri?: Maybe<Scalars['uri']['output']>;
+};
+export type ConsentPolicyInput = {
+    authority?: InputMaybe<Scalars['uri']['input']>;
+    uri?: InputMaybe<Scalars['uri']['input']>;
+};
+export type ConsentProvision = {
+    __typename?: 'ConsentProvision';
+    action?: Maybe<Array<Maybe<CodeableConcept>>>;
+    actor?: Maybe<Array<Maybe<ConsentActor>>>;
+    class?: Maybe<Array<Maybe<Coding>>>;
+    code?: Maybe<Array<Maybe<CodeableConcept>>>;
+    data?: Maybe<Array<Maybe<ConsentData>>>;
+    dataPeriod?: Maybe<Period>;
+    period?: Maybe<Period>;
+    provision?: Maybe<Array<Maybe<ConsentProvision>>>;
+    purpose?: Maybe<Array<Maybe<Coding>>>;
+    securityLabel?: Maybe<Array<Maybe<Coding>>>;
+    type?: Maybe<ConsentProvisionType>;
+};
+export type ConsentProvisionInput = {
+    action?: InputMaybe<Array<InputMaybe<CodeableConceptInput>>>;
+    actor?: InputMaybe<Array<InputMaybe<ConsentActorInput>>>;
+    class?: InputMaybe<Array<InputMaybe<CodingInput>>>;
+    code?: InputMaybe<Array<InputMaybe<CodeableConceptInput>>>;
+    data?: InputMaybe<Array<InputMaybe<ConsentDataInput>>>;
+    dataPeriod?: InputMaybe<Consent_PeriodInput>;
+    period?: InputMaybe<Consent_PeriodInput>;
+    provision?: InputMaybe<Array<InputMaybe<ConsentProvisionInput>>>;
+    purpose?: InputMaybe<Array<InputMaybe<CodingInput>>>;
+    securityLabel?: InputMaybe<Array<InputMaybe<CodingInput>>>;
+    type?: InputMaybe<ConsentProvisionType>;
+};
+export declare enum ConsentProvisionType {
+    Deny = "DENY",
+    Permit = "PERMIT"
+}
+export type ConsentSearch = {
+    category?: InputMaybe<CategoryCode>;
+    patientId?: InputMaybe<Scalars['String']['input']>;
+};
+export type ConsentSource = {
+    __typename?: 'ConsentSource';
+    sourceAttachment?: Maybe<Attachment>;
+    sourceReference?: Maybe<Scalars['reference']['output']>;
+};
+export type ConsentSourceInput = {
+    sourceAttachment?: InputMaybe<Consent_AttachmentInput>;
+    sourceReference?: InputMaybe<Scalars['reference']['input']>;
+};
+export declare enum ConsentStatus {
+    Active = "ACTIVE",
+    Draft = "DRAFT",
+    EnteredInError = "ENTERED_IN_ERROR",
+    Inactive = "INACTIVE",
+    Proposed = "PROPOSED",
+    Rejected = "REJECTED"
+}
+export type ConsentVerification = {
+    __typename?: 'ConsentVerification';
+    verificationDate?: Maybe<Scalars['dateTime']['output']>;
+    verified: Scalars['Boolean']['output'];
+    verifiedWith?: Maybe<Scalars['reference']['output']>;
+};
+export type ConsentVerificationInput = {
+    verificationDate?: InputMaybe<Scalars['dateTime']['input']>;
+    verified: Scalars['Boolean']['input'];
+    verifiedWith?: InputMaybe<Scalars['reference']['input']>;
+};
+export type Consent_AttachmentInput = {
+    contentType?: InputMaybe<Scalars['String']['input']>;
+    creation?: InputMaybe<Scalars['String']['input']>;
+    data?: InputMaybe<Scalars['String']['input']>;
+    duration?: InputMaybe<Scalars['Float']['input']>;
+    frames?: InputMaybe<Scalars['Int']['input']>;
+    hash?: InputMaybe<Scalars['String']['input']>;
+    height?: InputMaybe<Scalars['Int']['input']>;
+    language?: InputMaybe<Scalars['String']['input']>;
+    pages?: InputMaybe<Scalars['Int']['input']>;
+    size?: InputMaybe<Scalars['Float']['input']>;
+    title?: InputMaybe<Scalars['String']['input']>;
+    url?: InputMaybe<Scalars['String']['input']>;
+    width?: InputMaybe<Scalars['Int']['input']>;
+};
+export type Consent_PeriodInput = {
+    end?: InputMaybe<Scalars['DateTime']['input']>;
+    start?: InputMaybe<Scalars['DateTime']['input']>;
+};
+export type Consent_ReferenceInput = {
+    display?: InputMaybe<Scalars['String']['input']>;
+    identifier?: InputMaybe<IdentifierInput>;
+    reference?: InputMaybe<Scalars['String']['input']>;
+    type?: InputMaybe<Scalars['String']['input']>;
+};
+export type ContactPoint = {
+    __typename?: 'ContactPoint';
+    /** Can define enum */
+    rank?: Maybe<Scalars['Int']['output']>;
+    /** Follows https://www.hl7.org/fhir/datatypes.html#ContactPoint */
+    system?: Maybe<Scalars['String']['output']>;
+    use?: Maybe<Scalars['String']['output']>;
+    /** Can define enum */
+    value?: Maybe<Scalars['String']['output']>;
+};
+export type ContactPointInput = {
+    extension?: InputMaybe<Array<InputMaybe<ExtensionInput>>>;
+    id?: InputMaybe<Scalars['String']['input']>;
+    /** Can define enum */
+    rank?: InputMaybe<Scalars['Int']['input']>;
+    system?: InputMaybe<Scalars['String']['input']>;
+    use?: InputMaybe<Scalars['String']['input']>;
+    /** Can define enum */
+    value?: InputMaybe<Scalars['String']['input']>;
+};
+/** Supported ISO 4217 CurrencyCodes */
+export declare enum CurrencyCode {
+    Usd = "USD"
+}
+export declare enum DataConnectionStatus {
+    Connected = "CONNECTED",
+    Deleted = "DELETED",
+    Disconnected = "DISCONNECTED",
+    Error = "ERROR",
+    Expired = "EXPIRED"
+}
+export declare enum DataConnectionType {
+    Clinical = "CLINICAL",
+    Insurance = "INSURANCE",
+    Lab = "LAB",
+    Practitioner = "PRACTITIONER"
+}
+export declare enum DataSets {
+    Connecthub = "connecthub",
+    Nppes = "nppes"
+}
+export type DataSource = {
+    __typename?: 'DataSource';
+    category: ConnectionCategory;
+    id: Scalars['String']['output'];
+    isDirect: Scalars['Boolean']['output'];
+    name: Scalars['String']['output'];
+    type: DataConnectionType;
+};
+/** Input type defining a filter based on date values. */
+export type DateFilterInput = {
+    /** Array of date filters to apply. */
+    values?: InputMaybe<Array<InputMaybe<DateFilterValue>>>;
+};
+/** Input type representing the value for a date filter. */
+export type DateFilterValue = {
+    /** Start date for the filter, inclusive. */
+    greaterThanOrEqualTo?: InputMaybe<Scalars['Date']['input']>;
+    /** End date for the filter, inclusive. */
+    lessThanOrEqualTo?: InputMaybe<Scalars['Date']['input']>;
+};
+export type Detail = {
+    __typename?: 'Detail';
+    code?: Maybe<CodeableConcept>;
+    kind?: Maybe<Code>;
+    scheduledPeriod?: Maybe<Period>;
+    scheduledString?: Maybe<Scalars['String']['output']>;
+    scheduledTiming?: Maybe<Timing>;
+    status?: Maybe<Code>;
+};
+export type DisconnectConnection = {
+    __typename?: 'DisconnectConnection';
+    status?: Maybe<DataConnectionStatus>;
+    statusUpdated: Scalars['DateTime']['output'];
+};
+export type DispenseRequest = {
+    __typename?: 'DispenseRequest';
+    /** The minimum period of time that must occur between dispenses of the medication. */
+    dispenseInterval?: Maybe<Quantity>;
+    /** Identifies the period time over which the supplied product is expected to be used, or the length of time the dispense is expected to last. */
+    expectedSupplyDuration?: Maybe<Quantity>;
+    id?: Maybe<Scalars['ID']['output']>;
+    /** Indicates the quantity or duration for the first dispense of the medication. */
+    initialFill?: Maybe<InitialFill>;
+    /**
+     * An integer indicating the number of times, in addition to the original dispense,
+     * (aka refills or repeats) that the patient can receive the prescribed medication.
+     * Usage Notes: This integer does not include the original order dispense. This means
+     * that if an order indicates dispense 30 tablets plus "3 repeats", then the order
+     * can be dispensed a total of 4 times and the patient can receive a total of 120
+     * tablets. A prescriber may explicitly say that zero refills are permitted after
+     * the initial dispense.
+     */
+    numberOfRepeatsAllowed?: Maybe<Scalars['Int']['output']>;
+    /** Indicates the intended dispensing Organization specified by the prescriber. */
+    performer?: Maybe<Organization>;
+    quantity?: Maybe<Quantity>;
+    /** Period A time period defined by a start and end date and optionally time. If the element is present, it must have a value for at least one of the defined elements, an @id referenced from the Narrative, or extensions */
+    validityPeriod?: Maybe<Period>;
+};
+export type DomainResource = {
+    contained?: Maybe<Array<Maybe<Resource>>>;
+    extension?: Maybe<Array<Maybe<Extension>>>;
+    id?: Maybe<Scalars['String']['output']>;
+    implicitRules?: Maybe<Scalars['String']['output']>;
+    language?: Maybe<Scalars['String']['output']>;
+    meta?: Maybe<Meta>;
+    modifierExtension?: Maybe<Array<Maybe<Extension>>>;
+    resourceType: Scalars['String']['output'];
+    text?: Maybe<Scalars['String']['output']>;
+};
+export type Dosage = {
+    __typename?: 'Dosage';
+    additionalInstruction?: Maybe<Array<CodeableConcept>>;
+    asNeededBoolean?: Maybe<Scalars['Boolean']['output']>;
+    asNeededCodeableConcept?: Maybe<CodeableConcept>;
+    doseAndRate?: Maybe<Array<DoseAndRate>>;
+    id?: Maybe<Scalars['ID']['output']>;
+    maxDosePerAdministration?: Maybe<Quantity>;
+    maxDosePerLifetime?: Maybe<Quantity>;
+    maxDosePerPeriod?: Maybe<Ratio>;
+    method?: Maybe<CodeableConcept>;
+    patientInstruction?: Maybe<Scalars['String']['output']>;
+    route?: Maybe<CodeableConcept>;
+    sequence?: Maybe<Scalars['Int']['output']>;
+    site?: Maybe<CodeableConcept>;
+    text?: Maybe<Scalars['String']['output']>;
+    timing?: Maybe<Timing>;
+};
+export type DoseAndRate = {
+    __typename?: 'DoseAndRate';
+    doseQuantity?: Maybe<Quantity>;
+    doseRange?: Maybe<Range>;
+    id?: Maybe<Scalars['ID']['output']>;
+    rateQuantity?: Maybe<Quantity>;
+    rateRange?: Maybe<Range>;
+    rateRatio?: Maybe<Ratio>;
+    type?: Maybe<CodeableConcept>;
+};
+export type Element = {
+    extension?: Maybe<Extension>;
+    id?: Maybe<Scalars['String']['output']>;
+};
+export type EmbeddableConfiguration = {
+    __typename?: 'EmbeddableConfiguration';
+    authStrategy: Scalars['String']['output'];
+    idleThreshold: Scalars['Int']['output'];
+    routeDefinition: Array<RouteDefinition>;
+    webSdkVersion: Scalars['String']['output'];
+};
+export declare enum EmpiType {
+    BwellPatient = "BWELL_PATIENT",
+    BwellPerson = "BWELL_PERSON",
+    ClientPatient = "CLIENT_PATIENT",
+    ClientPerson = "CLIENT_PERSON"
+}
+export type EncounterGroup = ResourceGroup & {
+    __typename?: 'EncounterGroup';
+    /** The classification of the encounter (e.g., emergency, pediatric). */
+    class?: Maybe<Coding>;
+    /** Coding representing the kind of encounters in this composition */
+    coding?: Maybe<Coding>;
+    /** A time period with a defined start and end date and time. */
+    date?: Maybe<Scalars['DateTime']['output']>;
+    id?: Maybe<Scalars['ID']['output']>;
+    /** Human readable name of the encounter */
+    name?: Maybe<Scalars['String']['output']>;
+    /** The list of individuals involved in the encounter. */
+    participant?: Maybe<Scalars['String']['output']>;
+    /** Array of encounter id references in the Composition */
+    references?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+    /** Array of Strings representing the source of the data */
+    source?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+    /** The specific type of encounter (e.g., outpatient, inpatient). */
+    type?: Maybe<Coding>;
+};
+export type EncounterGroupQueryRequest = {
+    page?: InputMaybe<Scalars['Int']['input']>;
+    pageSize?: InputMaybe<Scalars['Int']['input']>;
+};
+export type EncounterGroupQueryResults = PagedQueryResults & {
+    __typename?: 'EncounterGroupQueryResults';
+    paging_info?: Maybe<PagingResults>;
+    resources: Array<EncounterGroup>;
+};
+export type EncounterQueryResults = PagedQueryResults & {
+    __typename?: 'EncounterQueryResults';
+    paging_info?: Maybe<PagingResults>;
+    resources: Array<EncounterResource>;
+};
+/** Input type for specifying the search criteria for encounters. */
+export type EncounterRequest = {
+    groupCode?: InputMaybe<SearchToken>;
+    ids?: InputMaybe<Array<Scalars['String']['input']>>;
+    /** Filters based on the meta.lastUpdated date of the resource */
+    lastUpdated?: InputMaybe<SearchDate>;
+    page?: InputMaybe<Scalars['Int']['input']>;
+    pageSize?: InputMaybe<Scalars['Int']['input']>;
+};
+/** A FHIR Encounter resource representing an interaction between a patient and healthcare provider. */
+export type EncounterResource = {
+    __typename?: 'EncounterResource';
+    /** The classification of the encounter (e.g., emergency, pediatric). */
+    class?: Maybe<Coding>;
+    /** The unique identifier for this Encounter resource. */
+    id: Scalars['ID']['output'];
+    /** Business identifier for the encounter */
+    identifier?: Maybe<Identifier>;
+    /** Represents details and position information for a physical place */
+    location?: Maybe<Location>;
+    /** Meta information about the Encounter, such as version, tags, etc. */
+    meta?: Maybe<Meta>;
+    /** The list of individuals involved in the encounter. */
+    participant?: Maybe<Array<Maybe<Participant>>>;
+    /** The time period during which the encounter occurred. */
+    period?: Maybe<Period>;
+    /** The reason the encounter took place. */
+    reasonCode?: Maybe<Array<Maybe<CodeableConcept>>>;
+    /** The status of the encounter (planned, in progress, etc.). */
+    status: Code;
+    /** The specific type of encounter (e.g., outpatient, inpatient). */
+    type?: Maybe<Array<Maybe<CodeableConcept>>>;
+};
+export type Endpoint = {
+    __typename?: 'Endpoint';
+    address?: Maybe<Scalars['String']['output']>;
+    connectionType?: Maybe<Coding>;
+    identifier?: Maybe<Array<Maybe<Identifier>>>;
+    name?: Maybe<Scalars['String']['output']>;
+    status?: Maybe<EndpointStatus>;
+};
+export declare enum EndpointStatus {
+    Active = "active",
+    EnteredInError = "entered_in_error",
+    Error = "error",
+    Off = "off",
+    Suspended = "suspended",
+    Test = "test"
+}
+export declare enum EventType {
+    CustomEvent = "CUSTOM_EVENT",
+    MobilePushOpen = "MOBILE_PUSH_OPEN"
+}
+/** Extension */
+export type Extension = {
+    __typename?: 'Extension';
+    id?: Maybe<Scalars['String']['output']>;
+    url?: Maybe<Scalars['String']['output']>;
+    valueCodeableConcept?: Maybe<CodeableConcept>;
+    valueExpression?: Maybe<Scalars['String']['output']>;
+    valueInteger?: Maybe<Scalars['Int']['output']>;
+    valueString?: Maybe<Scalars['String']['output']>;
+};
+export type ExtensionInput = {
+    id?: InputMaybe<Scalars['String']['input']>;
+    url?: InputMaybe<Scalars['String']['input']>;
+    valueCodeableConcept?: InputMaybe<CodeableConceptInput>;
+};
+export type Extension_Input = {
+    extension?: InputMaybe<Array<InputMaybe<Extension_Input>>>;
+    id?: InputMaybe<Scalars['String']['input']>;
+    url?: InputMaybe<Scalars['String']['input']>;
+    valueCodeableConcept?: InputMaybe<CodeableConcept_Input>;
+};
+export declare enum FhirPersonGender {
+    Female = "female",
+    Male = "male",
+    Other = "other",
+    Unknown = "unknown"
+}
+export type FhirPersonInput = {
+    active?: InputMaybe<Scalars['Boolean']['input']>;
+    address?: InputMaybe<Array<InputMaybe<AddressInput>>>;
+    birthDate?: InputMaybe<Scalars['String']['input']>;
+    extension?: InputMaybe<Array<InputMaybe<ExtensionInput>>>;
+    gender?: InputMaybe<FhirPersonGender>;
+    id?: InputMaybe<Scalars['String']['input']>;
+    identifier?: InputMaybe<Array<InputMaybe<IdentifierInput>>>;
+    implicitRules?: InputMaybe<Scalars['String']['input']>;
+    language?: InputMaybe<Scalars['String']['input']>;
+    link?: InputMaybe<Array<InputMaybe<PersonLinkInput>>>;
+    managingOrganization?: InputMaybe<ReferenceInput>;
+    meta?: InputMaybe<PersonMetaInput>;
+    modifierExtension?: InputMaybe<Array<InputMaybe<ExtensionInput>>>;
+    name?: InputMaybe<Array<InputMaybe<NameInput>>>;
+    photo?: InputMaybe<AttachmentInput>;
+    resourceType: FhirPersonResourceType;
+    telecom?: InputMaybe<Array<InputMaybe<ContactPointInput>>>;
+};
+export declare enum FhirPersonResourceType {
+    Person = "Person"
+}
+export type Fhir_Extension = {
+    __typename?: 'FHIR_Extension';
+    id?: Maybe<Scalars['String']['output']>;
+    url?: Maybe<Scalars['String']['output']>;
+    valueString?: Maybe<Scalars['String']['output']>;
+};
+export type FeatureFlag = {
+    __typename?: 'FeatureFlag';
+    id: Scalars['String']['output'];
+    name: Scalars['String']['output'];
+    variants: Array<Variant>;
+};
+export type FeatureFlagConfiguration = {
+    __typename?: 'FeatureFlagConfiguration';
+    featureFlagDefinitions?: Maybe<Array<FeatureFlag>>;
+};
+export type FhirFormQuestionnaire = {
+    __typename?: 'FhirFormQuestionnaire';
+    model?: Maybe<Model>;
+    schema?: Maybe<Schema>;
+    uiSchema?: Maybe<Scalars['uiSchema']['output']>;
+};
+export type FhirQuestionnaire = {
+    __typename?: 'FhirQuestionnaire';
+    description?: Maybe<Scalars['String']['output']>;
+    id?: Maybe<Scalars['id']['output']>;
+    item?: Maybe<Array<Maybe<FhirQuestionnaireItem>>>;
+    meta?: Maybe<Meta>;
+    name?: Maybe<Scalars['String']['output']>;
+    resourceType: Fhir_Questionnaire_Enum_Schema;
+    status?: Maybe<Scalars['code']['output']>;
+    subjectType?: Maybe<Array<Maybe<Scalars['code']['output']>>>;
+    title?: Maybe<Scalars['String']['output']>;
+    version?: Maybe<Scalars['String']['output']>;
+};
+export type FhirQuestionnaireItem = {
+    __typename?: 'FhirQuestionnaireItem';
+    code?: Maybe<Array<Maybe<Coding>>>;
+    extension?: Maybe<Array<Maybe<Extension>>>;
+    id?: Maybe<Scalars['String']['output']>;
+    item?: Maybe<Array<Maybe<FhirQuestionnaireItem>>>;
+    linkId?: Maybe<Scalars['String']['output']>;
+    required?: Maybe<Scalars['Boolean']['output']>;
+    text?: Maybe<Scalars['String']['output']>;
+    type?: Maybe<Scalars['code']['output']>;
+};
+export declare enum Fhir_Questionnaire_Enum_Schema {
+    Questionnaire = "Questionnaire"
+}
+export declare enum FilterField {
+    Characteristic = "characteristic",
+    Communication = "communication",
+    Gender = "gender",
+    Specialty = "specialty"
+}
+export type FilterValue = {
+    __typename?: 'FilterValue';
+    count?: Maybe<Scalars['Int']['output']>;
+    value?: Maybe<Scalars['String']['output']>;
+};
+export type FilterValues = {
+    __typename?: 'FilterValues';
+    field?: Maybe<FilterField>;
+    values?: Maybe<Array<Maybe<FilterValue>>>;
+};
+export type FrontendEnvironment = {
+    __typename?: 'FrontendEnvironment';
+    analytics: Analytics;
+};
+export declare enum Gender {
+    Female = "female",
+    /** Follows https://www.hl7.org/fhir/valueset-administrative-gender.html */
+    Male = "male",
+    Other = "other",
+    Unknown = "unknown"
+}
+export type GenerateUrl = {
+    __typename?: 'GenerateUrl';
+    redirectUrl: Scalars['String']['output'];
+};
+export type GoogleGeo = {
+    __typename?: 'GoogleGeo';
+    key: Scalars['String']['output'];
+    uri: Scalars['String']['output'];
+};
+export type GraphQlClientConfig = {
+    __typename?: 'GraphQLClientConfig';
+    authUrl: Scalars['String']['output'];
+    cache: Cache;
+    fetchPolicy: Scalars['String']['output'];
+    url: Scalars['String']['output'];
+};
+export declare enum HealthSummaryCategory {
+    AllergyIntolerance = "ALLERGY_INTOLERANCE",
+    CarePlan = "CARE_PLAN",
+    Condition = "CONDITION",
+    Encounter = "ENCOUNTER",
+    Immunization = "IMMUNIZATION",
+    Labs = "LABS",
+    Medications = "MEDICATIONS",
+    Procedure = "PROCEDURE",
+    VitalSigns = "VITAL_SIGNS"
+}
+export type HealthSummaryQueryResults = {
+    __typename?: 'HealthSummaryQueryResults';
+    resources: Array<HealthSummaryResource>;
+};
+export type HealthSummaryResource = {
+    __typename?: 'HealthSummaryResource';
+    category?: Maybe<HealthSummaryCategory>;
+    total?: Maybe<Scalars['Int']['output']>;
+};
+export type HttpClientConfig = {
+    __typename?: 'HttpClientConfig';
+    requestTimeout?: Maybe<Scalars['Float']['output']>;
+    retry?: Maybe<Retry>;
+};
+/** A data type for human names. */
+export type HumanName = {
+    __typename?: 'HumanName';
+    /** The family name or surname. */
+    family?: Maybe<Scalars['String']['output']>;
+    /** An ordered list of given names. */
+    given?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+    /** Prefixes such as "Mr." or "Dr.". */
+    prefix?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+    /** Suffixes such as "Jr." or "III". */
+    suffix?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+    /** Follows https://www.hl7.org/fhir/datatypes.html#HumanName */
+    text?: Maybe<Scalars['String']['output']>;
+};
+/** General identifier structure for various elements. */
+export type Identifier = {
+    __typename?: 'Identifier';
+    /** Unique identifier */
+    id?: Maybe<Scalars['ID']['output']>;
+    /** The system within which the identifier is used. */
+    system?: Maybe<Scalars['String']['output']>;
+    /** The type of identifier (e.g., MRN, SIN). */
+    type?: Maybe<CodeableConcept>;
+    /** The actual value of the identifier. */
+    value?: Maybe<Scalars['String']['output']>;
+};
+export type IdentifierInput = {
+    id?: InputMaybe<Scalars['String']['input']>;
+    system?: InputMaybe<Scalars['String']['input']>;
+    value?: InputMaybe<Scalars['String']['input']>;
+};
+export declare enum IdentifierUseKind {
+    Official = "official",
+    Old = "old",
+    Secondary = "secondary",
+    Temp = "temp",
+    Usual = "usual"
+}
+/** codeable concept */
+export type IdentityAuthed_CodeableConcept = {
+    __typename?: 'IdentityAuthed_CodeableConcept';
+    id?: Maybe<Scalars['String']['output']>;
+    text?: Maybe<Scalars['String']['output']>;
+};
+export type IdentityAuthed_Meta = {
+    __typename?: 'IdentityAuthed_Meta';
+    cards?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+    navItems?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+    settingsKeys?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+};
+/** operation outcome */
+export type IdentityAuthed_OperationOutcome = {
+    __typename?: 'IdentityAuthed_OperationOutcome';
+    issue?: Maybe<Array<OperationOutcome_Issue>>;
+    resourceType?: Maybe<Scalars['String']['output']>;
+};
+/** task meta */
+export type Identity_Meta = {
+    __typename?: 'Identity_Meta';
+    id?: Maybe<Scalars['String']['output']>;
+    lastUpdated?: Maybe<Scalars['DateTime']['output']>;
+    security?: Maybe<Array<Coding>>;
+    source?: Maybe<Scalars['String']['output']>;
+    tag?: Maybe<Array<Coding>>;
+    versionId?: Maybe<Scalars['String']['output']>;
+};
+/** Identity_Resource */
+export type Identity_Resource = {
+    id: Scalars['String']['output'];
+    implicitRules?: Maybe<Scalars['String']['output']>;
+    language?: Maybe<Scalars['String']['output']>;
+    meta: Identity_Meta;
+    resourceType: Scalars['String']['output'];
+};
+/** Identity_ResourceContainer */
+export type Identity_ResourceContainer = {
+    __typename?: 'Identity_ResourceContainer';
+    id_: Scalars['String']['output'];
+    meta: Identity_Meta;
+};
+/** task */
+export type Identity_Task = {
+    __typename?: 'Identity_Task';
+    For?: Maybe<Identity_Resource>;
+    authoredOn?: Maybe<Scalars['String']['output']>;
+    basedOn?: Maybe<Array<Identity_Resource>>;
+    basedOnV2?: Maybe<Array<TaskBasedOnV2>>;
+    code?: Maybe<CodeableConcept>;
+    contained?: Maybe<Array<Identity_ResourceContainer>>;
+    description?: Maybe<Scalars['String']['output']>;
+    executionPeriod?: Maybe<Period>;
+    extension?: Maybe<Array<Extension>>;
+    focus?: Maybe<Identity_Resource>;
+    focusV2?: Maybe<TaskFocusV2>;
+    forV2?: Maybe<TaskForV2>;
+    id?: Maybe<Scalars['String']['output']>;
+    identifier?: Maybe<Array<Identifier>>;
+    implicitRules?: Maybe<Scalars['String']['output']>;
+    instantiatesCanonical?: Maybe<Scalars['String']['output']>;
+    instantiatesUri?: Maybe<Scalars['String']['output']>;
+    intent?: Maybe<Scalars['String']['output']>;
+    language?: Maybe<Scalars['String']['output']>;
+    lastModified?: Maybe<Scalars['String']['output']>;
+    meta?: Maybe<Identity_Meta>;
+    modifierExtension?: Maybe<Array<Extension>>;
+    priority?: Maybe<Scalars['String']['output']>;
+    resourceType?: Maybe<Scalars['String']['output']>;
+    status?: Maybe<Scalars['String']['output']>;
+};
+export type ImmunizationGroup = ResourceGroup & {
+    __typename?: 'ImmunizationGroup';
+    /** Coding representing the kind of immunizations in this composition */
+    coding?: Maybe<Coding>;
+    id?: Maybe<Scalars['ID']['output']>;
+    /** Human readable name of the immunization */
+    name?: Maybe<Scalars['String']['output']>;
+    /** The date and time when the vaccine was administered. */
+    occurrenceDateTime?: Maybe<Scalars['DateTime']['output']>;
+    /** Array of immunization id references in the Composition */
+    references?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+    /** Array of Strings representing the source of the data */
+    source?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+};
+export type ImmunizationGroupQueryRequest = {
+    page?: InputMaybe<Scalars['Int']['input']>;
+    pageSize?: InputMaybe<Scalars['Int']['input']>;
+};
+export type ImmunizationGroupQueryResults = PagedQueryResults & {
+    __typename?: 'ImmunizationGroupQueryResults';
+    paging_info?: Maybe<PagingResults>;
+    resources: Array<ImmunizationGroup>;
+};
+export type ImmunizationQueryResults = PagedQueryResults & {
+    __typename?: 'ImmunizationQueryResults';
+    paging_info?: Maybe<PagingResults>;
+    resources: Array<ImmunizationResource>;
+};
+/** Input type for specifying the search criteria for immunization records. */
+export type ImmunizationRequest = {
+    groupCode?: InputMaybe<SearchToken>;
+    ids?: InputMaybe<Array<Scalars['String']['input']>>;
+    /** Filters based on the meta.lastUpdated date of the resource */
+    lastUpdated?: InputMaybe<SearchDate>;
+    page?: InputMaybe<Scalars['Int']['input']>;
+    pageSize?: InputMaybe<Scalars['Int']['input']>;
+};
+/** A FHIR Immunization resource representing an administration of a vaccine or a record thereof. */
+export type ImmunizationResource = {
+    __typename?: 'ImmunizationResource';
+    /** Amount of vaccine administered */
+    doseQuantity?: Maybe<Quantity>;
+    /** The encounter during which the vaccine was administered. */
+    encounter?: Maybe<EncounterResource>;
+    /** The unique identifier for this Immunization resource. */
+    id: Scalars['ID']['output'];
+    /** Where immunization occurred */
+    location?: Maybe<Location>;
+    /** Vaccine lot number */
+    lotNumber?: Maybe<Scalars['String']['output']>;
+    /** The manufacturer of the vaccine. */
+    manufacturer?: Maybe<Organization>;
+    /** Meta information about the Immunization, such as version, tags, etc. */
+    meta?: Maybe<Meta>;
+    /** The date and time when the vaccine was administered. */
+    occurrenceDateTime?: Maybe<Scalars['DateTime']['output']>;
+    /** Who performed event */
+    performer?: Maybe<Array<Maybe<Performer>>>;
+    /** Indicates context the data was recorded in */
+    primarySource?: Maybe<Scalars['Boolean']['output']>;
+    /** Information about the protocol under which the vaccine was administered. */
+    protocolApplied?: Maybe<Array<Maybe<ProtocolApplied>>>;
+    /** Any reactions to the vaccine that were recorded. */
+    reaction?: Maybe<Array<Maybe<Reaction>>>;
+    /** Why immunization occurred */
+    reasonCode?: Maybe<Array<Maybe<CodeableConcept>>>;
+    /** How vaccine entered body */
+    route?: Maybe<CodeableConcept>;
+    /** Body site vaccine was administered */
+    site?: Maybe<CodeableConcept>;
+    status: Code;
+    /** Consumer friendly name for immunization */
+    vaccine?: Maybe<Scalars['String']['output']>;
+    /** The vaccine that was administered. */
+    vaccineCode: CodeableConcept;
+};
+export type InitialFill = {
+    __typename?: 'InitialFill';
+    /** The length of time that the first dispense is expected to last. */
+    duration?: Maybe<Quantity>;
+    /** The amount or quantity to provide as part of the first dispense. */
+    quantity?: Maybe<Quantity>;
+};
+export type InputCoding = {
+    /** Follows https://www.hl7.org/fhir/datatypes.html#Coding */
+    code?: InputMaybe<Scalars['String']['input']>;
+    display?: InputMaybe<Scalars['String']['input']>;
+    system?: InputMaybe<Scalars['String']['input']>;
+};
+export type InputProfile = {
+    active?: InputMaybe<Scalars['Boolean']['input']>;
+    address?: InputMaybe<InputProfileAddress>;
+    birthDate?: InputMaybe<Scalars['String']['input']>;
+    email?: InputMaybe<Scalars['String']['input']>;
+    gender?: InputMaybe<Scalars['String']['input']>;
+    id?: InputMaybe<Scalars['String']['input']>;
+    language?: InputMaybe<Scalars['String']['input']>;
+    name?: InputMaybe<InputProfileName>;
+    phone?: InputMaybe<Scalars['String']['input']>;
+};
+export type InputProfileAddress = {
+    city?: InputMaybe<Scalars['String']['input']>;
+    country?: InputMaybe<Scalars['String']['input']>;
+    district?: InputMaybe<Scalars['String']['input']>;
+    line_1?: InputMaybe<Scalars['String']['input']>;
+    line_2?: InputMaybe<Scalars['String']['input']>;
+    postalCode?: InputMaybe<Scalars['String']['input']>;
+    state?: InputMaybe<Scalars['String']['input']>;
+};
+export type InputProfileContactPoint = {
+    phone?: InputMaybe<Scalars['String']['input']>;
+};
+export type InputProfileName = {
+    first?: InputMaybe<Scalars['String']['input']>;
+    last?: InputMaybe<Scalars['String']['input']>;
+};
+export declare enum InteractionType {
+    Clicked = "clicked"
+}
+export type Issue = {
+    __typename?: 'Issue';
+    code: Scalars['String']['output'];
+    details: CodeableConcept;
+    severity: Scalars['String']['output'];
+};
+export type Job = {
+    __typename?: 'Job';
+    attemptsMade?: Maybe<Scalars['Int']['output']>;
+    data?: Maybe<Scalars['JSON']['output']>;
+    failedReason?: Maybe<Scalars['String']['output']>;
+    finishedOn?: Maybe<Scalars['Int']['output']>;
+    id?: Maybe<Scalars['String']['output']>;
+    name?: Maybe<Scalars['String']['output']>;
+    processedOn?: Maybe<Scalars['Int']['output']>;
+    stacktrace?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+    timestamp?: Maybe<Scalars['Int']['output']>;
+};
+export type Job_Input = {
+    data?: InputMaybe<Scalars['JSON']['input']>;
+    name: Scalars['String']['input'];
+};
+export type LabGroup = ResourceGroup & {
+    __typename?: 'LabGroup';
+    /** A structured set of codes including a text representation. */
+    category?: Maybe<Array<Maybe<CodeableConcept>>>;
+    /** Coding representing the kind of Conditions in this ResourceGroup */
+    coding?: Maybe<Coding>;
+    /** Component observations as part of this observation. */
+    component?: Maybe<Array<Maybe<Component>>>;
+    /** The single point in time when the observation was made. */
+    effectiveDateTime?: Maybe<Scalars['DateTime']['output']>;
+    id?: Maybe<Scalars['ID']['output']>;
+    /** The interpretation of the observation results. */
+    interpretation?: Maybe<Array<Maybe<CodeableConcept>>>;
+    /** Human readable name of the Lab */
+    name?: Maybe<Scalars['String']['output']>;
+    /** Reference ranges for interpreting the observation value. */
+    referenceRange?: Maybe<Array<Maybe<ReferenceRange>>>;
+    /** Array of immunization id references in the ResourceGroup */
+    references?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+    /** Array of Strings representing the source of the data */
+    source?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+    value?: Maybe<Value>;
+};
+export type LabGroupQueryRequest = {
+    page?: InputMaybe<Scalars['Int']['input']>;
+    pageSize?: InputMaybe<Scalars['Int']['input']>;
+};
+export type LabGroupQueryResults = PagedQueryResults & {
+    __typename?: 'LabGroupQueryResults';
+    paging_info?: Maybe<PagingResults>;
+    resources: Array<LabGroup>;
+};
+/** Type representing detailed information about a Medication */
+export type LabKnowledgeEntry = {
+    __typename?: 'LabKnowledgeEntry';
+    /** Detailed information about the lab */
+    content: Scalars['String']['output'];
+};
+/** Type representing knowledge about a lab, like what it's testing for and what the results mean */
+export type LabKnowledgeQueryResults = PagedQueryResults & {
+    __typename?: 'LabKnowledgeQueryResults';
+    paging_info?: Maybe<PagingResults>;
+    resources: Array<LabKnowledgeEntry>;
+};
+/** Defines input parameters for querying Lab Knowledge resources. */
+export type LabKnowledgeRequest = {
+    /** ID of the lab */
+    labId: Scalars['ID']['input'];
+    page?: InputMaybe<Scalars['Int']['input']>;
+    pageSize?: InputMaybe<Scalars['Int']['input']>;
+};
+/** Defines input parameters for querying Lab resources. */
+export type LabRequest = {
+    groupCode?: InputMaybe<SearchToken>;
+    ids?: InputMaybe<Array<Scalars['String']['input']>>;
+    /** Filters based on the meta.lastUpdated date of the resource */
+    lastUpdated?: InputMaybe<SearchDate>;
+    /** Page offset */
+    page?: InputMaybe<Scalars['Int']['input']>;
+    /** The maximum number of results to return (for pagination). */
+    pageSize?: InputMaybe<Scalars['Int']['input']>;
+};
+export type LegacyConsent = {
+    __typename?: 'LegacyConsent';
+    category?: Maybe<Array<CodeableConcept>>;
+    dateTime?: Maybe<Scalars['dateTime']['output']>;
+    id?: Maybe<Scalars['String']['output']>;
+    organization?: Maybe<Scalars['reference']['output']>;
+    patient?: Maybe<Scalars['reference']['output']>;
+    provision?: Maybe<Scalars['consentProvision']['output']>;
+    resourceType?: Maybe<Scalars['String']['output']>;
+    scope?: Maybe<CodeableConcept>;
+    sourceReference?: Maybe<Scalars['reference']['output']>;
+    status?: Maybe<Scalars['code']['output']>;
+};
+/** Represents details and position information for a physical place */
+export type Location = {
+    __typename?: 'Location';
+    address?: Maybe<Address>;
+    alias?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+    description?: Maybe<Scalars['String']['output']>;
+    distanceInMiles?: Maybe<Scalars['Float']['output']>;
+    identifier?: Maybe<Array<Maybe<Identifier>>>;
+    /**
+     * Follows https://www.hl7.org/fhir/location.html#location
+     * and adds https://www.hl7.org/fhir/datatypes.html#Address
+     * and adds distance_in_miles
+     * and adds https://www.hl7.org/fhir/schedule.html
+     */
+    name?: Maybe<Scalars['String']['output']>;
+    position?: Maybe<Position>;
+    telecom?: Maybe<Array<Maybe<ContactPoint>>>;
+};
+export declare enum LogLevel {
+    Debug = "DEBUG",
+    Error = "ERROR",
+    Info = "INFO",
+    Verbose = "VERBOSE",
+    Warn = "WARN"
+}
+export type MedStatementCodeableConceptResource = {
+    __typename?: 'MedStatementCodeableConceptResource';
+    medicationCodeableConcept?: Maybe<CodeableConcept>;
+};
+export type MedicationGroup = ResourceGroup & {
+    __typename?: 'MedicationGroup';
+    authoredOn?: Maybe<Scalars['DateTime']['output']>;
+    /** Coding representing the kind of Conditions in this ResourceGroup */
+    coding?: Maybe<Coding>;
+    id?: Maybe<Scalars['ID']['output']>;
+    /** Human readable name of the Medication */
+    name?: Maybe<Scalars['String']['output']>;
+    /** Array of medication id references in the resource group */
+    references?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+    /** Array of Strings representing the source of the data */
+    source?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+    status?: Maybe<Code>;
+};
+export type MedicationGroupQueryRequest = {
+    page?: InputMaybe<Scalars['Int']['input']>;
+    pageSize?: InputMaybe<Scalars['Int']['input']>;
+};
+export type MedicationGroupQueryResults = PagedQueryResults & {
+    __typename?: 'MedicationGroupQueryResults';
+    paging_info?: Maybe<PagingResults>;
+    resources: Array<MedicationGroup>;
+};
+/** Type representing detailed information about a Medication */
+export type MedicationKnowledgeEntry = {
+    __typename?: 'MedicationKnowledgeEntry';
+    /** Detailed information about the medication */
+    content: Scalars['String']['output'];
+    /** The title describing the content in the content */
+    title: Scalars['String']['output'];
+};
+/** Type representing knowledge about a medication, such as instructions or clinical information */
+export type MedicationKnowledgeQueryResults = PagedQueryResults & {
+    __typename?: 'MedicationKnowledgeQueryResults';
+    paging_info?: Maybe<PagingResults>;
+    resources: Array<MedicationKnowledgeEntry>;
+};
+/** Input type for querying medication knowledge */
+export type MedicationKnowledgeRequest = {
+    /** The id of the Medication Statement for which to fetch Medication Knowledge */
+    medicationStatementId: Scalars['ID']['input'];
+    page?: InputMaybe<Scalars['Int']['input']>;
+    pageSize?: InputMaybe<Scalars['Int']['input']>;
+};
+/** Type representing the pricing information for a medication */
+export type MedicationPricing = {
+    __typename?: 'MedicationPricing';
+    /** The name of the pharmacy offering the medication at this price */
+    pharmacy: Scalars['String']['output'];
+    /** The price of the medication */
+    price?: Maybe<Money>;
+    /** A URL to the pharmacy's page for the medication, if available */
+    url?: Maybe<Scalars['String']['output']>;
+};
+export type MedicationPricingQueryResults = PagedQueryResults & {
+    __typename?: 'MedicationPricingQueryResults';
+    paging_info?: Maybe<PagingResults>;
+    resources: Array<MedicationPricing>;
+};
+/** Input type for querying medication knowledge */
+export type MedicationPricingRequest = {
+    /** The id of the Medication Statement for which to fetch Medication Pricing */
+    medicationStatementId: Scalars['ID']['input'];
+};
+export type MedicationStatementQueryRequest = {
+    groupCode?: InputMaybe<SearchToken>;
+    ids?: InputMaybe<Array<Scalars['String']['input']>>;
+    /** Filters based on the meta.lastUpdated date of the resource */
+    lastUpdated?: InputMaybe<SearchDate>;
+    page?: InputMaybe<Scalars['Int']['input']>;
+    pageSize?: InputMaybe<Scalars['Int']['input']>;
+};
+export type MedicationStatementQueryResults = PagedQueryResults & {
+    __typename?: 'MedicationStatementQueryResults';
+    paging_info?: Maybe<PagingResults>;
+    resources: Array<MedicationStatementResource>;
+};
+export type MedicationStatementResource = {
+    __typename?: 'MedicationStatementResource';
+    /** Authored on date of the most recent medication request */
+    authoredOn?: Maybe<Scalars['DateTime']['output']>;
+    /**
+     * Medication supply authorization
+     * https://hl7.org/fhir/R4B/medicationrequest-definitions.html#MedicationRequest.dispenseRequest
+     */
+    dispenseRequest?: Maybe<DispenseRequest>;
+    /** Details of how medication is/was taken or should be taken */
+    dosageInstruction?: Maybe<Array<Dosage>>;
+    /** Effective period of the derived medication statement */
+    effectiveDate?: Maybe<Period>;
+    id: Scalars['ID']['output'];
+    /** Codeable concept representing the medication */
+    medication?: Maybe<CodeableConcept>;
+    meta?: Maybe<Meta>;
+    /**
+     * Reason for why the medication is being/was taken
+     * https://hl7.org/fhir/R4B/medicationrequest-definitions.html#MedicationRequest.reasonCode
+     */
+    reasonCode?: Maybe<Array<CodeableConcept>>;
+    /** Requester of the most recent medication request */
+    requester?: Maybe<Actor>;
+    /** Source of medication data */
+    source?: Maybe<Array<Scalars['String']['output']>>;
+    /** Status of the derived medication statment */
+    status?: Maybe<Code>;
+};
+/** Meta type containing metadata tags and security labels for the resource. */
+export type Meta = {
+    __typename?: 'Meta';
+    /** When the resource last changed - e.g. when the version changed. */
+    lastUpdated?: Maybe<Scalars['DateTime']['output']>;
+    /** Security labels for access control. */
+    security?: Maybe<Array<Maybe<Coding>>>;
+    /** A uri that identifies the source system of the resource */
+    source?: Maybe<Scalars['String']['output']>;
+    /** Tags for categorization and classification. */
+    tag?: Maybe<Array<Maybe<Coding>>>;
+    /** The version specific identifier, as it appears in the version portion of the URL */
+    versionId?: Maybe<Scalars['String']['output']>;
+};
+export type MetaSecurity = {
+    __typename?: 'MetaSecurity';
+    code?: Maybe<Scalars['String']['output']>;
+    system?: Maybe<Scalars['String']['output']>;
+};
+export type MetaTag = {
+    __typename?: 'MetaTag';
+    code?: Maybe<Scalars['String']['output']>;
+    system?: Maybe<Scalars['String']['output']>;
+};
+export type MetadataId = {
+    __typename?: 'MetadataId';
+    bwellPatientId?: Maybe<Scalars['String']['output']>;
+    bwellPersonId?: Maybe<Scalars['String']['output']>;
+    clientPatientId?: Maybe<Scalars['String']['output']>;
+    clientPersonId?: Maybe<Scalars['String']['output']>;
+};
+export type MixPanel = {
+    __typename?: 'MixPanel';
+    key: Scalars['String']['output'];
+};
+export type Model = {
+    __typename?: 'Model';
+    item?: Maybe<Array<Maybe<QuestionnaireModelItem>>>;
+    resourceType?: Maybe<Questionnaire_Enum_Schema>;
+    status?: Maybe<Scalars['code']['output']>;
+};
+/** Represents monetary amounts with value and currency type */
+export type Money = {
+    __typename?: 'Money';
+    currency?: Maybe<CurrencyCode>;
+    value?: Maybe<Scalars['Float']['output']>;
+};
+export type Mutation = {
+    __typename?: 'Mutation';
+    createConnection: Connection;
+    createConsent?: Maybe<Consent>;
+    createMissingConsents?: Maybe<Scalars['String']['output']>;
+    createPersonWithClientId?: Maybe<PersonWithMetadata>;
+    createQuestionnaireResponse?: Maybe<QuestionnaireResponse>;
+    deleteConnection: ConnectionStatusUpdate;
+    deletePersonAndPatient?: Maybe<UpdatedPersonMetadata>;
+    disconnectConnection: DisconnectConnection;
+    extensionRepairProcess?: Maybe<UpdatedPersonMetadata>;
+    interacted?: Maybe<Scalars['Boolean']['output']>;
+    processConsentTasks?: Maybe<Array<Maybe<Job>>>;
+    publishEvent?: Maybe<Notification_OperationOutcome>;
+    redisCacheClean: RedisCacheCleanResponse;
+    redisClearQuestionnairesCache: RedisCacheCleanResponse;
+    /** Un-Authed Mutation */
+    requestConnection?: Maybe<RequestConnectionOutput>;
+    retryConsentJob?: Maybe<Scalars['Void']['output']>;
+    taskUpdateStatus?: Maybe<TaskUpdateStatusResponse>;
+    updateDeviceRegistration?: Maybe<Notification_OperationOutcome>;
+    updatePersonAndPatient?: Maybe<UpdatedPersonMetadata>;
+    updatePersonWithClientId?: Maybe<PersonWithMetadata>;
+    updateProfile?: Maybe<Profile>;
+    updateUserAccountStatus: IdentityAuthed_OperationOutcome;
+    updateUserProfile?: Maybe<Person>;
+    upsertPerson?: Maybe<PersonWithMetadata>;
+    upsertPersonWithRegCode?: Maybe<TaskWithMetadata>;
+};
+export type MutationCreateConnectionArgs = {
+    connectionId: Scalars['String']['input'];
+    password: Scalars['String']['input'];
+    username: Scalars['String']['input'];
+};
+export type MutationCreateConsentArgs = {
+    consentInput: ConsentInput;
+};
+export type MutationCreateMissingConsentsArgs = {
+    endDate?: InputMaybe<Scalars['dateTime']['input']>;
+    patientId?: InputMaybe<Scalars['String']['input']>;
+    questionnaireId?: InputMaybe<Scalars['String']['input']>;
+    questionnaireResponseId?: InputMaybe<Scalars['String']['input']>;
+    startDate?: InputMaybe<Scalars['dateTime']['input']>;
+};
+export type MutationCreatePersonWithClientIdArgs = {
+    bwellPatientId?: InputMaybe<Scalars['String']['input']>;
+    bwellPersonId?: InputMaybe<Scalars['String']['input']>;
+    clientPatientId?: InputMaybe<Scalars['String']['input']>;
+    clientPersonId?: InputMaybe<Scalars['String']['input']>;
+    input?: InputMaybe<PersonWithClientIdInput>;
+};
+export type MutationCreateQuestionnaireResponseArgs = {
+    input: QuestionnaireResponse_Input;
+};
+export type MutationDeleteConnectionArgs = {
+    connectionId: Scalars['String']['input'];
+};
+export type MutationDeletePersonAndPatientArgs = {
+    bwellPatientId?: InputMaybe<Scalars['String']['input']>;
+    bwellPersonId?: InputMaybe<Scalars['String']['input']>;
+    clientPatientId?: InputMaybe<Scalars['String']['input']>;
+    clientPersonId?: InputMaybe<Scalars['String']['input']>;
+};
+export type MutationDisconnectConnectionArgs = {
+    connectionId: Scalars['String']['input'];
+};
+export type MutationInteractedArgs = {
+    interaction?: InputMaybe<InteractionType>;
+    result_id?: InputMaybe<Scalars['String']['input']>;
+    user?: InputMaybe<User>;
+};
+export type MutationProcessConsentTasksArgs = {
+    jobs?: InputMaybe<Array<InputMaybe<Job_Input>>>;
+};
+export type MutationPublishEventArgs = {
+    input: PublishEventRequest;
+};
+export type MutationRedisCacheCleanArgs = {
+    key?: InputMaybe<Scalars['String']['input']>;
+};
+export type MutationRequestConnectionArgs = {
+    city?: InputMaybe<Scalars['String']['input']>;
+    institution?: InputMaybe<Scalars['String']['input']>;
+    provider?: InputMaybe<Scalars['String']['input']>;
+    state?: InputMaybe<Scalars['String']['input']>;
+};
+export type MutationRetryConsentJobArgs = {
+    jobID?: InputMaybe<Scalars['String']['input']>;
+};
+export type MutationTaskUpdateStatusArgs = {
+    input: TaskUpdateStatusRequest;
+};
+export type MutationUpdateDeviceRegistrationArgs = {
+    input: UpdateDeviceRegistrationRequest;
+};
+export type MutationUpdatePersonAndPatientArgs = {
+    bwellPersonId?: InputMaybe<Scalars['String']['input']>;
+    clientPersonId?: InputMaybe<Scalars['String']['input']>;
+    input?: InputMaybe<PersonInput>;
+};
+export type MutationUpdatePersonWithClientIdArgs = {
+    input?: InputMaybe<PersonWithClientIdInput>;
+};
+export type MutationUpdateProfileArgs = {
+    id?: InputMaybe<Scalars['String']['input']>;
+    input?: InputMaybe<InputProfile>;
+};
+export type MutationUpdateUserAccountStatusArgs = {
+    operation: Operation;
+};
+export type MutationUpdateUserProfileArgs = {
+    input?: InputMaybe<FhirPersonInput>;
+};
+export type MutationUpsertPersonArgs = {
+    input?: InputMaybe<PersonWithClientIdInput>;
+};
+export type MutationUpsertPersonWithRegCodeArgs = {
+    input?: InputMaybe<PersonWithClientIdInput>;
+    regCode?: InputMaybe<Scalars['String']['input']>;
+};
+export type Name = {
+    __typename?: 'Name';
+    extension?: Maybe<Array<Maybe<Extension>>>;
+    family?: Maybe<Scalars['String']['output']>;
+    given?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+    id?: Maybe<Scalars['String']['output']>;
+    period?: Maybe<Period>;
+    prefix?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+    suffix?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+    /** Can define enum */
+    text?: Maybe<Scalars['String']['output']>;
+    use?: Maybe<Scalars['String']['output']>;
+};
+export type NameInput = {
+    extension?: InputMaybe<Array<InputMaybe<ExtensionInput>>>;
+    family?: InputMaybe<Scalars['String']['input']>;
+    given?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
+    id?: InputMaybe<Scalars['String']['input']>;
+    prefix?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
+    suffix?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
+    /** Can define enum */
+    text?: InputMaybe<Scalars['String']['input']>;
+    use?: InputMaybe<Scalars['String']['input']>;
+};
+export type Narrative = {
+    __typename?: 'Narrative';
+    div: Scalars['String']['output'];
+    extension?: Maybe<Array<Maybe<Extension>>>;
+    id?: Maybe<Scalars['String']['output']>;
+    status: Scalars['String']['output'];
+};
+export type NotSearchTokenValue = {
+    code?: InputMaybe<Scalars['String']['input']>;
+    system?: InputMaybe<Scalars['String']['input']>;
+    value?: InputMaybe<Scalars['String']['input']>;
+    values?: InputMaybe<Array<InputMaybe<SearchTokenValue>>>;
+};
+export type Notification_Coding = {
+    __typename?: 'Notification_Coding';
+    code?: Maybe<Scalars['String']['output']>;
+    display?: Maybe<Scalars['String']['output']>;
+    system?: Maybe<Scalars['String']['output']>;
+};
+export type Notification_OperationOutcome = {
+    __typename?: 'Notification_OperationOutcome';
+    id: Scalars['ID']['output'];
+    issue: Array<OperationOutcomeIssue>;
+    resourceType: Scalars['String']['output'];
+};
+/** Classification of type of observation */
+export declare enum ObservationCategory {
+    Activity = "ACTIVITY",
+    Exam = "EXAM",
+    Imaging = "IMAGING",
+    Laboratory = "LABORATORY",
+    Procedure = "PROCEDURE",
+    SocialHistory = "SOCIAL_HISTORY",
+    Survey = "SURVEY",
+    Therapy = "THERAPY",
+    VitalSigns = "VITAL_SIGNS"
+}
+export type ObservationQueryResults = PagedQueryResults & {
+    __typename?: 'ObservationQueryResults';
+    paging_info?: Maybe<PagingResults>;
+    resources: Array<ObservationResource>;
+};
+/** Defines input parameters for querying Observation resources. */
+export type ObservationRequest = {
+    /** The type of observation: lab, vital-signs, etc. */
+    category?: InputMaybe<ObservationCategory>;
+    /** Filter for observations with the given code system */
+    groupCode?: InputMaybe<SearchToken>;
+    ids?: InputMaybe<Array<Scalars['String']['input']>>;
+    /** Filters based on the meta.lastUpdated date of the resource */
+    lastUpdated?: InputMaybe<SearchDate>;
+    /** Page offset */
+    page?: InputMaybe<Scalars['Int']['input']>;
+    /** The maximum number of results to return (for pagination). */
+    pageSize?: InputMaybe<Scalars['Int']['input']>;
+};
+/** The Observation resource type containing all the detailed information about a single observation. */
+export type ObservationResource = {
+    __typename?: 'ObservationResource';
+    /** The code that categorizes the observation. */
+    code: CodeableConcept;
+    /** Component observations as part of this observation. */
+    component?: Maybe<Array<Maybe<Component>>>;
+    /** Consumer friendly name for labs */
+    display?: Maybe<Scalars['String']['output']>;
+    /** The single point in time when the observation was made. */
+    effectiveDateTime?: Maybe<Scalars['DateTime']['output']>;
+    /** The period of time over which the observation was made. */
+    effectivePeriod?: Maybe<Period>;
+    /** The encounter associated with this observation. */
+    encounter?: Maybe<EncounterResource>;
+    /** Unique identifier for the Observation resource. */
+    id: Scalars['ID']['output'];
+    /** The interpretation of the observation results. */
+    interpretation?: Maybe<Array<Maybe<CodeableConcept>>>;
+    /** Metadata about the Observation resource. */
+    meta?: Maybe<Meta>;
+    /** Annotations or notes about the observation. */
+    note?: Maybe<Array<Maybe<Annotation>>>;
+    /** Who is responsible for the observation */
+    performer?: Maybe<Array<Maybe<Performer>>>;
+    /** Reference ranges for interpreting the observation value. */
+    referenceRange?: Maybe<Array<Maybe<ReferenceRange>>>;
+    /** Various types of values that an Observation can have, only one of these would typically be populated. */
+    value?: Maybe<Value>;
+};
+export declare enum Operation {
+    CancelDelete = "CANCEL_DELETE",
+    ConfirmDelete = "CONFIRM_DELETE",
+    RequestDelete = "REQUEST_DELETE"
+}
+export type OperationOutcomeDetails = {
+    __typename?: 'OperationOutcomeDetails';
+    coding?: Maybe<Array<Notification_Coding>>;
+    text?: Maybe<Scalars['String']['output']>;
+};
+export type OperationOutcomeIssue = {
+    __typename?: 'OperationOutcomeIssue';
+    code: Scalars['String']['output'];
+    details?: Maybe<OperationOutcomeDetails>;
+    diagnostics?: Maybe<Scalars['String']['output']>;
+    severity: Scalars['String']['output'];
+};
+/** operation outcome issue */
+export type OperationOutcome_Issue = {
+    __typename?: 'OperationOutcome_Issue';
+    code?: Maybe<Scalars['String']['output']>;
+    details?: Maybe<IdentityAuthed_CodeableConcept>;
+    severity?: Maybe<Scalars['String']['output']>;
+};
+export type OrderBy = {
+    field?: InputMaybe<SortField>;
+    order?: InputMaybe<SortOrder>;
+};
+/** Represents an organization such as a clinic or manufacturer. */
+export type Organization = {
+    __typename?: 'Organization';
+    endpoint?: Maybe<Array<Maybe<Endpoint>>>;
+    /** The name of the organization. */
+    name?: Maybe<Scalars['String']['output']>;
+};
+export declare enum OrganizationType {
+    C19Vaccine = "C19Vaccine",
+    Device = "Device",
+    Insurance = "Insurance",
+    Laboratory = "Laboratory",
+    Pharmacy = "Pharmacy",
+    Provider = "Provider",
+    Bus = "bus",
+    Cg = "cg",
+    Crs = "crs",
+    Dept = "dept",
+    Edu = "edu",
+    Govt = "govt",
+    Ins = "ins",
+    Other = "other",
+    Pay = "pay",
+    Prov = "prov",
+    Reli = "reli",
+    Team = "team"
+}
+/** All queries that return a list of resources return a type that implements this interface. */
+export type PagedQueryResults = {
+    paging_info?: Maybe<PagingResults>;
+};
+export type PagingInfo = {
+    __typename?: 'PagingInfo';
+    page_number: Scalars['Int']['output'];
+    page_size: Scalars['Int']['output'];
+    total_items: Scalars['Int']['output'];
+    total_pages: Scalars['Int']['output'];
+};
+export type PagingResults = {
+    __typename?: 'PagingResults';
+    page_number: Scalars['Int']['output'];
+    page_size: Scalars['Int']['output'];
+    total_items: Scalars['Int']['output'];
+    total_pages: Scalars['Int']['output'];
+};
+export type Participant = {
+    __typename?: 'Participant';
+    individual?: Maybe<PractitionerReference>;
+    period?: Maybe<Period>;
+    type?: Maybe<CodeableConcept>;
+};
+/** A representation of a patient associated with the condition. */
+export type Patient = {
+    __typename?: 'Patient';
+    /** The name(s) of the patient. */
+    name?: Maybe<Array<HumanName>>;
+};
+/** The people who performed the procedure */
+export type Performer = {
+    __typename?: 'Performer';
+    actor?: Maybe<Actor>;
+};
+/** A time period with a defined start and end date and time. */
+export type Period = {
+    __typename?: 'Period';
+    /** The end of the period. */
+    end?: Maybe<Scalars['DateTime']['output']>;
+    /** The start of the period. */
+    start?: Maybe<Scalars['DateTime']['output']>;
+};
+/** A time period with a defined start and end deate and time. */
+export type PeriodInput = {
+    /** The end of the period. */
+    end?: InputMaybe<Scalars['DateTime']['input']>;
+    /** The start of the period. */
+    start?: InputMaybe<Scalars['DateTime']['input']>;
+};
+export type Person = {
+    __typename?: 'Person';
+    active?: Maybe<Scalars['Boolean']['output']>;
+    address?: Maybe<Array<Maybe<Address>>>;
+    birthDate?: Maybe<Scalars['String']['output']>;
+    gender?: Maybe<Scalars['String']['output']>;
+    id?: Maybe<Scalars['String']['output']>;
+    identifier?: Maybe<Array<Maybe<Identifier>>>;
+    implicitRules?: Maybe<Scalars['String']['output']>;
+    language?: Maybe<Scalars['String']['output']>;
+    link?: Maybe<Array<Maybe<PersonLink>>>;
+    managingOrganization?: Maybe<Reference>;
+    meta?: Maybe<PersonMeta>;
+    modifierExtension?: Maybe<Array<Maybe<Extension>>>;
+    name?: Maybe<Array<Maybe<Name>>>;
+    resourceType: Scalars['String']['output'];
+    telecom?: Maybe<Array<Maybe<ContactPoint>>>;
+};
+export type PersonBundle = {
+    __typename?: 'PersonBundle';
+    person?: Maybe<PersonEntry>;
+};
+export type PersonEntry = {
+    __typename?: 'PersonEntry';
+    entry?: Maybe<Array<Maybe<PersonResource>>>;
+};
+export type PersonInfoForLogin = {
+    __typename?: 'PersonInfoForLogin';
+    bwellPatientId?: Maybe<Scalars['String']['output']>;
+    bwellPersonId?: Maybe<Scalars['String']['output']>;
+    clientPatientId?: Maybe<Scalars['String']['output']>;
+    clientPersonId?: Maybe<Scalars['String']['output']>;
+    personExists?: Maybe<Scalars['Boolean']['output']>;
+};
+export type PersonInput = {
+    active?: InputMaybe<Scalars['Boolean']['input']>;
+    address?: InputMaybe<Array<InputMaybe<AddressInput>>>;
+    birthDate?: InputMaybe<Scalars['String']['input']>;
+    extension?: InputMaybe<Array<InputMaybe<ExtensionInput>>>;
+    gender?: InputMaybe<Scalars['String']['input']>;
+    id?: InputMaybe<Scalars['String']['input']>;
+    identifier?: InputMaybe<Array<InputMaybe<IdentifierInput>>>;
+    implicitRules?: InputMaybe<Scalars['String']['input']>;
+    language?: InputMaybe<Scalars['String']['input']>;
+    link?: InputMaybe<Array<InputMaybe<PersonLinkInput>>>;
+    managingOrganization?: InputMaybe<ReferenceInput>;
+    meta?: InputMaybe<PersonMetaInput>;
+    modifierExtension?: InputMaybe<Array<InputMaybe<ExtensionInput>>>;
+    name?: InputMaybe<Array<InputMaybe<NameInput>>>;
+    photo?: InputMaybe<AttachmentInput>;
+    telecom?: InputMaybe<Array<InputMaybe<ContactPointInput>>>;
+};
+export type PersonLink = {
+    __typename?: 'PersonLink';
+    assurance?: Maybe<Scalars['String']['output']>;
+    extension?: Maybe<Array<Maybe<Extension>>>;
+    id: Scalars['String']['output'];
+    /** Can define enum */
+    modifierExtension?: Maybe<Array<Maybe<Extension>>>;
+    target?: Maybe<Target>;
+};
+export type PersonLinkInput = {
+    assurance?: InputMaybe<Scalars['String']['input']>;
+    extension?: InputMaybe<Array<InputMaybe<ExtensionInput>>>;
+    id: Scalars['String']['input'];
+    /** Can define enum */
+    modifierExtension?: InputMaybe<Array<InputMaybe<ExtensionInput>>>;
+};
+export type PersonMeta = {
+    __typename?: 'PersonMeta';
+    extension?: Maybe<Array<Maybe<Extension>>>;
+    id?: Maybe<Scalars['String']['output']>;
+    lastUpdated?: Maybe<Scalars['String']['output']>;
+    profile?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+    security?: Maybe<Array<Maybe<Security>>>;
+    source?: Maybe<Scalars['uri']['output']>;
+    tag?: Maybe<Array<Maybe<Coding>>>;
+    versionId?: Maybe<Scalars['String']['output']>;
+};
+export type PersonMetaInput = {
+    extension?: InputMaybe<Array<InputMaybe<ExtensionInput>>>;
+    id?: InputMaybe<Scalars['String']['input']>;
+    lastUpdated?: InputMaybe<Scalars['String']['input']>;
+    profile?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
+    source?: InputMaybe<Scalars['uri']['input']>;
+    tag?: InputMaybe<Array<InputMaybe<PersonMetaTag>>>;
+    versionId?: InputMaybe<Scalars['String']['input']>;
+};
+export type PersonMetaTag = {
+    code?: InputMaybe<Scalars['String']['input']>;
+    display?: InputMaybe<Scalars['String']['input']>;
+    system?: InputMaybe<Scalars['String']['input']>;
+};
+export type PersonMetadata = {
+    __typename?: 'PersonMetadata';
+    ids?: Maybe<MetadataId>;
+    /** Return statusCode as 200 in case of get and 201 if the resource was created */
+    statusCode: Scalars['String']['output'];
+};
+export type PersonMetadataInput = {
+    id: Scalars['ID']['input'];
+    /** Return statusCode as 200 in case of get and 201 if the resource was created */
+    statusCode: Scalars['String']['input'];
+};
+export type PersonResource = {
+    __typename?: 'PersonResource';
+    resource?: Maybe<Person>;
+};
+export type PersonWithClientIdInput = {
+    clientSlug: Scalars['String']['input'];
+    person: PersonInput;
+};
+export type PersonWithMetadata = {
+    __typename?: 'PersonWithMetadata';
+    metadata?: Maybe<PersonMetadata>;
+    person?: Maybe<Person>;
+};
+export type PersonWithMetadataInput = {
+    metadata?: InputMaybe<PersonMetadataInput>;
+    person?: InputMaybe<PersonInput>;
+};
+export type Person_MetaSecurity = {
+    __typename?: 'Person_MetaSecurity';
+    code?: Maybe<Scalars['String']['output']>;
+    id?: Maybe<Scalars['String']['output']>;
+    system?: Maybe<Scalars['String']['output']>;
+    version?: Maybe<Scalars['String']['output']>;
+};
+export type Person_Patient = {
+    __typename?: 'Person_Patient';
+    id?: Maybe<Scalars['String']['output']>;
+    resourceType: Scalars['String']['output'];
+};
+export type Person_Task = {
+    __typename?: 'Person_Task';
+    id?: Maybe<Scalars['String']['output']>;
+    meta?: Maybe<Person_TaskMeta>;
+    resourceType?: Maybe<Scalars['String']['output']>;
+    status?: Maybe<Scalars['String']['output']>;
+};
+export type Person_TaskMeta = {
+    __typename?: 'Person_TaskMeta';
+    security?: Maybe<Array<Maybe<Person_MetaSecurity>>>;
+    source?: Maybe<Scalars['String']['output']>;
+};
+export type PolicyBasisInput = {
+    reference?: InputMaybe<Scalars['reference']['input']>;
+    uri?: InputMaybe<Scalars['uri']['input']>;
+};
+export type Position = {
+    __typename?: 'Position';
+    /**
+     * Would have liked to follow https://www.hl7.org/fhir/backboneelement.html
+     * But have to use lat and lon so ElasticSearch understands this is a GeoPoint
+     */
+    lat?: Maybe<Scalars['Float']['output']>;
+    lon?: Maybe<Scalars['Float']['output']>;
+};
+/** Type representing a practitioner with a human name */
+export type Practitioner = {
+    __typename?: 'Practitioner';
+    /** The human name of the practitioner */
+    name?: Maybe<Array<HumanName>>;
+};
+/** A reference to a practitioner who may be involved in an encounter. */
+export type PractitionerReference = {
+    __typename?: 'PractitionerReference';
+    id?: Maybe<Scalars['ID']['output']>;
+    /** The human name of the practitioner. */
+    name?: Maybe<Array<HumanName>>;
+};
+export type ProcedureGroup = ResourceGroup & {
+    __typename?: 'ProcedureGroup';
+    /** Coding representing the kind of Procedure in this composition */
+    coding?: Maybe<Coding>;
+    id?: Maybe<Scalars['ID']['output']>;
+    /** Human readable name of the procedure */
+    name?: Maybe<Scalars['String']['output']>;
+    /** A time period with a defined start and end date and time. */
+    performedDate?: Maybe<Scalars['DateTime']['output']>;
+    /** The list of individuals involved in the procedure. */
+    performer?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+    /** Array of Procedure id references in the Composition */
+    references?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+    /** Array of Strings representing the source of the data */
+    source?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+};
+export type ProcedureGroupQueryRequest = {
+    page?: InputMaybe<Scalars['Int']['input']>;
+    pageSize?: InputMaybe<Scalars['Int']['input']>;
+};
+export type ProcedureGroupQueryResults = PagedQueryResults & {
+    __typename?: 'ProcedureGroupQueryResults';
+    paging_info?: Maybe<PagingResults>;
+    resources: Array<ProcedureGroup>;
+};
+export type ProcedureQueryResults = PagedQueryResults & {
+    __typename?: 'ProcedureQueryResults';
+    paging_info?: Maybe<PagingResults>;
+    resources: Array<ProcedureResource>;
+};
+/** Input type for the Procedure query arguments */
+export type ProcedureRequest = {
+    /** Filter procedures with the given system and/or code */
+    groupCode?: InputMaybe<SearchToken>;
+    ids?: InputMaybe<Array<Scalars['String']['input']>>;
+    /** Filters based on the meta.lastUpdated date of the resource */
+    lastUpdated?: InputMaybe<SearchDate>;
+    /** Page offset */
+    page?: InputMaybe<Scalars['Int']['input']>;
+    /** Count of procedure in one page */
+    pageSize?: InputMaybe<Scalars['Int']['input']>;
+};
+/** Resource type for a procedure */
+export type ProcedureResource = {
+    __typename?: 'ProcedureResource';
+    /** Bodily location on which the procedure was performed */
+    bodySite?: Maybe<Array<Maybe<CodeableConcept>>>;
+    /** Classification of the procedure */
+    category?: Maybe<CodeableConcept>;
+    /** Identification of the procedure */
+    code?: Maybe<CodeableConcept>;
+    /** Any complications following the procedure */
+    complication?: Maybe<Array<Maybe<CodeableConcept>>>;
+    /** Consumer friendly name for procedures */
+    display?: Maybe<Scalars['String']['output']>;
+    /** Encounter during which the procedure was performed */
+    encounter?: Maybe<EncounterResource>;
+    /** Any follow-up required after the procedure */
+    followUp?: Maybe<Array<Maybe<CodeableConcept>>>;
+    /** Unique identifier for the procedure (non-nullable) */
+    id: Scalars['ID']['output'];
+    /** Meta information about the resource */
+    meta?: Maybe<Meta>;
+    /** Notes about the procedure */
+    note?: Maybe<Array<Maybe<Annotation>>>;
+    /** Outcome of the procedure */
+    outcome?: Maybe<CodeableConcept>;
+    /** Exact date and time when the procedure was performed */
+    performedDateTime?: Maybe<Scalars['DateTime']['output']>;
+    /** The period over which the procedure was performed */
+    performedPeriod?: Maybe<Period>;
+    /** Individuals who performed the procedure */
+    performer?: Maybe<Array<Maybe<Performer>>>;
+    /** Coded reasons procedure was performed */
+    reasonCode?: Maybe<Array<Maybe<CodeableConcept>>>;
+    /**
+     * Status of the procedure
+     * https://hl7.org/fhir/R4B/valueset-event-status.html
+     */
+    status?: Maybe<Code>;
+};
+export type Profile = {
+    __typename?: 'Profile';
+    active?: Maybe<Scalars['Boolean']['output']>;
+    address?: Maybe<ProfileAddress>;
+    birthDate?: Maybe<Scalars['String']['output']>;
+    email?: Maybe<Scalars['String']['output']>;
+    gender?: Maybe<Scalars['String']['output']>;
+    id?: Maybe<Scalars['String']['output']>;
+    language?: Maybe<Scalars['String']['output']>;
+    meta?: Maybe<ProfileMeta>;
+    name?: Maybe<ProfileName>;
+    phone?: Maybe<Scalars['String']['output']>;
+};
+export type ProfileAddress = {
+    __typename?: 'ProfileAddress';
+    city?: Maybe<Scalars['String']['output']>;
+    country?: Maybe<Scalars['String']['output']>;
+    district?: Maybe<Scalars['String']['output']>;
+    line_1?: Maybe<Scalars['String']['output']>;
+    line_2?: Maybe<Scalars['String']['output']>;
+    postalCode?: Maybe<Scalars['String']['output']>;
+    state?: Maybe<Scalars['String']['output']>;
+};
+export type ProfileContactPoint = {
+    __typename?: 'ProfileContactPoint';
+    phone?: Maybe<Scalars['String']['output']>;
+};
+export type ProfileMeta = {
+    __typename?: 'ProfileMeta';
+    tag?: Maybe<Array<Maybe<ProfileMetaTag>>>;
+};
+export type ProfileMetaTag = {
+    __typename?: 'ProfileMetaTag';
+    code?: Maybe<Scalars['String']['output']>;
+    display?: Maybe<Scalars['String']['output']>;
+    system?: Maybe<Scalars['String']['output']>;
+};
+export type ProfileName = {
+    __typename?: 'ProfileName';
+    first?: Maybe<Scalars['String']['output']>;
+    last?: Maybe<Scalars['String']['output']>;
+};
+export type ProtocolApplied = {
+    __typename?: 'ProtocolApplied';
+    /** A positive integer representing the dose number. */
+    doseNumberPositiveInt?: Maybe<Scalars['Int']['output']>;
+    /** A string representing the dose number. */
+    doseNumberString?: Maybe<Scalars['String']['output']>;
+};
+export type ProviderResult = {
+    __typename?: 'ProviderResult';
+    /** collection of characteristics (attributes) for a provider. */
+    characteristic?: Maybe<Array<Maybe<Coding>>>;
+    /** to show the affiliated organization */
+    content?: Maybe<Scalars['String']['output']>;
+    /** PROA connection information */
+    endpoint?: Maybe<Array<Maybe<Endpoint>>>;
+    /** gender */
+    gender?: Maybe<Gender>;
+    /** File path of organization icon */
+    iconString?: Maybe<Scalars['String']['output']>;
+    /** id of provider.  NPI for practitioners. */
+    id?: Maybe<Scalars['String']['output']>;
+    /** locations the provider practices */
+    location?: Maybe<Array<Maybe<Location>>>;
+    /** name structure */
+    name?: Maybe<Array<Maybe<HumanName>>>;
+    /** npi numbers for provider */
+    npi?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+    /** Organizations/Health Systems a Provider has practiced at */
+    organization?: Maybe<Array<Maybe<Organization>>>;
+    /** FHIR types of Organization or PROA categories */
+    organization_type?: Maybe<Array<Maybe<CodeableConcept>>>;
+    /** url to the photo of this provider */
+    photo?: Maybe<Array<Maybe<Attachment>>>;
+    /** qualifications of this provider, using its own class derived from FHIR spec */
+    practitioner_qualification?: Maybe<Array<Maybe<Qualification>>>;
+    /** provider_type */
+    provider_type?: Maybe<ProviderType>;
+    /** specialty of provider */
+    specialty?: Maybe<Array<Maybe<Coding>>>;
+    /** telecom info for email address */
+    telecom?: Maybe<Array<Maybe<ContactPoint>>>;
+};
+export type ProviderResults = {
+    __typename?: 'ProviderResults';
+    filter_values?: Maybe<Array<Maybe<FilterValues>>>;
+    paging_info?: Maybe<PagingInfo>;
+    results?: Maybe<Array<Maybe<ProviderResult>>>;
+};
+export declare enum ProviderType {
+    Practice = "practice",
+    Practitioner = "practitioner"
+}
+export type PublishEventDataField = {
+    key: Scalars['String']['input'];
+    value?: InputMaybe<Scalars['String']['input']>;
+};
+export type PublishEventRequest = {
+    bwellPersonId?: InputMaybe<Scalars['String']['input']>;
+    campaignId?: InputMaybe<Scalars['String']['input']>;
+    clientId?: InputMaybe<Scalars['String']['input']>;
+    data?: InputMaybe<Array<InputMaybe<PublishEventDataField>>>;
+    eventName?: InputMaybe<Scalars['String']['input']>;
+    eventType: EventType;
+    messageId?: InputMaybe<Scalars['String']['input']>;
+    templateId?: InputMaybe<Scalars['String']['input']>;
+};
+export type Qualification = {
+    __typename?: 'Qualification';
+    code?: Maybe<CodeableConcept>;
+    identifier?: Maybe<Identifier>;
+    issuer?: Maybe<Reference>;
+    period?: Maybe<Period>;
+};
+/** A measurable amount, including units, used for any quantifiable observation value. */
+export type Quantity = {
+    __typename?: 'Quantity';
+    /** The code specifying the unit (according to the system). */
+    code?: Maybe<Scalars['String']['output']>;
+    /** A comparator symbol (<, <=, >=, >) if the value is an approximation. */
+    comparator?: Maybe<Scalars['String']['output']>;
+    /** The system that defines the coded unit. */
+    system?: Maybe<Scalars['String']['output']>;
+    /** The unit of measure for the value. */
+    unit?: Maybe<Scalars['String']['output']>;
+    /** The numerical value measured. */
+    value?: Maybe<Scalars['Float']['output']>;
+};
+export type Query = {
+    __typename?: 'Query';
+    Empi?: Maybe<PersonBundle>;
+    accountDeletionStatusByClientPerson?: Maybe<Identity_Task>;
+    bootstrap: BootstrapConfiguration;
+    consent?: Maybe<Array<Maybe<LegacyConsent>>>;
+    consentAsyncTasks?: Maybe<Array<Maybe<Job>>>;
+    findPersonWithClientSlugAndId?: Maybe<PersonInfoForLogin>;
+    getAllergyIntoleranceGroups: AllergyIntoleranceGroupQueryResults;
+    /** Retrieves a list of AllergyIntolerance resources based on the provided search criteria. */
+    getAllergyIntolerances: AllergyIntoleranceQueryResults;
+    getCarePlanGroups: CarePlanGroupQueryResults;
+    /** Retrieves a list of CarePlan resources based on the provided search criteria. */
+    getCarePlans: CarePlanQueryResults;
+    getConditionGroups: ConditionGroupQueryResults;
+    getConditions: ConditionQueryResults;
+    getConsentJob?: Maybe<Job>;
+    getDataSource: DataSource;
+    getEncounterGroups: EncounterGroupQueryResults;
+    /** Retrieves a list of Encounter resources based on the provided search criteria. */
+    getEncounters: EncounterQueryResults;
+    /** Retrieves a list of HealthSummary resources based on the provided search criteria. */
+    getHealthSummary: HealthSummaryQueryResults;
+    getImmunizationGroups: ImmunizationGroupQueryResults;
+    getImmunizations: ImmunizationQueryResults;
+    getLabGroups: LabGroupQueryResults;
+    /** Retrieves knowledge information for a specific lab. */
+    getLabKnowledge: LabKnowledgeQueryResults;
+    /** Retrieves a list of labs based on the provided request parameters. */
+    getLabs: ObservationQueryResults;
+    getMedicationGroups: MedicationGroupQueryResults;
+    /** Retrieves knowledge information for a specific medication. */
+    getMedicationKnowledge: MedicationKnowledgeQueryResults;
+    /** Retrieves pricing information for a specific medication */
+    getMedicationPricing: MedicationPricingQueryResults;
+    getMedicationStatements: MedicationStatementQueryResults;
+    getMemberConnections: Array<Connection>;
+    getOauthUrl: GenerateUrl;
+    /** Retrieves a list of observations based on the provided request parameters. */
+    getObservations: ObservationQueryResults;
+    getPersonById?: Maybe<Person>;
+    getPersonByRegCode?: Maybe<RegCodePersonDto>;
+    getProcedureGroups: ProcedureGroupQueryResults;
+    getProcedures: ProcedureQueryResults;
+    /** Query to search for tasks.  This query is the preferred method for searching for tasks. */
+    getTasks?: Maybe<TaskQueryResults>;
+    getToken: AuthTokens;
+    getVitalSignGroups: VitalSignGroupQueryResults;
+    /** Retrieves a list of vital signs based on the provided request parameters. */
+    getVitalSigns: ObservationQueryResults;
+    initSdk: SdkConfiguration;
+    person?: Maybe<Person>;
+    placeholderQuery?: Maybe<Scalars['String']['output']>;
+    profile?: Maybe<Profile>;
+    /** Searches providers based on filters. */
+    providers: ProviderResults;
+    questionnaire?: Maybe<FhirFormQuestionnaire>;
+    questionnaireResponse?: Maybe<QuestionnaireResponse>;
+    questionnaireResponses?: Maybe<QuestionnaireResponse>;
+    refresh: RefreshToken;
+    /** Un-Authed Queries */
+    requestConnection?: Maybe<RequestConnectionOutput>;
+    search?: Maybe<Array<Maybe<Consent>>>;
+    status?: Maybe<Scalars['String']['output']>;
+    subscription_subscription?: Maybe<Subscription_SubscriptionBundle>;
+    /**
+     * Legacy query to search for tasks.  This query is deprecated and will be
+     * removed in a future release.  Use getTasks instead.
+     */
+    taskSearch?: Maybe<Array<Maybe<Task>>>;
+    userProfile?: Maybe<Person>;
+    who?: Maybe<Scalars['String']['output']>;
+};
+export type QueryEmpiArgs = {
+    empiType?: InputMaybe<EmpiType>;
+    id?: InputMaybe<Scalars['String']['input']>;
+};
+export type QueryAccountDeletionStatusByClientPersonArgs = {
+    clientPersonId: Scalars['String']['input'];
+};
+export type QueryBootstrapArgs = {
+    clientKey: Scalars['String']['input'];
+};
+export type QueryConsentArgs = {
+    patientId: Scalars['String']['input'];
+    questionnaireId?: InputMaybe<Scalars['String']['input']>;
+    questionnaireName?: InputMaybe<Scalars['String']['input']>;
+    searchParams?: InputMaybe<Scalars['String']['input']>;
+};
+export type QueryConsentAsyncTasksArgs = {
+    asc?: InputMaybe<Scalars['Boolean']['input']>;
+    end?: InputMaybe<Scalars['Int']['input']>;
+    start?: InputMaybe<Scalars['Int']['input']>;
+    status: Array<InputMaybe<Scalars['String']['input']>>;
+};
+export type QueryFindPersonWithClientSlugAndIdArgs = {
+    input?: InputMaybe<ClientSlugAndIdentifierInput>;
+};
+export type QueryGetAllergyIntoleranceGroupsArgs = {
+    request?: InputMaybe<AllergyIntoleranceGroupQueryRequest>;
+};
+export type QueryGetAllergyIntolerancesArgs = {
+    request?: InputMaybe<AllergyIntolerancesRequest>;
+};
+export type QueryGetCarePlanGroupsArgs = {
+    request?: InputMaybe<CarePlanGroupQueryRequest>;
+};
+export type QueryGetCarePlansArgs = {
+    request?: InputMaybe<CarePlanRequest>;
+};
+export type QueryGetConditionGroupsArgs = {
+    request?: InputMaybe<ConditionGroupQueryRequest>;
+};
+export type QueryGetConditionsArgs = {
+    request?: InputMaybe<ConditionRequest>;
+};
+export type QueryGetConsentJobArgs = {
+    jobID?: InputMaybe<Scalars['String']['input']>;
+};
+export type QueryGetDataSourceArgs = {
+    connectionId: Scalars['String']['input'];
+};
+export type QueryGetEncounterGroupsArgs = {
+    request?: InputMaybe<EncounterGroupQueryRequest>;
+};
+export type QueryGetEncountersArgs = {
+    request?: InputMaybe<EncounterRequest>;
+};
+export type QueryGetImmunizationGroupsArgs = {
+    request?: InputMaybe<ImmunizationGroupQueryRequest>;
+};
+export type QueryGetImmunizationsArgs = {
+    request?: InputMaybe<ImmunizationRequest>;
+};
+export type QueryGetLabGroupsArgs = {
+    request?: InputMaybe<LabGroupQueryRequest>;
+};
+export type QueryGetLabKnowledgeArgs = {
+    request?: InputMaybe<LabKnowledgeRequest>;
+};
+export type QueryGetLabsArgs = {
+    request?: InputMaybe<LabRequest>;
+};
+export type QueryGetMedicationGroupsArgs = {
+    request?: InputMaybe<MedicationGroupQueryRequest>;
+};
+export type QueryGetMedicationKnowledgeArgs = {
+    request?: InputMaybe<MedicationKnowledgeRequest>;
+};
+export type QueryGetMedicationPricingArgs = {
+    request?: InputMaybe<MedicationPricingRequest>;
+};
+export type QueryGetMedicationStatementsArgs = {
+    request?: InputMaybe<MedicationStatementQueryRequest>;
+};
+export type QueryGetOauthUrlArgs = {
+    connectionId: Scalars['String']['input'];
+};
+export type QueryGetObservationsArgs = {
+    request?: InputMaybe<ObservationRequest>;
+};
+export type QueryGetPersonByIdArgs = {
+    id: Scalars['ID']['input'];
+};
+export type QueryGetPersonByRegCodeArgs = {
+    regCode?: InputMaybe<Scalars['String']['input']>;
+};
+export type QueryGetProcedureGroupsArgs = {
+    request?: InputMaybe<ProcedureGroupQueryRequest>;
+};
+export type QueryGetProceduresArgs = {
+    request?: InputMaybe<ProcedureRequest>;
+};
+export type QueryGetTasksArgs = {
+    request?: InputMaybe<TaskRequest>;
+};
+export type QueryGetVitalSignGroupsArgs = {
+    request?: InputMaybe<VitalSignGroupQueryRequest>;
+};
+export type QueryGetVitalSignsArgs = {
+    request?: InputMaybe<VitalSignRequest>;
+};
+export type QueryInitSdkArgs = {
+    clientKey: Scalars['String']['input'];
+};
+export type QueryPersonArgs = {
+    id: Scalars['ID']['input'];
+};
+export type QueryProfileArgs = {
+    id: Scalars['ID']['input'];
+};
+export type QueryProvidersArgs = {
+    client?: InputMaybe<Array<InputMaybe<Client>>>;
+    filter_values?: InputMaybe<Array<InputMaybe<FilterField>>>;
+    gender?: InputMaybe<Gender>;
+    id_?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
+    include_inactive?: InputMaybe<Scalars['Boolean']['input']>;
+    include_populated_PROA_only?: InputMaybe<Scalars['Boolean']['input']>;
+    order_by?: InputMaybe<Array<InputMaybe<OrderBy>>>;
+    organization_type?: InputMaybe<Array<InputMaybe<OrganizationType>>>;
+    page_number?: InputMaybe<Scalars['Int']['input']>;
+    page_size?: InputMaybe<Scalars['Int']['input']>;
+    search?: InputMaybe<Scalars['String']['input']>;
+    search_position?: InputMaybe<SearchPosition>;
+    specialty?: InputMaybe<Array<InputMaybe<InputCoding>>>;
+    user?: InputMaybe<User>;
+};
+export type QueryQuestionnaireArgs = {
+    id?: InputMaybe<Scalars['ID']['input']>;
+    name?: InputMaybe<Scalars['String']['input']>;
+};
+export type QueryQuestionnaireResponseArgs = {
+    patientId: Scalars['String']['input'];
+    questionnaireId?: InputMaybe<Scalars['String']['input']>;
+    questionnaireName?: InputMaybe<Scalars['String']['input']>;
+    searchParams?: InputMaybe<Scalars['String']['input']>;
+};
+export type QueryQuestionnaireResponsesArgs = {
+    patientId: Scalars['String']['input'];
+    questionnaireId?: InputMaybe<Scalars['String']['input']>;
+    questionnaireName?: InputMaybe<Scalars['String']['input']>;
+    searchParams?: InputMaybe<Scalars['String']['input']>;
+};
+export type QueryRequestConnectionArgs = {
+    input?: InputMaybe<RequestConnectionInput>;
+};
+export type QuerySearchArgs = {
+    params: ConsentSearch;
+};
+export type QuerySubscription_SubscriptionArgs = {
+    _count?: InputMaybe<Scalars['Int']['input']>;
+    _debug?: InputMaybe<Scalars['Boolean']['input']>;
+    _explain?: InputMaybe<Scalars['Boolean']['input']>;
+    _getpagesoffset?: InputMaybe<Scalars['Int']['input']>;
+    _id?: InputMaybe<SearchString>;
+    _sort?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
+    _total?: InputMaybe<TotalType>;
+};
+export type QueryTaskSearchArgs = {
+    _count?: InputMaybe<Scalars['Int']['input']>;
+    _debug?: InputMaybe<Scalars['Boolean']['input']>;
+    _explain?: InputMaybe<Scalars['Boolean']['input']>;
+    _getpagesoffset?: InputMaybe<Scalars['Int']['input']>;
+    _id?: InputMaybe<SearchString>;
+    _lastUpdated?: InputMaybe<SearchDate>;
+    _profile?: InputMaybe<SearchString>;
+    _security?: InputMaybe<SearchToken>;
+    _sort?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
+    _source?: InputMaybe<SearchString>;
+    _tag?: InputMaybe<SearchToken>;
+    _total?: InputMaybe<TotalType>;
+    authored_on?: InputMaybe<SearchDate>;
+    based_on?: InputMaybe<SearchReference>;
+    code?: InputMaybe<SearchToken>;
+    contentLanguage?: InputMaybe<Scalars['String']['input']>;
+    enrichContent?: InputMaybe<Scalars['Boolean']['input']>;
+    focus?: InputMaybe<SearchReference>;
+    id?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
+    identifier?: InputMaybe<SearchToken>;
+    patient?: InputMaybe<SearchReference>;
+    period?: InputMaybe<SearchDate>;
+    sortMethod?: InputMaybe<Scalars['String']['input']>;
+    status?: InputMaybe<SearchToken>;
+    subject?: InputMaybe<SearchReference>;
+};
+export type Questionnaire = TaskBasedOnV2 & {
+    __typename?: 'Questionnaire';
+    approvalDate?: Maybe<Scalars['String']['output']>;
+    code?: Maybe<Array<Maybe<Coding>>>;
+    contained?: Maybe<Array<Maybe<ResourceContainer>>>;
+    copyright?: Maybe<Scalars['String']['output']>;
+    date?: Maybe<Scalars['String']['output']>;
+    derivedFrom?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+    description?: Maybe<Scalars['String']['output']>;
+    effectivePeriod?: Maybe<Period>;
+    experimental?: Maybe<Scalars['Boolean']['output']>;
+    extension?: Maybe<Array<Maybe<Extension>>>;
+    id?: Maybe<Scalars['String']['output']>;
+    identifier?: Maybe<Array<Maybe<Identifier>>>;
+    implicitRules?: Maybe<Scalars['String']['output']>;
+    item?: Maybe<Array<Maybe<QuestionnaireItem>>>;
+    jurisdiction?: Maybe<Array<Maybe<CodeableConcept>>>;
+    language?: Maybe<Scalars['String']['output']>;
+    lastReviewDate?: Maybe<Scalars['String']['output']>;
+    meta?: Maybe<Meta>;
+    modifierExtension?: Maybe<Array<Maybe<Extension>>>;
+    name?: Maybe<Scalars['String']['output']>;
+    publisher?: Maybe<Scalars['String']['output']>;
+    purpose?: Maybe<Scalars['String']['output']>;
+    resourceType?: Maybe<Scalars['String']['output']>;
+    status: Scalars['String']['output'];
+    subjectType?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+    text?: Maybe<Narrative>;
+    title?: Maybe<Scalars['String']['output']>;
+    url?: Maybe<Scalars['String']['output']>;
+    version?: Maybe<Scalars['String']['output']>;
+};
+export type QuestionnaireAnswerOption = {
+    __typename?: 'QuestionnaireAnswerOption';
+    extension?: Maybe<Array<Maybe<Extension>>>;
+    id?: Maybe<Scalars['String']['output']>;
+    initialSelected?: Maybe<Scalars['Boolean']['output']>;
+    modifierExtension?: Maybe<Array<Maybe<Extension>>>;
+    valueCoding?: Maybe<Coding>;
+    valueDate?: Maybe<Scalars['String']['output']>;
+    valueInteger?: Maybe<Scalars['Int']['output']>;
+    valueReference?: Maybe<Resource>;
+    valueString?: Maybe<Scalars['String']['output']>;
+    valueTime?: Maybe<Scalars['String']['output']>;
+};
+export type QuestionnaireEnableWhen = {
+    __typename?: 'QuestionnaireEnableWhen';
+    answerBoolean?: Maybe<Scalars['Boolean']['output']>;
+    answerCoding?: Maybe<Coding>;
+    answerDate?: Maybe<Scalars['String']['output']>;
+    answerDateTime?: Maybe<Scalars['String']['output']>;
+    answerDecimal?: Maybe<Scalars['String']['output']>;
+    answerInteger?: Maybe<Scalars['Int']['output']>;
+    answerReference?: Maybe<Resource>;
+    answerString?: Maybe<Scalars['String']['output']>;
+    answerTime?: Maybe<Scalars['String']['output']>;
+    extension?: Maybe<Array<Maybe<Extension>>>;
+    id?: Maybe<Scalars['String']['output']>;
+    modifierExtension?: Maybe<Array<Maybe<Extension>>>;
+    operator: Scalars['String']['output'];
+    question: Scalars['String']['output'];
+};
+export type QuestionnaireInitial = {
+    __typename?: 'QuestionnaireInitial';
+    extension?: Maybe<Array<Maybe<Extension>>>;
+    id?: Maybe<Scalars['String']['output']>;
+    modifierExtension?: Maybe<Array<Maybe<Extension>>>;
+    valueAttachment?: Maybe<Attachment>;
+    valueBoolean?: Maybe<Scalars['Boolean']['output']>;
+    valueCoding?: Maybe<Coding>;
+    valueDate?: Maybe<Scalars['String']['output']>;
+    valueDateTime?: Maybe<Scalars['String']['output']>;
+    valueDecimal?: Maybe<Scalars['String']['output']>;
+    valueInteger?: Maybe<Scalars['Int']['output']>;
+    valueReference?: Maybe<Resource>;
+    valueString?: Maybe<Scalars['String']['output']>;
+    valueTime?: Maybe<Scalars['String']['output']>;
+    valueUri?: Maybe<Scalars['String']['output']>;
+};
+export type QuestionnaireItem = {
+    __typename?: 'QuestionnaireItem';
+    answerOption?: Maybe<Array<Maybe<QuestionnaireAnswerOption>>>;
+    answerValueSet?: Maybe<Scalars['String']['output']>;
+    code?: Maybe<Array<Maybe<Coding>>>;
+    definition?: Maybe<Scalars['String']['output']>;
+    enableBehavior?: Maybe<Scalars['String']['output']>;
+    enableWhen?: Maybe<Array<Maybe<QuestionnaireEnableWhen>>>;
+    extension?: Maybe<Array<Maybe<Extension>>>;
+    id?: Maybe<Scalars['String']['output']>;
+    initial?: Maybe<Array<Maybe<QuestionnaireInitial>>>;
+    item?: Maybe<Array<Maybe<QuestionnaireItem>>>;
+    linkId: Scalars['String']['output'];
+    maxLength?: Maybe<Scalars['Int']['output']>;
+    modifierExtension?: Maybe<Array<Maybe<Extension>>>;
+    prefix?: Maybe<Scalars['String']['output']>;
+    readOnly?: Maybe<Scalars['Boolean']['output']>;
+    repeats?: Maybe<Scalars['Boolean']['output']>;
+    required?: Maybe<Scalars['Boolean']['output']>;
+    text?: Maybe<Scalars['String']['output']>;
+    type: Scalars['String']['output'];
+};
+export type QuestionnaireModelItem = {
+    __typename?: 'QuestionnaireModelItem';
+    answer?: Maybe<Array<Maybe<Scalars['QuestionnaireItemAnswer']['output']>>>;
+    code?: Maybe<Array<Maybe<Coding>>>;
+    extension?: Maybe<Array<Maybe<Extension>>>;
+    id?: Maybe<Scalars['String']['output']>;
+    item?: Maybe<Array<Maybe<QuestionnaireModelItem>>>;
+    linkId?: Maybe<Scalars['String']['output']>;
+    required?: Maybe<Scalars['Boolean']['output']>;
+    text?: Maybe<Scalars['String']['output']>;
+    type?: Maybe<Scalars['code']['output']>;
+};
+export type QuestionnaireResponse = {
+    __typename?: 'QuestionnaireResponse';
+    data?: Maybe<Scalars['QuestionnaireResponseData']['output']>;
+    patientId?: Maybe<Scalars['String']['output']>;
+    questionnaireName?: Maybe<Scalars['String']['output']>;
+};
+export type QuestionnaireResponseAnswer = {
+    __typename?: 'QuestionnaireResponseAnswer';
+    extension?: Maybe<Array<Maybe<Extension>>>;
+    id?: Maybe<Scalars['String']['output']>;
+    item?: Maybe<Array<Maybe<QuestionnaireResponseItem>>>;
+    modifierExtension?: Maybe<Array<Maybe<Extension>>>;
+    valueAttachment?: Maybe<Attachment>;
+    valueBoolean?: Maybe<Scalars['Boolean']['output']>;
+    valueCoding?: Maybe<Coding>;
+    valueDate?: Maybe<Scalars['String']['output']>;
+    valueDateTime?: Maybe<Scalars['String']['output']>;
+    valueDecimal?: Maybe<Scalars['String']['output']>;
+    valueInteger?: Maybe<Scalars['Int']['output']>;
+    valueReference?: Maybe<Resource>;
+    valueString?: Maybe<Scalars['String']['output']>;
+    valueTime?: Maybe<Scalars['String']['output']>;
+    valueUri?: Maybe<Scalars['String']['output']>;
+};
+export type QuestionnaireResponseAuthor = {
+    id?: Maybe<Scalars['String']['output']>;
+};
+export type QuestionnaireResponseBasedOn = {
+    id?: Maybe<Scalars['String']['output']>;
+};
+export type QuestionnaireResponseItem = {
+    __typename?: 'QuestionnaireResponseItem';
+    answer?: Maybe<Array<Maybe<QuestionnaireResponseAnswer>>>;
+    definition?: Maybe<Scalars['String']['output']>;
+    extension?: Maybe<Array<Maybe<Extension>>>;
+    id?: Maybe<Scalars['String']['output']>;
+    item?: Maybe<Array<Maybe<QuestionnaireResponseItem>>>;
+    linkId: Scalars['String']['output'];
+    modifierExtension?: Maybe<Array<Maybe<Extension>>>;
+    text?: Maybe<Scalars['String']['output']>;
+};
+export type QuestionnaireResponseModel = {
+    __typename?: 'QuestionnaireResponseModel';
+    author?: Maybe<Reference>;
+    authored?: Maybe<Scalars['dateTime']['output']>;
+    id?: Maybe<Scalars['String']['output']>;
+    identifier?: Maybe<Identifier>;
+    item?: Maybe<Array<Maybe<QuestionnaireResponseModelItem>>>;
+    resourceType?: Maybe<Scalars['String']['output']>;
+    status?: Maybe<Scalars['code']['output']>;
+    subject?: Maybe<Reference>;
+};
+export type QuestionnaireResponseModelItem = {
+    __typename?: 'QuestionnaireResponseModelItem';
+    answer?: Maybe<Array<Maybe<Scalars['QuestionnaireItemAnswer']['output']>>>;
+    code?: Maybe<Array<Maybe<Coding>>>;
+    extension?: Maybe<Array<Maybe<Extension>>>;
+    id?: Maybe<Scalars['String']['output']>;
+    item?: Maybe<Array<Maybe<QuestionnaireResponseModelItem>>>;
+    linkId?: Maybe<Scalars['String']['output']>;
+    required?: Maybe<Scalars['Boolean']['output']>;
+    text?: Maybe<Scalars['String']['output']>;
+    type?: Maybe<Scalars['code']['output']>;
+};
+export type QuestionnaireResponsePartOf = {
+    id?: Maybe<Scalars['String']['output']>;
+};
+export type QuestionnaireResponseSchema = {
+    __typename?: 'QuestionnaireResponseSchema';
+    description?: Maybe<Scalars['String']['output']>;
+    properties?: Maybe<Scalars['schemaProperties']['output']>;
+    required?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+    title?: Maybe<Scalars['String']['output']>;
+    type?: Maybe<Scalars['String']['output']>;
+};
+export type QuestionnaireResponseSource = {
+    id?: Maybe<Scalars['String']['output']>;
+};
+export type QuestionnaireResponseSubjectV2 = {
+    id?: Maybe<Scalars['String']['output']>;
+};
+export type QuestionnaireResponse_Input = {
+    data: Scalars['String']['input'];
+    patientId: Scalars['String']['input'];
+    questionnaireId?: InputMaybe<Scalars['String']['input']>;
+    questionnaireName?: InputMaybe<Scalars['String']['input']>;
+    source?: InputMaybe<Scalars['String']['input']>;
+    subject?: InputMaybe<Scalars['String']['input']>;
+};
+export declare enum Questionnaire_Enum_Schema {
+    QuestionnaireResponse = "QuestionnaireResponse"
+}
+/** A type defining a range with a low and high boundary, used for observations that have a range of values. */
+export type Range = {
+    __typename?: 'Range';
+    /** The high end of the range. */
+    high?: Maybe<Quantity>;
+    /** The low end of the range. */
+    low?: Maybe<Quantity>;
+};
+/** A type defining a ratio, which is a relationship between two Quantity values. */
+export type Ratio = {
+    __typename?: 'Ratio';
+    /** The denominator in the ratio. */
+    denominator?: Maybe<Quantity>;
+    /** The numerator in the ratio. */
+    numerator?: Maybe<Quantity>;
+};
+export type Reaction = {
+    __typename?: 'Reaction';
+    /** The date on which the reaction occurred. */
+    date?: Maybe<Scalars['DateTime']['output']>;
+    /** Text description of the reaction. */
+    description?: Maybe<Scalars['String']['output']>;
+    /** A detailed description of the reaction. */
+    detail?: Maybe<ObservationResource>;
+    /** The clinical symptoms/signs associated with the event. */
+    manifestation?: Maybe<Array<Maybe<CodeableConcept>>>;
+    /** Text about event not captured in other fields */
+    note?: Maybe<Array<Maybe<Annotation>>>;
+    /** When the reaction started. */
+    onset?: Maybe<Scalars['DateTime']['output']>;
+    /** Whether the reaction was reported by a clinician. */
+    reported?: Maybe<Scalars['Boolean']['output']>;
+    /** The severity of the reaction (e.g., mild, moderate, severe). */
+    severity?: Maybe<Code>;
+};
+/** Individual who recorded the record and takes responsibility for its content. */
+export type Recorder = Patient | Practitioner;
+export type RedisCacheCleanResponse = {
+    __typename?: 'RedisCacheCleanResponse';
+    cleared: Scalars['Boolean']['output'];
+    message?: Maybe<Scalars['String']['output']>;
+};
+export type Reference = {
+    __typename?: 'Reference';
+    display?: Maybe<Scalars['String']['output']>;
+    identifier?: Maybe<Identifier>;
+    reference?: Maybe<Scalars['String']['output']>;
+    type?: Maybe<Scalars['String']['output']>;
+};
+export type ReferenceInput = {
+    display?: InputMaybe<Scalars['String']['input']>;
+    extension?: InputMaybe<Array<InputMaybe<ExtensionInput>>>;
+    id: Scalars['String']['input'];
+    identifier?: InputMaybe<IdentifierInput>;
+    reference?: InputMaybe<Scalars['String']['input']>;
+    type?: InputMaybe<Scalars['uri']['input']>;
+};
+export type ReferenceRange = {
+    __typename?: 'ReferenceRange';
+    /** The high end of the normal range. */
+    high?: Maybe<Quantity>;
+    /** The low end of the normal range. */
+    low?: Maybe<Quantity>;
+    /** A textual representation or description of the range. */
+    text?: Maybe<Scalars['String']['output']>;
+};
+export type RefreshPayload = {
+    __typename?: 'RefreshPayload';
+    token: Scalars['String']['output'];
+};
+export type RefreshToken = {
+    __typename?: 'RefreshToken';
+    accessToken: Scalars['String']['output'];
+    idToken: Scalars['String']['output'];
+};
+export type RegCodePersonDto = {
+    __typename?: 'RegCodePersonDTO';
+    clientPatient?: Maybe<Person_Patient>;
+    isTaskExpired?: Maybe<Scalars['Boolean']['output']>;
+    masterPerson?: Maybe<Person>;
+    person?: Maybe<Person>;
+    taskExist?: Maybe<Scalars['Boolean']['output']>;
+};
+/** Un-Authed schema types */
+export type RequestConnectionInput = {
+    city?: InputMaybe<Scalars['String']['input']>;
+    institution?: InputMaybe<Scalars['String']['input']>;
+    provider?: InputMaybe<Scalars['String']['input']>;
+    state?: InputMaybe<Scalars['String']['input']>;
+};
+export type RequestConnectionOutput = {
+    __typename?: 'RequestConnectionOutput';
+    issue?: Maybe<Array<Maybe<Issue>>>;
+    resourceType?: Maybe<Scalars['String']['output']>;
+};
+export type Resource = {
+    id?: Maybe<Scalars['String']['output']>;
+    implicitRules?: Maybe<Scalars['String']['output']>;
+    language?: Maybe<Scalars['String']['output']>;
+    meta?: Maybe<Meta>;
+    resourceType?: Maybe<Scalars['String']['output']>;
+};
+export type ResourceContainer = {
+    __typename?: 'ResourceContainer';
+    id_?: Maybe<Scalars['String']['output']>;
+    meta?: Maybe<Meta>;
+};
+/** Base type to be implemented by other Group types */
+export type ResourceGroup = {
+    /** Coding representing the kind of data in this resource group */
+    coding?: Maybe<Coding>;
+    id?: Maybe<Scalars['ID']['output']>;
+    /** Human readable name of the composition data */
+    name?: Maybe<Scalars['String']['output']>;
+    /** Array of id references in the ResourceGroup */
+    references?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+    /** Array of Strings representing the source of the data */
+    source?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+};
+export type Rest = {
+    __typename?: 'Rest';
+    endpoints: RestEndpoints;
+};
+export type RestEndpoints = {
+    __typename?: 'RestEndpoints';
+    ats: Scalars['String']['output'];
+    big: Scalars['String']['output'];
+    health: Scalars['String']['output'];
+    healthProgramsGateway: Scalars['String']['output'];
+    user: Scalars['String']['output'];
+};
+export type Retry = {
+    __typename?: 'Retry';
+    attempts: Scalars['Float']['output'];
+    interval: Scalars['Float']['output'];
+};
+export type RouteDefinition = {
+    __typename?: 'RouteDefinition';
+    children?: Maybe<Array<Maybe<RouteDefinition>>>;
+    elementId?: Maybe<Scalars['String']['output']>;
+    id?: Maybe<Scalars['ID']['output']>;
+    index?: Maybe<Scalars['Boolean']['output']>;
+    meta?: Maybe<IdentityAuthed_Meta>;
+    path?: Maybe<Scalars['String']['output']>;
+};
+export type Schema = {
+    __typename?: 'Schema';
+    description?: Maybe<Scalars['String']['output']>;
+    properties?: Maybe<Scalars['schemaProperties']['output']>;
+    required?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+    title?: Maybe<Scalars['String']['output']>;
+    type?: Maybe<Scalars['String']['output']>;
+};
+export type SdkConfiguration = {
+    __typename?: 'SdkConfiguration';
+    graphQLClient: GraphQlClientConfig;
+    httpClient: HttpClientConfig;
+    logLevel?: Maybe<LogLevel>;
+    telemetry: TelemetryConfig;
+};
+export type SearchDate = {
+    missing?: InputMaybe<Scalars['Boolean']['input']>;
+    searchType?: InputMaybe<Scalars['String']['input']>;
+    value?: InputMaybe<SearchDateValue>;
+    values?: InputMaybe<Array<InputMaybe<SearchDateValue>>>;
+};
+/** Search parameter for filtering by date */
+export type SearchDateValue = {
+    /**
+     * the value for the parameter in the resource is approximately the same to the provided value.
+     * Note that the recommended value for the approximation is 10% of the stated value (or for a date, 10% of the gap between now and the date), but systems may choose other values where appropriate
+     */
+    approximately?: InputMaybe<Scalars['date']['input']>;
+    /** the value for the parameter in the resource ends before the provided value */
+    endsBefore?: InputMaybe<Scalars['date']['input']>;
+    /** the value for the parameter in the resource is equal to the provided value */
+    equals?: InputMaybe<Scalars['date']['input']>;
+    /** the value for the parameter in the resource is greater than the provided value */
+    greaterThan?: InputMaybe<Scalars['date']['input']>;
+    /** the value for the parameter in the resource is greater or equal to the provided value */
+    greaterThanOrEqualTo?: InputMaybe<Scalars['date']['input']>;
+    /** the value for the parameter in the resource is less than the provided value */
+    lessThan?: InputMaybe<Scalars['date']['input']>;
+    /** the value for the parameter in the resource is less or equal to the provided value */
+    lessThanOrEqualTo?: InputMaybe<Scalars['date']['input']>;
+    /** the value for the parameter in the resource is not equal to the provided value */
+    notEquals?: InputMaybe<Scalars['date']['input']>;
+    /** the value for the parameter in the resource starts after the provided value */
+    startsAfter?: InputMaybe<Scalars['date']['input']>;
+};
+export type SearchPosition = {
+    distance?: InputMaybe<Scalars['Float']['input']>;
+    /**
+     * Would have liked to follow https://www.hl7.org/fhir/backboneelement.html
+     * But have to use lat and lon so ElasticSearch understands this is a GeoPoint
+     */
+    lat: Scalars['Float']['input'];
+    lon: Scalars['Float']['input'];
+};
+export type SearchReference = {
+    missing?: InputMaybe<Scalars['Boolean']['input']>;
+    notEquals?: InputMaybe<SearchReferenceValue>;
+    searchType?: InputMaybe<Scalars['String']['input']>;
+    target?: InputMaybe<Scalars['String']['input']>;
+    value?: InputMaybe<Scalars['String']['input']>;
+};
+export type SearchReferenceValue = {
+    target?: InputMaybe<Scalars['String']['input']>;
+    value?: InputMaybe<Scalars['String']['input']>;
+};
+export type SearchString = {
+    above?: InputMaybe<Scalars['Boolean']['input']>;
+    below?: InputMaybe<Scalars['Boolean']['input']>;
+    missing?: InputMaybe<Scalars['Boolean']['input']>;
+    notEquals?: InputMaybe<SearchStringValue>;
+    searchType?: InputMaybe<Scalars['String']['input']>;
+    value?: InputMaybe<Scalars['String']['input']>;
+    values?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
+};
+export type SearchStringValue = {
+    value?: InputMaybe<Scalars['String']['input']>;
+    values?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
+};
+export type SearchToken = {
+    missing?: InputMaybe<Scalars['Boolean']['input']>;
+    notEquals?: InputMaybe<NotSearchTokenValue>;
+    searchType?: InputMaybe<Scalars['String']['input']>;
+    value?: InputMaybe<SearchTokenValue>;
+    values?: InputMaybe<Array<InputMaybe<SearchTokenValue>>>;
+};
+/** A custom scalar type for search tokens, typically used in FHIR for coded elements in searches. */
+export type SearchTokenValue = {
+    code?: InputMaybe<Scalars['String']['input']>;
+    notEquals?: InputMaybe<NotSearchTokenValue>;
+    system?: InputMaybe<Scalars['String']['input']>;
+    value?: InputMaybe<Scalars['String']['input']>;
+};
+export type Security = {
+    __typename?: 'Security';
+    code?: Maybe<Scalars['String']['output']>;
+    id?: Maybe<Scalars['String']['output']>;
+    system?: Maybe<Scalars['String']['output']>;
+};
+export declare enum SortField {
+    Content = "content",
+    Distance = "distance",
+    Relevance = "relevance"
+}
+export declare enum SortOrder {
+    Asc = "asc",
+    Desc = "desc"
+}
+/** Represents the subject (patient or group) of the care plan. */
+export type Subject = {
+    __typename?: 'Subject';
+    /** The type of the referenced resource. */
+    _resourceType?: Maybe<Scalars['String']['output']>;
+    /** The unique identifier of the subject resource. */
+    id?: Maybe<Scalars['ID']['output']>;
+};
+export type Subscription_Subscription = {
+    __typename?: 'Subscription_Subscription';
+    client_person_id?: Maybe<Scalars['String']['output']>;
+    connection_name?: Maybe<Scalars['String']['output']>;
+    connection_type?: Maybe<Scalars['String']['output']>;
+    criteria?: Maybe<Scalars['String']['output']>;
+    end?: Maybe<Scalars['instant']['output']>;
+    error?: Maybe<Scalars['String']['output']>;
+    id?: Maybe<Scalars['id']['output']>;
+    master_person_id?: Maybe<Scalars['String']['output']>;
+    reason?: Maybe<Scalars['String']['output']>;
+    resourceType?: Maybe<Scalars['String']['output']>;
+    service_slug?: Maybe<Scalars['String']['output']>;
+    source_patient_id?: Maybe<Scalars['String']['output']>;
+    status?: Maybe<Scalars['code']['output']>;
+    subscriptionStatus?: Maybe<Array<Maybe<Subscription_SubscriptionStatus>>>;
+};
+export type Subscription_SubscriptionBundle = {
+    __typename?: 'Subscription_SubscriptionBundle';
+    entry?: Maybe<Array<Maybe<Subscription_SubscriptionBundleEntry>>>;
+    id?: Maybe<Scalars['String']['output']>;
+    timestamp?: Maybe<Scalars['instant']['output']>;
+    total?: Maybe<Scalars['Int']['output']>;
+    type?: Maybe<Scalars['code']['output']>;
+};
+export type Subscription_SubscriptionBundleEntry = {
+    __typename?: 'Subscription_SubscriptionBundleEntry';
+    fullUrl?: Maybe<Scalars['uri']['output']>;
+    id?: Maybe<Scalars['String']['output']>;
+    resource?: Maybe<Subscription_Subscription>;
+};
+export type Subscription_SubscriptionStatus = {
+    __typename?: 'Subscription_SubscriptionStatus';
+    error?: Maybe<Array<Maybe<CodeableConcept>>>;
+    extension?: Maybe<Array<Maybe<Fhir_Extension>>>;
+    id?: Maybe<Scalars['id']['output']>;
+    notificationEvent?: Maybe<Array<Maybe<Subscription_SubscriptionStatusNotificationEvent>>>;
+    resourceType?: Maybe<Scalars['String']['output']>;
+    status?: Maybe<Scalars['code']['output']>;
+    subscription?: Maybe<Subscription_Subscription>;
+    subscriptionTopic?: Maybe<Subscription_SubscriptionTopic>;
+    topic?: Maybe<Scalars['canonical']['output']>;
+    type?: Maybe<Scalars['code']['output']>;
+};
+export type Subscription_SubscriptionStatusNotificationEvent = {
+    __typename?: 'Subscription_SubscriptionStatusNotificationEvent';
+    eventNumber?: Maybe<Scalars['String']['output']>;
+    id?: Maybe<Scalars['String']['output']>;
+    timestamp?: Maybe<Scalars['instant']['output']>;
+};
+export type Subscription_SubscriptionTopic = {
+    __typename?: 'Subscription_SubscriptionTopic';
+    id?: Maybe<Scalars['id']['output']>;
+    resourceTrigger?: Maybe<Array<Maybe<Subscription_SubscriptionTopicResourceTrigger>>>;
+    resourceType?: Maybe<Scalars['String']['output']>;
+    status?: Maybe<Scalars['code']['output']>;
+    title?: Maybe<Scalars['String']['output']>;
+    url?: Maybe<Scalars['uri']['output']>;
+    version?: Maybe<Scalars['String']['output']>;
+};
+export type Subscription_SubscriptionTopicResourceTrigger = {
+    __typename?: 'Subscription_SubscriptionTopicResourceTrigger';
+    id?: Maybe<Scalars['String']['output']>;
+    resource?: Maybe<Scalars['uri']['output']>;
+};
+export declare enum SyncStatus {
+    Error = "ERROR",
+    Pending = "PENDING",
+    Retrieved = "RETRIEVED",
+    Retrieving = "RETRIEVING"
+}
+export type Target = {
+    __typename?: 'Target';
+    id?: Maybe<Scalars['String']['output']>;
+    identifier?: Maybe<Array<Maybe<Identifier>>>;
+    link?: Maybe<Array<Maybe<PersonLink>>>;
+    meta?: Maybe<PersonMeta>;
+    resourceType?: Maybe<Scalars['String']['output']>;
+};
+export type Task = {
+    __typename?: 'Task';
+    For?: Maybe<Resource>;
+    authoredOn?: Maybe<Scalars['String']['output']>;
+    basedOn?: Maybe<Array<Maybe<Resource>>>;
+    basedOnV2?: Maybe<Array<Maybe<TaskBasedOnV2>>>;
+    code?: Maybe<CodeableConcept>;
+    contained?: Maybe<Array<Maybe<ResourceContainer>>>;
+    description?: Maybe<Scalars['String']['output']>;
+    executionPeriod?: Maybe<Period>;
+    extension?: Maybe<Array<Maybe<Extension>>>;
+    focus?: Maybe<Resource>;
+    focusV2?: Maybe<TaskFocusV2>;
+    forV2?: Maybe<TaskForV2>;
+    id?: Maybe<Scalars['String']['output']>;
+    identifier?: Maybe<Array<Maybe<Identifier>>>;
+    implicitRules?: Maybe<Scalars['String']['output']>;
+    instantiatesCanonical?: Maybe<Scalars['String']['output']>;
+    /** Below are not used but have simple types so we can just include them */
+    instantiatesUri?: Maybe<Scalars['String']['output']>;
+    intent?: Maybe<Scalars['String']['output']>;
+    language?: Maybe<Scalars['String']['output']>;
+    lastModified?: Maybe<Scalars['String']['output']>;
+    meta?: Maybe<Meta>;
+    modifierExtension?: Maybe<Array<Maybe<Extension>>>;
+    priority?: Maybe<Scalars['String']['output']>;
+    /** Below are all types currently used in the Task resource */
+    resourceType?: Maybe<Scalars['String']['output']>;
+    status?: Maybe<Scalars['String']['output']>;
+};
+/** TaskBasedOnV2 */
+export type TaskBasedOnV2 = {
+    id?: Maybe<Scalars['String']['output']>;
+};
+/** TaskFocusV2 */
+export type TaskFocusV2 = {
+    id?: Maybe<Scalars['String']['output']>;
+};
+/** TaskForV2 */
+export type TaskForV2 = {
+    id?: Maybe<Scalars['String']['output']>;
+};
+export type TaskQueryResults = PagedQueryResults & {
+    __typename?: 'TaskQueryResults';
+    paging_info?: Maybe<PagingResults>;
+    resources: Array<TaskResource>;
+};
+export type TaskRequest = {
+    code?: InputMaybe<SearchToken>;
+    contentLanguage?: InputMaybe<Scalars['String']['input']>;
+    enrichContent?: InputMaybe<Scalars['Boolean']['input']>;
+    id?: InputMaybe<SearchToken>;
+    identifier?: InputMaybe<SearchToken>;
+    page?: InputMaybe<Scalars['Int']['input']>;
+    pageSize?: InputMaybe<Scalars['Int']['input']>;
+    sortMethod?: InputMaybe<Scalars['String']['input']>;
+    status?: InputMaybe<SearchToken>;
+    subject?: InputMaybe<SearchToken>;
+    tag?: InputMaybe<SearchToken>;
+};
+export type TaskResource = {
+    __typename?: 'TaskResource';
+    businessStatus?: Maybe<CodeableConcept>;
+    code?: Maybe<CodeableConcept>;
+    description?: Maybe<Scalars['String']['output']>;
+    executionPeriod?: Maybe<Period>;
+    extension?: Maybe<Array<Maybe<Extension>>>;
+    for?: Maybe<Reference>;
+    id: Scalars['ID']['output'];
+    identifier?: Maybe<Array<Maybe<Identifier>>>;
+    instantiatesCanonical?: Maybe<Scalars['String']['output']>;
+    lastModified?: Maybe<Scalars['Date']['output']>;
+    meta?: Maybe<Meta>;
+    resourceType?: Maybe<Scalars['String']['output']>;
+    status?: Maybe<Code>;
+    statusReason?: Maybe<CodeableConcept>;
+};
+export declare enum TaskStatus {
+    Accepted = "ACCEPTED",
+    Cancelled = "CANCELLED",
+    Completed = "COMPLETED",
+    Draft = "DRAFT",
+    EnteredInError = "ENTERED_IN_ERROR",
+    Failed = "FAILED",
+    InProgress = "IN_PROGRESS",
+    OnHold = "ON_HOLD",
+    Ready = "READY",
+    Received = "RECEIVED",
+    Rejected = "REJECTED",
+    Requested = "REQUESTED"
+}
+export type TaskUpdateStatusRequest = {
+    newStatus: TaskStatus;
+    taskId: Scalars['String']['input'];
+};
+export type TaskUpdateStatusResponse = {
+    __typename?: 'TaskUpdateStatusResponse';
+    id?: Maybe<Scalars['String']['output']>;
+    status?: Maybe<TaskStatus>;
+};
+export type TaskWithMetadata = {
+    __typename?: 'TaskWithMetadata';
+    metadata?: Maybe<PersonMetadata>;
+    task?: Maybe<Person_Task>;
+};
+export type TelemetryConfig = {
+    __typename?: 'TelemetryConfig';
+    collectorUrl: Scalars['String']['output'];
+    enabled?: Maybe<Scalars['Boolean']['output']>;
+};
+export type Timing = {
+    __typename?: 'Timing';
+    code?: Maybe<CodeableConcept>;
+    event?: Maybe<Array<Scalars['DateTime']['output']>>;
+    id?: Maybe<Scalars['ID']['output']>;
+    repeat?: Maybe<TimingRepeat>;
+};
+export type TimingRepeat = {
+    __typename?: 'TimingRepeat';
+    boundsDuration?: Maybe<Quantity>;
+    boundsPeriod?: Maybe<Period>;
+    boundsRange?: Maybe<Range>;
+    count?: Maybe<Scalars['Int']['output']>;
+    countMax?: Maybe<Scalars['Int']['output']>;
+    dayOfWeek?: Maybe<Array<Code>>;
+    duration?: Maybe<Scalars['Float']['output']>;
+    durationMax?: Maybe<Scalars['Float']['output']>;
+    durationUnit?: Maybe<Code>;
+    frequency?: Maybe<Scalars['Int']['output']>;
+    frequencyMax?: Maybe<Scalars['Int']['output']>;
+    id?: Maybe<Scalars['ID']['output']>;
+    offset?: Maybe<Scalars['Int']['output']>;
+    period?: Maybe<Scalars['Float']['output']>;
+    periodMax?: Maybe<Scalars['Float']['output']>;
+    periodUnit?: Maybe<Code>;
+    /** https://hl7.org/fhir/R4B/datatypes.html#time */
+    timeOfDay?: Maybe<Array<Scalars['String']['output']>>;
+    when?: Maybe<Array<Code>>;
+};
+export type TokenPayload = {
+    __typename?: 'TokenPayload';
+    jwtToken: Scalars['String']['output'];
+};
+export declare enum TotalType {
+    Accurate = "accurate",
+    Estimate = "estimate"
+}
+export type UpdateDeviceRegistrationRequest = {
+    applicationName: Scalars['String']['input'];
+    bwellPersonId?: InputMaybe<Scalars['String']['input']>;
+    clientId?: InputMaybe<Scalars['String']['input']>;
+    deviceToken: Scalars['String']['input'];
+    notificationPreference: Scalars['Boolean']['input'];
+    platform: Scalars['String']['input'];
+};
+export type UpdatedPersonMetadata = {
+    __typename?: 'UpdatedPersonMetadata';
+    statusCode?: Maybe<Scalars['String']['output']>;
+};
+export type User = {
+    app_id?: InputMaybe<Scalars['String']['input']>;
+    email?: InputMaybe<Scalars['String']['input']>;
+    id?: InputMaybe<Scalars['String']['input']>;
+    ip?: InputMaybe<Scalars['String']['input']>;
+    referring_url?: InputMaybe<Scalars['String']['input']>;
+    request_id?: InputMaybe<Scalars['String']['input']>;
+    session_id?: InputMaybe<Scalars['String']['input']>;
+};
+export type Value = {
+    __typename?: 'Value';
+    /** A boolean value for the Observation. */
+    valueBoolean?: Maybe<Scalars['Boolean']['output']>;
+    /** A coded value for the Observation. */
+    valueCodeableConcept?: Maybe<CodeableConcept>;
+    /** A date and time value for the Observation. */
+    valueDateTime?: Maybe<Scalars['DateTime']['output']>;
+    /** An integer value for the Observation. */
+    valueInteger?: Maybe<Scalars['Int']['output']>;
+    /** A period or interval of time for the Observation. */
+    valuePeriod?: Maybe<Period>;
+    /** Numerical value with units for the Observation. */
+    valueQuantity?: Maybe<Quantity>;
+    /** A range of values (with low and high bounds) for the Observation. */
+    valueRange?: Maybe<Range>;
+    /** A ratio of two Quantity values for the Observation. */
+    valueRatio?: Maybe<Ratio>;
+    /** A string value for the Observation. */
+    valueString?: Maybe<Scalars['String']['output']>;
+    /** A time value for the Observation (without date). */
+    valueTime?: Maybe<Scalars['String']['output']>;
+};
+export type Variant = {
+    __typename?: 'Variant';
+    name: Scalars['String']['output'];
+    percent: Scalars['Float']['output'];
+    value: Scalars['String']['output'];
+};
+export type VitalSignGroup = ResourceGroup & {
+    __typename?: 'VitalSignGroup';
+    /** A structured set of codes including a text representation. */
+    category?: Maybe<Array<Maybe<CodeableConcept>>>;
+    /** Coding representing the kind of Vital Sign in this ResourceGroup */
+    coding?: Maybe<Coding>;
+    /** Component observations as part of this observation. */
+    component?: Maybe<Array<Maybe<Component>>>;
+    /** The single point in time when the observation was made. */
+    effectiveDateTime?: Maybe<Scalars['DateTime']['output']>;
+    id?: Maybe<Scalars['ID']['output']>;
+    /** The interpretation of the observation results. */
+    interpretation?: Maybe<Array<Maybe<CodeableConcept>>>;
+    /** Human readable name of the Vital Sign */
+    name?: Maybe<Scalars['String']['output']>;
+    /** Reference ranges for interpreting the observation value. */
+    referenceRange?: Maybe<Array<Maybe<ReferenceRange>>>;
+    /** Array of immunization id references in the ResourceGroup */
+    references?: Maybe<Array<Scalars['String']['output']>>;
+    /** Array of Strings representing the source of the data */
+    source?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
+    /** The value of the observation. At most, one ObservationValue type will be returned per Observation */
+    value?: Maybe<Value>;
+};
+export type VitalSignGroupQueryRequest = {
+    page?: InputMaybe<Scalars['Int']['input']>;
+    pageSize?: InputMaybe<Scalars['Int']['input']>;
+};
+export type VitalSignGroupQueryResults = PagedQueryResults & {
+    __typename?: 'VitalSignGroupQueryResults';
+    paging_info?: Maybe<PagingResults>;
+    resources: Array<VitalSignGroup>;
+};
+/** Defines input parameters for querying Vital Sign resources. */
+export type VitalSignRequest = {
+    /** Filter for vital signs with the given code system */
+    groupCode?: InputMaybe<SearchToken>;
+    ids?: InputMaybe<Array<Scalars['String']['input']>>;
+    /** Filters based on the meta.lastUpdated date of the resource */
+    lastUpdated?: InputMaybe<SearchDate>;
+    /** Page offset */
+    page?: InputMaybe<Scalars['Int']['input']>;
+    /** The maximum number of results to return (for pagination). */
+    pageSize?: InputMaybe<Scalars['Int']['input']>;
+};
+export type Zendesk = {
+    __typename?: 'Zendesk';
+    key?: Maybe<Scalars['String']['output']>;
+    uri: Scalars['String']['output'];
+};