@synanetics/types
Version:
Common types for cross repository use
259 lines • 9.9 kB
TypeScript
import { DomainResource, Extension, Identifier, Reference } from 'fhir/r4.js';
import { ResourceTypes } from './resourceTypes.js';
import { InterweaveMessageEventType } from '../../common.js';
export interface DataProviderSupportedResource {
/**
* Unique id for the element within a resource (for internal references)
* This may be any string value that does not contain spaces
*/
id?: string;
/**
* May be used to represent additional information
* that is not part of the basic definition of the element.
* In order to make the use of extensions safe and manageable,
* there is a strict set of governance applied to the definition and use of extensions.
* Though any implementer is allowed to define an extension,
* there is a set of requirements that SHALL be met as part of the definition of the extension.
*/
extension?: Extension;
/**
* May be used to represent additional information
* that is not part of the basic definition of the element,
* and that modifies the understanding of the element that contains it.
* Usually modifier elements provide negation or qualification.
* In order to make the use of extensions safe and manageable,
* there is a strict set of governance applied to the definition and use of extensions.
* Though any implementer is allowed to define an extension,
* there is a set of requirements that SHALL be met as part of the definition of the extension.
* Applications processing a resource are required to check for modifier extensions.
*/
modifierExtension?: Extension;
/**
* The resourceType of the supported resource
*/
resource: ResourceTypes;
/**
* A status to indicate if this resource is publicly available or for clinical safety only
*/
status: string;
/**
* A description why this entry is present
*/
description?: string;
}
export interface DataProviderEndpoint {
/**
* Unique id for the element within a resource (for internal references)
* This may be any string value that does not contain spaces
*/
id?: string;
/**
* May be used to represent additional information
* that is not part of the basic definition of the element.
* In order to make the use of extensions safe and manageable,
* there is a strict set of governance applied to the definition and use of extensions.
* Though any implementer is allowed to define an extension,
* there is a set of requirements that SHALL be met as part of the definition of the extension.
*/
extension?: Extension;
/**
* May be used to represent additional information
* that is not part of the basic definition of the element,
* and that modifies the understanding of the element that contains it.
* Usually modifier elements provide negation or qualification.
* In order to make the use of extensions safe and manageable,
* there is a strict set of governance applied to the definition and use of extensions.
* Though any implementer is allowed to define an extension,
* there is a set of requirements that SHALL be met as part of the definition of the extension.
* Applications processing a resource are required to check for modifier extensions.
*/
modifierExtension?: Extension;
/**
* What type of endpoint this is (synchronous, asynchronous, management or messaging)
*/
type: 'sync' | 'async' | 'man' | 'msg';
/**
* URL of endpoint
*/
address: string;
/**
* Certificate details
*/
certificateDN?: string;
/**
* Does this provider restrict which consumers can access and if so,
* is the list inclusive or exclusive?
*/
pairingInclusive?: 'inclusive' | 'exclusive';
/**
* Consumers that are paired with this provider on inclusive or exclusive basis
*/
pairedConsumer?: Reference[];
/**
* Set of headers expected by endpoint
*/
header?: string[];
}
export interface DataProviderClient {
/**
* Unique id for the element within a resource (for internal references)
* This may be any string value that does not contain spaces
*/
id?: string;
/**
* May be used to represent additional information
* that is not part of the basic definition of the element.
* In order to make the use of extensions safe and manageable,
* there is a strict set of governance applied to the definition and use of extensions.
* Though any implementer is allowed to define an extension,
* there is a set of requirements that SHALL be met as part of the definition of the extension.
*/
extension?: Extension;
/**
* May be used to represent additional information
* that is not part of the basic definition of the element,
* and that modifies the understanding of the element that contains it.
* Usually modifier elements provide negation or qualification.
* In order to make the use of extensions safe and manageable,
* there is a strict set of governance applied to the definition and use of extensions.
* Though any implementer is allowed to define an extension,
* there is a set of requirements that SHALL be met as part of the definition of the extension.
* Applications processing a resource are required to check for modifier extensions.
*/
modifierExtension?: Extension;
/**
* What type of client this is (subscription or messaging)
*/
type: 'sub' | 'msg';
/**
* URL of client
*/
address?: string;
/**
* Certificate details
*/
certificateDN?: string;
/**
* The message type as defined by messageheader.event.coding that this endpoint accepts.
*/
messageEventType?: InterweaveMessageEventType[];
/**
* Set of headers expected by msg endpoint
*/
header?: string[];
}
/**
* DataProvider defines a source of data for the regional shared care record
*/
export interface DataProvider extends DomainResource {
/**
* The resourceType, always DataProvider
*/
readonly resourceType: 'DataProvider';
/**
* An identifier for this DataProvider
*/
identifier?: Identifier[];
/**
* A label assigned to the provider for human identification and communication
*/
name: string;
/**
* A short mnemonic assigned to the provider
* for labelling of resource ids that apply to the provider
*/
prefix: string;
/**
* A description of provider for human identification and communication
*/
narrative?: string;
/**
* Whether the DataProvider is actively connected to the System of Systems
*/
status: 'active' | 'inactive';
/**
* The date that the provider was registered
*/
registered: string;
/**
* The DNS domain for the provider
*/
domainName?: string;
/**
* Organization that is the owner of the data provider
*/
organization: Reference;
/**
* The maturity index of the provider
*/
maturity: number;
/**
* Whether a provider supports being called implicitly (when a PIX Linkage is found for an entity)
*/
implicitRouting?: boolean;
/**
* Determines when explicit routing is allowed:
* pix means route only if there is a Linkage for the patient in PIX for this provider
*/
explicitRouting?: 'always' | 'always-identifier' | 'pix' | 'pix-no-sub';
/**
* Roles that are allowed to access data from the data provider
* If blank, then all roles are allowed
*/
roles?: string[];
/**
* Access reasons that are allowed to access data from the data provider
* If blank, then all reasons are allowed
*/
reasonForAccess?: string[];
/**
* A list of resources that the data provider will support.
* If blank, then all resources are supported.
*/
supportedResource?: DataProviderSupportedResource[];
/**
* IAM info for provider
*/
iam: {
/**
* Unique id for the element within a resource (for internal references)
* This may be any string value that does not contain spaces
*/
id?: string;
/**
* May be used to represent additional information
* that is not part of the basic definition of the element.
* In order to make the use of extensions safe and manageable,
* there is a strict set of governance applied to the definition and use of extensions.
* Though any implementer is allowed to define an extension,
* there is a set of requirements that SHALL be met as part of the definition of the extension.
*/
extension?: Extension;
/**
* May be used to represent additional information
* that is not part of the basic definition of the element,
* and that modifies the understanding of the element that contains it.
* Usually modifier elements provide negation or qualification.
* In order to make the use of extensions safe and manageable,
* there is a strict set of governance applied to the definition and use of extensions.
* Though any implementer is allowed to define an extension,
* there is a set of requirements that SHALL be met as part of the definition of the extension.
* Applications processing a resource are required to check for modifier extensions.
*/
modifierExtension?: Extension;
/**
* Credentials for the provider
*/
secretHash: string;
/**
* Public key to verify signed token
*/
certificate: string;
};
/**
* Endpoints exposed by the provider
*/
endpoint?: DataProviderEndpoint[];
client?: DataProviderClient[];
}
//# sourceMappingURL=dataProvider.d.ts.map