@nsshunt/stsfhirclient 1.0.77 → 1.0.78

package/types/fhir-ts/CapabilityStatement_Document.d.ts

@@ -0,0 +1,40 @@
+import { Extension } from "./Extension";
+import { FhirPrimitive } from "./FhirPrimitive";
+export interface CapabilityStatement_Document {
+    /**
+     * @description Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.
+     * @short Unique id for inter-element referencing
+     */
+    id?: string;
+    /**
+     * @description May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and managable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.
+     * @comment There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.
+     * @short Additional content defined by implementations
+     */
+    extension?: Extension[];
+    /**
+     * @description 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 in which it is contained andor the understanding of the containing element's descendants. Usually modifier elements provide negation or qualification. To make the use of extensions safe and managable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can 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.
+  
+  Modifier extensions SHALL NOT change the meaning of any elements on Resource or DomainResource (including cannot change the meaning of modifierExtension itself).
+     * @comment There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.
+     * @short Extensions that cannot be ignored even if unrecognized
+     */
+    modifierExtension?: Extension[];
+    /**
+     * @description Mode of this document declaration - whether an application is a producer or consumer.
+     * @short producer | consumer
+     */
+    mode: FhirPrimitive<string>;
+    /**
+     * @description A description of how the application supports or uses the specified document profile.  For example, when documents are created, what action is taken with consumed documents, etc.
+     * @short Description of document support
+     */
+    documentation?: FhirPrimitive<string>;
+    /**
+     * @description A profile on the document Bundle that constrains which resources are present, and their contents.
+     * @comment The profile is actually on the Bundle.
+     * @short Constraint on the resources used in the document
+     */
+    profile: FhirPrimitive<string>;
+}
+//# sourceMappingURL=CapabilityStatement_Document.d.ts.map

package/types/fhir-ts/CapabilityStatement_Document.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CapabilityStatement_Document.d.ts","sourceRoot":"","sources":["../../src/fhir-ts/CapabilityStatement_Document.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAGhD,MAAM,WAAW,4BAA4B;IAC3C;;;OAGG;IACH,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ;;;;OAIG;IACH,SAAS,CAAC,EAAE,SAAS,EAAE,CAAC;IACxB;;;;;;OAMG;IACH,iBAAiB,CAAC,EAAE,SAAS,EAAE,CAAC;IAChC;;;OAGG;IACH,IAAI,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAC5B;;;OAGG;IACH,aAAa,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACtC;;;;OAIG;IACH,OAAO,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;CAChC"}

package/types/fhir-ts/CapabilityStatement_Implementation.d.ts

@@ -0,0 +1,41 @@
+import { Extension } from "./Extension";
+import { FhirPrimitive } from "./FhirPrimitive";
+import { Organization } from "./Organization";
+import { Reference } from "./Reference";
+export interface CapabilityStatement_Implementation {
+    /**
+     * @description Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.
+     * @short Unique id for inter-element referencing
+     */
+    id?: string;
+    /**
+     * @description May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and managable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.
+     * @comment There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.
+     * @short Additional content defined by implementations
+     */
+    extension?: Extension[];
+    /**
+     * @description 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 in which it is contained andor the understanding of the containing element's descendants. Usually modifier elements provide negation or qualification. To make the use of extensions safe and managable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can 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.
+  
+  Modifier extensions SHALL NOT change the meaning of any elements on Resource or DomainResource (including cannot change the meaning of modifierExtension itself).
+     * @comment There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.
+     * @short Extensions that cannot be ignored even if unrecognized
+     */
+    modifierExtension?: Extension[];
+    /**
+     * @description Information about the specific installation that this capability statement relates to.
+     * @short Describes this specific instance
+     */
+    description: FhirPrimitive<string>;
+    /**
+     * @description An absolute base URL for the implementation.  This forms the base for REST interfaces as well as the mailbox and document interfaces.
+     * @short Base URL for the installation
+     */
+    url?: FhirPrimitive<string>;
+    /**
+     * @description The organization responsible for the management of the instance and oversight of the data on the server at the specified URL.
+     * @short Organization that manages the data
+     */
+    custodian?: Reference<Organization>;
+}
+//# sourceMappingURL=CapabilityStatement_Implementation.d.ts.map

package/types/fhir-ts/CapabilityStatement_Implementation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CapabilityStatement_Implementation.d.ts","sourceRoot":"","sources":["../../src/fhir-ts/CapabilityStatement_Implementation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAGxC,MAAM,WAAW,kCAAkC;IACjD;;;OAGG;IACH,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ;;;;OAIG;IACH,SAAS,CAAC,EAAE,SAAS,EAAE,CAAC;IACxB;;;;;;OAMG;IACH,iBAAiB,CAAC,EAAE,SAAS,EAAE,CAAC;IAChC;;;OAGG;IACH,WAAW,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACnC;;;OAGG;IACH,GAAG,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAC5B;;;OAGG;IACH,SAAS,CAAC,EAAE,SAAS,CAAC,YAAY,CAAC,CAAC;CACrC"}

package/types/fhir-ts/CapabilityStatement_Messaging.d.ts

@@ -0,0 +1,45 @@
+import { CapabilityStatement_Messaging_Endpoint } from "./CapabilityStatement_Messaging_Endpoint";
+import { CapabilityStatement_Messaging_SupportedMessage } from "./CapabilityStatement_Messaging_SupportedMessage";
+import { Extension } from "./Extension";
+import { FhirPrimitive } from "./FhirPrimitive";
+export interface CapabilityStatement_Messaging {
+    /**
+     * @description Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.
+     * @short Unique id for inter-element referencing
+     */
+    id?: string;
+    /**
+     * @description May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and managable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.
+     * @comment There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.
+     * @short Additional content defined by implementations
+     */
+    extension?: Extension[];
+    /**
+     * @description 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 in which it is contained andor the understanding of the containing element's descendants. Usually modifier elements provide negation or qualification. To make the use of extensions safe and managable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can 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.
+  
+  Modifier extensions SHALL NOT change the meaning of any elements on Resource or DomainResource (including cannot change the meaning of modifierExtension itself).
+     * @comment There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.
+     * @short Extensions that cannot be ignored even if unrecognized
+     */
+    modifierExtension?: Extension[];
+    /**
+     * @backbone Nested BackboneElement: endpoint [0..1]
+     */
+    endpoint?: CapabilityStatement_Messaging_Endpoint;
+    /**
+     * @description Length if the receiver's reliable messaging cache in minutes (if a receiver) or how long the cache length on the receiver should be (if a sender).
+     * @comment If this value is missing then the application does not implement (receiver) or depend on (sender) reliable messaging.
+     * @short Reliable Message Cache Length (min)
+     */
+    reliableCache?: FhirPrimitive<number>;
+    /**
+     * @description Documentation about the system's messaging capabilities for this endpoint not otherwise documented by the capability statement.  For example, the process for becoming an authorized messaging exchange partner.
+     * @short Messaging interface behavior details
+     */
+    documentation?: FhirPrimitive<string>;
+    /**
+     * @backbone Nested BackboneElement: supportedMessage [0..1]
+     */
+    supportedMessage?: CapabilityStatement_Messaging_SupportedMessage;
+}
+//# sourceMappingURL=CapabilityStatement_Messaging.d.ts.map

package/types/fhir-ts/CapabilityStatement_Messaging.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CapabilityStatement_Messaging.d.ts","sourceRoot":"","sources":["../../src/fhir-ts/CapabilityStatement_Messaging.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,sCAAsC,EAAE,MAAM,0CAA0C,CAAC;AAClG,OAAO,EAAE,8CAA8C,EAAE,MAAM,kDAAkD,CAAC;AAClH,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAGhD,MAAM,WAAW,6BAA6B;IAC5C;;;OAGG;IACH,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ;;;;OAIG;IACH,SAAS,CAAC,EAAE,SAAS,EAAE,CAAC;IACxB;;;;;;OAMG;IACH,iBAAiB,CAAC,EAAE,SAAS,EAAE,CAAC;IAChC;;OAEG;IACH,QAAQ,CAAC,EAAE,sCAAsC,CAAC;IAClD;;;;OAIG;IACH,aAAa,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACtC;;;OAGG;IACH,aAAa,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACtC;;OAEG;IACH,gBAAgB,CAAC,EAAE,8CAA8C,CAAC;CACnE"}

package/types/fhir-ts/CapabilityStatement_Messaging_Endpoint.d.ts

@@ -0,0 +1,35 @@
+import { Coding } from "./Coding";
+import { Extension } from "./Extension";
+import { FhirPrimitive } from "./FhirPrimitive";
+export interface CapabilityStatement_Messaging_Endpoint {
+    /**
+     * @description Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.
+     * @short Unique id for inter-element referencing
+     */
+    id?: string;
+    /**
+     * @description May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and managable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.
+     * @comment There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.
+     * @short Additional content defined by implementations
+     */
+    extension?: Extension[];
+    /**
+     * @description 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 in which it is contained andor the understanding of the containing element's descendants. Usually modifier elements provide negation or qualification. To make the use of extensions safe and managable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can 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.
+  
+  Modifier extensions SHALL NOT change the meaning of any elements on Resource or DomainResource (including cannot change the meaning of modifierExtension itself).
+     * @comment There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.
+     * @short Extensions that cannot be ignored even if unrecognized
+     */
+    modifierExtension?: Extension[];
+    /**
+     * @description A list of the messaging transport protocol(s) identifiers, supported by this endpoint.
+     * @short http | ftp | mllp +
+     */
+    protocol: Coding;
+    /**
+     * @description The network address of the endpoint. For solutions that do not use network addresses for routing, it can be just an identifier.
+     * @short Network address or identifier of the end-point
+     */
+    address: FhirPrimitive<string>;
+}
+//# sourceMappingURL=CapabilityStatement_Messaging_Endpoint.d.ts.map

package/types/fhir-ts/CapabilityStatement_Messaging_Endpoint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CapabilityStatement_Messaging_Endpoint.d.ts","sourceRoot":"","sources":["../../src/fhir-ts/CapabilityStatement_Messaging_Endpoint.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAClC,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAGhD,MAAM,WAAW,sCAAsC;IACrD;;;OAGG;IACH,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ;;;;OAIG;IACH,SAAS,CAAC,EAAE,SAAS,EAAE,CAAC;IACxB;;;;;;OAMG;IACH,iBAAiB,CAAC,EAAE,SAAS,EAAE,CAAC;IAChC;;;OAGG;IACH,QAAQ,EAAE,MAAM,CAAC;IACjB;;;OAGG;IACH,OAAO,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;CAChC"}

package/types/fhir-ts/CapabilityStatement_Messaging_SupportedMessage.d.ts

@@ -0,0 +1,34 @@
+import { Extension } from "./Extension";
+import { FhirPrimitive } from "./FhirPrimitive";
+export interface CapabilityStatement_Messaging_SupportedMessage {
+    /**
+     * @description Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.
+     * @short Unique id for inter-element referencing
+     */
+    id?: string;
+    /**
+     * @description May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and managable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.
+     * @comment There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.
+     * @short Additional content defined by implementations
+     */
+    extension?: Extension[];
+    /**
+     * @description 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 in which it is contained andor the understanding of the containing element's descendants. Usually modifier elements provide negation or qualification. To make the use of extensions safe and managable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can 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.
+  
+  Modifier extensions SHALL NOT change the meaning of any elements on Resource or DomainResource (including cannot change the meaning of modifierExtension itself).
+     * @comment There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.
+     * @short Extensions that cannot be ignored even if unrecognized
+     */
+    modifierExtension?: Extension[];
+    /**
+     * @description The mode of this event declaration - whether application is sender or receiver.
+     * @short sender | receiver
+     */
+    mode: FhirPrimitive<string>;
+    /**
+     * @description Points to a message definition that identifies the messaging event, message structure, allowed responses, etc.
+     * @short Message supported by this system
+     */
+    definition: FhirPrimitive<string>;
+}
+//# sourceMappingURL=CapabilityStatement_Messaging_SupportedMessage.d.ts.map

package/types/fhir-ts/CapabilityStatement_Messaging_SupportedMessage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CapabilityStatement_Messaging_SupportedMessage.d.ts","sourceRoot":"","sources":["../../src/fhir-ts/CapabilityStatement_Messaging_SupportedMessage.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAGhD,MAAM,WAAW,8CAA8C;IAC7D;;;OAGG;IACH,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ;;;;OAIG;IACH,SAAS,CAAC,EAAE,SAAS,EAAE,CAAC;IACxB;;;;;;OAMG;IACH,iBAAiB,CAAC,EAAE,SAAS,EAAE,CAAC;IAChC;;;OAGG;IACH,IAAI,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAC5B;;;OAGG;IACH,UAAU,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;CACnC"}

package/types/fhir-ts/CapabilityStatement_Rest.d.ts

@@ -0,0 +1,67 @@
+import { CapabilityStatement_Rest_Interaction } from "./CapabilityStatement_Rest_Interaction";
+import { CapabilityStatement_Rest_Resource } from "./CapabilityStatement_Rest_Resource";
+import { CapabilityStatement_Rest_Security } from "./CapabilityStatement_Rest_Security";
+import { Extension } from "./Extension";
+import { FhirPrimitive } from "./FhirPrimitive";
+export interface CapabilityStatement_Rest {
+    /**
+     * @description Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.
+     * @short Unique id for inter-element referencing
+     */
+    id?: string;
+    /**
+     * @description May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and managable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.
+     * @comment There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.
+     * @short Additional content defined by implementations
+     */
+    extension?: Extension[];
+    /**
+     * @description 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 in which it is contained andor the understanding of the containing element's descendants. Usually modifier elements provide negation or qualification. To make the use of extensions safe and managable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can 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.
+  
+  Modifier extensions SHALL NOT change the meaning of any elements on Resource or DomainResource (including cannot change the meaning of modifierExtension itself).
+     * @comment There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.
+     * @short Extensions that cannot be ignored even if unrecognized
+     */
+    modifierExtension?: Extension[];
+    /**
+     * @description Identifies whether this portion of the statement is describing the ability to initiate or receive restful operations.
+     * @short client | server
+     */
+    mode: FhirPrimitive<string>;
+    /**
+     * @description Information about the system's restful capabilities that apply across all applications, such as security.
+     * @short General description of implementation
+     */
+    documentation?: FhirPrimitive<string>;
+    /**
+     * @backbone Nested BackboneElement: security [0..1]
+     */
+    security?: CapabilityStatement_Rest_Security;
+    /**
+     * @backbone Nested BackboneElement: resource [0..1]
+     */
+    resource?: CapabilityStatement_Rest_Resource;
+    /**
+     * @backbone Nested BackboneElement: interaction [0..1]
+     */
+    interaction?: CapabilityStatement_Rest_Interaction;
+    /**
+     * @description Search parameters that are supported for searching all resources for implementations to support andor make use of - either references to ones defined in the specification, or additional ones defined forby the implementation. This is only for searches executed against the system-level endpoint.
+     * @comment Typically, the only search parameters supported for all searches are those that apply to all resources - tags, profiles, text search etc. These search parameters should include the control search parameters such as _sort, _count, etc. that also apply to this resource (though many will be listed at [CapabilityStatement.rest.searchParam](capabilitystatement-definitions.html#CapabilityStatement.rest.searchParam)). The behavior of some search parameters may be further described by other code or extension elements, or narrative within the capability statement or linked [SearchParameter](searchparameter.html#) definitions.
+     * @short Search parameters for searching all resources
+     */
+    searchParam?: any[];
+    /**
+     * @description Definition of an operation or a named query together with its parameters and their meaning and type.
+     * @comment CapabilityStatement.rest.operation is for operations invoked at the system level, or for operations that are supported across multiple resource types. Operations linked from CapabilityStatement.rest.operation must have OperationDefinition.system = true, or more than one Operation.resource.
+     * @short Definition of a system level operation
+     */
+    operation?: any[];
+    /**
+     * @description An absolute URI which is a reference to the definition of a compartment that the system supports. The reference is to a CompartmentDefinition resource by its canonical URL .
+     * @comment At present, the only defined compartments are at [CompartmentDefinition](compartmentdefinition.html).
+     * @short Compartments servedused by system
+     */
+    compartment?: FhirPrimitive<string>[];
+}
+//# sourceMappingURL=CapabilityStatement_Rest.d.ts.map

package/types/fhir-ts/CapabilityStatement_Rest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CapabilityStatement_Rest.d.ts","sourceRoot":"","sources":["../../src/fhir-ts/CapabilityStatement_Rest.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,oCAAoC,EAAE,MAAM,wCAAwC,CAAC;AAC9F,OAAO,EAAE,iCAAiC,EAAE,MAAM,qCAAqC,CAAC;AACxF,OAAO,EAAE,iCAAiC,EAAE,MAAM,qCAAqC,CAAC;AACxF,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAIhD,MAAM,WAAW,wBAAwB;IACvC;;;OAGG;IACH,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ;;;;OAIG;IACH,SAAS,CAAC,EAAE,SAAS,EAAE,CAAC;IACxB;;;;;;OAMG;IACH,iBAAiB,CAAC,EAAE,SAAS,EAAE,CAAC;IAChC;;;OAGG;IACH,IAAI,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAC5B;;;OAGG;IACH,aAAa,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACtC;;OAEG;IACH,QAAQ,CAAC,EAAE,iCAAiC,CAAC;IAC7C;;OAEG;IACH,QAAQ,CAAC,EAAE,iCAAiC,CAAC;IAC7C;;OAEG;IACH,WAAW,CAAC,EAAE,oCAAoC,CAAC;IACnD;;;;OAIG;IACH,WAAW,CAAC,EAAE,GAAG,EAAE,CAAC;IACpB;;;;OAIG;IACH,SAAS,CAAC,EAAE,GAAG,EAAE,CAAC;IAClB;;;;OAIG;IACH,WAAW,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,EAAE,CAAC;CACvC"}

package/types/fhir-ts/CapabilityStatement_Rest_Interaction.d.ts

@@ -0,0 +1,34 @@
+import { Extension } from "./Extension";
+import { FhirPrimitive } from "./FhirPrimitive";
+export interface CapabilityStatement_Rest_Interaction {
+    /**
+     * @description Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.
+     * @short Unique id for inter-element referencing
+     */
+    id?: string;
+    /**
+     * @description May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and managable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.
+     * @comment There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.
+     * @short Additional content defined by implementations
+     */
+    extension?: Extension[];
+    /**
+     * @description 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 in which it is contained andor the understanding of the containing element's descendants. Usually modifier elements provide negation or qualification. To make the use of extensions safe and managable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can 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.
+  
+  Modifier extensions SHALL NOT change the meaning of any elements on Resource or DomainResource (including cannot change the meaning of modifierExtension itself).
+     * @comment There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.
+     * @short Extensions that cannot be ignored even if unrecognized
+     */
+    modifierExtension?: Extension[];
+    /**
+     * @description A coded identifier of the operation, supported by the system.
+     * @short transaction | batch | search-system | history-system
+     */
+    code: FhirPrimitive<string>;
+    /**
+     * @description Guidance specific to the implementation of this operation, such as limitations on the kind of transactions allowed, or information about system wide search is implemented.
+     * @short Anything special about operation behavior
+     */
+    documentation?: FhirPrimitive<string>;
+}
+//# sourceMappingURL=CapabilityStatement_Rest_Interaction.d.ts.map

package/types/fhir-ts/CapabilityStatement_Rest_Interaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CapabilityStatement_Rest_Interaction.d.ts","sourceRoot":"","sources":["../../src/fhir-ts/CapabilityStatement_Rest_Interaction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAGhD,MAAM,WAAW,oCAAoC;IACnD;;;OAGG;IACH,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ;;;;OAIG;IACH,SAAS,CAAC,EAAE,SAAS,EAAE,CAAC;IACxB;;;;;;OAMG;IACH,iBAAiB,CAAC,EAAE,SAAS,EAAE,CAAC;IAChC;;;OAGG;IACH,IAAI,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAC5B;;;OAGG;IACH,aAAa,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;CACvC"}

package/types/fhir-ts/CapabilityStatement_Rest_Resource.d.ts

@@ -0,0 +1,133 @@
+import { CapabilityStatement_Rest_Resource_Interaction } from "./CapabilityStatement_Rest_Resource_Interaction";
+import { CapabilityStatement_Rest_Resource_Operation } from "./CapabilityStatement_Rest_Resource_Operation";
+import { CapabilityStatement_Rest_Resource_SearchParam } from "./CapabilityStatement_Rest_Resource_SearchParam";
+import { Extension } from "./Extension";
+import { FhirPrimitive } from "./FhirPrimitive";
+export interface CapabilityStatement_Rest_Resource {
+    /**
+     * @description Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.
+     * @short Unique id for inter-element referencing
+     */
+    id?: string;
+    /**
+     * @description May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and managable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.
+     * @comment There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.
+     * @short Additional content defined by implementations
+     */
+    extension?: Extension[];
+    /**
+     * @description 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 in which it is contained andor the understanding of the containing element's descendants. Usually modifier elements provide negation or qualification. To make the use of extensions safe and managable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can 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.
+  
+  Modifier extensions SHALL NOT change the meaning of any elements on Resource or DomainResource (including cannot change the meaning of modifierExtension itself).
+     * @comment There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.
+     * @short Extensions that cannot be ignored even if unrecognized
+     */
+    modifierExtension?: Extension[];
+    /**
+     * @description A type of resource exposed via the restful interface.
+     * @short A resource type that is supported
+     */
+    type: FhirPrimitive<string>;
+    /**
+     * @description A system-wide profile that is applied across all instances of the resource supported by the system. For example, if declared on Observation, this profile is the "superset" of capabilities for laboratory and vitals and other domains. See further discussion in [Using Profiles](profiling.html#profile-uses).
+     * @comment All other profiles for this type that are listed in `.rest.resource.supportedProfile` must conform to this profile.
+     * @short System-wide profile
+     */
+    profile?: FhirPrimitive<string>;
+    /**
+     * @description A list of profiles representing different use cases the system hostsproduces. A supported profile is a statement about the functionality of the data and services provided by the server (or the client) for supported use cases. For example, a system can define and declare multiple Observation profiles for laboratory observations, vital sign observations, etc. By declaring supported profiles, systems provide a way to determine whether individual resources are conformant. See further discussion in [Using Profiles](profiling.html#profile-uses).
+     * @comment Supported profiles must conform to the resource profile in the `.rest.resource.profile` element if it is present. The resource profile is a system-wide profile applied across all instances of the resource supported by the system. A supported profile is a statement about the functionality of the data and services provided by the server (or used by the client) for a particular set of use cases and will not necessarily apply to all data consumed or exposed by the server.
+     * @short Use-case specific profiles
+     */
+    supportedProfile?: FhirPrimitive<string>[];
+    /**
+     * @description Additional information about the resource type used by the system.
+     * @short Additional information about the use of the resource type
+     */
+    documentation?: FhirPrimitive<string>;
+    /**
+     * @backbone Nested BackboneElement: interaction [0..1]
+     */
+    interaction?: CapabilityStatement_Rest_Resource_Interaction;
+    /**
+     * @description This field is set to no-version to specify that the system does not support (server) or use (client) versioning for this resource type. If this has some other value, the server must at least correctly track and populate the versionId meta-property on resources. If the value is 'versioned-update', then the server supports all the versioning features, including using e-tags for version integrity in the API.
+     * @comment If a server supports versionIds correctly, it SHOULD support vread too, but is not required to do so.
+     * @short no-version | versioned | versioned-update
+     */
+    versioning?: FhirPrimitive<string>;
+    /**
+     * @description A flag for whether the server is able to return past versions as part of the vRead operation.
+     * @comment It is useful to support the vRead operation for current operations, even if past versions aren't available.
+     * @short Whether vRead can return past versions
+     */
+    readHistory?: FhirPrimitive<boolean>;
+    /**
+     * @description A flag to indicate that the server allows or needs to allow the client to create new identities on the server (that is, the client PUTs to a location where there is no existing resource). Allowing this operation means that the server allows the client to create new identities on the server.
+     * @comment Allowing the clients to create new identities on the server means that the system administrator needs to have confidence that the clients do not create clashing identities between them. Obviously, if there is only one client, this won't happen. While creating identities on the client means that the clients need to be managed, it's much more convenient for many scenarios if such management can be put in place.
+     * @short If update can commit to a new identity
+     */
+    updateCreate?: FhirPrimitive<boolean>;
+    /**
+     * @description A flag that indicates that the server supports conditional create.
+     * @comment Conditional Create is mainly appropriate for interface engine scripts converting from other formats, such as v2.
+     * @short If allowsuses conditional create
+     */
+    conditionalCreate?: FhirPrimitive<boolean>;
+    /**
+     * @description A code that indicates how the server supports conditional read.
+     * @comment Conditional Read is mainly appropriate for interface engine scripts converting from other formats, such as v2.
+     * @short not-supported | modified-since | not-match | full-support
+     */
+    conditionalRead?: FhirPrimitive<string>;
+    /**
+     * @description A flag that indicates that the server supports conditional update.
+     * @comment Conditional Update is mainly appropriate for interface engine scripts converting from other formats, such as v2.
+     * @short If allowsuses conditional update
+     */
+    conditionalUpdate?: FhirPrimitive<boolean>;
+    /**
+     * @description A flag that indicates that the server supports conditional patch.
+     * @comment Conditional Patch is mainly appropriate for interface engine scripts converting from other formats, such as v2.
+     * @short If allowsuses conditional patch
+     */
+    conditionalPatch?: FhirPrimitive<boolean>;
+    /**
+     * @description A code that indicates how the server supports conditional delete.
+     * @comment Conditional Delete is mainly appropriate for interface engine scripts converting from other formats, such as v2.
+     * @short not-supported | single | multiple - how conditional delete is supported
+     */
+    conditionalDelete?: FhirPrimitive<string>;
+    /**
+     * @description A set of flags that defines how references are supported.
+     * @short literal | logical | resolves | enforced | local
+     */
+    referencePolicy?: FhirPrimitive<string>[];
+    /**
+     * @description A list of _include values supported by the server.
+     * @comment Documenting [`_include`](http:hl7.orgfhirR5search.html#revinclude) support helps set conformance expectations for the desired system. Still, it is a level of detail that might not be exposed by production servers or clients when using CapabilityStatement to describe an actual implementation. If this list is empty, the server does not support includes. Support for iterative (a.k.a., recursive) `_include` is communicated by listing the iterative includes values supported by the server in the `searchInclude` element of the "root" resource type. For example, to support the following search:
+  
+  `GET [base]CarePlan?_include=CarePlan:activity-reference:DeviceRequest&_include:iterate=DeviceRequest:device`
+  
+  These values would be listed as part of capabilities for "CarePlan":
+  
+  "searchInclude" : ["CarePlan:activity-reference:DeviceRequest","DeviceRequest:device"],
+  
+     * @short _include values supported by the server
+     */
+    searchInclude?: FhirPrimitive<string>[];
+    /**
+     * @description A list of _revinclude (reverse include) values supported by the server.
+     * @comment See `CapabilityStatement.rest.resource.searchInclude` comments.
+     * @short _revinclude values supported by the server
+     */
+    searchRevInclude?: FhirPrimitive<string>[];
+    /**
+     * @backbone Nested BackboneElement: searchParam [0..1]
+     */
+    searchParam?: CapabilityStatement_Rest_Resource_SearchParam;
+    /**
+     * @backbone Nested BackboneElement: operation [0..1]
+     */
+    operation?: CapabilityStatement_Rest_Resource_Operation;
+}
+//# sourceMappingURL=CapabilityStatement_Rest_Resource.d.ts.map

package/types/fhir-ts/CapabilityStatement_Rest_Resource.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CapabilityStatement_Rest_Resource.d.ts","sourceRoot":"","sources":["../../src/fhir-ts/CapabilityStatement_Rest_Resource.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,6CAA6C,EAAE,MAAM,iDAAiD,CAAC;AAChH,OAAO,EAAE,2CAA2C,EAAE,MAAM,+CAA+C,CAAC;AAC5G,OAAO,EAAE,6CAA6C,EAAE,MAAM,iDAAiD,CAAC;AAChH,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAGhD,MAAM,WAAW,iCAAiC;IAChD;;;OAGG;IACH,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ;;;;OAIG;IACH,SAAS,CAAC,EAAE,SAAS,EAAE,CAAC;IACxB;;;;;;OAMG;IACH,iBAAiB,CAAC,EAAE,SAAS,EAAE,CAAC;IAChC;;;OAGG;IACH,IAAI,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAC5B;;;;OAIG;IACH,OAAO,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAChC;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,EAAE,CAAC;IAC3C;;;OAGG;IACH,aAAa,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACtC;;OAEG;IACH,WAAW,CAAC,EAAE,6CAA6C,CAAC;IAC5D;;;;OAIG;IACH,UAAU,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACnC;;;;OAIG;IACH,WAAW,CAAC,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC;IACrC;;;;OAIG;IACH,YAAY,CAAC,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC;IACtC;;;;OAIG;IACH,iBAAiB,CAAC,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC;IAC3C;;;;OAIG;IACH,eAAe,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACxC;;;;OAIG;IACH,iBAAiB,CAAC,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC;IAC3C;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC;IAC1C;;;;OAIG;IACH,iBAAiB,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAC1C;;;OAGG;IACH,eAAe,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,EAAE,CAAC;IAC1C;;;;;;;;;;;OAWG;IACH,aAAa,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,EAAE,CAAC;IACxC;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,EAAE,CAAC;IAC3C;;OAEG;IACH,WAAW,CAAC,EAAE,6CAA6C,CAAC;IAC5D;;OAEG;IACH,SAAS,CAAC,EAAE,2CAA2C,CAAC;CACzD"}

package/types/fhir-ts/CapabilityStatement_Rest_Resource_Interaction.d.ts

@@ -0,0 +1,34 @@
+import { Extension } from "./Extension";
+import { FhirPrimitive } from "./FhirPrimitive";
+export interface CapabilityStatement_Rest_Resource_Interaction {
+    /**
+     * @description Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.
+     * @short Unique id for inter-element referencing
+     */
+    id?: string;
+    /**
+     * @description May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and managable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.
+     * @comment There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.
+     * @short Additional content defined by implementations
+     */
+    extension?: Extension[];
+    /**
+     * @description 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 in which it is contained andor the understanding of the containing element's descendants. Usually modifier elements provide negation or qualification. To make the use of extensions safe and managable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can 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.
+  
+  Modifier extensions SHALL NOT change the meaning of any elements on Resource or DomainResource (including cannot change the meaning of modifierExtension itself).
+     * @comment There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.
+     * @short Extensions that cannot be ignored even if unrecognized
+     */
+    modifierExtension?: Extension[];
+    /**
+     * @description Coded identifier of the operation, supported by the system resource.
+     * @short read | vread | update | patch | delete | history-instance | history-type | create | search-type
+     */
+    code: FhirPrimitive<string>;
+    /**
+     * @description Guidance specific to the implementation of this operation, such as 'delete is a logical delete' or 'updates are only allowed with version id' or 'creates permitted from pre-authorized certificates only'.
+     * @short Anything special about operation behavior
+     */
+    documentation?: FhirPrimitive<string>;
+}
+//# sourceMappingURL=CapabilityStatement_Rest_Resource_Interaction.d.ts.map

package/types/fhir-ts/CapabilityStatement_Rest_Resource_Interaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CapabilityStatement_Rest_Resource_Interaction.d.ts","sourceRoot":"","sources":["../../src/fhir-ts/CapabilityStatement_Rest_Resource_Interaction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAGhD,MAAM,WAAW,6CAA6C;IAC5D;;;OAGG;IACH,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ;;;;OAIG;IACH,SAAS,CAAC,EAAE,SAAS,EAAE,CAAC;IACxB;;;;;;OAMG;IACH,iBAAiB,CAAC,EAAE,SAAS,EAAE,CAAC;IAChC;;;OAGG;IACH,IAAI,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAC5B;;;OAGG;IACH,aAAa,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;CACvC"}

package/types/fhir-ts/CapabilityStatement_Rest_Resource_Operation.d.ts

@@ -0,0 +1,41 @@
+import { Extension } from "./Extension";
+import { FhirPrimitive } from "./FhirPrimitive";
+export interface CapabilityStatement_Rest_Resource_Operation {
+    /**
+     * @description Unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.
+     * @short Unique id for inter-element referencing
+     */
+    id?: string;
+    /**
+     * @description May be used to represent additional information that is not part of the basic definition of the element. To make the use of extensions safe and managable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.
+     * @comment There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.
+     * @short Additional content defined by implementations
+     */
+    extension?: Extension[];
+    /**
+     * @description 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 in which it is contained andor the understanding of the containing element's descendants. Usually modifier elements provide negation or qualification. To make the use of extensions safe and managable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer can 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.
+  
+  Modifier extensions SHALL NOT change the meaning of any elements on Resource or DomainResource (including cannot change the meaning of modifierExtension itself).
+     * @comment There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions.  The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.
+     * @short Extensions that cannot be ignored even if unrecognized
+     */
+    modifierExtension?: Extension[];
+    /**
+     * @description The name of the operation or query. For an operation, this name is prefixed with $ and used in the URL. For a query, this is the name used in the _query parameter when the query is called. This SHOULD be the same as the OperationDefinition.code of the defining OperationDefinition.  However, it can sometimes differ if necessary to disambiguate when a server supports multiple OperationDefinition that happen to share the same code.
+     * @comment The name here SHOULD be the same as the OperationDefinition.code in the referenced OperationDefinition, unless there is a name clash and the OperationDefinition.code cannot be used. The name does not include the "$" portion that is always included in the URL. There is no correspondence whatsoever between CapabilityStatement's operation.name and OperationDefinition.name - the latter is used as a class name when generating code for the operation. HL7 will never define operations that have conflicting names.
+     * @short Name by which the operationquery is invoked
+     */
+    name: FhirPrimitive<string>;
+    /**
+     * @description Where the formal definition can be found. If a server references the base definition of an Operation (i.e. from the specification itself such as ```http:hl7.orgfhirOperationDefinitionValueSet-expand```), that means it supports the full capabilities of the operation - e.g. both GET and POST invocation.  If it only supports a subset, it must define its own custom [OperationDefinition](operationdefinition.html#) with a 'base' of the original OperationDefinition.  The custom definition would describe the specific subset of functionality supported.
+     * @comment This can be used to build an HTML form to invoke the operation, for instance.
+     * @short The defined operationquery
+     */
+    definition: FhirPrimitive<string>;
+    /**
+     * @description Documentation that describes anything special about the operation behavior, possibly detailing different behavior for system, type and instance-level invocation of the operation.
+     * @short Specific details about operation behavior
+     */
+    documentation?: FhirPrimitive<string>;
+}
+//# sourceMappingURL=CapabilityStatement_Rest_Resource_Operation.d.ts.map

package/types/fhir-ts/CapabilityStatement_Rest_Resource_Operation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CapabilityStatement_Rest_Resource_Operation.d.ts","sourceRoot":"","sources":["../../src/fhir-ts/CapabilityStatement_Rest_Resource_Operation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAGhD,MAAM,WAAW,2CAA2C;IAC1D;;;OAGG;IACH,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ;;;;OAIG;IACH,SAAS,CAAC,EAAE,SAAS,EAAE,CAAC;IACxB;;;;;;OAMG;IACH,iBAAiB,CAAC,EAAE,SAAS,EAAE,CAAC;IAChC;;;;OAIG;IACH,IAAI,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAC5B;;;;OAIG;IACH,UAAU,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAClC;;;OAGG;IACH,aAAa,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;CACvC"}