@haste-health/generated-ops 0.12.3

package/lib/r4/ops.d.ts

@@ -0,0 +1,741 @@
+import type * as fhirTypes from "@haste-health/fhir-types/r4/types";
+import { IOperation } from "@haste-health/operation-execution";
+export declare namespace ProjectInformation {
+    type Input = Record<string, never>;
+    type Output = {
+        project: fhirTypes.Project;
+    };
+    type IOp = IOperation<Input, Output>;
+    const Op: IOp;
+}
+export declare namespace TenantInformation {
+    type Input = Record<string, never>;
+    type Output = {
+        id: fhirTypes.string;
+        subscription: fhirTypes.code;
+    };
+    type IOp = IOperation<Input, Output>;
+    const Op: IOp;
+}
+export declare namespace HasteHealthDeployOperation {
+    type Input = {
+        code: fhirTypes.string;
+        environment?: Array<{
+            name: fhirTypes.string;
+            value: fhirTypes.string;
+        }>;
+    };
+    type Output = fhirTypes.OperationOutcome;
+    type IOp = IOperation<Input, Output>;
+    const Op: IOp;
+}
+export declare namespace HasteHealthEncrypt {
+    type Input = {
+        value: fhirTypes.string;
+    };
+    type Output = {
+        encryptedValue: fhirTypes.string;
+    };
+    type IOp = IOperation<Input, Output>;
+    const Op: IOp;
+}
+export declare namespace HasteHealthEvaluatePolicy {
+    type Input = {
+        user?: fhirTypes.Reference;
+        request: fhirTypes.Bundle;
+    };
+    type Output = fhirTypes.OperationOutcome;
+    type IOp = IOperation<Input, Output>;
+    const Op: IOp;
+}
+export declare namespace HasteHealthIdpRegistrationInfo {
+    type Input = Record<string, never>;
+    type Output = {
+        information?: Array<{
+            name: fhirTypes.string;
+            value: fhirTypes.string;
+        }>;
+    };
+    type IOp = IOperation<Input, Output>;
+    const Op: IOp;
+}
+export declare namespace HasteHealthInviteUser {
+    type Input = {
+        email: fhirTypes.string;
+        role: fhirTypes.code;
+        accessPolicy?: fhirTypes.Reference;
+    };
+    type Output = fhirTypes.OperationOutcome;
+    type IOp = IOperation<Input, Output>;
+    const Op: IOp;
+}
+export declare namespace HasteHealthMessagePost {
+    type Input = {
+        input: fhirTypes.Resource;
+    };
+    type Output = fhirTypes.OperationOutcome;
+    type IOp = IOperation<Input, Output>;
+    const Op: IOp;
+}
+export declare namespace HasteHealthPasswordReset {
+    type Input = {
+        email: {
+            subject: fhirTypes.string;
+            body: fhirTypes.string;
+            acceptText: fhirTypes.string;
+        };
+    };
+    type Output = fhirTypes.OperationOutcome;
+    type IOp = IOperation<Input, Output>;
+    const Op: IOp;
+}
+export declare namespace HasteHealthDeleteRefreshToken {
+    type Input = {
+        client_id: fhirTypes.id;
+        user_agent?: fhirTypes.string;
+    };
+    type Output = fhirTypes.OperationOutcome;
+    type IOp = IOperation<Input, Output>;
+    const Op: IOp;
+}
+export declare namespace HasteHealthListRefreshTokens {
+    type Input = Record<string, never>;
+    type Output = {
+        "refresh-tokens"?: Array<{
+            client_id: fhirTypes.id;
+            user_agent: fhirTypes.string;
+            created_at: fhirTypes.dateTime;
+        }>;
+    };
+    type IOp = IOperation<Input, Output>;
+    const Op: IOp;
+}
+export declare namespace HasteHealthDeleteScope {
+    type Input = {
+        client_id: fhirTypes.id;
+    };
+    type Output = fhirTypes.OperationOutcome;
+    type IOp = IOperation<Input, Output>;
+    const Op: IOp;
+}
+export declare namespace HasteHealthListScopes {
+    type Input = Record<string, never>;
+    type Output = {
+        scopes?: Array<{
+            client_id: fhirTypes.id;
+            scopes: fhirTypes.string;
+            created_at: fhirTypes.dateTime;
+        }>;
+    };
+    type IOp = IOperation<Input, Output>;
+    const Op: IOp;
+}
+export declare namespace HasteHealthUsageStatistics {
+    type Input = Record<string, never>;
+    type Output = {
+        statistics?: Array<{
+            name: fhirTypes.string;
+            version: fhirTypes.string;
+            limit: fhirTypes.integer;
+            usage: fhirTypes.integer;
+            description: fhirTypes.string;
+        }>;
+    };
+    type IOp = IOperation<Input, Output>;
+    const Op: IOp;
+}
+export declare namespace ActivityDefinitionApply {
+    type Input = {
+        activityDefinition?: fhirTypes.ActivityDefinition;
+        subject: Array<fhirTypes.string>;
+        encounter?: fhirTypes.string;
+        practitioner?: fhirTypes.string;
+        organization?: fhirTypes.string;
+        userType?: fhirTypes.CodeableConcept;
+        userLanguage?: fhirTypes.CodeableConcept;
+        userTaskContext?: fhirTypes.CodeableConcept;
+        setting?: fhirTypes.CodeableConcept;
+        settingContext?: fhirTypes.CodeableConcept;
+    };
+    type Output = fhirTypes.Resource;
+    type IOp = IOperation<Input, Output>;
+    const Op: IOp;
+}
+export declare namespace ActivityDefinitionDataRequirements {
+    type Input = Record<string, never>;
+    type Output = fhirTypes.Library;
+    type IOp = IOperation<Input, Output>;
+    const Op: IOp;
+}
+export declare namespace CapabilityStatementConforms {
+    type Input = {
+        left?: fhirTypes.canonical;
+        right?: fhirTypes.canonical;
+        mode?: fhirTypes.code;
+    };
+    type Output = {
+        issues: fhirTypes.OperationOutcome;
+        union?: fhirTypes.CapabilityStatement;
+        intersection?: fhirTypes.CapabilityStatement;
+    };
+    type IOp = IOperation<Input, Output>;
+    const Op: IOp;
+}
+export declare namespace CapabilityStatementImplements {
+    type Input = {
+        server?: fhirTypes.canonical;
+        client?: fhirTypes.canonical;
+        resource?: fhirTypes.CapabilityStatement;
+    };
+    type Output = fhirTypes.OperationOutcome;
+    type IOp = IOperation<Input, Output>;
+    const Op: IOp;
+}
+export declare namespace CapabilityStatementSubset {
+    type Input = {
+        server?: fhirTypes.uri;
+        resource: Array<fhirTypes.code>;
+    };
+    type Output = fhirTypes.CapabilityStatement;
+    type IOp = IOperation<Input, Output>;
+    const Op: IOp;
+}
+export declare namespace CapabilityStatementVersions {
+    type Input = Record<string, never>;
+    type Output = {
+        version: Array<fhirTypes.code>;
+        default: fhirTypes.code;
+    };
+    type IOp = IOperation<Input, Output>;
+    const Op: IOp;
+}
+export declare namespace ChargeItemDefinitionApply {
+    type Input = {
+        chargeItem: fhirTypes.Reference;
+        account?: fhirTypes.Reference;
+    };
+    type Output = fhirTypes.Resource;
+    type IOp = IOperation<Input, Output>;
+    const Op: IOp;
+}
+export declare namespace ClaimSubmit {
+    type Input = {
+        resource: fhirTypes.Resource;
+    };
+    type Output = fhirTypes.Resource;
+    type IOp = IOperation<Input, Output>;
+    const Op: IOp;
+}
+export declare namespace CodeSystemFindMatches {
+    type Input = {
+        system?: fhirTypes.uri;
+        version?: fhirTypes.string;
+        property?: Array<{
+            code: fhirTypes.code;
+            value?: fhirTypes.Element;
+            subproperty?: Array<{
+                code: fhirTypes.code;
+                value: fhirTypes.Element;
+            }>;
+        }>;
+        exact: fhirTypes.boolean;
+        compositional?: fhirTypes.boolean;
+    };
+    type Output = {
+        match?: Array<{
+            code: fhirTypes.Coding;
+            unmatched?: Array<{
+                code: fhirTypes.code;
+                value: fhirTypes.Element;
+                property?: Array<{
+                    code: fhirTypes.code;
+                    value: fhirTypes.Element;
+                }>;
+            }>;
+            comment?: fhirTypes.string;
+        }>;
+    };
+    type IOp = IOperation<Input, Output>;
+    const Op: IOp;
+}
+export declare namespace CodeSystemLookup {
+    type Input = {
+        code?: fhirTypes.code;
+        system?: fhirTypes.uri;
+        version?: fhirTypes.string;
+        coding?: fhirTypes.Coding;
+        date?: fhirTypes.dateTime;
+        displayLanguage?: fhirTypes.code;
+        property?: Array<fhirTypes.code>;
+    };
+    type Output = {
+        name: fhirTypes.string;
+        version?: fhirTypes.string;
+        display: fhirTypes.string;
+        designation?: Array<{
+            language?: fhirTypes.code;
+            use?: fhirTypes.Coding;
+            value: fhirTypes.string;
+        }>;
+        property?: Array<{
+            code: fhirTypes.code;
+            value?: fhirTypes.Element;
+            description?: fhirTypes.string;
+            subproperty?: Array<{
+                code: fhirTypes.code;
+                value: fhirTypes.Element;
+                description?: fhirTypes.string;
+            }>;
+        }>;
+    };
+    type IOp = IOperation<Input, Output>;
+    const Op: IOp;
+}
+export declare namespace CodeSystemSubsumes {
+    type Input = {
+        codeA?: fhirTypes.code;
+        codeB?: fhirTypes.code;
+        system?: fhirTypes.uri;
+        version?: fhirTypes.string;
+        codingA?: fhirTypes.Coding;
+        codingB?: fhirTypes.Coding;
+    };
+    type Output = {
+        outcome: fhirTypes.code;
+    };
+    type IOp = IOperation<Input, Output>;
+    const Op: IOp;
+}
+export declare namespace CodeSystemValidateCode {
+    type Input = {
+        url?: fhirTypes.uri;
+        codeSystem?: fhirTypes.CodeSystem;
+        code?: fhirTypes.code;
+        version?: fhirTypes.string;
+        display?: fhirTypes.string;
+        coding?: fhirTypes.Coding;
+        codeableConcept?: fhirTypes.CodeableConcept;
+        date?: fhirTypes.dateTime;
+        abstract?: fhirTypes.boolean;
+        displayLanguage?: fhirTypes.code;
+    };
+    type Output = {
+        result: fhirTypes.boolean;
+        message?: fhirTypes.string;
+        display?: fhirTypes.string;
+    };
+    type IOp = IOperation<Input, Output>;
+    const Op: IOp;
+}
+export declare namespace CompositionDocument {
+    type Input = {
+        id?: fhirTypes.uri;
+        persist?: fhirTypes.boolean;
+        graph?: fhirTypes.uri;
+    };
+    type Output = Record<string, never>;
+    type IOp = IOperation<Input, Output>;
+    const Op: IOp;
+}
+export declare namespace ConceptMapClosure {
+    type Input = {
+        name: fhirTypes.string;
+        concept?: Array<fhirTypes.Coding>;
+        version?: fhirTypes.string;
+    };
+    type Output = fhirTypes.ConceptMap;
+    type IOp = IOperation<Input, Output>;
+    const Op: IOp;
+}
+export declare namespace ConceptMapTranslate {
+    type Input = {
+        url?: fhirTypes.uri;
+        conceptMap?: fhirTypes.ConceptMap;
+        conceptMapVersion?: fhirTypes.string;
+        code?: fhirTypes.code;
+        system?: fhirTypes.uri;
+        version?: fhirTypes.string;
+        source?: fhirTypes.uri;
+        coding?: fhirTypes.Coding;
+        codeableConcept?: fhirTypes.CodeableConcept;
+        target?: fhirTypes.uri;
+        targetsystem?: fhirTypes.uri;
+        dependency?: Array<{
+            element?: fhirTypes.uri;
+            concept?: fhirTypes.CodeableConcept;
+        }>;
+        reverse?: fhirTypes.boolean;
+    };
+    type Output = {
+        result: fhirTypes.boolean;
+        message?: fhirTypes.string;
+        match?: Array<{
+            equivalence?: fhirTypes.code;
+            concept?: fhirTypes.Coding;
+            product?: Array<{
+                element?: fhirTypes.uri;
+                concept?: fhirTypes.Coding;
+            }>;
+            source?: fhirTypes.uri;
+        }>;
+    };
+    type IOp = IOperation<Input, Output>;
+    const Op: IOp;
+}
+export declare namespace CoverageEligibilityRequestSubmit {
+    type Input = {
+        resource: fhirTypes.Resource;
+    };
+    type Output = fhirTypes.Resource;
+    type IOp = IOperation<Input, Output>;
+    const Op: IOp;
+}
+export declare namespace EncounterEverything {
+    type Input = {
+        _since?: fhirTypes.instant;
+        _type?: Array<fhirTypes.code>;
+        _count?: fhirTypes.integer;
+    };
+    type Output = fhirTypes.Bundle;
+    type IOp = IOperation<Input, Output>;
+    const Op: IOp;
+}
+export declare namespace GroupEverything {
+    type Input = {
+        start?: fhirTypes.date;
+        end?: fhirTypes.date;
+        _since?: fhirTypes.instant;
+        _type?: Array<fhirTypes.code>;
+        _count?: fhirTypes.integer;
+    };
+    type Output = fhirTypes.Bundle;
+    type IOp = IOperation<Input, Output>;
+    const Op: IOp;
+}
+export declare namespace LibraryDataRequirements {
+    type Input = {
+        target?: fhirTypes.string;
+    };
+    type Output = fhirTypes.Library;
+    type IOp = IOperation<Input, Output>;
+    const Op: IOp;
+}
+export declare namespace ListFind {
+    type Input = {
+        patient: fhirTypes.id;
+        name: fhirTypes.code;
+    };
+    type Output = Record<string, never>;
+    type IOp = IOperation<Input, Output>;
+    const Op: IOp;
+}
+export declare namespace MeasureCareGaps {
+    type Input = {
+        periodStart: fhirTypes.date;
+        periodEnd: fhirTypes.date;
+        topic: fhirTypes.string;
+        subject: fhirTypes.string;
+    };
+    type Output = fhirTypes.Bundle;
+    type IOp = IOperation<Input, Output>;
+    const Op: IOp;
+}
+export declare namespace MeasureCollectData {
+    type Input = {
+        periodStart: fhirTypes.date;
+        periodEnd: fhirTypes.date;
+        measure?: fhirTypes.string;
+        subject?: fhirTypes.string;
+        practitioner?: fhirTypes.string;
+        lastReceivedOn?: fhirTypes.dateTime;
+    };
+    type Output = {
+        measureReport: fhirTypes.MeasureReport;
+        resource?: Array<fhirTypes.Resource>;
+    };
+    type IOp = IOperation<Input, Output>;
+    const Op: IOp;
+}
+export declare namespace MeasureDataRequirements {
+    type Input = {
+        periodStart: fhirTypes.date;
+        periodEnd: fhirTypes.date;
+    };
+    type Output = fhirTypes.Library;
+    type IOp = IOperation<Input, Output>;
+    const Op: IOp;
+}
+export declare namespace MeasureEvaluateMeasure {
+    type Input = {
+        periodStart: fhirTypes.date;
+        periodEnd: fhirTypes.date;
+        measure?: fhirTypes.string;
+        reportType?: fhirTypes.code;
+        subject?: fhirTypes.string;
+        practitioner?: fhirTypes.string;
+        lastReceivedOn?: fhirTypes.dateTime;
+    };
+    type Output = fhirTypes.MeasureReport;
+    type IOp = IOperation<Input, Output>;
+    const Op: IOp;
+}
+export declare namespace MeasureSubmitData {
+    type Input = {
+        measureReport: fhirTypes.MeasureReport;
+        resource?: Array<fhirTypes.Resource>;
+    };
+    type Output = Record<string, never>;
+    type IOp = IOperation<Input, Output>;
+    const Op: IOp;
+}
+export declare namespace MedicinalProductEverything {
+    type Input = {
+        _since?: fhirTypes.instant;
+        _count?: fhirTypes.integer;
+    };
+    type Output = fhirTypes.Bundle;
+    type IOp = IOperation<Input, Output>;
+    const Op: IOp;
+}
+export declare namespace MessageHeaderProcessMessage {
+    type Input = {
+        content: fhirTypes.Bundle;
+        async?: fhirTypes.boolean;
+        "response-url"?: fhirTypes.url;
+    };
+    type Output = fhirTypes.Bundle;
+    type IOp = IOperation<Input, Output>;
+    const Op: IOp;
+}
+export declare namespace NamingSystemPreferredId {
+    type Input = {
+        id: fhirTypes.string;
+        type: fhirTypes.code;
+    };
+    type Output = {
+        result: fhirTypes.string;
+    };
+    type IOp = IOperation<Input, Output>;
+    const Op: IOp;
+}
+export declare namespace ObservationLastn {
+    type Input = {
+        max?: fhirTypes.positiveInt;
+    };
+    type Output = fhirTypes.Bundle;
+    type IOp = IOperation<Input, Output>;
+    const Op: IOp;
+}
+export declare namespace ObservationStats {
+    type Input = {
+        subject: fhirTypes.uri;
+        code?: Array<fhirTypes.string>;
+        system?: fhirTypes.uri;
+        coding?: Array<fhirTypes.Coding>;
+        duration?: fhirTypes.decimal;
+        period?: fhirTypes.Period;
+        statistic: Array<fhirTypes.code>;
+        include?: fhirTypes.boolean;
+        limit?: fhirTypes.positiveInt;
+    };
+    type Output = {
+        statistics: Array<fhirTypes.Observation>;
+        source?: Array<fhirTypes.Observation>;
+    };
+    type IOp = IOperation<Input, Output>;
+    const Op: IOp;
+}
+export declare namespace PatientEverything {
+    type Input = {
+        start?: fhirTypes.date;
+        end?: fhirTypes.date;
+        _since?: fhirTypes.instant;
+        _type?: Array<fhirTypes.code>;
+        _count?: fhirTypes.integer;
+    };
+    type Output = fhirTypes.Bundle;
+    type IOp = IOperation<Input, Output>;
+    const Op: IOp;
+}
+export declare namespace PatientMatch {
+    type Input = {
+        resource: fhirTypes.Resource;
+        onlyCertainMatches?: fhirTypes.boolean;
+        count?: fhirTypes.integer;
+    };
+    type Output = fhirTypes.Bundle;
+    type IOp = IOperation<Input, Output>;
+    const Op: IOp;
+}
+export declare namespace PlanDefinitionApply {
+    type Input = {
+        planDefinition?: fhirTypes.PlanDefinition;
+        subject: Array<fhirTypes.string>;
+        encounter?: fhirTypes.string;
+        practitioner?: fhirTypes.string;
+        organization?: fhirTypes.string;
+        userType?: fhirTypes.CodeableConcept;
+        userLanguage?: fhirTypes.CodeableConcept;
+        userTaskContext?: fhirTypes.CodeableConcept;
+        setting?: fhirTypes.CodeableConcept;
+        settingContext?: fhirTypes.CodeableConcept;
+    };
+    type Output = fhirTypes.CarePlan;
+    type IOp = IOperation<Input, Output>;
+    const Op: IOp;
+}
+export declare namespace PlanDefinitionDataRequirements {
+    type Input = Record<string, never>;
+    type Output = fhirTypes.Library;
+    type IOp = IOperation<Input, Output>;
+    const Op: IOp;
+}
+export declare namespace ResourceConvert {
+    type Input = {
+        input: fhirTypes.Resource;
+    };
+    type Output = {
+        output: fhirTypes.Resource;
+    };
+    type IOp = IOperation<Input, Output>;
+    const Op: IOp;
+}
+export declare namespace ResourceGraph {
+    type Input = {
+        graph: fhirTypes.uri;
+    };
+    type Output = {
+        result: fhirTypes.Bundle;
+    };
+    type IOp = IOperation<Input, Output>;
+    const Op: IOp;
+}
+export declare namespace ResourceGraphql {
+    type Input = {
+        query: fhirTypes.string;
+    };
+    type Output = {
+        result: fhirTypes.Binary;
+    };
+    type IOp = IOperation<Input, Output>;
+    const Op: IOp;
+}
+export declare namespace ResourceMeta {
+    type Input = Record<string, never>;
+    type Output = {
+        return: fhirTypes.Meta;
+    };
+    type IOp = IOperation<Input, Output>;
+    const Op: IOp;
+}
+export declare namespace ResourceMetaAdd {
+    type Input = {
+        meta: fhirTypes.Meta;
+    };
+    type Output = {
+        return: fhirTypes.Meta;
+    };
+    type IOp = IOperation<Input, Output>;
+    const Op: IOp;
+}
+export declare namespace ResourceMetaDelete {
+    type Input = {
+        meta: fhirTypes.Meta;
+    };
+    type Output = {
+        return: fhirTypes.Meta;
+    };
+    type IOp = IOperation<Input, Output>;
+    const Op: IOp;
+}
+export declare namespace ResourceValidate {
+    type Input = {
+        resource?: fhirTypes.Resource;
+        mode?: fhirTypes.code;
+        profile?: fhirTypes.uri;
+    };
+    type Output = fhirTypes.OperationOutcome;
+    type IOp = IOperation<Input, Output>;
+    const Op: IOp;
+}
+export declare namespace StructureDefinitionQuestionnaire {
+    type Input = {
+        identifier?: fhirTypes.canonical;
+        profile?: fhirTypes.string;
+        url?: fhirTypes.canonical;
+        supportedOnly?: fhirTypes.boolean;
+    };
+    type Output = fhirTypes.Questionnaire;
+    type IOp = IOperation<Input, Output>;
+    const Op: IOp;
+}
+export declare namespace StructureDefinitionSnapshot {
+    type Input = {
+        definition?: fhirTypes.StructureDefinition;
+        url?: fhirTypes.string;
+    };
+    type Output = fhirTypes.StructureDefinition;
+    type IOp = IOperation<Input, Output>;
+    const Op: IOp;
+}
+export declare namespace StructureMapTransform {
+    type Input = {
+        source?: fhirTypes.uri;
+        content: fhirTypes.Resource;
+    };
+    type Output = fhirTypes.Resource;
+    type IOp = IOperation<Input, Output>;
+    const Op: IOp;
+}
+export declare namespace ValueSetExpand {
+    type Input = {
+        url?: fhirTypes.uri;
+        valueSet?: fhirTypes.ValueSet;
+        valueSetVersion?: fhirTypes.string;
+        context?: fhirTypes.uri;
+        contextDirection?: fhirTypes.code;
+        filter?: fhirTypes.string;
+        date?: fhirTypes.dateTime;
+        offset?: fhirTypes.integer;
+        count?: fhirTypes.integer;
+        includeDesignations?: fhirTypes.boolean;
+        designation?: Array<fhirTypes.string>;
+        includeDefinition?: fhirTypes.boolean;
+        activeOnly?: fhirTypes.boolean;
+        excludeNested?: fhirTypes.boolean;
+        excludeNotForUI?: fhirTypes.boolean;
+        excludePostCoordinated?: fhirTypes.boolean;
+        displayLanguage?: fhirTypes.code;
+        "exclude-system"?: Array<fhirTypes.canonical>;
+        "system-version"?: Array<fhirTypes.canonical>;
+        "check-system-version"?: Array<fhirTypes.canonical>;
+        "force-system-version"?: Array<fhirTypes.canonical>;
+    };
+    type Output = fhirTypes.ValueSet;
+    type IOp = IOperation<Input, Output>;
+    const Op: IOp;
+}
+export declare namespace ValueSetValidateCode {
+    type Input = {
+        url?: fhirTypes.uri;
+        context?: fhirTypes.uri;
+        valueSet?: fhirTypes.ValueSet;
+        valueSetVersion?: fhirTypes.string;
+        code?: fhirTypes.code;
+        system?: fhirTypes.uri;
+        systemVersion?: fhirTypes.string;
+        display?: fhirTypes.string;
+        coding?: fhirTypes.Coding;
+        codeableConcept?: fhirTypes.CodeableConcept;
+        date?: fhirTypes.dateTime;
+        abstract?: fhirTypes.boolean;
+        displayLanguage?: fhirTypes.code;
+    };
+    type Output = {
+        result: fhirTypes.boolean;
+        message?: fhirTypes.string;
+        display?: fhirTypes.string;
+    };
+    type IOp = IOperation<Input, Output>;
+    const Op: IOp;
+}