@nsshunt/stsappframework 3.1.149 → 3.1.151

package/src/fhir/STSFhirTypes.ts

@@ -1,541 +0,0 @@
-import { IDBAccessLayer } from '@nsshunt/stsdatamanagement'
-import { JSONObject } from '@nsshunt/stsutils'
-
-export interface IBase {
-
-}
-
-export interface IExtension {
-
-}
-
-export interface IElement extends IBase {
-    id?: string
-    extension?: IExtension
-}
-
-export interface IDataType extends IElement {
-
-}
-
-export interface IPrimitiveType extends IDataType {
-
-}
-
-export interface ICode extends IPrimitiveType {
-
-}
-
-export interface IResource extends IBase {
-    id?: IId
-    meta?: IMeta
-    implicitRules?: string // uri
-    language?: string // code
-}
-
-export type IId = string;
-
-export type IUri = string;
-
-export type IUrl = string;
-
-export interface ICanonical<T> extends IPrimitiveType {
-    uri: IUri
-    _type: T
-}
-
-export type IMarkdown = string;
-
-export type IMimeType = string;
-
-export interface IMeta extends IDataType {
-    // from Element: extension
-    versionId? : IId, // Version specific identifier
-    lastUpdated? : IInstant, // When the resource version last changed
-    source? : IUri, // Identifies where the resource comes from
-    profile? : ICanonical<IStructureDefinition>[], // Profiles this resource claims to conform to
-    security? : ICoding[], // Security Labels applied to this resource
-    tag? : ICoding[] // Tags applied to this resource
-}
-
-// https://www.hl7.org/fhir/narrative.html#Narrative
-export interface INarrative extends IDataType {
-    status: 'generated' | 'extensions' | 'additional' | 'empty'
-    div: string // xhtml 
-}
-
-// https://www.hl7.org/fhir/domainresource.html
-export interface IDomainResource extends IResource {
-    text?: INarrative
-    contained?: IResource
-    extension?: IExtension
-    modifierExtension?: IExtension
-    _resourceType: string
-}
-
-// https://hl7.org/fhir/R5/structuredefinition.html#StructureDefinition
-export interface IStructureDefinition extends IDomainResource {
-    _resourceType : "StructureDefinition",
-    // from Resource: id, meta, implicitRules, and language
-    // from DomainResource: text, contained, extension, and modifierExtension
-    url : IUri, // I R!  Canonical identifier for this structure definition, represented as a URI (globally unique)
-    identifier? : IIdentifier[], // Additional identifier for the structure definition
-    version? : string, // Business version of the structure definition
-    // versionAlgorithm[x]: How to compare versions. One of these 2:
-    versionAlgorithmString? : string,
-    versionAlgorithmCoding? : ICoding,
-    name : string, // I R!  Name for this structure definition (computer friendly)
-    title? : string, // Name for this structure definition (human friendly)
-    status : 'draft' | 'active' | 'retired' | 'unknown'
-    experimental? : boolean, // For testing purposes, not real usage
-    date? : IDateTime, // Date last changed
-    publisher? : string, // Name of the publisher/steward (organization or individual)
-    contact? : IContactDetail[], // Contact details for the publisher
-    description? : IMarkdown // "<markdown>", // Natural language description of the structure definition
-    useContext? : IUsageContext[] // The context that the content is intended to support
-    jurisdiction? : ICodeableConcept[], // Intended jurisdiction for structure definition (if applicable)
-    purpose? : IMarkdown // "<markdown>", // Why this structure definition is defined
-    copyright? : IMarkdown // "<markdown>", // Use and/or publishing restrictions
-    copyrightLabel? : string, // Copyright holder and year(s)
-    keyword? : ICoding[], // Assist with indexing and finding
-    fhirVersion? : ICode // "<code>", // FHIR Version this StructureDefinition targets
-    mapping? : { // External specification that the content is mapped to
-        identity : IId, // R!  Internal id when this mapping is used
-        uri? : IUri, // I Identifies what this mapping refers to
-        name? : string, // I Names what this mapping refers to
-        comment? : string // Versions, Issues, Scope limitations etc
-    }[],
-    kind : 'primitive-type' | 'complex-type' | 'resource' | 'logical'
-    abstract : boolean, // I R!  Whether the structure is abstract
-    context?: { // I If an extension, where it can be used in instances
-        type : 'fhirpath' | 'element' | 'extension'
-        expression : string // R!  Where the extension can be used in instances
-    }[],
-    contextInvariant? : string[], // I FHIRPath invariants - when the extension can be used
-    type : IUri, // I R!  Type defined or constrained by this structure
-    baseDefinition? : ICanonical<IStructureDefinition>, // I Definition that this type is constrained/specialized from
-    derivation? : 'specialization' | 'constraint' // - How relates to base definition
-    snapshot? : { // I Snapshot view of the structure
-        element : IElementDefinition[] // I R!  Definition of elements in the resource (if no StructureDefinition)
-    },
-    differential? : { // I Differential view of the structure
-        element : IElementDefinition[] // I R!  Definition of elements in the resource (if no StructureDefinition)
-    }
-}
-
-// https://hl7.org/fhir/R5/datatypes.html#Coding
-// https://hl7.org/fhir/R5/datatypes.html#code
-export interface ICoding extends IDataType {
-    // from Element: extension
-    system? : IUri // "<uri>", // Identity of the terminology system
-    version? : string // Version of the system - if relevant
-    code? : string // "<code>", // I Symbol in syntax defined by the system
-    display? : string // I Representation defined by the system
-    userSelected? : boolean // If this coding was chosen directly by the user
-}
-
-// https://hl7.org/fhir/R5/datatypes.html#CodeableConcept
-export interface ICodeableConcept {
-    // from Element: extension
-    coding? : ICoding[], // Code defined by a terminology system
-    text? : string // Plain text representation of the concept
-}
-
-// https://www.hl7.org/fhir/references.html#Reference
-export interface IReference<T> extends IDataType {
-    // from Element: extension
-    reference? : string, // I Literal reference, Relative, internal or absolute URL
-    type? : IUri // "<uri>", // Type the reference refers to (e.g. "Patient") - must be a resource in resources
-    identifier? : IIdentifier // I Logical reference, when literal reference is not known
-    display? : string // I Text alternative for the resource
-    _type: T
-}
-
-// https://www.hl7.org/fhir/references.html#CodeableReference
-export interface ICodeableReference<T> extends IDataType {
-    // from Element: extension
-    concept? : ICodeableConcept, // Reference to a concept (by class)
-    reference? : IReference<T> // Reference to a resource (by instance)
-}
-
-// https://hl7.org/fhir/R5/datatypes.html#identifier
-export interface IIdentifier extends IDataType {
-    // from Element: extension
-    use? : "usual" | "official" | "temp" | "secondary" | "old"
-    type? : ICodeableConcept, // Description of identifier
-    system? : string // "<uri>", // The namespace for the identifier value
-    value? : string, // I The value that is unique
-    period? : IPeriod, // Time period when id is/was valid for use
-    assigner? : IReference<IOrganization> // Organization that issued id (may be just text)
-}
-
-// https://www.hl7.org/fhir/datatypes.html#Period
-export interface IPeriod extends IDataType {
-    // from Element: extension
-    start? : Date // "<dateTime>", // I Starting time with inclusive boundary
-    end? : Date // "<dateTime>" // I End time with inclusive boundary, if not ongoing
-}
-
-// https://www.hl7.org/fhir/datatypes.html#instant
-export interface IInstant extends IPrimitiveType {
-    dateTime: Date | number | string
-}
-
-// https://www.hl7.org/fhir/datatypes.html#dateTime
-export interface IDateTime extends IPrimitiveType {
-    dateTime: Date | number | string
-}
-
-// https://www.hl7.org/fhir/datatypes.html#Money
-export interface IMoney extends IDataType {
-    // from Element: extension
-    value? : number // <decimal>, // Numerical value (with implicit precision)
-    currency? : string // "<code>" // ISO 4217 Currency Code
-}
-
-export interface IContactDetail {
-
-}
-
-export interface IElementDefinition {
-
-}
-
-export interface IUsageContext {
-
-}
-
-
-
-/*
-declare interface IElement<T> {
-    id: string
-    extension: IExtension[]
-}
-*/
-
-/*
-// https://hl7.org/fhir/R5/extensibility.html#extension
-declare interface IExtension {
-    // from Element: extension
-    "url" : string // "<uri>", // R!  identifies the meaning of the extension
-    // value[x]: Value of extension. One of these 54:
-    "valueBase64Binary" : "<base64Binary>"
-    "valueBoolean" : boolean,
-    "valueCanonical" : "<canonical>",
-    "valueCode" : "<code>",
-    "valueDate" : "<date>",
-    "valueDateTime" : "<dateTime>",
-    "valueDecimal" : <decimal>,
-    "valueId" : "<id>",
-    "valueInstant" : "<instant>",
-    "valueInteger" : <integer>,
-    "valueInteger64" : "<integer64>",
-    "valueMarkdown" : "<markdown>",
-    "valueOid" : "<oid>",
-    "valuePositiveInt" : "<positiveInt>",
-    "valueString" : "<string>",
-    "valueTime" : "<time>",
-    "valueUnsignedInt" : "<unsignedInt>",
-    "valueUri" : "<uri>",
-    "valueUrl" : "<url>",
-    "valueUuid" : "<uuid>",
-    "valueAddress" : { Address },
-    "valueAge" : { Age },
-    "valueAnnotation" : { Annotation },
-    "valueAttachment" : { Attachment },
-    "valueCodeableConcept" : { CodeableConcept },
-    "valueCodeableReference" : { CodeableReference },
-    "valueCoding" : { Coding },
-    "valueContactPoint" : { ContactPoint },
-    "valueCount" : { Count },
-    "valueDistance" : { Distance },
-    "valueDuration" : { Duration },
-    "valueHumanName" : { HumanName },
-    "valueIdentifier" : { Identifier },
-    "valueMoney" : { Money },
-    "valuePeriod" : { Period },
-    "valueQuantity" : { Quantity },
-    "valueRange" : { Range },
-    "valueRatio" : { Ratio },
-    "valueRatioRange" : { RatioRange },
-    "valueReference" : { Reference },
-    "valueSampledData" : { SampledData },
-    "valueSignature" : { Signature },
-    "valueTiming" : { Timing },
-    "valueContactDetail" : { ContactDetail },
-    "valueDataRequirement" : { DataRequirement },
-    "valueExpression" : { Expression },
-    "valueParameterDefinition" : { ParameterDefinition },
-    "valueRelatedArtifact" : { RelatedArtifact },
-    "valueTriggerDefinition" : { TriggerDefinition },
-    "valueUsageContext" : { UsageContext },
-    "valueAvailability" : { Availability },
-    "valueExtendedContactDetail" : { ExtendedContactDetail },
-    "valueDosage" : { Dosage },
-    "valueMeta" : { Meta },
-}
-*/
-
-// https://www.hl7.org/fhir/account.html
-export interface IAccount extends IDomainResource {
-    _resourceType : "Account",
-    // from Resource: id, meta, implicitRules, and language
-    // from DomainResource: text, contained, extension, and modifierExtension
-    identifier? : IIdentifier[], // Account number
-    status : "active" | "inactive" | "entered-in-error" | "on-hold" | "unknown"
-    billingStatus? : ICodeableConcept, // Tracks the lifecycle of the account through the billing process
-    type? : ICodeableConcept, // E.g. patient, expense, depreciation
-    name? : string, // Human-readable label
-    subject? : IReference<IDevice | IHealthcareService | ILocation | IOrganization | IPatient | IPractitioner | IPractitionerRole>[], // The entity that caused the expenses
-    servicePeriod? : IPeriod, // Transaction window
-    coverage? : [{ // The party(s) that are responsible for covering the payment of this account, and what order should they be applied to the account
-        coverage : IReference<ICoverage>, // R!  The party(s), such as insurances, that may contribute to the payment of this account
-        priority? : number // "<positiveInt>" // The priority of the coverage in the context of this account
-    }],
-    owner? : IReference<IOrganization>, // Entity managing the Account
-    description? : string; // "<markdown>", // Explanation of purpose/use
-    guarantor? : { // The parties ultimately responsible for balancing the Account
-        party : IReference<IOrganization | IPatient | IRelatedPerson>, // R!  Responsible entity
-        onHold? : true, // Credit or other hold applied
-        period? : IPeriod // Guarantee account during
-    }[],
-    diagnosis? : { // The list of diagnoses relevant to this account
-        sequence? : number // "<positiveInt>", // Ranking of the diagnosis (for each type)
-        condition : ICodeableReference<ICondition>, // I R!  The diagnosis relevant to the account
-        dateOfDiagnosis? : IDateTime // "<dateTime>", // I Date of the diagnosis (when coded diagnosis)
-        type? : ICodeableConcept[], // Type that this diagnosis has relevant to the account (e.g. admission, billing, discharge …)
-        onAdmission? : boolean, // Diagnosis present on Admission
-        packageCode? : ICodeableConcept[] // Package Code specific for billing
-    }[],
-    procedure? : { // The list of procedures relevant to this account
-        sequence? : number // "<positiveInt>", // Ranking of the procedure (for each type)
-        code : ICodeableReference<IProcedure>, // I R!  The procedure relevant to the account
-        dateOfService? : IDateTime, // I Date of the procedure (when coded procedure)
-        type? : ICodeableConcept[], // How this procedure value should be used in charging the account
-        packageCode? : ICodeableConcept[], // Package Code specific for billing
-        device? : IReference<IDevice>[] // Any devices that were associated with the procedure
-    }[],
-    relatedAccount? : { // Other associated accounts related to this account
-        relationship? : ICodeableConcept, // Relationship of the associated Account
-        account : IReference<IAccount> // R!  Reference to an associated Account
-    }[],
-    currency? : ICodeableConcept, // The base or default currency
-    balance?: { // Calculated account balance(s)
-        aggregate? : ICodeableConcept, // Who is expected to pay this part of the balance
-        term? : ICodeableConcept, // current | 30 | 60 | 90 | 120
-        estimate? : boolean, // Estimated balance
-        amount : IMoney // R!  Calculated amount
-    }[],
-    calculatedAt? : IInstant // Time the balance amount was calculated
-}
-
-// https://www.hl7.org/fhir/organization.html#Organization
-export interface IOrganization extends IDomainResource {
-    _resourceType : "Organization",
-    // from Resource: id, meta, implicitRules, and language
-    // from DomainResource: text, contained, extension, and modifierExtension
-    identifier? : IIdentifier[], // I Identifies this organization  across multiple systems
-    active? : boolean, // Whether the organization's record is still in active use
-    type? : ICodeableConcept[], // Kind of organization
-    name? : string, // I Name used for the organization
-    alias? : string[], // A list of alternate names that the organization is known as, or was known as in the past
-    description? : IMarkdown // "<markdown>", // Additional details about the Organization that could be displayed as further information to identify the Organization beyond its name
-    contact? : IExtendedContactDetail[], // Official contact details for the Organization
-    partOf? : IReference<IOrganization>, // The organization of which this organization forms a part
-    endpoint? : IReference<IEndpoint>[], // Technical endpoints providing access to services operated for the organization
-    qualification? : { // Qualifications, certifications, accreditations, licenses, training, etc. pertaining to the provision of care
-        identifier? : IIdentifier[], // An identifier for this qualification for the organization
-        code : ICodeableConcept, // R!  Coded representation of the qualification
-        period? : IPeriod, // Period during which the qualification is valid
-        issuer? : IReference<IOrganization> // Organization that regulates and issues the qualification
-    }[]
-}
-
-// https://www.hl7.org/fhir/endpoint.html#Endpoint
-export interface IEndpoint extends IDomainResource{
-    resourceType : "Endpoint",
-    // from Resource: id, meta, implicitRules, and language
-    // from DomainResource: text, contained, extension, and modifierExtension
-    identifier? : IIdentifier[], // Identifies this endpoint across multiple systems
-    status : 'active' | 'suspended' | 'error' | 'off' | 'entered-in-error' | 'test'
-    connectionType : ICodeableConcept[], // R!  Protocol/Profile/Standard to be used with this endpoint connection
-    name? : string, // A name that this endpoint can be identified by
-    description? : string, // Additional details about the endpoint that could be displayed as further information to identify the description beyond its name
-    environmentType? : ICodeableConcept[], // The type of environment(s) exposed at this endpoint
-    managingOrganization? : IReference<IOrganization>, // Organization that manages this endpoint (might not be the organization that exposes the endpoint)
-    contact? : IContactPoint[], // Contact details for source (e.g. troubleshooting)
-    period? : IPeriod, // Interval the endpoint is expected to be operational
-    payload? : { // Set of payloads that are provided by this endpoint
-        type? : ICodeableConcept[], // The type of content that may be used at this endpoint (e.g. XDS Discharge summaries)
-        mimeType? : IMimeType[] // Mimetype to send. If not specified, the content could be anything (including no payload, if the connectionType defined this)
-    }[],
-    address : IUrl, // R!  The technical base address for connecting to this endpoint
-    header? : string[] // Usage depends on the channel type
-}
-
-// https://www.hl7.org/fhir/metadatatypes.html#ExtendedContactDetail
-export interface IExtendedContactDetail extends IDataType {
-    // from Element: extension
-    purpose? : ICodeableConcept, // The type of contact icon
-    name? : IHumanName[], // Name of an individual to contact
-    telecom? : IContactPoint[], // Contact details (e.g.phone/fax/url)
-    address? : IAddress, // Address for the contact
-    organization? : IReference<IOrganization>, // This contact detail is handled/monitored by a specific organization
-    period? : IPeriod // Period that this contact was valid for usage
-}
-
-// https://www.hl7.org/fhir/datatypes.html#humanname
-export interface IHumanName extends IDataType {
-    // from Element: extension
-    use? : 'usual' | 'official' | 'temp' | 'nickname' | 'anonymous' | 'old' | 'maiden'
-    text? : string, // Text representation of the full name
-    family? : string, // Family name (often called 'Surname')
-    given? : string[], // Given names (not always 'first'). Includes middle names
-    prefix? : string[], // Parts that come before the name
-    suffix? : string[], // Parts that come after the name
-    period? : IPeriod // Time period when name was/is in use
-}
-
-// https://www.hl7.org/fhir/datatypes.html#ContactPoint
-export interface IContactPoint extends IDataType {
-    // from Element: extension
-    system? : 'phone' | 'fax' | 'email' | 'pager' | 'url' | 'sms' | 'other'
-    value? : string, // I The actual contact point details
-    use? : 'home' | 'work' | 'temp' | 'old' | 'mobile' // purpose of this contact point'
-    rank? : number // "<positiveInt>", // Specify preferred order of use (1 = highest)
-    period? : IPeriod // Time period when the contact point was/is in use
-}
-
-export interface IAddress {
-
-}
-
-export interface ICoverage {
-
-}
-
-export interface IPatient {
-
-}
-
-export interface IDevice {
-
-}
-
-export interface IHealthcareService {
-
-}
-
-export interface ILocation {
-
-}
-
-export interface IPractitioner {
-
-}
-
-export interface IPractitionerRole {
-
-}
-
-export interface IRelatedPerson {
-
-}
-
-export interface ICondition {
-
-}
-
-export interface IProcedure {
-
-}
-
-export interface IAttachment {
-
-}
-
-export interface IPerson extends IDomainResource {
-    _resourceType : "Person",
-    // from Resource: id, meta, implicitRules, and language
-    // from DomainResource: text, contained, extension, and modifierExtension
-    identifier? : IIdentifier[], // A human identifier for this person
-    active? : boolean, // This person's record is in active use
-    name? : IHumanName[], // A name associated with the person
-    telecom? : IContactPoint[], // A contact detail for the person
-    gender? : 'male' | 'female' | 'other' | 'unknown'
-    birthDate? : Date, // The date on which the person was born
-    // deceased[x]: Indicates if the individual is deceased or not. One of these 2:
-    deceasedBoolean? : boolean,
-    deceasedDateTime? : IDateTime,
-    address? : IAddress[], // One or more addresses for the person
-    maritalStatus? : ICodeableConcept, // Marital (civil) status of a person
-    photo? : IAttachment[], // Image of the person
-    communication? : { // A language which may be used to communicate with the person about his or her health
-        language : ICodeableConcept, // R!  The language which can be used to communicate with the person about his or her health
-        preferred? : boolean // Language preference indicator
-    }[],
-    managingOrganization? : IReference<IOrganization>[], // The organization that is the custodian of the person record
-    link? : { // Link to a resource that concerns the same actual person
-      target : IReference<IPatient|IPerson|IPractitioner|IRelatedPerson>, // R!  The resource to which this actual person is associated
-      assurance? : 'level1' | 'level2' | 'level3' | 'level4'
-    }[]
-}
-
-// -------------------------------------------------------------------------------------------------
-
-export interface IFHIRResource {
-    name: string
-    description: string
-    notes: string
-}
-
-export interface IPersonResource {
-    name: string
-    description: string
-    notes: string
-}
-
-export interface IDALFhirDataAccessManager<T> {
-    GetFhirResource(fhir: Partial<T>, ecb?: (fhir: Partial<T>, error: Error) => void): Promise<T | null>
-    GetFhirResources(filters: string[], ecb?: (filters: string[], error: Error) => void): Promise<T[] | null>
-    CreateFhirResource(fhir: T, ecb?: (fhir: T, error: Error) => void): Promise<T | null>
-    CreateFhirResources(fhir: T[], ecb?: (fhir: T, error: Error) => void): Promise<(T | null)[]>
-    UpdateFhirResource(fhir: T, ecb?: (fhir: T, error: Error) => void): Promise<T | null>
-    UpdateFhirResources(fhir: T[], ecb?: (fhir: T, error: Error) => void): Promise<(T | null)[]>
-    DeleteFhirResource(fhir: Partial<T>, ecb?: (fhir: Partial<T>, error: Error) => void): Promise<T | null>
-    DeleteFhirResources(fhir: Partial<T>[], ecb?: (fhir: Partial<T>, error: Error) => void): Promise<(T | null)[]>
-    Start(): Promise<void>
-    Stop(): Promise<void>
-    get options()
-    set options(options: JSONObject)
-}
-
-export interface IFhirManagerBaseOptions {
-    resourceName: string
-    dbactionuser: string
-}
-
-export interface IFhirManagerPGResOptions extends IFhirManagerBaseOptions {
-    accessLayer: IDBAccessLayer
-}
-
-export interface IFhirManagerPGResEntityOptions extends IFhirManagerBaseOptions {
-    accessLayer: IDBAccessLayer
-}
-
-export interface IFhirManagerRedisJsonOptions extends IFhirManagerBaseOptions {
-    redisUrl: string
-}
-
-export enum IFhirPersistenceType {
-    postgresResources,
-    postgresResourcesEntities,
-    redisJson,
-    ioredisJson
-}
-
-export interface IDALFhirManagerOptions {
-    persistenceType: IFhirPersistenceType
-    persistenceTypeOptions: IFhirManagerPGResOptions | IFhirManagerPGResEntityOptions | IFhirManagerRedisJsonOptions
-}

package/src/fhir/dalFhirManager.ts

@@ -1,33 +0,0 @@
-import { IDALFhirDataAccessManager, IFhirManagerPGResOptions, IFhirManagerPGResEntityOptions, IFhirManagerRedisJsonOptions, 
-    IDALFhirManagerOptions, IFhirPersistenceType } from './STSFhirTypes'
-import { DALFhirManagerPGRes } from './dalFhirManagerPGRes'
-import { DALFhirManagerPGResEntity } from './dalFhirManagerPGResEntity'
-import { DALFhirManagerRedisJson } from './dalFhirManagerRedisJson'
-import { DALFhirManagerIORedisJson } from './dalFhirManagerIORedisJson'
-
-export class DALFhirManager<T> {
-    #fhirDataAccessManager: IDALFhirDataAccessManager<T>;
-
-    constructor(options: IDALFhirManagerOptions) {
-        switch (options.persistenceType) {
-        case IFhirPersistenceType.postgresResources :
-            this.#fhirDataAccessManager = new DALFhirManagerPGRes<T>(options.persistenceTypeOptions as IFhirManagerPGResOptions);
-            break;
-        case IFhirPersistenceType.postgresResourcesEntities :
-            this.#fhirDataAccessManager = new DALFhirManagerPGResEntity<T>(options.persistenceTypeOptions as IFhirManagerPGResEntityOptions);
-            break;
-        case IFhirPersistenceType.redisJson:
-            this.#fhirDataAccessManager = new DALFhirManagerRedisJson<T>(options.persistenceTypeOptions as IFhirManagerRedisJsonOptions);
-            break;
-        case IFhirPersistenceType.ioredisJson:
-            this.#fhirDataAccessManager = new DALFhirManagerIORedisJson<T>(options.persistenceTypeOptions as IFhirManagerRedisJsonOptions);
-            break;
-        default :
-            this.#fhirDataAccessManager = new DALFhirManagerPGRes<T>(options.persistenceTypeOptions as IFhirManagerPGResOptions);
-        }
-    }
-
-    get fhirDataAccessManager() {
-        return this.#fhirDataAccessManager;
-    }
-}

package/src/fhir/dalFhirManagerBase.ts

@@ -1,77 +0,0 @@
-/* eslint @typescript-eslint/no-unused-vars: 0 */  // --> OFF
-import { IDomainResource, IDALFhirDataAccessManager, IFhirManagerBaseOptions } from './STSFhirTypes'
-
-export abstract class DALFhirManagerBase<T> implements IDALFhirDataAccessManager<T> {
-    #options: IFhirManagerBaseOptions;
-
-    constructor(options: IFhirManagerBaseOptions) {
-        this.#options = options;
-    }
-
-    get options() {
-        return this.#options;
-    }
-
-    set options(options: IFhirManagerBaseOptions) {
-        this.#options = options;
-    }
-
-    async Start() {
-
-    }
-
-    async Stop() {
-
-    }
-
-    GetResourceType(fhir: Partial<T>): string {
-        return `${this.#options.resourceName}_${(fhir as Partial<IDomainResource>).id}`;
-    }
-
-    async GetFhirResource(fhir: Partial<T>, ecb?: (fhir: Partial<T>, error: Error) => void): Promise<T | null> {
-        return null;
-    }
-
-    async CreateFhirResource(fhir: T, ecb?: (fhir: T, error: Error) => void): Promise<T | null> {
-        return null;
-    }
-
-    async UpdateFhirResource(fhir: T, ecb?: (fhir: T, error: Error) => void): Promise<T | null> {
-        return null;
-    }
-
-    async DeleteFhirResource(fhir: Partial<T>, ecb?: (fhir: Partial<T>, error: Error) => void): Promise<T | null> {
-        return null;
-    }
-
-    async GetFhirResources(filters: string[], ecb?: (filters: string[], error: Error) => void): Promise<T[] | null> {
-        return null;
-    }
-
-    async CreateFhirResources(fhir: T[], ecb?: (fhir: T, error: Error) => void): Promise<(T | null)[]> {
-        const promArray: Promise<T | null>[] = [ ];
-        fhir.forEach(async (f) => {
-            promArray.push(this.CreateFhirResource(f, ecb));
-        })
-        const promRetVal = await Promise.all(promArray);
-        return promRetVal;
-    }
-
-    async UpdateFhirResources(fhir: T[], ecb?: (fhir: T, error: Error) => void): Promise<(T | null)[]> {
-        const promArray: Promise<T | null>[] = [ ];
-        fhir.forEach(async (f) => {
-            promArray.push(this.UpdateFhirResource(f, ecb));
-        })
-        const promRetVal = await Promise.all(promArray);
-        return promRetVal;
-    }
-
-    async DeleteFhirResources(fhir: Partial<T>[], ecb?: (fhir: Partial<T>, error: Error) => void): Promise<(T | null)[]> {
-        const promArray: Promise<T | null>[] = [ ];
-        fhir.forEach(async (f) => {
-            promArray.push(this.DeleteFhirResource(f, ecb));
-        })
-        const promRetVal = await Promise.all(promArray);
-        return promRetVal;
-    }
-}