fhir - v0.1.0

fhir/r5_rsvp

https://hl7.org/fhir/r5 r5 client using rsvp

Types

Err

</> 
pub type Err {
  ErrRsvp(err: rsvp.Error)
  ErrSansio(err: r5_sansio.Err)
}

Constructors

ErrNoId

</>

When using rsvp, if you attempt update or delete a resource with no id, we do not even send the request or give you an effect to use. Instead of an effect you get just Error(ErrNoId)

pub type ErrNoId {
  ErrNoId
}

Constructors 

  • ErrNoId

FhirClient

</> 
pub type FhirClient =
  r5_sansio.FhirClient

Values

account_create

</> 
pub fn account_create(
  resource: r5.Account,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Account, Err)) -> a,
) -> effect.Effect(a)

account_delete

</> 
pub fn account_delete(
  resource: r5.Account,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

account_read

</> 
pub fn account_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Account, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn account_search(
  search_for search_args: r5_sansio.SpAccount,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(List(r5.Account), Err)) -> msg,
) -> effect.Effect(msg)

account_search_bundled

</> 
pub fn account_search_bundled(
  search_for search_args: r5_sansio.SpAccount,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

account_update

</> 
pub fn account_update(
  resource: r5.Account,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Account, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

activitydefinition_create

</> 
pub fn activitydefinition_create(
  resource: r5.Activitydefinition,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Activitydefinition, Err)) -> a,
) -> effect.Effect(a)

activitydefinition_delete

</> 
pub fn activitydefinition_delete(
  resource: r5.Activitydefinition,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

activitydefinition_read

</> 
pub fn activitydefinition_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Activitydefinition, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn activitydefinition_search(
  search_for search_args: r5_sansio.SpActivitydefinition,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Activitydefinition), Err),
  ) -> msg,
) -> effect.Effect(msg)

activitydefinition_search_bundled

</> 
pub fn activitydefinition_search_bundled(
  search_for search_args: r5_sansio.SpActivitydefinition,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

activitydefinition_update

</> 
pub fn activitydefinition_update(
  resource: r5.Activitydefinition,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Activitydefinition, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

actordefinition_create

</> 
pub fn actordefinition_create(
  resource: r5.Actordefinition,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Actordefinition, Err)) -> a,
) -> effect.Effect(a)

actordefinition_delete

</> 
pub fn actordefinition_delete(
  resource: r5.Actordefinition,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

actordefinition_read

</> 
pub fn actordefinition_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Actordefinition, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn actordefinition_search(
  search_for search_args: r5_sansio.SpActordefinition,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Actordefinition), Err),
  ) -> msg,
) -> effect.Effect(msg)

actordefinition_search_bundled

</> 
pub fn actordefinition_search_bundled(
  search_for search_args: r5_sansio.SpActordefinition,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

actordefinition_update

</> 
pub fn actordefinition_update(
  resource: r5.Actordefinition,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Actordefinition, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

administrableproductdefinition_create

</> 
pub fn administrableproductdefinition_create(
  resource: r5.Administrableproductdefinition,
  client: r5_sansio.FhirClient,
  handle_response: fn(
    Result(r5.Administrableproductdefinition, Err),
  ) -> a,
) -> effect.Effect(a)

administrableproductdefinition_delete

</> 
pub fn administrableproductdefinition_delete(
  resource: r5.Administrableproductdefinition,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

administrableproductdefinition_read

</> 
pub fn administrableproductdefinition_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(
    Result(r5.Administrableproductdefinition, Err),
  ) -> a,
) -> effect.Effect(a)
</> 
pub fn administrableproductdefinition_search(
  search_for search_args: r5_sansio.SpAdministrableproductdefinition,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Administrableproductdefinition), Err),
  ) -> msg,
) -> effect.Effect(msg)

administrableproductdefinition_search_bundled

</> 
pub fn administrableproductdefinition_search_bundled(
  search_for search_args: r5_sansio.SpAdministrableproductdefinition,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

administrableproductdefinition_update

</> 
pub fn administrableproductdefinition_update(
  resource: r5.Administrableproductdefinition,
  client: r5_sansio.FhirClient,
  handle_response: fn(
    Result(r5.Administrableproductdefinition, Err),
  ) -> a,
) -> Result(effect.Effect(a), ErrNoId)

adverseevent_create

</> 
pub fn adverseevent_create(
  resource: r5.Adverseevent,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Adverseevent, Err)) -> a,
) -> effect.Effect(a)

adverseevent_delete

</> 
pub fn adverseevent_delete(
  resource: r5.Adverseevent,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

adverseevent_read

</> 
pub fn adverseevent_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Adverseevent, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn adverseevent_search(
  search_for search_args: r5_sansio.SpAdverseevent,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Adverseevent), Err),
  ) -> msg,
) -> effect.Effect(msg)

adverseevent_search_bundled

</> 
pub fn adverseevent_search_bundled(
  search_for search_args: r5_sansio.SpAdverseevent,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

adverseevent_update

</> 
pub fn adverseevent_update(
  resource: r5.Adverseevent,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Adverseevent, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

allergyintolerance_create

</> 
pub fn allergyintolerance_create(
  resource: r5.Allergyintolerance,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Allergyintolerance, Err)) -> a,
) -> effect.Effect(a)

allergyintolerance_delete

</> 
pub fn allergyintolerance_delete(
  resource: r5.Allergyintolerance,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

allergyintolerance_read

</> 
pub fn allergyintolerance_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Allergyintolerance, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn allergyintolerance_search(
  search_for search_args: r5_sansio.SpAllergyintolerance,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Allergyintolerance), Err),
  ) -> msg,
) -> effect.Effect(msg)

allergyintolerance_search_bundled

</> 
pub fn allergyintolerance_search_bundled(
  search_for search_args: r5_sansio.SpAllergyintolerance,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

allergyintolerance_update

</> 
pub fn allergyintolerance_update(
  resource: r5.Allergyintolerance,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Allergyintolerance, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

appointment_create

</> 
pub fn appointment_create(
  resource: r5.Appointment,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Appointment, Err)) -> a,
) -> effect.Effect(a)

appointment_delete

</> 
pub fn appointment_delete(
  resource: r5.Appointment,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

appointment_read

</> 
pub fn appointment_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Appointment, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn appointment_search(
  search_for search_args: r5_sansio.SpAppointment,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Appointment), Err),
  ) -> msg,
) -> effect.Effect(msg)

appointment_search_bundled

</> 
pub fn appointment_search_bundled(
  search_for search_args: r5_sansio.SpAppointment,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

appointment_update

</> 
pub fn appointment_update(
  resource: r5.Appointment,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Appointment, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

appointmentresponse_create

</> 
pub fn appointmentresponse_create(
  resource: r5.Appointmentresponse,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Appointmentresponse, Err)) -> a,
) -> effect.Effect(a)

appointmentresponse_delete

</> 
pub fn appointmentresponse_delete(
  resource: r5.Appointmentresponse,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

appointmentresponse_read

</> 
pub fn appointmentresponse_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Appointmentresponse, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn appointmentresponse_search(
  search_for search_args: r5_sansio.SpAppointmentresponse,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Appointmentresponse), Err),
  ) -> msg,
) -> effect.Effect(msg)

appointmentresponse_search_bundled

</> 
pub fn appointmentresponse_search_bundled(
  search_for search_args: r5_sansio.SpAppointmentresponse,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

appointmentresponse_update

</> 
pub fn appointmentresponse_update(
  resource: r5.Appointmentresponse,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Appointmentresponse, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

artifactassessment_create

</> 
pub fn artifactassessment_create(
  resource: r5.Artifactassessment,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Artifactassessment, Err)) -> a,
) -> effect.Effect(a)

artifactassessment_delete

</> 
pub fn artifactassessment_delete(
  resource: r5.Artifactassessment,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

artifactassessment_read

</> 
pub fn artifactassessment_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Artifactassessment, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn artifactassessment_search(
  search_for search_args: r5_sansio.SpArtifactassessment,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Artifactassessment), Err),
  ) -> msg,
) -> effect.Effect(msg)

artifactassessment_search_bundled

</> 
pub fn artifactassessment_search_bundled(
  search_for search_args: r5_sansio.SpArtifactassessment,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

artifactassessment_update

</> 
pub fn artifactassessment_update(
  resource: r5.Artifactassessment,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Artifactassessment, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

auditevent_create

</> 
pub fn auditevent_create(
  resource: r5.Auditevent,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Auditevent, Err)) -> a,
) -> effect.Effect(a)

auditevent_delete

</> 
pub fn auditevent_delete(
  resource: r5.Auditevent,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

auditevent_read

</> 
pub fn auditevent_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Auditevent, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn auditevent_search(
  search_for search_args: r5_sansio.SpAuditevent,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Auditevent), Err),
  ) -> msg,
) -> effect.Effect(msg)

auditevent_search_bundled

</> 
pub fn auditevent_search_bundled(
  search_for search_args: r5_sansio.SpAuditevent,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

auditevent_update

</> 
pub fn auditevent_update(
  resource: r5.Auditevent,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Auditevent, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

basic_create

</> 
pub fn basic_create(
  resource: r5.Basic,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Basic, Err)) -> a,
) -> effect.Effect(a)

basic_delete

</> 
pub fn basic_delete(
  resource: r5.Basic,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

basic_read

</> 
pub fn basic_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Basic, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn basic_search(
  search_for search_args: r5_sansio.SpBasic,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(List(r5.Basic), Err)) -> msg,
) -> effect.Effect(msg)

basic_search_bundled

</> 
pub fn basic_search_bundled(
  search_for search_args: r5_sansio.SpBasic,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

basic_update

</> 
pub fn basic_update(
  resource: r5.Basic,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Basic, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

binary_create

</> 
pub fn binary_create(
  resource: r5.Binary,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Binary, Err)) -> a,
) -> effect.Effect(a)

binary_delete

</> 
pub fn binary_delete(
  resource: r5.Binary,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

binary_read

</> 
pub fn binary_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Binary, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn binary_search(
  search_for search_args: r5_sansio.SpBinary,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(List(r5.Binary), Err)) -> msg,
) -> effect.Effect(msg)

binary_search_bundled

</> 
pub fn binary_search_bundled(
  search_for search_args: r5_sansio.SpBinary,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

binary_update

</> 
pub fn binary_update(
  resource: r5.Binary,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Binary, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

biologicallyderivedproduct_create

</> 
pub fn biologicallyderivedproduct_create(
  resource: r5.Biologicallyderivedproduct,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Biologicallyderivedproduct, Err)) -> a,
) -> effect.Effect(a)

biologicallyderivedproduct_delete

</> 
pub fn biologicallyderivedproduct_delete(
  resource: r5.Biologicallyderivedproduct,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

biologicallyderivedproduct_read

</> 
pub fn biologicallyderivedproduct_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Biologicallyderivedproduct, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn biologicallyderivedproduct_search(
  search_for search_args: r5_sansio.SpBiologicallyderivedproduct,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Biologicallyderivedproduct), Err),
  ) -> msg,
) -> effect.Effect(msg)

biologicallyderivedproduct_search_bundled

</> 
pub fn biologicallyderivedproduct_search_bundled(
  search_for search_args: r5_sansio.SpBiologicallyderivedproduct,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

biologicallyderivedproduct_update

</> 
pub fn biologicallyderivedproduct_update(
  resource: r5.Biologicallyderivedproduct,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Biologicallyderivedproduct, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

biologicallyderivedproductdispense_create

</> 
pub fn biologicallyderivedproductdispense_create(
  resource: r5.Biologicallyderivedproductdispense,
  client: r5_sansio.FhirClient,
  handle_response: fn(
    Result(r5.Biologicallyderivedproductdispense, Err),
  ) -> a,
) -> effect.Effect(a)

biologicallyderivedproductdispense_delete

</> 
pub fn biologicallyderivedproductdispense_delete(
  resource: r5.Biologicallyderivedproductdispense,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

biologicallyderivedproductdispense_read

</> 
pub fn biologicallyderivedproductdispense_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(
    Result(r5.Biologicallyderivedproductdispense, Err),
  ) -> a,
) -> effect.Effect(a)
</> 
pub fn biologicallyderivedproductdispense_search(
  search_for search_args: r5_sansio.SpBiologicallyderivedproductdispense,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Biologicallyderivedproductdispense), Err),
  ) -> msg,
) -> effect.Effect(msg)

biologicallyderivedproductdispense_search_bundled

</> 
pub fn biologicallyderivedproductdispense_search_bundled(
  search_for search_args: r5_sansio.SpBiologicallyderivedproductdispense,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

biologicallyderivedproductdispense_update

</> 
pub fn biologicallyderivedproductdispense_update(
  resource: r5.Biologicallyderivedproductdispense,
  client: r5_sansio.FhirClient,
  handle_response: fn(
    Result(r5.Biologicallyderivedproductdispense, Err),
  ) -> a,
) -> Result(effect.Effect(a), ErrNoId)

bodystructure_create

</> 
pub fn bodystructure_create(
  resource: r5.Bodystructure,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Bodystructure, Err)) -> a,
) -> effect.Effect(a)

bodystructure_delete

</> 
pub fn bodystructure_delete(
  resource: r5.Bodystructure,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

bodystructure_read

</> 
pub fn bodystructure_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Bodystructure, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn bodystructure_search(
  search_for search_args: r5_sansio.SpBodystructure,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Bodystructure), Err),
  ) -> msg,
) -> effect.Effect(msg)

bodystructure_search_bundled

</> 
pub fn bodystructure_search_bundled(
  search_for search_args: r5_sansio.SpBodystructure,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

bodystructure_update

</> 
pub fn bodystructure_update(
  resource: r5.Bodystructure,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Bodystructure, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

bundle_create

</> 
pub fn bundle_create(
  resource: r5.Bundle,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Bundle, Err)) -> a,
) -> effect.Effect(a)

bundle_delete

</> 
pub fn bundle_delete(
  resource: r5.Bundle,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

bundle_read

</> 
pub fn bundle_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Bundle, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn bundle_search(
  search_for search_args: r5_sansio.SpBundle,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(List(r5.Bundle), Err)) -> msg,
) -> effect.Effect(msg)

bundle_search_bundled

</> 
pub fn bundle_search_bundled(
  search_for search_args: r5_sansio.SpBundle,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

bundle_update

</> 
pub fn bundle_update(
  resource: r5.Bundle,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Bundle, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

capabilitystatement_create

</> 
pub fn capabilitystatement_create(
  resource: r5.Capabilitystatement,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Capabilitystatement, Err)) -> a,
) -> effect.Effect(a)

capabilitystatement_delete

</> 
pub fn capabilitystatement_delete(
  resource: r5.Capabilitystatement,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

capabilitystatement_read

</> 
pub fn capabilitystatement_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Capabilitystatement, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn capabilitystatement_search(
  search_for search_args: r5_sansio.SpCapabilitystatement,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Capabilitystatement), Err),
  ) -> msg,
) -> effect.Effect(msg)

capabilitystatement_search_bundled

</> 
pub fn capabilitystatement_search_bundled(
  search_for search_args: r5_sansio.SpCapabilitystatement,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

capabilitystatement_update

</> 
pub fn capabilitystatement_update(
  resource: r5.Capabilitystatement,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Capabilitystatement, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

careplan_create

</> 
pub fn careplan_create(
  resource: r5.Careplan,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Careplan, Err)) -> a,
) -> effect.Effect(a)

careplan_delete

</> 
pub fn careplan_delete(
  resource: r5.Careplan,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

careplan_read

</> 
pub fn careplan_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Careplan, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn careplan_search(
  search_for search_args: r5_sansio.SpCareplan,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(List(r5.Careplan), Err)) -> msg,
) -> effect.Effect(msg)

careplan_search_bundled

</> 
pub fn careplan_search_bundled(
  search_for search_args: r5_sansio.SpCareplan,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

careplan_update

</> 
pub fn careplan_update(
  resource: r5.Careplan,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Careplan, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

careteam_create

</> 
pub fn careteam_create(
  resource: r5.Careteam,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Careteam, Err)) -> a,
) -> effect.Effect(a)

careteam_delete

</> 
pub fn careteam_delete(
  resource: r5.Careteam,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

careteam_read

</> 
pub fn careteam_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Careteam, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn careteam_search(
  search_for search_args: r5_sansio.SpCareteam,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(List(r5.Careteam), Err)) -> msg,
) -> effect.Effect(msg)

careteam_search_bundled

</> 
pub fn careteam_search_bundled(
  search_for search_args: r5_sansio.SpCareteam,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

careteam_update

</> 
pub fn careteam_update(
  resource: r5.Careteam,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Careteam, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

chargeitem_create

</> 
pub fn chargeitem_create(
  resource: r5.Chargeitem,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Chargeitem, Err)) -> a,
) -> effect.Effect(a)

chargeitem_delete

</> 
pub fn chargeitem_delete(
  resource: r5.Chargeitem,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

chargeitem_read

</> 
pub fn chargeitem_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Chargeitem, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn chargeitem_search(
  search_for search_args: r5_sansio.SpChargeitem,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Chargeitem), Err),
  ) -> msg,
) -> effect.Effect(msg)

chargeitem_search_bundled

</> 
pub fn chargeitem_search_bundled(
  search_for search_args: r5_sansio.SpChargeitem,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

chargeitem_update

</> 
pub fn chargeitem_update(
  resource: r5.Chargeitem,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Chargeitem, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

chargeitemdefinition_create

</> 
pub fn chargeitemdefinition_create(
  resource: r5.Chargeitemdefinition,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Chargeitemdefinition, Err)) -> a,
) -> effect.Effect(a)

chargeitemdefinition_delete

</> 
pub fn chargeitemdefinition_delete(
  resource: r5.Chargeitemdefinition,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

chargeitemdefinition_read

</> 
pub fn chargeitemdefinition_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Chargeitemdefinition, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn chargeitemdefinition_search(
  search_for search_args: r5_sansio.SpChargeitemdefinition,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Chargeitemdefinition), Err),
  ) -> msg,
) -> effect.Effect(msg)

chargeitemdefinition_search_bundled

</> 
pub fn chargeitemdefinition_search_bundled(
  search_for search_args: r5_sansio.SpChargeitemdefinition,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

chargeitemdefinition_update

</> 
pub fn chargeitemdefinition_update(
  resource: r5.Chargeitemdefinition,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Chargeitemdefinition, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

citation_create

</> 
pub fn citation_create(
  resource: r5.Citation,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Citation, Err)) -> a,
) -> effect.Effect(a)

citation_delete

</> 
pub fn citation_delete(
  resource: r5.Citation,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

citation_read

</> 
pub fn citation_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Citation, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn citation_search(
  search_for search_args: r5_sansio.SpCitation,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(List(r5.Citation), Err)) -> msg,
) -> effect.Effect(msg)

citation_search_bundled

</> 
pub fn citation_search_bundled(
  search_for search_args: r5_sansio.SpCitation,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

citation_update

</> 
pub fn citation_update(
  resource: r5.Citation,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Citation, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

claim_create

</> 
pub fn claim_create(
  resource: r5.Claim,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Claim, Err)) -> a,
) -> effect.Effect(a)

claim_delete

</> 
pub fn claim_delete(
  resource: r5.Claim,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

claim_read

</> 
pub fn claim_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Claim, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn claim_search(
  search_for search_args: r5_sansio.SpClaim,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(List(r5.Claim), Err)) -> msg,
) -> effect.Effect(msg)

claim_search_bundled

</> 
pub fn claim_search_bundled(
  search_for search_args: r5_sansio.SpClaim,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

claim_update

</> 
pub fn claim_update(
  resource: r5.Claim,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Claim, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

claimresponse_create

</> 
pub fn claimresponse_create(
  resource: r5.Claimresponse,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Claimresponse, Err)) -> a,
) -> effect.Effect(a)

claimresponse_delete

</> 
pub fn claimresponse_delete(
  resource: r5.Claimresponse,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

claimresponse_read

</> 
pub fn claimresponse_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Claimresponse, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn claimresponse_search(
  search_for search_args: r5_sansio.SpClaimresponse,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Claimresponse), Err),
  ) -> msg,
) -> effect.Effect(msg)

claimresponse_search_bundled

</> 
pub fn claimresponse_search_bundled(
  search_for search_args: r5_sansio.SpClaimresponse,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

claimresponse_update

</> 
pub fn claimresponse_update(
  resource: r5.Claimresponse,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Claimresponse, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

clinicalimpression_create

</> 
pub fn clinicalimpression_create(
  resource: r5.Clinicalimpression,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Clinicalimpression, Err)) -> a,
) -> effect.Effect(a)

clinicalimpression_delete

</> 
pub fn clinicalimpression_delete(
  resource: r5.Clinicalimpression,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

clinicalimpression_read

</> 
pub fn clinicalimpression_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Clinicalimpression, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn clinicalimpression_search(
  search_for search_args: r5_sansio.SpClinicalimpression,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Clinicalimpression), Err),
  ) -> msg,
) -> effect.Effect(msg)

clinicalimpression_search_bundled

</> 
pub fn clinicalimpression_search_bundled(
  search_for search_args: r5_sansio.SpClinicalimpression,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

clinicalimpression_update

</> 
pub fn clinicalimpression_update(
  resource: r5.Clinicalimpression,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Clinicalimpression, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

clinicalusedefinition_create

</> 
pub fn clinicalusedefinition_create(
  resource: r5.Clinicalusedefinition,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Clinicalusedefinition, Err)) -> a,
) -> effect.Effect(a)

clinicalusedefinition_delete

</> 
pub fn clinicalusedefinition_delete(
  resource: r5.Clinicalusedefinition,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

clinicalusedefinition_read

</> 
pub fn clinicalusedefinition_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Clinicalusedefinition, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn clinicalusedefinition_search(
  search_for search_args: r5_sansio.SpClinicalusedefinition,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Clinicalusedefinition), Err),
  ) -> msg,
) -> effect.Effect(msg)

clinicalusedefinition_search_bundled

</> 
pub fn clinicalusedefinition_search_bundled(
  search_for search_args: r5_sansio.SpClinicalusedefinition,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

clinicalusedefinition_update

</> 
pub fn clinicalusedefinition_update(
  resource: r5.Clinicalusedefinition,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Clinicalusedefinition, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

codesystem_create

</> 
pub fn codesystem_create(
  resource: r5.Codesystem,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Codesystem, Err)) -> a,
) -> effect.Effect(a)

codesystem_delete

</> 
pub fn codesystem_delete(
  resource: r5.Codesystem,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

codesystem_read

</> 
pub fn codesystem_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Codesystem, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn codesystem_search(
  search_for search_args: r5_sansio.SpCodesystem,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Codesystem), Err),
  ) -> msg,
) -> effect.Effect(msg)

codesystem_search_bundled

</> 
pub fn codesystem_search_bundled(
  search_for search_args: r5_sansio.SpCodesystem,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

codesystem_update

</> 
pub fn codesystem_update(
  resource: r5.Codesystem,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Codesystem, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

communication_create

</> 
pub fn communication_create(
  resource: r5.Communication,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Communication, Err)) -> a,
) -> effect.Effect(a)

communication_delete

</> 
pub fn communication_delete(
  resource: r5.Communication,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

communication_read

</> 
pub fn communication_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Communication, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn communication_search(
  search_for search_args: r5_sansio.SpCommunication,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Communication), Err),
  ) -> msg,
) -> effect.Effect(msg)

communication_search_bundled

</> 
pub fn communication_search_bundled(
  search_for search_args: r5_sansio.SpCommunication,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

communication_update

</> 
pub fn communication_update(
  resource: r5.Communication,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Communication, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

communicationrequest_create

</> 
pub fn communicationrequest_create(
  resource: r5.Communicationrequest,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Communicationrequest, Err)) -> a,
) -> effect.Effect(a)

communicationrequest_delete

</> 
pub fn communicationrequest_delete(
  resource: r5.Communicationrequest,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

communicationrequest_read

</> 
pub fn communicationrequest_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Communicationrequest, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn communicationrequest_search(
  search_for search_args: r5_sansio.SpCommunicationrequest,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Communicationrequest), Err),
  ) -> msg,
) -> effect.Effect(msg)

communicationrequest_search_bundled

</> 
pub fn communicationrequest_search_bundled(
  search_for search_args: r5_sansio.SpCommunicationrequest,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

communicationrequest_update

</> 
pub fn communicationrequest_update(
  resource: r5.Communicationrequest,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Communicationrequest, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

compartmentdefinition_create

</> 
pub fn compartmentdefinition_create(
  resource: r5.Compartmentdefinition,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Compartmentdefinition, Err)) -> a,
) -> effect.Effect(a)

compartmentdefinition_delete

</> 
pub fn compartmentdefinition_delete(
  resource: r5.Compartmentdefinition,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

compartmentdefinition_read

</> 
pub fn compartmentdefinition_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Compartmentdefinition, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn compartmentdefinition_search(
  search_for search_args: r5_sansio.SpCompartmentdefinition,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Compartmentdefinition), Err),
  ) -> msg,
) -> effect.Effect(msg)

compartmentdefinition_search_bundled

</> 
pub fn compartmentdefinition_search_bundled(
  search_for search_args: r5_sansio.SpCompartmentdefinition,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

compartmentdefinition_update

</> 
pub fn compartmentdefinition_update(
  resource: r5.Compartmentdefinition,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Compartmentdefinition, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

composition_create

</> 
pub fn composition_create(
  resource: r5.Composition,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Composition, Err)) -> a,
) -> effect.Effect(a)

composition_delete

</> 
pub fn composition_delete(
  resource: r5.Composition,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

composition_read

</> 
pub fn composition_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Composition, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn composition_search(
  search_for search_args: r5_sansio.SpComposition,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Composition), Err),
  ) -> msg,
) -> effect.Effect(msg)

composition_search_bundled

</> 
pub fn composition_search_bundled(
  search_for search_args: r5_sansio.SpComposition,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

composition_update

</> 
pub fn composition_update(
  resource: r5.Composition,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Composition, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

conceptmap_create

</> 
pub fn conceptmap_create(
  resource: r5.Conceptmap,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Conceptmap, Err)) -> a,
) -> effect.Effect(a)

conceptmap_delete

</> 
pub fn conceptmap_delete(
  resource: r5.Conceptmap,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

conceptmap_read

</> 
pub fn conceptmap_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Conceptmap, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn conceptmap_search(
  search_for search_args: r5_sansio.SpConceptmap,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Conceptmap), Err),
  ) -> msg,
) -> effect.Effect(msg)

conceptmap_search_bundled

</> 
pub fn conceptmap_search_bundled(
  search_for search_args: r5_sansio.SpConceptmap,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

conceptmap_update

</> 
pub fn conceptmap_update(
  resource: r5.Conceptmap,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Conceptmap, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

condition_create

</> 
pub fn condition_create(
  resource: r5.Condition,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Condition, Err)) -> a,
) -> effect.Effect(a)

condition_delete

</> 
pub fn condition_delete(
  resource: r5.Condition,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

condition_read

</> 
pub fn condition_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Condition, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn condition_search(
  search_for search_args: r5_sansio.SpCondition,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Condition), Err),
  ) -> msg,
) -> effect.Effect(msg)

condition_search_bundled

</> 
pub fn condition_search_bundled(
  search_for search_args: r5_sansio.SpCondition,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

condition_update

</> 
pub fn condition_update(
  resource: r5.Condition,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Condition, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

conditiondefinition_create

</> 
pub fn conditiondefinition_create(
  resource: r5.Conditiondefinition,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Conditiondefinition, Err)) -> a,
) -> effect.Effect(a)

conditiondefinition_delete

</> 
pub fn conditiondefinition_delete(
  resource: r5.Conditiondefinition,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

conditiondefinition_read

</> 
pub fn conditiondefinition_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Conditiondefinition, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn conditiondefinition_search(
  search_for search_args: r5_sansio.SpConditiondefinition,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Conditiondefinition), Err),
  ) -> msg,
) -> effect.Effect(msg)

conditiondefinition_search_bundled

</> 
pub fn conditiondefinition_search_bundled(
  search_for search_args: r5_sansio.SpConditiondefinition,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

conditiondefinition_update

</> 
pub fn conditiondefinition_update(
  resource: r5.Conditiondefinition,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Conditiondefinition, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)
</> 
pub fn consent_create(
  resource: r5.Consent,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Consent, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn consent_delete(
  resource: r5.Consent,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)
</> 
pub fn consent_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Consent, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn consent_search(
  search_for search_args: r5_sansio.SpConsent,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(List(r5.Consent), Err)) -> msg,
) -> effect.Effect(msg)
</> 
pub fn consent_search_bundled(
  search_for search_args: r5_sansio.SpConsent,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)
</> 
pub fn consent_update(
  resource: r5.Consent,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Consent, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

contract_create

</> 
pub fn contract_create(
  resource: r5.Contract,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Contract, Err)) -> a,
) -> effect.Effect(a)

contract_delete

</> 
pub fn contract_delete(
  resource: r5.Contract,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

contract_read

</> 
pub fn contract_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Contract, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn contract_search(
  search_for search_args: r5_sansio.SpContract,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(List(r5.Contract), Err)) -> msg,
) -> effect.Effect(msg)

contract_search_bundled

</> 
pub fn contract_search_bundled(
  search_for search_args: r5_sansio.SpContract,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

contract_update

</> 
pub fn contract_update(
  resource: r5.Contract,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Contract, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

coverage_create

</> 
pub fn coverage_create(
  resource: r5.Coverage,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Coverage, Err)) -> a,
) -> effect.Effect(a)

coverage_delete

</> 
pub fn coverage_delete(
  resource: r5.Coverage,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

coverage_read

</> 
pub fn coverage_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Coverage, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn coverage_search(
  search_for search_args: r5_sansio.SpCoverage,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(List(r5.Coverage), Err)) -> msg,
) -> effect.Effect(msg)

coverage_search_bundled

</> 
pub fn coverage_search_bundled(
  search_for search_args: r5_sansio.SpCoverage,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

coverage_update

</> 
pub fn coverage_update(
  resource: r5.Coverage,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Coverage, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

coverageeligibilityrequest_create

</> 
pub fn coverageeligibilityrequest_create(
  resource: r5.Coverageeligibilityrequest,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Coverageeligibilityrequest, Err)) -> a,
) -> effect.Effect(a)

coverageeligibilityrequest_delete

</> 
pub fn coverageeligibilityrequest_delete(
  resource: r5.Coverageeligibilityrequest,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

coverageeligibilityrequest_read

</> 
pub fn coverageeligibilityrequest_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Coverageeligibilityrequest, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn coverageeligibilityrequest_search(
  search_for search_args: r5_sansio.SpCoverageeligibilityrequest,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Coverageeligibilityrequest), Err),
  ) -> msg,
) -> effect.Effect(msg)

coverageeligibilityrequest_search_bundled

</> 
pub fn coverageeligibilityrequest_search_bundled(
  search_for search_args: r5_sansio.SpCoverageeligibilityrequest,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

coverageeligibilityrequest_update

</> 
pub fn coverageeligibilityrequest_update(
  resource: r5.Coverageeligibilityrequest,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Coverageeligibilityrequest, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

coverageeligibilityresponse_create

</> 
pub fn coverageeligibilityresponse_create(
  resource: r5.Coverageeligibilityresponse,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Coverageeligibilityresponse, Err)) -> a,
) -> effect.Effect(a)

coverageeligibilityresponse_delete

</> 
pub fn coverageeligibilityresponse_delete(
  resource: r5.Coverageeligibilityresponse,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

coverageeligibilityresponse_read

</> 
pub fn coverageeligibilityresponse_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Coverageeligibilityresponse, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn coverageeligibilityresponse_search(
  search_for search_args: r5_sansio.SpCoverageeligibilityresponse,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Coverageeligibilityresponse), Err),
  ) -> msg,
) -> effect.Effect(msg)

coverageeligibilityresponse_search_bundled

</> 
pub fn coverageeligibilityresponse_search_bundled(
  search_for search_args: r5_sansio.SpCoverageeligibilityresponse,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

coverageeligibilityresponse_update

</> 
pub fn coverageeligibilityresponse_update(
  resource: r5.Coverageeligibilityresponse,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Coverageeligibilityresponse, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

detectedissue_create

</> 
pub fn detectedissue_create(
  resource: r5.Detectedissue,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Detectedissue, Err)) -> a,
) -> effect.Effect(a)

detectedissue_delete

</> 
pub fn detectedissue_delete(
  resource: r5.Detectedissue,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

detectedissue_read

</> 
pub fn detectedissue_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Detectedissue, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn detectedissue_search(
  search_for search_args: r5_sansio.SpDetectedissue,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Detectedissue), Err),
  ) -> msg,
) -> effect.Effect(msg)

detectedissue_search_bundled

</> 
pub fn detectedissue_search_bundled(
  search_for search_args: r5_sansio.SpDetectedissue,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

detectedissue_update

</> 
pub fn detectedissue_update(
  resource: r5.Detectedissue,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Detectedissue, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

device_create

</> 
pub fn device_create(
  resource: r5.Device,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Device, Err)) -> a,
) -> effect.Effect(a)

device_delete

</> 
pub fn device_delete(
  resource: r5.Device,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

device_read

</> 
pub fn device_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Device, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn device_search(
  search_for search_args: r5_sansio.SpDevice,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(List(r5.Device), Err)) -> msg,
) -> effect.Effect(msg)

device_search_bundled

</> 
pub fn device_search_bundled(
  search_for search_args: r5_sansio.SpDevice,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

device_update

</> 
pub fn device_update(
  resource: r5.Device,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Device, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

deviceassociation_create

</> 
pub fn deviceassociation_create(
  resource: r5.Deviceassociation,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Deviceassociation, Err)) -> a,
) -> effect.Effect(a)

deviceassociation_delete

</> 
pub fn deviceassociation_delete(
  resource: r5.Deviceassociation,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

deviceassociation_read

</> 
pub fn deviceassociation_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Deviceassociation, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn deviceassociation_search(
  search_for search_args: r5_sansio.SpDeviceassociation,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Deviceassociation), Err),
  ) -> msg,
) -> effect.Effect(msg)

deviceassociation_search_bundled

</> 
pub fn deviceassociation_search_bundled(
  search_for search_args: r5_sansio.SpDeviceassociation,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

deviceassociation_update

</> 
pub fn deviceassociation_update(
  resource: r5.Deviceassociation,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Deviceassociation, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

devicedefinition_create

</> 
pub fn devicedefinition_create(
  resource: r5.Devicedefinition,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Devicedefinition, Err)) -> a,
) -> effect.Effect(a)

devicedefinition_delete

</> 
pub fn devicedefinition_delete(
  resource: r5.Devicedefinition,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

devicedefinition_read

</> 
pub fn devicedefinition_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Devicedefinition, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn devicedefinition_search(
  search_for search_args: r5_sansio.SpDevicedefinition,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Devicedefinition), Err),
  ) -> msg,
) -> effect.Effect(msg)

devicedefinition_search_bundled

</> 
pub fn devicedefinition_search_bundled(
  search_for search_args: r5_sansio.SpDevicedefinition,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

devicedefinition_update

</> 
pub fn devicedefinition_update(
  resource: r5.Devicedefinition,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Devicedefinition, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

devicedispense_create

</> 
pub fn devicedispense_create(
  resource: r5.Devicedispense,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Devicedispense, Err)) -> a,
) -> effect.Effect(a)

devicedispense_delete

</> 
pub fn devicedispense_delete(
  resource: r5.Devicedispense,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

devicedispense_read

</> 
pub fn devicedispense_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Devicedispense, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn devicedispense_search(
  search_for search_args: r5_sansio.SpDevicedispense,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Devicedispense), Err),
  ) -> msg,
) -> effect.Effect(msg)

devicedispense_search_bundled

</> 
pub fn devicedispense_search_bundled(
  search_for search_args: r5_sansio.SpDevicedispense,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

devicedispense_update

</> 
pub fn devicedispense_update(
  resource: r5.Devicedispense,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Devicedispense, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

devicemetric_create

</> 
pub fn devicemetric_create(
  resource: r5.Devicemetric,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Devicemetric, Err)) -> a,
) -> effect.Effect(a)

devicemetric_delete

</> 
pub fn devicemetric_delete(
  resource: r5.Devicemetric,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

devicemetric_read

</> 
pub fn devicemetric_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Devicemetric, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn devicemetric_search(
  search_for search_args: r5_sansio.SpDevicemetric,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Devicemetric), Err),
  ) -> msg,
) -> effect.Effect(msg)

devicemetric_search_bundled

</> 
pub fn devicemetric_search_bundled(
  search_for search_args: r5_sansio.SpDevicemetric,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

devicemetric_update

</> 
pub fn devicemetric_update(
  resource: r5.Devicemetric,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Devicemetric, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

devicerequest_create

</> 
pub fn devicerequest_create(
  resource: r5.Devicerequest,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Devicerequest, Err)) -> a,
) -> effect.Effect(a)

devicerequest_delete

</> 
pub fn devicerequest_delete(
  resource: r5.Devicerequest,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

devicerequest_read

</> 
pub fn devicerequest_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Devicerequest, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn devicerequest_search(
  search_for search_args: r5_sansio.SpDevicerequest,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Devicerequest), Err),
  ) -> msg,
) -> effect.Effect(msg)

devicerequest_search_bundled

</> 
pub fn devicerequest_search_bundled(
  search_for search_args: r5_sansio.SpDevicerequest,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

devicerequest_update

</> 
pub fn devicerequest_update(
  resource: r5.Devicerequest,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Devicerequest, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

deviceusage_create

</> 
pub fn deviceusage_create(
  resource: r5.Deviceusage,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Deviceusage, Err)) -> a,
) -> effect.Effect(a)

deviceusage_delete

</> 
pub fn deviceusage_delete(
  resource: r5.Deviceusage,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

deviceusage_read

</> 
pub fn deviceusage_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Deviceusage, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn deviceusage_search(
  search_for search_args: r5_sansio.SpDeviceusage,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Deviceusage), Err),
  ) -> msg,
) -> effect.Effect(msg)

deviceusage_search_bundled

</> 
pub fn deviceusage_search_bundled(
  search_for search_args: r5_sansio.SpDeviceusage,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

deviceusage_update

</> 
pub fn deviceusage_update(
  resource: r5.Deviceusage,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Deviceusage, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

diagnosticreport_create

</> 
pub fn diagnosticreport_create(
  resource: r5.Diagnosticreport,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Diagnosticreport, Err)) -> a,
) -> effect.Effect(a)

diagnosticreport_delete

</> 
pub fn diagnosticreport_delete(
  resource: r5.Diagnosticreport,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

diagnosticreport_read

</> 
pub fn diagnosticreport_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Diagnosticreport, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn diagnosticreport_search(
  search_for search_args: r5_sansio.SpDiagnosticreport,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Diagnosticreport), Err),
  ) -> msg,
) -> effect.Effect(msg)

diagnosticreport_search_bundled

</> 
pub fn diagnosticreport_search_bundled(
  search_for search_args: r5_sansio.SpDiagnosticreport,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

diagnosticreport_update

</> 
pub fn diagnosticreport_update(
  resource: r5.Diagnosticreport,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Diagnosticreport, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

documentreference_create

</> 
pub fn documentreference_create(
  resource: r5.Documentreference,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Documentreference, Err)) -> a,
) -> effect.Effect(a)

documentreference_delete

</> 
pub fn documentreference_delete(
  resource: r5.Documentreference,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

documentreference_read

</> 
pub fn documentreference_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Documentreference, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn documentreference_search(
  search_for search_args: r5_sansio.SpDocumentreference,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Documentreference), Err),
  ) -> msg,
) -> effect.Effect(msg)

documentreference_search_bundled

</> 
pub fn documentreference_search_bundled(
  search_for search_args: r5_sansio.SpDocumentreference,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

documentreference_update

</> 
pub fn documentreference_update(
  resource: r5.Documentreference,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Documentreference, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

encounter_create

</> 
pub fn encounter_create(
  resource: r5.Encounter,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Encounter, Err)) -> a,
) -> effect.Effect(a)

encounter_delete

</> 
pub fn encounter_delete(
  resource: r5.Encounter,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

encounter_read

</> 
pub fn encounter_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Encounter, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn encounter_search(
  search_for search_args: r5_sansio.SpEncounter,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Encounter), Err),
  ) -> msg,
) -> effect.Effect(msg)

encounter_search_bundled

</> 
pub fn encounter_search_bundled(
  search_for search_args: r5_sansio.SpEncounter,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

encounter_update

</> 
pub fn encounter_update(
  resource: r5.Encounter,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Encounter, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

encounterhistory_create

</> 
pub fn encounterhistory_create(
  resource: r5.Encounterhistory,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Encounterhistory, Err)) -> a,
) -> effect.Effect(a)

encounterhistory_delete

</> 
pub fn encounterhistory_delete(
  resource: r5.Encounterhistory,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

encounterhistory_read

</> 
pub fn encounterhistory_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Encounterhistory, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn encounterhistory_search(
  search_for search_args: r5_sansio.SpEncounterhistory,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Encounterhistory), Err),
  ) -> msg,
) -> effect.Effect(msg)

encounterhistory_search_bundled

</> 
pub fn encounterhistory_search_bundled(
  search_for search_args: r5_sansio.SpEncounterhistory,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

encounterhistory_update

</> 
pub fn encounterhistory_update(
  resource: r5.Encounterhistory,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Encounterhistory, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

endpoint_create

</> 
pub fn endpoint_create(
  resource: r5.Endpoint,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Endpoint, Err)) -> a,
) -> effect.Effect(a)

endpoint_delete

</> 
pub fn endpoint_delete(
  resource: r5.Endpoint,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

endpoint_read

</> 
pub fn endpoint_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Endpoint, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn endpoint_search(
  search_for search_args: r5_sansio.SpEndpoint,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(List(r5.Endpoint), Err)) -> msg,
) -> effect.Effect(msg)

endpoint_search_bundled

</> 
pub fn endpoint_search_bundled(
  search_for search_args: r5_sansio.SpEndpoint,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

endpoint_update

</> 
pub fn endpoint_update(
  resource: r5.Endpoint,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Endpoint, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

enrollmentrequest_create

</> 
pub fn enrollmentrequest_create(
  resource: r5.Enrollmentrequest,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Enrollmentrequest, Err)) -> a,
) -> effect.Effect(a)

enrollmentrequest_delete

</> 
pub fn enrollmentrequest_delete(
  resource: r5.Enrollmentrequest,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

enrollmentrequest_read

</> 
pub fn enrollmentrequest_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Enrollmentrequest, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn enrollmentrequest_search(
  search_for search_args: r5_sansio.SpEnrollmentrequest,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Enrollmentrequest), Err),
  ) -> msg,
) -> effect.Effect(msg)

enrollmentrequest_search_bundled

</> 
pub fn enrollmentrequest_search_bundled(
  search_for search_args: r5_sansio.SpEnrollmentrequest,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

enrollmentrequest_update

</> 
pub fn enrollmentrequest_update(
  resource: r5.Enrollmentrequest,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Enrollmentrequest, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

enrollmentresponse_create

</> 
pub fn enrollmentresponse_create(
  resource: r5.Enrollmentresponse,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Enrollmentresponse, Err)) -> a,
) -> effect.Effect(a)

enrollmentresponse_delete

</> 
pub fn enrollmentresponse_delete(
  resource: r5.Enrollmentresponse,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

enrollmentresponse_read

</> 
pub fn enrollmentresponse_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Enrollmentresponse, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn enrollmentresponse_search(
  search_for search_args: r5_sansio.SpEnrollmentresponse,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Enrollmentresponse), Err),
  ) -> msg,
) -> effect.Effect(msg)

enrollmentresponse_search_bundled

</> 
pub fn enrollmentresponse_search_bundled(
  search_for search_args: r5_sansio.SpEnrollmentresponse,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

enrollmentresponse_update

</> 
pub fn enrollmentresponse_update(
  resource: r5.Enrollmentresponse,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Enrollmentresponse, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

episodeofcare_create

</> 
pub fn episodeofcare_create(
  resource: r5.Episodeofcare,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Episodeofcare, Err)) -> a,
) -> effect.Effect(a)

episodeofcare_delete

</> 
pub fn episodeofcare_delete(
  resource: r5.Episodeofcare,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

episodeofcare_read

</> 
pub fn episodeofcare_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Episodeofcare, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn episodeofcare_search(
  search_for search_args: r5_sansio.SpEpisodeofcare,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Episodeofcare), Err),
  ) -> msg,
) -> effect.Effect(msg)

episodeofcare_search_bundled

</> 
pub fn episodeofcare_search_bundled(
  search_for search_args: r5_sansio.SpEpisodeofcare,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

episodeofcare_update

</> 
pub fn episodeofcare_update(
  resource: r5.Episodeofcare,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Episodeofcare, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

eventdefinition_create

</> 
pub fn eventdefinition_create(
  resource: r5.Eventdefinition,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Eventdefinition, Err)) -> a,
) -> effect.Effect(a)

eventdefinition_delete

</> 
pub fn eventdefinition_delete(
  resource: r5.Eventdefinition,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

eventdefinition_read

</> 
pub fn eventdefinition_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Eventdefinition, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn eventdefinition_search(
  search_for search_args: r5_sansio.SpEventdefinition,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Eventdefinition), Err),
  ) -> msg,
) -> effect.Effect(msg)

eventdefinition_search_bundled

</> 
pub fn eventdefinition_search_bundled(
  search_for search_args: r5_sansio.SpEventdefinition,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

eventdefinition_update

</> 
pub fn eventdefinition_update(
  resource: r5.Eventdefinition,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Eventdefinition, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

evidence_create

</> 
pub fn evidence_create(
  resource: r5.Evidence,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Evidence, Err)) -> a,
) -> effect.Effect(a)

evidence_delete

</> 
pub fn evidence_delete(
  resource: r5.Evidence,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

evidence_read

</> 
pub fn evidence_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Evidence, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn evidence_search(
  search_for search_args: r5_sansio.SpEvidence,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(List(r5.Evidence), Err)) -> msg,
) -> effect.Effect(msg)

evidence_search_bundled

</> 
pub fn evidence_search_bundled(
  search_for search_args: r5_sansio.SpEvidence,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

evidence_update

</> 
pub fn evidence_update(
  resource: r5.Evidence,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Evidence, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

evidencereport_create

</> 
pub fn evidencereport_create(
  resource: r5.Evidencereport,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Evidencereport, Err)) -> a,
) -> effect.Effect(a)

evidencereport_delete

</> 
pub fn evidencereport_delete(
  resource: r5.Evidencereport,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

evidencereport_read

</> 
pub fn evidencereport_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Evidencereport, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn evidencereport_search(
  search_for search_args: r5_sansio.SpEvidencereport,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Evidencereport), Err),
  ) -> msg,
) -> effect.Effect(msg)

evidencereport_search_bundled

</> 
pub fn evidencereport_search_bundled(
  search_for search_args: r5_sansio.SpEvidencereport,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

evidencereport_update

</> 
pub fn evidencereport_update(
  resource: r5.Evidencereport,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Evidencereport, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

evidencevariable_create

</> 
pub fn evidencevariable_create(
  resource: r5.Evidencevariable,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Evidencevariable, Err)) -> a,
) -> effect.Effect(a)

evidencevariable_delete

</> 
pub fn evidencevariable_delete(
  resource: r5.Evidencevariable,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

evidencevariable_read

</> 
pub fn evidencevariable_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Evidencevariable, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn evidencevariable_search(
  search_for search_args: r5_sansio.SpEvidencevariable,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Evidencevariable), Err),
  ) -> msg,
) -> effect.Effect(msg)

evidencevariable_search_bundled

</> 
pub fn evidencevariable_search_bundled(
  search_for search_args: r5_sansio.SpEvidencevariable,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

evidencevariable_update

</> 
pub fn evidencevariable_update(
  resource: r5.Evidencevariable,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Evidencevariable, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

examplescenario_create

</> 
pub fn examplescenario_create(
  resource: r5.Examplescenario,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Examplescenario, Err)) -> a,
) -> effect.Effect(a)

examplescenario_delete

</> 
pub fn examplescenario_delete(
  resource: r5.Examplescenario,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

examplescenario_read

</> 
pub fn examplescenario_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Examplescenario, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn examplescenario_search(
  search_for search_args: r5_sansio.SpExamplescenario,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Examplescenario), Err),
  ) -> msg,
) -> effect.Effect(msg)

examplescenario_search_bundled

</> 
pub fn examplescenario_search_bundled(
  search_for search_args: r5_sansio.SpExamplescenario,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

examplescenario_update

</> 
pub fn examplescenario_update(
  resource: r5.Examplescenario,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Examplescenario, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

explanationofbenefit_create

</> 
pub fn explanationofbenefit_create(
  resource: r5.Explanationofbenefit,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Explanationofbenefit, Err)) -> a,
) -> effect.Effect(a)

explanationofbenefit_delete

</> 
pub fn explanationofbenefit_delete(
  resource: r5.Explanationofbenefit,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

explanationofbenefit_read

</> 
pub fn explanationofbenefit_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Explanationofbenefit, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn explanationofbenefit_search(
  search_for search_args: r5_sansio.SpExplanationofbenefit,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Explanationofbenefit), Err),
  ) -> msg,
) -> effect.Effect(msg)

explanationofbenefit_search_bundled

</> 
pub fn explanationofbenefit_search_bundled(
  search_for search_args: r5_sansio.SpExplanationofbenefit,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

explanationofbenefit_update

</> 
pub fn explanationofbenefit_update(
  resource: r5.Explanationofbenefit,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Explanationofbenefit, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

familymemberhistory_create

</> 
pub fn familymemberhistory_create(
  resource: r5.Familymemberhistory,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Familymemberhistory, Err)) -> a,
) -> effect.Effect(a)

familymemberhistory_delete

</> 
pub fn familymemberhistory_delete(
  resource: r5.Familymemberhistory,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

familymemberhistory_read

</> 
pub fn familymemberhistory_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Familymemberhistory, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn familymemberhistory_search(
  search_for search_args: r5_sansio.SpFamilymemberhistory,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Familymemberhistory), Err),
  ) -> msg,
) -> effect.Effect(msg)

familymemberhistory_search_bundled

</> 
pub fn familymemberhistory_search_bundled(
  search_for search_args: r5_sansio.SpFamilymemberhistory,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

familymemberhistory_update

</> 
pub fn familymemberhistory_update(
  resource: r5.Familymemberhistory,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Familymemberhistory, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

fhirclient_new

</> 
pub fn fhirclient_new(baseurl: String) -> r5_sansio.FhirClient

flag_create

</> 
pub fn flag_create(
  resource: r5.Flag,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Flag, Err)) -> a,
) -> effect.Effect(a)

flag_delete

</> 
pub fn flag_delete(
  resource: r5.Flag,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

flag_read

</> 
pub fn flag_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Flag, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn flag_search(
  search_for search_args: r5_sansio.SpFlag,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(List(r5.Flag), Err)) -> msg,
) -> effect.Effect(msg)

flag_search_bundled

</> 
pub fn flag_search_bundled(
  search_for search_args: r5_sansio.SpFlag,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

flag_update

</> 
pub fn flag_update(
  resource: r5.Flag,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Flag, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

formularyitem_create

</> 
pub fn formularyitem_create(
  resource: r5.Formularyitem,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Formularyitem, Err)) -> a,
) -> effect.Effect(a)

formularyitem_delete

</> 
pub fn formularyitem_delete(
  resource: r5.Formularyitem,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

formularyitem_read

</> 
pub fn formularyitem_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Formularyitem, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn formularyitem_search(
  search_for search_args: r5_sansio.SpFormularyitem,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Formularyitem), Err),
  ) -> msg,
) -> effect.Effect(msg)

formularyitem_search_bundled

</> 
pub fn formularyitem_search_bundled(
  search_for search_args: r5_sansio.SpFormularyitem,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

formularyitem_update

</> 
pub fn formularyitem_update(
  resource: r5.Formularyitem,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Formularyitem, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

genomicstudy_create

</> 
pub fn genomicstudy_create(
  resource: r5.Genomicstudy,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Genomicstudy, Err)) -> a,
) -> effect.Effect(a)

genomicstudy_delete

</> 
pub fn genomicstudy_delete(
  resource: r5.Genomicstudy,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

genomicstudy_read

</> 
pub fn genomicstudy_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Genomicstudy, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn genomicstudy_search(
  search_for search_args: r5_sansio.SpGenomicstudy,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Genomicstudy), Err),
  ) -> msg,
) -> effect.Effect(msg)

genomicstudy_search_bundled

</> 
pub fn genomicstudy_search_bundled(
  search_for search_args: r5_sansio.SpGenomicstudy,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

genomicstudy_update

</> 
pub fn genomicstudy_update(
  resource: r5.Genomicstudy,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Genomicstudy, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

goal_create

</> 
pub fn goal_create(
  resource: r5.Goal,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Goal, Err)) -> a,
) -> effect.Effect(a)

goal_delete

</> 
pub fn goal_delete(
  resource: r5.Goal,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

goal_read

</> 
pub fn goal_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Goal, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn goal_search(
  search_for search_args: r5_sansio.SpGoal,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(List(r5.Goal), Err)) -> msg,
) -> effect.Effect(msg)

goal_search_bundled

</> 
pub fn goal_search_bundled(
  search_for search_args: r5_sansio.SpGoal,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

goal_update

</> 
pub fn goal_update(
  resource: r5.Goal,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Goal, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

graphdefinition_create

</> 
pub fn graphdefinition_create(
  resource: r5.Graphdefinition,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Graphdefinition, Err)) -> a,
) -> effect.Effect(a)

graphdefinition_delete

</> 
pub fn graphdefinition_delete(
  resource: r5.Graphdefinition,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

graphdefinition_read

</> 
pub fn graphdefinition_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Graphdefinition, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn graphdefinition_search(
  search_for search_args: r5_sansio.SpGraphdefinition,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Graphdefinition), Err),
  ) -> msg,
) -> effect.Effect(msg)

graphdefinition_search_bundled

</> 
pub fn graphdefinition_search_bundled(
  search_for search_args: r5_sansio.SpGraphdefinition,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

graphdefinition_update

</> 
pub fn graphdefinition_update(
  resource: r5.Graphdefinition,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Graphdefinition, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

group_create

</> 
pub fn group_create(
  resource: r5.Group,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Group, Err)) -> a,
) -> effect.Effect(a)

group_delete

</> 
pub fn group_delete(
  resource: r5.Group,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

group_read

</> 
pub fn group_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Group, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn group_search(
  search_for search_args: r5_sansio.SpGroup,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(List(r5.Group), Err)) -> msg,
) -> effect.Effect(msg)

group_search_bundled

</> 
pub fn group_search_bundled(
  search_for search_args: r5_sansio.SpGroup,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

group_update

</> 
pub fn group_update(
  resource: r5.Group,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Group, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

guidanceresponse_create

</> 
pub fn guidanceresponse_create(
  resource: r5.Guidanceresponse,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Guidanceresponse, Err)) -> a,
) -> effect.Effect(a)

guidanceresponse_delete

</> 
pub fn guidanceresponse_delete(
  resource: r5.Guidanceresponse,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

guidanceresponse_read

</> 
pub fn guidanceresponse_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Guidanceresponse, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn guidanceresponse_search(
  search_for search_args: r5_sansio.SpGuidanceresponse,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Guidanceresponse), Err),
  ) -> msg,
) -> effect.Effect(msg)

guidanceresponse_search_bundled

</> 
pub fn guidanceresponse_search_bundled(
  search_for search_args: r5_sansio.SpGuidanceresponse,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

guidanceresponse_update

</> 
pub fn guidanceresponse_update(
  resource: r5.Guidanceresponse,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Guidanceresponse, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

healthcareservice_create

</> 
pub fn healthcareservice_create(
  resource: r5.Healthcareservice,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Healthcareservice, Err)) -> a,
) -> effect.Effect(a)

healthcareservice_delete

</> 
pub fn healthcareservice_delete(
  resource: r5.Healthcareservice,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

healthcareservice_read

</> 
pub fn healthcareservice_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Healthcareservice, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn healthcareservice_search(
  search_for search_args: r5_sansio.SpHealthcareservice,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Healthcareservice), Err),
  ) -> msg,
) -> effect.Effect(msg)

healthcareservice_search_bundled

</> 
pub fn healthcareservice_search_bundled(
  search_for search_args: r5_sansio.SpHealthcareservice,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

healthcareservice_update

</> 
pub fn healthcareservice_update(
  resource: r5.Healthcareservice,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Healthcareservice, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

imagingselection_create

</> 
pub fn imagingselection_create(
  resource: r5.Imagingselection,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Imagingselection, Err)) -> a,
) -> effect.Effect(a)

imagingselection_delete

</> 
pub fn imagingselection_delete(
  resource: r5.Imagingselection,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

imagingselection_read

</> 
pub fn imagingselection_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Imagingselection, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn imagingselection_search(
  search_for search_args: r5_sansio.SpImagingselection,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Imagingselection), Err),
  ) -> msg,
) -> effect.Effect(msg)

imagingselection_search_bundled

</> 
pub fn imagingselection_search_bundled(
  search_for search_args: r5_sansio.SpImagingselection,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

imagingselection_update

</> 
pub fn imagingselection_update(
  resource: r5.Imagingselection,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Imagingselection, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

imagingstudy_create

</> 
pub fn imagingstudy_create(
  resource: r5.Imagingstudy,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Imagingstudy, Err)) -> a,
) -> effect.Effect(a)

imagingstudy_delete

</> 
pub fn imagingstudy_delete(
  resource: r5.Imagingstudy,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

imagingstudy_read

</> 
pub fn imagingstudy_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Imagingstudy, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn imagingstudy_search(
  search_for search_args: r5_sansio.SpImagingstudy,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Imagingstudy), Err),
  ) -> msg,
) -> effect.Effect(msg)

imagingstudy_search_bundled

</> 
pub fn imagingstudy_search_bundled(
  search_for search_args: r5_sansio.SpImagingstudy,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

imagingstudy_update

</> 
pub fn imagingstudy_update(
  resource: r5.Imagingstudy,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Imagingstudy, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

immunization_create

</> 
pub fn immunization_create(
  resource: r5.Immunization,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Immunization, Err)) -> a,
) -> effect.Effect(a)

immunization_delete

</> 
pub fn immunization_delete(
  resource: r5.Immunization,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

immunization_read

</> 
pub fn immunization_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Immunization, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn immunization_search(
  search_for search_args: r5_sansio.SpImmunization,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Immunization), Err),
  ) -> msg,
) -> effect.Effect(msg)

immunization_search_bundled

</> 
pub fn immunization_search_bundled(
  search_for search_args: r5_sansio.SpImmunization,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

immunization_update

</> 
pub fn immunization_update(
  resource: r5.Immunization,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Immunization, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

immunizationevaluation_create

</> 
pub fn immunizationevaluation_create(
  resource: r5.Immunizationevaluation,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Immunizationevaluation, Err)) -> a,
) -> effect.Effect(a)

immunizationevaluation_delete

</> 
pub fn immunizationevaluation_delete(
  resource: r5.Immunizationevaluation,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

immunizationevaluation_read

</> 
pub fn immunizationevaluation_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Immunizationevaluation, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn immunizationevaluation_search(
  search_for search_args: r5_sansio.SpImmunizationevaluation,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Immunizationevaluation), Err),
  ) -> msg,
) -> effect.Effect(msg)

immunizationevaluation_search_bundled

</> 
pub fn immunizationevaluation_search_bundled(
  search_for search_args: r5_sansio.SpImmunizationevaluation,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

immunizationevaluation_update

</> 
pub fn immunizationevaluation_update(
  resource: r5.Immunizationevaluation,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Immunizationevaluation, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

immunizationrecommendation_create

</> 
pub fn immunizationrecommendation_create(
  resource: r5.Immunizationrecommendation,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Immunizationrecommendation, Err)) -> a,
) -> effect.Effect(a)

immunizationrecommendation_delete

</> 
pub fn immunizationrecommendation_delete(
  resource: r5.Immunizationrecommendation,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

immunizationrecommendation_read

</> 
pub fn immunizationrecommendation_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Immunizationrecommendation, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn immunizationrecommendation_search(
  search_for search_args: r5_sansio.SpImmunizationrecommendation,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Immunizationrecommendation), Err),
  ) -> msg,
) -> effect.Effect(msg)

immunizationrecommendation_search_bundled

</> 
pub fn immunizationrecommendation_search_bundled(
  search_for search_args: r5_sansio.SpImmunizationrecommendation,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

immunizationrecommendation_update

</> 
pub fn immunizationrecommendation_update(
  resource: r5.Immunizationrecommendation,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Immunizationrecommendation, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

implementationguide_create

</> 
pub fn implementationguide_create(
  resource: r5.Implementationguide,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Implementationguide, Err)) -> a,
) -> effect.Effect(a)

implementationguide_delete

</> 
pub fn implementationguide_delete(
  resource: r5.Implementationguide,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

implementationguide_read

</> 
pub fn implementationguide_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Implementationguide, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn implementationguide_search(
  search_for search_args: r5_sansio.SpImplementationguide,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Implementationguide), Err),
  ) -> msg,
) -> effect.Effect(msg)

implementationguide_search_bundled

</> 
pub fn implementationguide_search_bundled(
  search_for search_args: r5_sansio.SpImplementationguide,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

implementationguide_update

</> 
pub fn implementationguide_update(
  resource: r5.Implementationguide,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Implementationguide, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

ingredient_create

</> 
pub fn ingredient_create(
  resource: r5.Ingredient,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Ingredient, Err)) -> a,
) -> effect.Effect(a)

ingredient_delete

</> 
pub fn ingredient_delete(
  resource: r5.Ingredient,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

ingredient_read

</> 
pub fn ingredient_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Ingredient, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn ingredient_search(
  search_for search_args: r5_sansio.SpIngredient,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Ingredient), Err),
  ) -> msg,
) -> effect.Effect(msg)

ingredient_search_bundled

</> 
pub fn ingredient_search_bundled(
  search_for search_args: r5_sansio.SpIngredient,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

ingredient_update

</> 
pub fn ingredient_update(
  resource: r5.Ingredient,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Ingredient, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

insuranceplan_create

</> 
pub fn insuranceplan_create(
  resource: r5.Insuranceplan,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Insuranceplan, Err)) -> a,
) -> effect.Effect(a)

insuranceplan_delete

</> 
pub fn insuranceplan_delete(
  resource: r5.Insuranceplan,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

insuranceplan_read

</> 
pub fn insuranceplan_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Insuranceplan, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn insuranceplan_search(
  search_for search_args: r5_sansio.SpInsuranceplan,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Insuranceplan), Err),
  ) -> msg,
) -> effect.Effect(msg)

insuranceplan_search_bundled

</> 
pub fn insuranceplan_search_bundled(
  search_for search_args: r5_sansio.SpInsuranceplan,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

insuranceplan_update

</> 
pub fn insuranceplan_update(
  resource: r5.Insuranceplan,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Insuranceplan, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

inventoryitem_create

</> 
pub fn inventoryitem_create(
  resource: r5.Inventoryitem,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Inventoryitem, Err)) -> a,
) -> effect.Effect(a)

inventoryitem_delete

</> 
pub fn inventoryitem_delete(
  resource: r5.Inventoryitem,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

inventoryitem_read

</> 
pub fn inventoryitem_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Inventoryitem, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn inventoryitem_search(
  search_for search_args: r5_sansio.SpInventoryitem,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Inventoryitem), Err),
  ) -> msg,
) -> effect.Effect(msg)

inventoryitem_search_bundled

</> 
pub fn inventoryitem_search_bundled(
  search_for search_args: r5_sansio.SpInventoryitem,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

inventoryitem_update

</> 
pub fn inventoryitem_update(
  resource: r5.Inventoryitem,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Inventoryitem, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

inventoryreport_create

</> 
pub fn inventoryreport_create(
  resource: r5.Inventoryreport,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Inventoryreport, Err)) -> a,
) -> effect.Effect(a)

inventoryreport_delete

</> 
pub fn inventoryreport_delete(
  resource: r5.Inventoryreport,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

inventoryreport_read

</> 
pub fn inventoryreport_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Inventoryreport, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn inventoryreport_search(
  search_for search_args: r5_sansio.SpInventoryreport,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Inventoryreport), Err),
  ) -> msg,
) -> effect.Effect(msg)

inventoryreport_search_bundled

</> 
pub fn inventoryreport_search_bundled(
  search_for search_args: r5_sansio.SpInventoryreport,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

inventoryreport_update

</> 
pub fn inventoryreport_update(
  resource: r5.Inventoryreport,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Inventoryreport, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

invoice_create

</> 
pub fn invoice_create(
  resource: r5.Invoice,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Invoice, Err)) -> a,
) -> effect.Effect(a)

invoice_delete

</> 
pub fn invoice_delete(
  resource: r5.Invoice,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

invoice_read

</> 
pub fn invoice_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Invoice, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn invoice_search(
  search_for search_args: r5_sansio.SpInvoice,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(List(r5.Invoice), Err)) -> msg,
) -> effect.Effect(msg)

invoice_search_bundled

</> 
pub fn invoice_search_bundled(
  search_for search_args: r5_sansio.SpInvoice,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

invoice_update

</> 
pub fn invoice_update(
  resource: r5.Invoice,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Invoice, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

library_create

</> 
pub fn library_create(
  resource: r5.Library,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Library, Err)) -> a,
) -> effect.Effect(a)

library_delete

</> 
pub fn library_delete(
  resource: r5.Library,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

library_read

</> 
pub fn library_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Library, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn library_search(
  search_for search_args: r5_sansio.SpLibrary,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(List(r5.Library), Err)) -> msg,
) -> effect.Effect(msg)

library_search_bundled

</> 
pub fn library_search_bundled(
  search_for search_args: r5_sansio.SpLibrary,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

library_update

</> 
pub fn library_update(
  resource: r5.Library,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Library, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

linkage_create

</> 
pub fn linkage_create(
  resource: r5.Linkage,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Linkage, Err)) -> a,
) -> effect.Effect(a)

linkage_delete

</> 
pub fn linkage_delete(
  resource: r5.Linkage,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

linkage_read

</> 
pub fn linkage_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Linkage, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn linkage_search(
  search_for search_args: r5_sansio.SpLinkage,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(List(r5.Linkage), Err)) -> msg,
) -> effect.Effect(msg)

linkage_search_bundled

</> 
pub fn linkage_search_bundled(
  search_for search_args: r5_sansio.SpLinkage,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

linkage_update

</> 
pub fn linkage_update(
  resource: r5.Linkage,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Linkage, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

listfhir_create

</> 
pub fn listfhir_create(
  resource: r5.Listfhir,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Listfhir, Err)) -> a,
) -> effect.Effect(a)

listfhir_delete

</> 
pub fn listfhir_delete(
  resource: r5.Listfhir,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

listfhir_read

</> 
pub fn listfhir_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Listfhir, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn listfhir_search(
  search_for search_args: r5_sansio.SpListfhir,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(List(r5.Listfhir), Err)) -> msg,
) -> effect.Effect(msg)

listfhir_search_bundled

</> 
pub fn listfhir_search_bundled(
  search_for search_args: r5_sansio.SpListfhir,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

listfhir_update

</> 
pub fn listfhir_update(
  resource: r5.Listfhir,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Listfhir, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

location_create

</> 
pub fn location_create(
  resource: r5.Location,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Location, Err)) -> a,
) -> effect.Effect(a)

location_delete

</> 
pub fn location_delete(
  resource: r5.Location,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

location_read

</> 
pub fn location_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Location, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn location_search(
  search_for search_args: r5_sansio.SpLocation,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(List(r5.Location), Err)) -> msg,
) -> effect.Effect(msg)

location_search_bundled

</> 
pub fn location_search_bundled(
  search_for search_args: r5_sansio.SpLocation,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

location_update

</> 
pub fn location_update(
  resource: r5.Location,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Location, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

manufactureditemdefinition_create

</> 
pub fn manufactureditemdefinition_create(
  resource: r5.Manufactureditemdefinition,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Manufactureditemdefinition, Err)) -> a,
) -> effect.Effect(a)

manufactureditemdefinition_delete

</> 
pub fn manufactureditemdefinition_delete(
  resource: r5.Manufactureditemdefinition,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

manufactureditemdefinition_read

</> 
pub fn manufactureditemdefinition_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Manufactureditemdefinition, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn manufactureditemdefinition_search(
  search_for search_args: r5_sansio.SpManufactureditemdefinition,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Manufactureditemdefinition), Err),
  ) -> msg,
) -> effect.Effect(msg)

manufactureditemdefinition_search_bundled

</> 
pub fn manufactureditemdefinition_search_bundled(
  search_for search_args: r5_sansio.SpManufactureditemdefinition,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

manufactureditemdefinition_update

</> 
pub fn manufactureditemdefinition_update(
  resource: r5.Manufactureditemdefinition,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Manufactureditemdefinition, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

measure_create

</> 
pub fn measure_create(
  resource: r5.Measure,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Measure, Err)) -> a,
) -> effect.Effect(a)

measure_delete

</> 
pub fn measure_delete(
  resource: r5.Measure,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

measure_read

</> 
pub fn measure_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Measure, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn measure_search(
  search_for search_args: r5_sansio.SpMeasure,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(List(r5.Measure), Err)) -> msg,
) -> effect.Effect(msg)

measure_search_bundled

</> 
pub fn measure_search_bundled(
  search_for search_args: r5_sansio.SpMeasure,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

measure_update

</> 
pub fn measure_update(
  resource: r5.Measure,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Measure, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

measurereport_create

</> 
pub fn measurereport_create(
  resource: r5.Measurereport,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Measurereport, Err)) -> a,
) -> effect.Effect(a)

measurereport_delete

</> 
pub fn measurereport_delete(
  resource: r5.Measurereport,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

measurereport_read

</> 
pub fn measurereport_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Measurereport, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn measurereport_search(
  search_for search_args: r5_sansio.SpMeasurereport,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Measurereport), Err),
  ) -> msg,
) -> effect.Effect(msg)

measurereport_search_bundled

</> 
pub fn measurereport_search_bundled(
  search_for search_args: r5_sansio.SpMeasurereport,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

measurereport_update

</> 
pub fn measurereport_update(
  resource: r5.Measurereport,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Measurereport, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

medication_create

</> 
pub fn medication_create(
  resource: r5.Medication,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Medication, Err)) -> a,
) -> effect.Effect(a)

medication_delete

</> 
pub fn medication_delete(
  resource: r5.Medication,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

medication_read

</> 
pub fn medication_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Medication, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn medication_search(
  search_for search_args: r5_sansio.SpMedication,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Medication), Err),
  ) -> msg,
) -> effect.Effect(msg)

medication_search_bundled

</> 
pub fn medication_search_bundled(
  search_for search_args: r5_sansio.SpMedication,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

medication_update

</> 
pub fn medication_update(
  resource: r5.Medication,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Medication, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

medicationadministration_create

</> 
pub fn medicationadministration_create(
  resource: r5.Medicationadministration,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Medicationadministration, Err)) -> a,
) -> effect.Effect(a)

medicationadministration_delete

</> 
pub fn medicationadministration_delete(
  resource: r5.Medicationadministration,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

medicationadministration_read

</> 
pub fn medicationadministration_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Medicationadministration, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn medicationadministration_search(
  search_for search_args: r5_sansio.SpMedicationadministration,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Medicationadministration), Err),
  ) -> msg,
) -> effect.Effect(msg)

medicationadministration_search_bundled

</> 
pub fn medicationadministration_search_bundled(
  search_for search_args: r5_sansio.SpMedicationadministration,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

medicationadministration_update

</> 
pub fn medicationadministration_update(
  resource: r5.Medicationadministration,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Medicationadministration, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

medicationdispense_create

</> 
pub fn medicationdispense_create(
  resource: r5.Medicationdispense,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Medicationdispense, Err)) -> a,
) -> effect.Effect(a)

medicationdispense_delete

</> 
pub fn medicationdispense_delete(
  resource: r5.Medicationdispense,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

medicationdispense_read

</> 
pub fn medicationdispense_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Medicationdispense, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn medicationdispense_search(
  search_for search_args: r5_sansio.SpMedicationdispense,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Medicationdispense), Err),
  ) -> msg,
) -> effect.Effect(msg)

medicationdispense_search_bundled

</> 
pub fn medicationdispense_search_bundled(
  search_for search_args: r5_sansio.SpMedicationdispense,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

medicationdispense_update

</> 
pub fn medicationdispense_update(
  resource: r5.Medicationdispense,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Medicationdispense, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

medicationknowledge_create

</> 
pub fn medicationknowledge_create(
  resource: r5.Medicationknowledge,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Medicationknowledge, Err)) -> a,
) -> effect.Effect(a)

medicationknowledge_delete

</> 
pub fn medicationknowledge_delete(
  resource: r5.Medicationknowledge,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

medicationknowledge_read

</> 
pub fn medicationknowledge_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Medicationknowledge, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn medicationknowledge_search(
  search_for search_args: r5_sansio.SpMedicationknowledge,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Medicationknowledge), Err),
  ) -> msg,
) -> effect.Effect(msg)

medicationknowledge_search_bundled

</> 
pub fn medicationknowledge_search_bundled(
  search_for search_args: r5_sansio.SpMedicationknowledge,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

medicationknowledge_update

</> 
pub fn medicationknowledge_update(
  resource: r5.Medicationknowledge,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Medicationknowledge, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

medicationrequest_create

</> 
pub fn medicationrequest_create(
  resource: r5.Medicationrequest,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Medicationrequest, Err)) -> a,
) -> effect.Effect(a)

medicationrequest_delete

</> 
pub fn medicationrequest_delete(
  resource: r5.Medicationrequest,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

medicationrequest_read

</> 
pub fn medicationrequest_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Medicationrequest, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn medicationrequest_search(
  search_for search_args: r5_sansio.SpMedicationrequest,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Medicationrequest), Err),
  ) -> msg,
) -> effect.Effect(msg)

medicationrequest_search_bundled

</> 
pub fn medicationrequest_search_bundled(
  search_for search_args: r5_sansio.SpMedicationrequest,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

medicationrequest_update

</> 
pub fn medicationrequest_update(
  resource: r5.Medicationrequest,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Medicationrequest, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

medicationstatement_create

</> 
pub fn medicationstatement_create(
  resource: r5.Medicationstatement,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Medicationstatement, Err)) -> a,
) -> effect.Effect(a)

medicationstatement_delete

</> 
pub fn medicationstatement_delete(
  resource: r5.Medicationstatement,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

medicationstatement_read

</> 
pub fn medicationstatement_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Medicationstatement, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn medicationstatement_search(
  search_for search_args: r5_sansio.SpMedicationstatement,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Medicationstatement), Err),
  ) -> msg,
) -> effect.Effect(msg)

medicationstatement_search_bundled

</> 
pub fn medicationstatement_search_bundled(
  search_for search_args: r5_sansio.SpMedicationstatement,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

medicationstatement_update

</> 
pub fn medicationstatement_update(
  resource: r5.Medicationstatement,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Medicationstatement, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

medicinalproductdefinition_create

</> 
pub fn medicinalproductdefinition_create(
  resource: r5.Medicinalproductdefinition,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Medicinalproductdefinition, Err)) -> a,
) -> effect.Effect(a)

medicinalproductdefinition_delete

</> 
pub fn medicinalproductdefinition_delete(
  resource: r5.Medicinalproductdefinition,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

medicinalproductdefinition_read

</> 
pub fn medicinalproductdefinition_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Medicinalproductdefinition, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn medicinalproductdefinition_search(
  search_for search_args: r5_sansio.SpMedicinalproductdefinition,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Medicinalproductdefinition), Err),
  ) -> msg,
) -> effect.Effect(msg)

medicinalproductdefinition_search_bundled

</> 
pub fn medicinalproductdefinition_search_bundled(
  search_for search_args: r5_sansio.SpMedicinalproductdefinition,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

medicinalproductdefinition_update

</> 
pub fn medicinalproductdefinition_update(
  resource: r5.Medicinalproductdefinition,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Medicinalproductdefinition, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

messagedefinition_create

</> 
pub fn messagedefinition_create(
  resource: r5.Messagedefinition,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Messagedefinition, Err)) -> a,
) -> effect.Effect(a)

messagedefinition_delete

</> 
pub fn messagedefinition_delete(
  resource: r5.Messagedefinition,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

messagedefinition_read

</> 
pub fn messagedefinition_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Messagedefinition, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn messagedefinition_search(
  search_for search_args: r5_sansio.SpMessagedefinition,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Messagedefinition), Err),
  ) -> msg,
) -> effect.Effect(msg)

messagedefinition_search_bundled

</> 
pub fn messagedefinition_search_bundled(
  search_for search_args: r5_sansio.SpMessagedefinition,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

messagedefinition_update

</> 
pub fn messagedefinition_update(
  resource: r5.Messagedefinition,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Messagedefinition, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

messageheader_create

</> 
pub fn messageheader_create(
  resource: r5.Messageheader,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Messageheader, Err)) -> a,
) -> effect.Effect(a)

messageheader_delete

</> 
pub fn messageheader_delete(
  resource: r5.Messageheader,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

messageheader_read

</> 
pub fn messageheader_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Messageheader, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn messageheader_search(
  search_for search_args: r5_sansio.SpMessageheader,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Messageheader), Err),
  ) -> msg,
) -> effect.Effect(msg)

messageheader_search_bundled

</> 
pub fn messageheader_search_bundled(
  search_for search_args: r5_sansio.SpMessageheader,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

messageheader_update

</> 
pub fn messageheader_update(
  resource: r5.Messageheader,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Messageheader, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

molecularsequence_create

</> 
pub fn molecularsequence_create(
  resource: r5.Molecularsequence,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Molecularsequence, Err)) -> a,
) -> effect.Effect(a)

molecularsequence_delete

</> 
pub fn molecularsequence_delete(
  resource: r5.Molecularsequence,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

molecularsequence_read

</> 
pub fn molecularsequence_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Molecularsequence, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn molecularsequence_search(
  search_for search_args: r5_sansio.SpMolecularsequence,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Molecularsequence), Err),
  ) -> msg,
) -> effect.Effect(msg)

molecularsequence_search_bundled

</> 
pub fn molecularsequence_search_bundled(
  search_for search_args: r5_sansio.SpMolecularsequence,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

molecularsequence_update

</> 
pub fn molecularsequence_update(
  resource: r5.Molecularsequence,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Molecularsequence, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

namingsystem_create

</> 
pub fn namingsystem_create(
  resource: r5.Namingsystem,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Namingsystem, Err)) -> a,
) -> effect.Effect(a)

namingsystem_delete

</> 
pub fn namingsystem_delete(
  resource: r5.Namingsystem,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

namingsystem_read

</> 
pub fn namingsystem_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Namingsystem, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn namingsystem_search(
  search_for search_args: r5_sansio.SpNamingsystem,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Namingsystem), Err),
  ) -> msg,
) -> effect.Effect(msg)

namingsystem_search_bundled

</> 
pub fn namingsystem_search_bundled(
  search_for search_args: r5_sansio.SpNamingsystem,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

namingsystem_update

</> 
pub fn namingsystem_update(
  resource: r5.Namingsystem,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Namingsystem, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

nutritionintake_create

</> 
pub fn nutritionintake_create(
  resource: r5.Nutritionintake,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Nutritionintake, Err)) -> a,
) -> effect.Effect(a)

nutritionintake_delete

</> 
pub fn nutritionintake_delete(
  resource: r5.Nutritionintake,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

nutritionintake_read

</> 
pub fn nutritionintake_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Nutritionintake, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn nutritionintake_search(
  search_for search_args: r5_sansio.SpNutritionintake,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Nutritionintake), Err),
  ) -> msg,
) -> effect.Effect(msg)

nutritionintake_search_bundled

</> 
pub fn nutritionintake_search_bundled(
  search_for search_args: r5_sansio.SpNutritionintake,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

nutritionintake_update

</> 
pub fn nutritionintake_update(
  resource: r5.Nutritionintake,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Nutritionintake, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

nutritionorder_create

</> 
pub fn nutritionorder_create(
  resource: r5.Nutritionorder,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Nutritionorder, Err)) -> a,
) -> effect.Effect(a)

nutritionorder_delete

</> 
pub fn nutritionorder_delete(
  resource: r5.Nutritionorder,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

nutritionorder_read

</> 
pub fn nutritionorder_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Nutritionorder, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn nutritionorder_search(
  search_for search_args: r5_sansio.SpNutritionorder,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Nutritionorder), Err),
  ) -> msg,
) -> effect.Effect(msg)

nutritionorder_search_bundled

</> 
pub fn nutritionorder_search_bundled(
  search_for search_args: r5_sansio.SpNutritionorder,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

nutritionorder_update

</> 
pub fn nutritionorder_update(
  resource: r5.Nutritionorder,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Nutritionorder, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

nutritionproduct_create

</> 
pub fn nutritionproduct_create(
  resource: r5.Nutritionproduct,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Nutritionproduct, Err)) -> a,
) -> effect.Effect(a)

nutritionproduct_delete

</> 
pub fn nutritionproduct_delete(
  resource: r5.Nutritionproduct,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

nutritionproduct_read

</> 
pub fn nutritionproduct_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Nutritionproduct, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn nutritionproduct_search(
  search_for search_args: r5_sansio.SpNutritionproduct,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Nutritionproduct), Err),
  ) -> msg,
) -> effect.Effect(msg)

nutritionproduct_search_bundled

</> 
pub fn nutritionproduct_search_bundled(
  search_for search_args: r5_sansio.SpNutritionproduct,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

nutritionproduct_update

</> 
pub fn nutritionproduct_update(
  resource: r5.Nutritionproduct,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Nutritionproduct, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

observation_create

</> 
pub fn observation_create(
  resource: r5.Observation,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Observation, Err)) -> a,
) -> effect.Effect(a)

observation_delete

</> 
pub fn observation_delete(
  resource: r5.Observation,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

observation_read

</> 
pub fn observation_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Observation, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn observation_search(
  search_for search_args: r5_sansio.SpObservation,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Observation), Err),
  ) -> msg,
) -> effect.Effect(msg)

observation_search_bundled

</> 
pub fn observation_search_bundled(
  search_for search_args: r5_sansio.SpObservation,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

observation_update

</> 
pub fn observation_update(
  resource: r5.Observation,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Observation, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

observationdefinition_create

</> 
pub fn observationdefinition_create(
  resource: r5.Observationdefinition,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Observationdefinition, Err)) -> a,
) -> effect.Effect(a)

observationdefinition_delete

</> 
pub fn observationdefinition_delete(
  resource: r5.Observationdefinition,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

observationdefinition_read

</> 
pub fn observationdefinition_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Observationdefinition, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn observationdefinition_search(
  search_for search_args: r5_sansio.SpObservationdefinition,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Observationdefinition), Err),
  ) -> msg,
) -> effect.Effect(msg)

observationdefinition_search_bundled

</> 
pub fn observationdefinition_search_bundled(
  search_for search_args: r5_sansio.SpObservationdefinition,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

observationdefinition_update

</> 
pub fn observationdefinition_update(
  resource: r5.Observationdefinition,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Observationdefinition, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

operation_any

</> 
pub fn operation_any(
  params params: option.Option(r5.Parameters),
  operation_name operation_name: String,
  res_type res_type: String,
  res_id res_id: option.Option(String),
  res_decoder res_decoder: decode.Decoder(res),
  client client: r5_sansio.FhirClient,
  handle_response handle_response: fn(Result(res, Err)) -> msg,
) -> effect.Effect(msg)

operationdefinition_create

</> 
pub fn operationdefinition_create(
  resource: r5.Operationdefinition,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationdefinition, Err)) -> a,
) -> effect.Effect(a)

operationdefinition_delete

</> 
pub fn operationdefinition_delete(
  resource: r5.Operationdefinition,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

operationdefinition_read

</> 
pub fn operationdefinition_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationdefinition, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn operationdefinition_search(
  search_for search_args: r5_sansio.SpOperationdefinition,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Operationdefinition), Err),
  ) -> msg,
) -> effect.Effect(msg)

operationdefinition_search_bundled

</> 
pub fn operationdefinition_search_bundled(
  search_for search_args: r5_sansio.SpOperationdefinition,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

operationdefinition_update

</> 
pub fn operationdefinition_update(
  resource: r5.Operationdefinition,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationdefinition, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

operationoutcome_create

</> 
pub fn operationoutcome_create(
  resource: r5.Operationoutcome,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> effect.Effect(a)

operationoutcome_delete

</> 
pub fn operationoutcome_delete(
  resource: r5.Operationoutcome,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

operationoutcome_read

</> 
pub fn operationoutcome_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn operationoutcome_search(
  search_for search_args: r5_sansio.SpOperationoutcome,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Operationoutcome), Err),
  ) -> msg,
) -> effect.Effect(msg)

operationoutcome_search_bundled

</> 
pub fn operationoutcome_search_bundled(
  search_for search_args: r5_sansio.SpOperationoutcome,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

operationoutcome_update

</> 
pub fn operationoutcome_update(
  resource: r5.Operationoutcome,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

organization_create

</> 
pub fn organization_create(
  resource: r5.Organization,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Organization, Err)) -> a,
) -> effect.Effect(a)

organization_delete

</> 
pub fn organization_delete(
  resource: r5.Organization,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

organization_read

</> 
pub fn organization_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Organization, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn organization_search(
  search_for search_args: r5_sansio.SpOrganization,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Organization), Err),
  ) -> msg,
) -> effect.Effect(msg)

organization_search_bundled

</> 
pub fn organization_search_bundled(
  search_for search_args: r5_sansio.SpOrganization,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

organization_update

</> 
pub fn organization_update(
  resource: r5.Organization,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Organization, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

organizationaffiliation_create

</> 
pub fn organizationaffiliation_create(
  resource: r5.Organizationaffiliation,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Organizationaffiliation, Err)) -> a,
) -> effect.Effect(a)

organizationaffiliation_delete

</> 
pub fn organizationaffiliation_delete(
  resource: r5.Organizationaffiliation,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

organizationaffiliation_read

</> 
pub fn organizationaffiliation_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Organizationaffiliation, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn organizationaffiliation_search(
  search_for search_args: r5_sansio.SpOrganizationaffiliation,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Organizationaffiliation), Err),
  ) -> msg,
) -> effect.Effect(msg)

organizationaffiliation_search_bundled

</> 
pub fn organizationaffiliation_search_bundled(
  search_for search_args: r5_sansio.SpOrganizationaffiliation,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

organizationaffiliation_update

</> 
pub fn organizationaffiliation_update(
  resource: r5.Organizationaffiliation,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Organizationaffiliation, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

packagedproductdefinition_create

</> 
pub fn packagedproductdefinition_create(
  resource: r5.Packagedproductdefinition,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Packagedproductdefinition, Err)) -> a,
) -> effect.Effect(a)

packagedproductdefinition_delete

</> 
pub fn packagedproductdefinition_delete(
  resource: r5.Packagedproductdefinition,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

packagedproductdefinition_read

</> 
pub fn packagedproductdefinition_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Packagedproductdefinition, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn packagedproductdefinition_search(
  search_for search_args: r5_sansio.SpPackagedproductdefinition,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Packagedproductdefinition), Err),
  ) -> msg,
) -> effect.Effect(msg)

packagedproductdefinition_search_bundled

</> 
pub fn packagedproductdefinition_search_bundled(
  search_for search_args: r5_sansio.SpPackagedproductdefinition,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

packagedproductdefinition_update

</> 
pub fn packagedproductdefinition_update(
  resource: r5.Packagedproductdefinition,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Packagedproductdefinition, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

patient_create

</> 
pub fn patient_create(
  resource: r5.Patient,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Patient, Err)) -> a,
) -> effect.Effect(a)

patient_delete

</> 
pub fn patient_delete(
  resource: r5.Patient,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

patient_read

</> 
pub fn patient_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Patient, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn patient_search(
  search_for search_args: r5_sansio.SpPatient,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(List(r5.Patient), Err)) -> msg,
) -> effect.Effect(msg)

patient_search_bundled

</> 
pub fn patient_search_bundled(
  search_for search_args: r5_sansio.SpPatient,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

patient_update

</> 
pub fn patient_update(
  resource: r5.Patient,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Patient, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

paymentnotice_create

</> 
pub fn paymentnotice_create(
  resource: r5.Paymentnotice,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Paymentnotice, Err)) -> a,
) -> effect.Effect(a)

paymentnotice_delete

</> 
pub fn paymentnotice_delete(
  resource: r5.Paymentnotice,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

paymentnotice_read

</> 
pub fn paymentnotice_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Paymentnotice, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn paymentnotice_search(
  search_for search_args: r5_sansio.SpPaymentnotice,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Paymentnotice), Err),
  ) -> msg,
) -> effect.Effect(msg)

paymentnotice_search_bundled

</> 
pub fn paymentnotice_search_bundled(
  search_for search_args: r5_sansio.SpPaymentnotice,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

paymentnotice_update

</> 
pub fn paymentnotice_update(
  resource: r5.Paymentnotice,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Paymentnotice, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

paymentreconciliation_create

</> 
pub fn paymentreconciliation_create(
  resource: r5.Paymentreconciliation,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Paymentreconciliation, Err)) -> a,
) -> effect.Effect(a)

paymentreconciliation_delete

</> 
pub fn paymentreconciliation_delete(
  resource: r5.Paymentreconciliation,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

paymentreconciliation_read

</> 
pub fn paymentreconciliation_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Paymentreconciliation, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn paymentreconciliation_search(
  search_for search_args: r5_sansio.SpPaymentreconciliation,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Paymentreconciliation), Err),
  ) -> msg,
) -> effect.Effect(msg)

paymentreconciliation_search_bundled

</> 
pub fn paymentreconciliation_search_bundled(
  search_for search_args: r5_sansio.SpPaymentreconciliation,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

paymentreconciliation_update

</> 
pub fn paymentreconciliation_update(
  resource: r5.Paymentreconciliation,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Paymentreconciliation, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

permission_create

</> 
pub fn permission_create(
  resource: r5.Permission,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Permission, Err)) -> a,
) -> effect.Effect(a)

permission_delete

</> 
pub fn permission_delete(
  resource: r5.Permission,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

permission_read

</> 
pub fn permission_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Permission, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn permission_search(
  search_for search_args: r5_sansio.SpPermission,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Permission), Err),
  ) -> msg,
) -> effect.Effect(msg)

permission_search_bundled

</> 
pub fn permission_search_bundled(
  search_for search_args: r5_sansio.SpPermission,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

permission_update

</> 
pub fn permission_update(
  resource: r5.Permission,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Permission, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

person_create

</> 
pub fn person_create(
  resource: r5.Person,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Person, Err)) -> a,
) -> effect.Effect(a)

person_delete

</> 
pub fn person_delete(
  resource: r5.Person,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

person_read

</> 
pub fn person_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Person, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn person_search(
  search_for search_args: r5_sansio.SpPerson,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(List(r5.Person), Err)) -> msg,
) -> effect.Effect(msg)

person_search_bundled

</> 
pub fn person_search_bundled(
  search_for search_args: r5_sansio.SpPerson,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

person_update

</> 
pub fn person_update(
  resource: r5.Person,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Person, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

plandefinition_create

</> 
pub fn plandefinition_create(
  resource: r5.Plandefinition,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Plandefinition, Err)) -> a,
) -> effect.Effect(a)

plandefinition_delete

</> 
pub fn plandefinition_delete(
  resource: r5.Plandefinition,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

plandefinition_read

</> 
pub fn plandefinition_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Plandefinition, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn plandefinition_search(
  search_for search_args: r5_sansio.SpPlandefinition,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Plandefinition), Err),
  ) -> msg,
) -> effect.Effect(msg)

plandefinition_search_bundled

</> 
pub fn plandefinition_search_bundled(
  search_for search_args: r5_sansio.SpPlandefinition,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

plandefinition_update

</> 
pub fn plandefinition_update(
  resource: r5.Plandefinition,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Plandefinition, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

practitioner_create

</> 
pub fn practitioner_create(
  resource: r5.Practitioner,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Practitioner, Err)) -> a,
) -> effect.Effect(a)

practitioner_delete

</> 
pub fn practitioner_delete(
  resource: r5.Practitioner,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

practitioner_read

</> 
pub fn practitioner_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Practitioner, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn practitioner_search(
  search_for search_args: r5_sansio.SpPractitioner,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Practitioner), Err),
  ) -> msg,
) -> effect.Effect(msg)

practitioner_search_bundled

</> 
pub fn practitioner_search_bundled(
  search_for search_args: r5_sansio.SpPractitioner,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

practitioner_update

</> 
pub fn practitioner_update(
  resource: r5.Practitioner,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Practitioner, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

practitionerrole_create

</> 
pub fn practitionerrole_create(
  resource: r5.Practitionerrole,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Practitionerrole, Err)) -> a,
) -> effect.Effect(a)

practitionerrole_delete

</> 
pub fn practitionerrole_delete(
  resource: r5.Practitionerrole,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

practitionerrole_read

</> 
pub fn practitionerrole_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Practitionerrole, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn practitionerrole_search(
  search_for search_args: r5_sansio.SpPractitionerrole,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Practitionerrole), Err),
  ) -> msg,
) -> effect.Effect(msg)

practitionerrole_search_bundled

</> 
pub fn practitionerrole_search_bundled(
  search_for search_args: r5_sansio.SpPractitionerrole,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

practitionerrole_update

</> 
pub fn practitionerrole_update(
  resource: r5.Practitionerrole,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Practitionerrole, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

procedure_create

</> 
pub fn procedure_create(
  resource: r5.Procedure,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Procedure, Err)) -> a,
) -> effect.Effect(a)

procedure_delete

</> 
pub fn procedure_delete(
  resource: r5.Procedure,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

procedure_read

</> 
pub fn procedure_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Procedure, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn procedure_search(
  search_for search_args: r5_sansio.SpProcedure,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Procedure), Err),
  ) -> msg,
) -> effect.Effect(msg)

procedure_search_bundled

</> 
pub fn procedure_search_bundled(
  search_for search_args: r5_sansio.SpProcedure,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

procedure_update

</> 
pub fn procedure_update(
  resource: r5.Procedure,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Procedure, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

provenance_create

</> 
pub fn provenance_create(
  resource: r5.Provenance,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Provenance, Err)) -> a,
) -> effect.Effect(a)

provenance_delete

</> 
pub fn provenance_delete(
  resource: r5.Provenance,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

provenance_read

</> 
pub fn provenance_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Provenance, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn provenance_search(
  search_for search_args: r5_sansio.SpProvenance,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Provenance), Err),
  ) -> msg,
) -> effect.Effect(msg)

provenance_search_bundled

</> 
pub fn provenance_search_bundled(
  search_for search_args: r5_sansio.SpProvenance,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

provenance_update

</> 
pub fn provenance_update(
  resource: r5.Provenance,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Provenance, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

questionnaire_create

</> 
pub fn questionnaire_create(
  resource: r5.Questionnaire,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Questionnaire, Err)) -> a,
) -> effect.Effect(a)

questionnaire_delete

</> 
pub fn questionnaire_delete(
  resource: r5.Questionnaire,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

questionnaire_read

</> 
pub fn questionnaire_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Questionnaire, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn questionnaire_search(
  search_for search_args: r5_sansio.SpQuestionnaire,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Questionnaire), Err),
  ) -> msg,
) -> effect.Effect(msg)

questionnaire_search_bundled

</> 
pub fn questionnaire_search_bundled(
  search_for search_args: r5_sansio.SpQuestionnaire,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

questionnaire_update

</> 
pub fn questionnaire_update(
  resource: r5.Questionnaire,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Questionnaire, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

questionnaireresponse_create

</> 
pub fn questionnaireresponse_create(
  resource: r5.Questionnaireresponse,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Questionnaireresponse, Err)) -> a,
) -> effect.Effect(a)

questionnaireresponse_delete

</> 
pub fn questionnaireresponse_delete(
  resource: r5.Questionnaireresponse,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

questionnaireresponse_read

</> 
pub fn questionnaireresponse_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Questionnaireresponse, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn questionnaireresponse_search(
  search_for search_args: r5_sansio.SpQuestionnaireresponse,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Questionnaireresponse), Err),
  ) -> msg,
) -> effect.Effect(msg)

questionnaireresponse_search_bundled

</> 
pub fn questionnaireresponse_search_bundled(
  search_for search_args: r5_sansio.SpQuestionnaireresponse,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

questionnaireresponse_update

</> 
pub fn questionnaireresponse_update(
  resource: r5.Questionnaireresponse,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Questionnaireresponse, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

regulatedauthorization_create

</> 
pub fn regulatedauthorization_create(
  resource: r5.Regulatedauthorization,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Regulatedauthorization, Err)) -> a,
) -> effect.Effect(a)

regulatedauthorization_delete

</> 
pub fn regulatedauthorization_delete(
  resource: r5.Regulatedauthorization,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

regulatedauthorization_read

</> 
pub fn regulatedauthorization_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Regulatedauthorization, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn regulatedauthorization_search(
  search_for search_args: r5_sansio.SpRegulatedauthorization,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Regulatedauthorization), Err),
  ) -> msg,
) -> effect.Effect(msg)

regulatedauthorization_search_bundled

</> 
pub fn regulatedauthorization_search_bundled(
  search_for search_args: r5_sansio.SpRegulatedauthorization,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

regulatedauthorization_update

</> 
pub fn regulatedauthorization_update(
  resource: r5.Regulatedauthorization,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Regulatedauthorization, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

relatedperson_create

</> 
pub fn relatedperson_create(
  resource: r5.Relatedperson,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Relatedperson, Err)) -> a,
) -> effect.Effect(a)

relatedperson_delete

</> 
pub fn relatedperson_delete(
  resource: r5.Relatedperson,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

relatedperson_read

</> 
pub fn relatedperson_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Relatedperson, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn relatedperson_search(
  search_for search_args: r5_sansio.SpRelatedperson,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Relatedperson), Err),
  ) -> msg,
) -> effect.Effect(msg)

relatedperson_search_bundled

</> 
pub fn relatedperson_search_bundled(
  search_for search_args: r5_sansio.SpRelatedperson,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

relatedperson_update

</> 
pub fn relatedperson_update(
  resource: r5.Relatedperson,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Relatedperson, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

requestorchestration_create

</> 
pub fn requestorchestration_create(
  resource: r5.Requestorchestration,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Requestorchestration, Err)) -> a,
) -> effect.Effect(a)

requestorchestration_delete

</> 
pub fn requestorchestration_delete(
  resource: r5.Requestorchestration,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

requestorchestration_read

</> 
pub fn requestorchestration_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Requestorchestration, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn requestorchestration_search(
  search_for search_args: r5_sansio.SpRequestorchestration,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Requestorchestration), Err),
  ) -> msg,
) -> effect.Effect(msg)

requestorchestration_search_bundled

</> 
pub fn requestorchestration_search_bundled(
  search_for search_args: r5_sansio.SpRequestorchestration,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

requestorchestration_update

</> 
pub fn requestorchestration_update(
  resource: r5.Requestorchestration,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Requestorchestration, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

requirements_create

</> 
pub fn requirements_create(
  resource: r5.Requirements,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Requirements, Err)) -> a,
) -> effect.Effect(a)

requirements_delete

</> 
pub fn requirements_delete(
  resource: r5.Requirements,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

requirements_read

</> 
pub fn requirements_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Requirements, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn requirements_search(
  search_for search_args: r5_sansio.SpRequirements,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Requirements), Err),
  ) -> msg,
) -> effect.Effect(msg)

requirements_search_bundled

</> 
pub fn requirements_search_bundled(
  search_for search_args: r5_sansio.SpRequirements,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

requirements_update

</> 
pub fn requirements_update(
  resource: r5.Requirements,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Requirements, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

researchstudy_create

</> 
pub fn researchstudy_create(
  resource: r5.Researchstudy,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Researchstudy, Err)) -> a,
) -> effect.Effect(a)

researchstudy_delete

</> 
pub fn researchstudy_delete(
  resource: r5.Researchstudy,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

researchstudy_read

</> 
pub fn researchstudy_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Researchstudy, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn researchstudy_search(
  search_for search_args: r5_sansio.SpResearchstudy,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Researchstudy), Err),
  ) -> msg,
) -> effect.Effect(msg)

researchstudy_search_bundled

</> 
pub fn researchstudy_search_bundled(
  search_for search_args: r5_sansio.SpResearchstudy,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

researchstudy_update

</> 
pub fn researchstudy_update(
  resource: r5.Researchstudy,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Researchstudy, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

researchsubject_create

</> 
pub fn researchsubject_create(
  resource: r5.Researchsubject,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Researchsubject, Err)) -> a,
) -> effect.Effect(a)

researchsubject_delete

</> 
pub fn researchsubject_delete(
  resource: r5.Researchsubject,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

researchsubject_read

</> 
pub fn researchsubject_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Researchsubject, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn researchsubject_search(
  search_for search_args: r5_sansio.SpResearchsubject,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Researchsubject), Err),
  ) -> msg,
) -> effect.Effect(msg)

researchsubject_search_bundled

</> 
pub fn researchsubject_search_bundled(
  search_for search_args: r5_sansio.SpResearchsubject,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

researchsubject_update

</> 
pub fn researchsubject_update(
  resource: r5.Researchsubject,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Researchsubject, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

riskassessment_create

</> 
pub fn riskassessment_create(
  resource: r5.Riskassessment,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Riskassessment, Err)) -> a,
) -> effect.Effect(a)

riskassessment_delete

</> 
pub fn riskassessment_delete(
  resource: r5.Riskassessment,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

riskassessment_read

</> 
pub fn riskassessment_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Riskassessment, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn riskassessment_search(
  search_for search_args: r5_sansio.SpRiskassessment,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Riskassessment), Err),
  ) -> msg,
) -> effect.Effect(msg)

riskassessment_search_bundled

</> 
pub fn riskassessment_search_bundled(
  search_for search_args: r5_sansio.SpRiskassessment,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

riskassessment_update

</> 
pub fn riskassessment_update(
  resource: r5.Riskassessment,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Riskassessment, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

schedule_create

</> 
pub fn schedule_create(
  resource: r5.Schedule,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Schedule, Err)) -> a,
) -> effect.Effect(a)

schedule_delete

</> 
pub fn schedule_delete(
  resource: r5.Schedule,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

schedule_read

</> 
pub fn schedule_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Schedule, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn schedule_search(
  search_for search_args: r5_sansio.SpSchedule,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(List(r5.Schedule), Err)) -> msg,
) -> effect.Effect(msg)

schedule_search_bundled

</> 
pub fn schedule_search_bundled(
  search_for search_args: r5_sansio.SpSchedule,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

schedule_update

</> 
pub fn schedule_update(
  resource: r5.Schedule,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Schedule, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

search_any

</> 
pub fn search_any(
  search_string: String,
  res_type: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

write out search string manually, in case typed search params don’t work

searchparameter_create

</> 
pub fn searchparameter_create(
  resource: r5.Searchparameter,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Searchparameter, Err)) -> a,
) -> effect.Effect(a)

searchparameter_delete

</> 
pub fn searchparameter_delete(
  resource: r5.Searchparameter,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

searchparameter_read

</> 
pub fn searchparameter_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Searchparameter, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn searchparameter_search(
  search_for search_args: r5_sansio.SpSearchparameter,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Searchparameter), Err),
  ) -> msg,
) -> effect.Effect(msg)

searchparameter_search_bundled

</> 
pub fn searchparameter_search_bundled(
  search_for search_args: r5_sansio.SpSearchparameter,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

searchparameter_update

</> 
pub fn searchparameter_update(
  resource: r5.Searchparameter,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Searchparameter, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

servicerequest_create

</> 
pub fn servicerequest_create(
  resource: r5.Servicerequest,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Servicerequest, Err)) -> a,
) -> effect.Effect(a)

servicerequest_delete

</> 
pub fn servicerequest_delete(
  resource: r5.Servicerequest,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

servicerequest_read

</> 
pub fn servicerequest_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Servicerequest, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn servicerequest_search(
  search_for search_args: r5_sansio.SpServicerequest,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Servicerequest), Err),
  ) -> msg,
) -> effect.Effect(msg)

servicerequest_search_bundled

</> 
pub fn servicerequest_search_bundled(
  search_for search_args: r5_sansio.SpServicerequest,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

servicerequest_update

</> 
pub fn servicerequest_update(
  resource: r5.Servicerequest,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Servicerequest, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

slot_create

</> 
pub fn slot_create(
  resource: r5.Slot,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Slot, Err)) -> a,
) -> effect.Effect(a)

slot_delete

</> 
pub fn slot_delete(
  resource: r5.Slot,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

slot_read

</> 
pub fn slot_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Slot, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn slot_search(
  search_for search_args: r5_sansio.SpSlot,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(List(r5.Slot), Err)) -> msg,
) -> effect.Effect(msg)

slot_search_bundled

</> 
pub fn slot_search_bundled(
  search_for search_args: r5_sansio.SpSlot,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

slot_update

</> 
pub fn slot_update(
  resource: r5.Slot,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Slot, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

specimen_create

</> 
pub fn specimen_create(
  resource: r5.Specimen,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Specimen, Err)) -> a,
) -> effect.Effect(a)

specimen_delete

</> 
pub fn specimen_delete(
  resource: r5.Specimen,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

specimen_read

</> 
pub fn specimen_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Specimen, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn specimen_search(
  search_for search_args: r5_sansio.SpSpecimen,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(List(r5.Specimen), Err)) -> msg,
) -> effect.Effect(msg)

specimen_search_bundled

</> 
pub fn specimen_search_bundled(
  search_for search_args: r5_sansio.SpSpecimen,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

specimen_update

</> 
pub fn specimen_update(
  resource: r5.Specimen,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Specimen, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

specimendefinition_create

</> 
pub fn specimendefinition_create(
  resource: r5.Specimendefinition,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Specimendefinition, Err)) -> a,
) -> effect.Effect(a)

specimendefinition_delete

</> 
pub fn specimendefinition_delete(
  resource: r5.Specimendefinition,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

specimendefinition_read

</> 
pub fn specimendefinition_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Specimendefinition, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn specimendefinition_search(
  search_for search_args: r5_sansio.SpSpecimendefinition,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Specimendefinition), Err),
  ) -> msg,
) -> effect.Effect(msg)

specimendefinition_search_bundled

</> 
pub fn specimendefinition_search_bundled(
  search_for search_args: r5_sansio.SpSpecimendefinition,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

specimendefinition_update

</> 
pub fn specimendefinition_update(
  resource: r5.Specimendefinition,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Specimendefinition, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

structuredefinition_create

</> 
pub fn structuredefinition_create(
  resource: r5.Structuredefinition,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Structuredefinition, Err)) -> a,
) -> effect.Effect(a)

structuredefinition_delete

</> 
pub fn structuredefinition_delete(
  resource: r5.Structuredefinition,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

structuredefinition_read

</> 
pub fn structuredefinition_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Structuredefinition, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn structuredefinition_search(
  search_for search_args: r5_sansio.SpStructuredefinition,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Structuredefinition), Err),
  ) -> msg,
) -> effect.Effect(msg)

structuredefinition_search_bundled

</> 
pub fn structuredefinition_search_bundled(
  search_for search_args: r5_sansio.SpStructuredefinition,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

structuredefinition_update

</> 
pub fn structuredefinition_update(
  resource: r5.Structuredefinition,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Structuredefinition, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

structuremap_create

</> 
pub fn structuremap_create(
  resource: r5.Structuremap,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Structuremap, Err)) -> a,
) -> effect.Effect(a)

structuremap_delete

</> 
pub fn structuremap_delete(
  resource: r5.Structuremap,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

structuremap_read

</> 
pub fn structuremap_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Structuremap, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn structuremap_search(
  search_for search_args: r5_sansio.SpStructuremap,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Structuremap), Err),
  ) -> msg,
) -> effect.Effect(msg)

structuremap_search_bundled

</> 
pub fn structuremap_search_bundled(
  search_for search_args: r5_sansio.SpStructuremap,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

structuremap_update

</> 
pub fn structuremap_update(
  resource: r5.Structuremap,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Structuremap, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

subscription_create

</> 
pub fn subscription_create(
  resource: r5.Subscription,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Subscription, Err)) -> a,
) -> effect.Effect(a)

subscription_delete

</> 
pub fn subscription_delete(
  resource: r5.Subscription,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

subscription_read

</> 
pub fn subscription_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Subscription, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn subscription_search(
  search_for search_args: r5_sansio.SpSubscription,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Subscription), Err),
  ) -> msg,
) -> effect.Effect(msg)

subscription_search_bundled

</> 
pub fn subscription_search_bundled(
  search_for search_args: r5_sansio.SpSubscription,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

subscription_update

</> 
pub fn subscription_update(
  resource: r5.Subscription,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Subscription, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

subscriptionstatus_create

</> 
pub fn subscriptionstatus_create(
  resource: r5.Subscriptionstatus,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Subscriptionstatus, Err)) -> a,
) -> effect.Effect(a)

subscriptionstatus_delete

</> 
pub fn subscriptionstatus_delete(
  resource: r5.Subscriptionstatus,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

subscriptionstatus_read

</> 
pub fn subscriptionstatus_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Subscriptionstatus, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn subscriptionstatus_search(
  search_for search_args: r5_sansio.SpSubscriptionstatus,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Subscriptionstatus), Err),
  ) -> msg,
) -> effect.Effect(msg)

subscriptionstatus_search_bundled

</> 
pub fn subscriptionstatus_search_bundled(
  search_for search_args: r5_sansio.SpSubscriptionstatus,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

subscriptionstatus_update

</> 
pub fn subscriptionstatus_update(
  resource: r5.Subscriptionstatus,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Subscriptionstatus, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

subscriptiontopic_create

</> 
pub fn subscriptiontopic_create(
  resource: r5.Subscriptiontopic,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Subscriptiontopic, Err)) -> a,
) -> effect.Effect(a)

subscriptiontopic_delete

</> 
pub fn subscriptiontopic_delete(
  resource: r5.Subscriptiontopic,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

subscriptiontopic_read

</> 
pub fn subscriptiontopic_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Subscriptiontopic, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn subscriptiontopic_search(
  search_for search_args: r5_sansio.SpSubscriptiontopic,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Subscriptiontopic), Err),
  ) -> msg,
) -> effect.Effect(msg)

subscriptiontopic_search_bundled

</> 
pub fn subscriptiontopic_search_bundled(
  search_for search_args: r5_sansio.SpSubscriptiontopic,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

subscriptiontopic_update

</> 
pub fn subscriptiontopic_update(
  resource: r5.Subscriptiontopic,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Subscriptiontopic, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

substance_create

</> 
pub fn substance_create(
  resource: r5.Substance,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Substance, Err)) -> a,
) -> effect.Effect(a)

substance_delete

</> 
pub fn substance_delete(
  resource: r5.Substance,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

substance_read

</> 
pub fn substance_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Substance, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn substance_search(
  search_for search_args: r5_sansio.SpSubstance,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Substance), Err),
  ) -> msg,
) -> effect.Effect(msg)

substance_search_bundled

</> 
pub fn substance_search_bundled(
  search_for search_args: r5_sansio.SpSubstance,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

substance_update

</> 
pub fn substance_update(
  resource: r5.Substance,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Substance, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

substancedefinition_create

</> 
pub fn substancedefinition_create(
  resource: r5.Substancedefinition,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Substancedefinition, Err)) -> a,
) -> effect.Effect(a)

substancedefinition_delete

</> 
pub fn substancedefinition_delete(
  resource: r5.Substancedefinition,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

substancedefinition_read

</> 
pub fn substancedefinition_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Substancedefinition, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn substancedefinition_search(
  search_for search_args: r5_sansio.SpSubstancedefinition,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Substancedefinition), Err),
  ) -> msg,
) -> effect.Effect(msg)

substancedefinition_search_bundled

</> 
pub fn substancedefinition_search_bundled(
  search_for search_args: r5_sansio.SpSubstancedefinition,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

substancedefinition_update

</> 
pub fn substancedefinition_update(
  resource: r5.Substancedefinition,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Substancedefinition, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

substancenucleicacid_create

</> 
pub fn substancenucleicacid_create(
  resource: r5.Substancenucleicacid,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Substancenucleicacid, Err)) -> a,
) -> effect.Effect(a)

substancenucleicacid_delete

</> 
pub fn substancenucleicacid_delete(
  resource: r5.Substancenucleicacid,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

substancenucleicacid_read

</> 
pub fn substancenucleicacid_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Substancenucleicacid, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn substancenucleicacid_search(
  search_for search_args: r5_sansio.SpSubstancenucleicacid,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Substancenucleicacid), Err),
  ) -> msg,
) -> effect.Effect(msg)

substancenucleicacid_search_bundled

</> 
pub fn substancenucleicacid_search_bundled(
  search_for search_args: r5_sansio.SpSubstancenucleicacid,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

substancenucleicacid_update

</> 
pub fn substancenucleicacid_update(
  resource: r5.Substancenucleicacid,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Substancenucleicacid, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

substancepolymer_create

</> 
pub fn substancepolymer_create(
  resource: r5.Substancepolymer,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Substancepolymer, Err)) -> a,
) -> effect.Effect(a)

substancepolymer_delete

</> 
pub fn substancepolymer_delete(
  resource: r5.Substancepolymer,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

substancepolymer_read

</> 
pub fn substancepolymer_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Substancepolymer, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn substancepolymer_search(
  search_for search_args: r5_sansio.SpSubstancepolymer,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Substancepolymer), Err),
  ) -> msg,
) -> effect.Effect(msg)

substancepolymer_search_bundled

</> 
pub fn substancepolymer_search_bundled(
  search_for search_args: r5_sansio.SpSubstancepolymer,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

substancepolymer_update

</> 
pub fn substancepolymer_update(
  resource: r5.Substancepolymer,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Substancepolymer, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

substanceprotein_create

</> 
pub fn substanceprotein_create(
  resource: r5.Substanceprotein,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Substanceprotein, Err)) -> a,
) -> effect.Effect(a)

substanceprotein_delete

</> 
pub fn substanceprotein_delete(
  resource: r5.Substanceprotein,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

substanceprotein_read

</> 
pub fn substanceprotein_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Substanceprotein, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn substanceprotein_search(
  search_for search_args: r5_sansio.SpSubstanceprotein,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Substanceprotein), Err),
  ) -> msg,
) -> effect.Effect(msg)

substanceprotein_search_bundled

</> 
pub fn substanceprotein_search_bundled(
  search_for search_args: r5_sansio.SpSubstanceprotein,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

substanceprotein_update

</> 
pub fn substanceprotein_update(
  resource: r5.Substanceprotein,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Substanceprotein, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

substancereferenceinformation_create

</> 
pub fn substancereferenceinformation_create(
  resource: r5.Substancereferenceinformation,
  client: r5_sansio.FhirClient,
  handle_response: fn(
    Result(r5.Substancereferenceinformation, Err),
  ) -> a,
) -> effect.Effect(a)

substancereferenceinformation_delete

</> 
pub fn substancereferenceinformation_delete(
  resource: r5.Substancereferenceinformation,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

substancereferenceinformation_read

</> 
pub fn substancereferenceinformation_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(
    Result(r5.Substancereferenceinformation, Err),
  ) -> a,
) -> effect.Effect(a)
</> 
pub fn substancereferenceinformation_search(
  search_for search_args: r5_sansio.SpSubstancereferenceinformation,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Substancereferenceinformation), Err),
  ) -> msg,
) -> effect.Effect(msg)

substancereferenceinformation_search_bundled

</> 
pub fn substancereferenceinformation_search_bundled(
  search_for search_args: r5_sansio.SpSubstancereferenceinformation,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

substancereferenceinformation_update

</> 
pub fn substancereferenceinformation_update(
  resource: r5.Substancereferenceinformation,
  client: r5_sansio.FhirClient,
  handle_response: fn(
    Result(r5.Substancereferenceinformation, Err),
  ) -> a,
) -> Result(effect.Effect(a), ErrNoId)

substancesourcematerial_create

</> 
pub fn substancesourcematerial_create(
  resource: r5.Substancesourcematerial,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Substancesourcematerial, Err)) -> a,
) -> effect.Effect(a)

substancesourcematerial_delete

</> 
pub fn substancesourcematerial_delete(
  resource: r5.Substancesourcematerial,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

substancesourcematerial_read

</> 
pub fn substancesourcematerial_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Substancesourcematerial, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn substancesourcematerial_search(
  search_for search_args: r5_sansio.SpSubstancesourcematerial,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Substancesourcematerial), Err),
  ) -> msg,
) -> effect.Effect(msg)

substancesourcematerial_search_bundled

</> 
pub fn substancesourcematerial_search_bundled(
  search_for search_args: r5_sansio.SpSubstancesourcematerial,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

substancesourcematerial_update

</> 
pub fn substancesourcematerial_update(
  resource: r5.Substancesourcematerial,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Substancesourcematerial, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

supplydelivery_create

</> 
pub fn supplydelivery_create(
  resource: r5.Supplydelivery,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Supplydelivery, Err)) -> a,
) -> effect.Effect(a)

supplydelivery_delete

</> 
pub fn supplydelivery_delete(
  resource: r5.Supplydelivery,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

supplydelivery_read

</> 
pub fn supplydelivery_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Supplydelivery, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn supplydelivery_search(
  search_for search_args: r5_sansio.SpSupplydelivery,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Supplydelivery), Err),
  ) -> msg,
) -> effect.Effect(msg)

supplydelivery_search_bundled

</> 
pub fn supplydelivery_search_bundled(
  search_for search_args: r5_sansio.SpSupplydelivery,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

supplydelivery_update

</> 
pub fn supplydelivery_update(
  resource: r5.Supplydelivery,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Supplydelivery, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

supplyrequest_create

</> 
pub fn supplyrequest_create(
  resource: r5.Supplyrequest,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Supplyrequest, Err)) -> a,
) -> effect.Effect(a)

supplyrequest_delete

</> 
pub fn supplyrequest_delete(
  resource: r5.Supplyrequest,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

supplyrequest_read

</> 
pub fn supplyrequest_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Supplyrequest, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn supplyrequest_search(
  search_for search_args: r5_sansio.SpSupplyrequest,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Supplyrequest), Err),
  ) -> msg,
) -> effect.Effect(msg)

supplyrequest_search_bundled

</> 
pub fn supplyrequest_search_bundled(
  search_for search_args: r5_sansio.SpSupplyrequest,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

supplyrequest_update

</> 
pub fn supplyrequest_update(
  resource: r5.Supplyrequest,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Supplyrequest, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

task_create

</> 
pub fn task_create(
  resource: r5.Task,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Task, Err)) -> a,
) -> effect.Effect(a)

task_delete

</> 
pub fn task_delete(
  resource: r5.Task,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

task_read

</> 
pub fn task_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Task, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn task_search(
  search_for search_args: r5_sansio.SpTask,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(List(r5.Task), Err)) -> msg,
) -> effect.Effect(msg)

task_search_bundled

</> 
pub fn task_search_bundled(
  search_for search_args: r5_sansio.SpTask,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

task_update

</> 
pub fn task_update(
  resource: r5.Task,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Task, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

terminologycapabilities_create

</> 
pub fn terminologycapabilities_create(
  resource: r5.Terminologycapabilities,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Terminologycapabilities, Err)) -> a,
) -> effect.Effect(a)

terminologycapabilities_delete

</> 
pub fn terminologycapabilities_delete(
  resource: r5.Terminologycapabilities,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

terminologycapabilities_read

</> 
pub fn terminologycapabilities_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Terminologycapabilities, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn terminologycapabilities_search(
  search_for search_args: r5_sansio.SpTerminologycapabilities,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Terminologycapabilities), Err),
  ) -> msg,
) -> effect.Effect(msg)

terminologycapabilities_search_bundled

</> 
pub fn terminologycapabilities_search_bundled(
  search_for search_args: r5_sansio.SpTerminologycapabilities,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

terminologycapabilities_update

</> 
pub fn terminologycapabilities_update(
  resource: r5.Terminologycapabilities,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Terminologycapabilities, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

testplan_create

</> 
pub fn testplan_create(
  resource: r5.Testplan,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Testplan, Err)) -> a,
) -> effect.Effect(a)

testplan_delete

</> 
pub fn testplan_delete(
  resource: r5.Testplan,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

testplan_read

</> 
pub fn testplan_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Testplan, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn testplan_search(
  search_for search_args: r5_sansio.SpTestplan,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(List(r5.Testplan), Err)) -> msg,
) -> effect.Effect(msg)

testplan_search_bundled

</> 
pub fn testplan_search_bundled(
  search_for search_args: r5_sansio.SpTestplan,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

testplan_update

</> 
pub fn testplan_update(
  resource: r5.Testplan,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Testplan, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

testreport_create

</> 
pub fn testreport_create(
  resource: r5.Testreport,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Testreport, Err)) -> a,
) -> effect.Effect(a)

testreport_delete

</> 
pub fn testreport_delete(
  resource: r5.Testreport,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

testreport_read

</> 
pub fn testreport_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Testreport, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn testreport_search(
  search_for search_args: r5_sansio.SpTestreport,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Testreport), Err),
  ) -> msg,
) -> effect.Effect(msg)

testreport_search_bundled

</> 
pub fn testreport_search_bundled(
  search_for search_args: r5_sansio.SpTestreport,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

testreport_update

</> 
pub fn testreport_update(
  resource: r5.Testreport,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Testreport, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

testscript_create

</> 
pub fn testscript_create(
  resource: r5.Testscript,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Testscript, Err)) -> a,
) -> effect.Effect(a)

testscript_delete

</> 
pub fn testscript_delete(
  resource: r5.Testscript,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

testscript_read

</> 
pub fn testscript_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Testscript, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn testscript_search(
  search_for search_args: r5_sansio.SpTestscript,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Testscript), Err),
  ) -> msg,
) -> effect.Effect(msg)

testscript_search_bundled

</> 
pub fn testscript_search_bundled(
  search_for search_args: r5_sansio.SpTestscript,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

testscript_update

</> 
pub fn testscript_update(
  resource: r5.Testscript,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Testscript, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

transport_create

</> 
pub fn transport_create(
  resource: r5.Transport,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Transport, Err)) -> a,
) -> effect.Effect(a)

transport_delete

</> 
pub fn transport_delete(
  resource: r5.Transport,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

transport_read

</> 
pub fn transport_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Transport, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn transport_search(
  search_for search_args: r5_sansio.SpTransport,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Transport), Err),
  ) -> msg,
) -> effect.Effect(msg)

transport_search_bundled

</> 
pub fn transport_search_bundled(
  search_for search_args: r5_sansio.SpTransport,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

transport_update

</> 
pub fn transport_update(
  resource: r5.Transport,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Transport, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

valueset_create

</> 
pub fn valueset_create(
  resource: r5.Valueset,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Valueset, Err)) -> a,
) -> effect.Effect(a)

valueset_delete

</> 
pub fn valueset_delete(
  resource: r5.Valueset,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

valueset_read

</> 
pub fn valueset_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Valueset, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn valueset_search(
  search_for search_args: r5_sansio.SpValueset,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(List(r5.Valueset), Err)) -> msg,
) -> effect.Effect(msg)

valueset_search_bundled

</> 
pub fn valueset_search_bundled(
  search_for search_args: r5_sansio.SpValueset,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

valueset_update

</> 
pub fn valueset_update(
  resource: r5.Valueset,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Valueset, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

verificationresult_create

</> 
pub fn verificationresult_create(
  resource: r5.Verificationresult,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Verificationresult, Err)) -> a,
) -> effect.Effect(a)

verificationresult_delete

</> 
pub fn verificationresult_delete(
  resource: r5.Verificationresult,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

verificationresult_read

</> 
pub fn verificationresult_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Verificationresult, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn verificationresult_search(
  search_for search_args: r5_sansio.SpVerificationresult,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Verificationresult), Err),
  ) -> msg,
) -> effect.Effect(msg)

verificationresult_search_bundled

</> 
pub fn verificationresult_search_bundled(
  search_for search_args: r5_sansio.SpVerificationresult,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

verificationresult_update

</> 
pub fn verificationresult_update(
  resource: r5.Verificationresult,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Verificationresult, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

visionprescription_create

</> 
pub fn visionprescription_create(
  resource: r5.Visionprescription,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Visionprescription, Err)) -> a,
) -> effect.Effect(a)

visionprescription_delete

</> 
pub fn visionprescription_delete(
  resource: r5.Visionprescription,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Operationoutcome, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)

visionprescription_read

</> 
pub fn visionprescription_read(
  id: String,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Visionprescription, Err)) -> a,
) -> effect.Effect(a)
</> 
pub fn visionprescription_search(
  search_for search_args: r5_sansio.SpVisionprescription,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(
    Result(List(r5.Visionprescription), Err),
  ) -> msg,
) -> effect.Effect(msg)

visionprescription_search_bundled

</> 
pub fn visionprescription_search_bundled(
  search_for search_args: r5_sansio.SpVisionprescription,
  with_client client: r5_sansio.FhirClient,
  response_msg handle_response: fn(Result(r5.Bundle, Err)) -> msg,
) -> effect.Effect(msg)

visionprescription_update

</> 
pub fn visionprescription_update(
  resource: r5.Visionprescription,
  client: r5_sansio.FhirClient,
  handle_response: fn(Result(r5.Visionprescription, Err)) -> a,
) -> Result(effect.Effect(a), ErrNoId)
✨ Search Document