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