Struct Appointment 

pub struct Appointment {

    pub id: Option<Id>,
    pub meta: Option<Meta>,
    pub implicit_rules: Option<UriDt>,
    pub language: Option<CodeDt>,
    pub text: Option<Narrative>,
    pub contained: Option<Vec<AnyResource>>,
    pub extension: Option<Vec<Extension>>,
    pub modifier_extension: Option<Vec<Extension>>,
    pub identifier: Option<Vec<Identifier>>,
    pub status: Option<CodeDt>,
    pub cancellation_reason: Option<CodeableConcept>,
    pub class: Option<Vec<CodeableConcept>>,
    pub service_category: Option<Vec<CodeableConcept>>,
    pub service_type: Option<Vec<CodeableReference>>,
    pub specialty: Option<Vec<CodeableConcept>>,
    pub appointment_type: Option<CodeableConcept>,
    pub reason: Option<Vec<CodeableReference>>,
    pub priority: Option<CodeableConcept>,
    pub description: Option<StringDt>,
    pub replaces: Option<Vec<Reference>>,
    pub virtual_service: Option<Vec<VirtualServiceDetail>>,
    pub supporting_information: Option<Vec<Reference>>,
    pub previous_appointment: Option<Reference>,
    pub originating_appointment: Option<Reference>,
    pub start: Option<InstantDt>,
    pub end: Option<InstantDt>,
    pub minutes_duration: Option<PositiveIntDt>,
    pub requested_period: Option<Vec<Period>>,
    pub slot: Option<Vec<Reference>>,
    pub account: Option<Vec<Reference>>,
    pub created: Option<DateTimeDt>,
    pub cancellation_date: Option<DateTimeDt>,
    pub note: Option<Vec<Annotation>>,
    pub patient_instruction: Option<Vec<CodeableReference>>,
    pub based_on: Option<Vec<Reference>>,
    pub subject: Option<Reference>,
    pub participant: Option<Vec<AppointmentParticipantBackboneElement>>,
    pub recurrence_id: Option<PositiveIntDt>,
    pub occurrence_changed: Option<BooleanDt>,
    pub recurrence_template: Option<Vec<AppointmentRecurrenceTemplateBackboneElement>>,
}

Fields

id: Option<Id>

Logical id of this artifact

meta: Option<Meta>

Metadata about the resource

implicit_rules: Option<UriDt>

A set of rules under which this content was created

language: Option<CodeDt>

Language of the resource content

text: Option<Narrative>

Text summary of the resource, for human interpretation

contained: Option<Vec<AnyResource>>

Contained, inline Resources

extension: Option<Vec<Extension>>

Additional content defined by implementations

modifier_extension: Option<Vec<Extension>>

Extensions that cannot be ignored

identifier: Option<Vec<Identifier>>

External Ids for this item

status: Option<CodeDt>

proposed | pending | booked | arrived | fulfilled | cancelled | noshow | entered-in-error | checked-in | waitlist

cancellation_reason: Option<CodeableConcept>

The coded reason for the appointment being cancelled

class: Option<Vec<CodeableConcept>>

Classification when becoming an encounter

service_category: Option<Vec<CodeableConcept>>

A broad categorization of the service that is to be performed during this appointment

service_type: Option<Vec<CodeableReference>>

The specific service that is to be performed during this appointment

specialty: Option<Vec<CodeableConcept>>

The specialty of a practitioner that would be required to perform the service requested in this appointment

appointment_type: Option<CodeableConcept>

The style of appointment or patient that has been booked in the slot (not service type)

reason: Option<Vec<CodeableReference>>

Reason this appointment is scheduled

priority: Option<CodeableConcept>

Used to make informed decisions if needing to re-prioritize

description: Option<StringDt>

Shown on a subject line in a meeting request, or appointment list

replaces: Option<Vec<Reference>>

Appointment replaced by this Appointment

virtual_service: Option<Vec<VirtualServiceDetail>>

Connection details of a virtual service (e.g. conference call)

supporting_information: Option<Vec<Reference>>

Additional information to support the appointment

previous_appointment: Option<Reference>

The previous appointment in a series

originating_appointment: Option<Reference>

The originating appointment in a recurring set of appointments

start: Option<InstantDt>

When appointment is to take place

end: Option<InstantDt>

When appointment is to conclude

minutes_duration: Option<PositiveIntDt>

Can be less than start/end (e.g. estimate)

requested_period: Option<Vec<Period>>

Potential date/time interval(s) requested to allocate the appointment within

slot: Option<Vec<Reference>>

The slots that this appointment is filling

account: Option<Vec<Reference>>

The set of accounts that may be used for billing for this Appointment

created: Option<DateTimeDt>

The date that this appointment was initially created

cancellation_date: Option<DateTimeDt>

When the appointment was cancelled

note: Option<Vec<Annotation>>

Additional comments

patient_instruction: Option<Vec<CodeableReference>>

Detailed information and instructions for the patient

based_on: Option<Vec<Reference>>

The request this appointment is allocated to assess

subject: Option<Reference>

The patient or group associated with the appointment

participant: Option<Vec<AppointmentParticipantBackboneElement>>

Participants involved in appointment

recurrence_id: Option<PositiveIntDt>

The sequence number in the recurrence

occurrence_changed: Option<BooleanDt>

Indicates that this appointment varies from a recurrence pattern

recurrence_template: Option<Vec<AppointmentRecurrenceTemplateBackboneElement>>

Details of the recurrence pattern/template used to generate occurrences

Implementations

impl Appointment

pub fn set_identifier(self, v: Vec<Identifier>) -> Self

pub fn add_identifier(self, v: Identifier) -> Self

pub fn set_status<T: Into<CodeDt>>(self, v: T) -> Self

pub fn set_cancellation_reason(self, v: CodeableConcept) -> Self

pub fn set_class(self, v: Vec<CodeableConcept>) -> Self

pub fn add_class(self, v: CodeableConcept) -> Self

pub fn set_service_category(self, v: Vec<CodeableConcept>) -> Self

pub fn add_service_category(self, v: CodeableConcept) -> Self

pub fn set_service_type(self, v: Vec<CodeableReference>) -> Self

pub fn add_service_type(self, v: CodeableReference) -> Self

pub fn set_specialty(self, v: Vec<CodeableConcept>) -> Self

pub fn add_specialty(self, v: CodeableConcept) -> Self

pub fn set_appointment_type(self, v: CodeableConcept) -> Self

pub fn set_reason(self, v: Vec<CodeableReference>) -> Self

pub fn add_reason(self, v: CodeableReference) -> Self

pub fn set_priority(self, v: CodeableConcept) -> Self

pub fn set_description<T: Into<StringDt>>(self, v: T) -> Self

pub fn set_replaces(self, v: Vec<Reference>) -> Self

pub fn add_replaces(self, v: Reference) -> Self

pub fn set_virtual_service(self, v: Vec<VirtualServiceDetail>) -> Self

pub fn add_virtual_service(self, v: VirtualServiceDetail) -> Self

pub fn set_supporting_information(self, v: Vec<Reference>) -> Self

pub fn add_supporting_information(self, v: Reference) -> Self

pub fn set_previous_appointment(self, v: Reference) -> Self

pub fn set_originating_appointment(self, v: Reference) -> Self

pub fn set_start<T: Into<InstantDt>>(self, v: T) -> Self

pub fn set_end<T: Into<InstantDt>>(self, v: T) -> Self

pub fn set_minutes_duration<T: Into<PositiveIntDt>>(self, v: T) -> Self

pub fn set_requested_period(self, v: Vec<Period>) -> Self

pub fn add_requested_period(self, v: Period) -> Self

pub fn set_slot(self, v: Vec<Reference>) -> Self

pub fn add_slot(self, v: Reference) -> Self

pub fn set_account(self, v: Vec<Reference>) -> Self

pub fn add_account(self, v: Reference) -> Self

pub fn set_created<T: Into<DateTimeDt>>(self, v: T) -> Self

pub fn set_cancellation_date<T: Into<DateTimeDt>>(self, v: T) -> Self

pub fn set_note(self, v: Vec<Annotation>) -> Self

pub fn add_note(self, v: Annotation) -> Self

pub fn set_patient_instruction(self, v: Vec<CodeableReference>) -> Self

pub fn add_patient_instruction(self, v: CodeableReference) -> Self

pub fn set_based_on(self, v: Vec<Reference>) -> Self

pub fn add_based_on(self, v: Reference) -> Self

pub fn set_subject(self, v: Reference) -> Self

pub fn set_participant( self, v: Vec<AppointmentParticipantBackboneElement>, ) -> Self

pub fn add_participant(self, v: AppointmentParticipantBackboneElement) -> Self

pub fn set_recurrence_id<T: Into<PositiveIntDt>>(self, v: T) -> Self

pub fn set_occurrence_changed<T: Into<BooleanDt>>(self, v: T) -> Self

pub fn set_recurrence_template( self, v: Vec<AppointmentRecurrenceTemplateBackboneElement>, ) -> Self

pub fn add_recurrence_template( self, v: AppointmentRecurrenceTemplateBackboneElement, ) -> Self

Trait Implementations

impl Base for Appointment

fn type_name(&self) -> &str

impl Clone for Appointment

fn clone(&self) -> Appointment

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Compare for Appointment

fn eq(&self, _right: &dyn Executor) -> Result<bool>

fn gt(&self, _right: &dyn Executor) -> Result<bool>

fn ge(&self, _right: &dyn Executor) -> Result<bool>

fn lt(&self, _right: &dyn Executor) -> Result<bool>

fn le(&self, _right: &dyn Executor) -> Result<bool>

impl Convert for Appointment

fn to_integer(&self) -> Result<Integer>

fn to_decimal(&self) -> Result<Decimal>

fn to_strings(&self) -> Result<String>

fn to_datetime(&self) -> Result<DateTime>

fn to_boolean(&self) -> Result<Boolean>

impl Debug for Appointment

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Appointment

fn default() -> Appointment

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Appointment

fn deserialize<De>(deserializer: De) -> Result<Self>

where De: Deserializer<'de>,

impl DomainResource for Appointment

fn extension(&self) -> &Option<Vec<Extension>>

fn set_extension(self, ext: Vec<Extension>) -> Self

fn add_extension(self, ext: Extension) -> Self

fn modifier_extension(&self) -> &Option<Vec<Extension>>

fn set_modifier_extension(self, ext: Vec<Extension>) -> Self

fn add_modifier_extension(self, ext: Extension) -> Self

impl Executor for Appointment

fn element(&self, symbol: &String, index: &Option<usize>) -> Result<Collection>

fn to_collection(&self, index: &Option<usize>) -> Collection

fn child(&self, _index: usize) -> Result<Collection>

impl Resource for Appointment

fn id(&self) -> &Option<String>

fn set_id<T: Into<Id>>(self, id: T) -> Self

fn meta(&self) -> &Option<Meta>

fn set_meta(self, meta: Meta) -> Self

impl Serialize for Appointment

fn serialize<Ser: Serializer>(&self, serializer: Ser) -> Result<()>