# 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

-     ErrRsvp(err: rsvp.Error)

-     ErrSansio(err: r5_sansio.Err)

## 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 just an 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)

## account_search

</>

    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)

## activitydefinition_search

</>

    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)

## actordefinition_search

</>

    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)

## administrableproductdefinition_search

</>

    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)

## adverseevent_search

</>

    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)

## allergyintolerance_search

</>

    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)

## appointment_search

</>

    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)

## appointmentresponse_search

</>

    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)

## artifactassessment_search

</>

    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)

## auditevent_search

</>

    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)

## basic_search

</>

    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)

## binary_search

</>

    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)

## biologicallyderivedproduct_search

</>

    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)

## biologicallyderivedproductdispense_search

</>

    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)

## bodystructure_search

</>

    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)

## bundle_search

</>

    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)

## capabilitystatement_search

</>

    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)

## careplan_search

</>

    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)

## careteam_search

</>

    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)

## chargeitem_search

</>

    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)

## chargeitemdefinition_search

</>

    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)

## citation_search

</>

    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)

## claim_search

</>

    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)

## claimresponse_search

</>

    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)

## clinicalimpression_search

</>

    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)

## clinicalusedefinition_search

</>

    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)

## codesystem_search

</>

    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)

## communication_search

</>

    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)

## communicationrequest_search

</>

    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)

## compartmentdefinition_search

</>

    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)

## composition_search

</>

    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)

## conceptmap_search

</>

    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)

## condition_search

</>

    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)

## conditiondefinition_search

</>

    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)

## consent_create

</>

    pub fn consent_create(
      resource: r5.Consent,
      client: r5_sansio.FhirClient,
      handle_response: fn(Result(r5.Consent, Err)) -> a,
    ) -> effect.Effect(a)

## consent_delete

</>

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

## consent_read

</>

    pub fn consent_read(
      id: String,
      client: r5_sansio.FhirClient,
      handle_response: fn(Result(r5.Consent, Err)) -> a,
    ) -> effect.Effect(a)

## consent_search

</>

    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)

## consent_search_bundled

</>

    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)

## consent_update

</>

    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)

## contract_search

</>

    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)

## coverage_search

</>

    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)

## coverageeligibilityrequest_search

</>

    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)

## coverageeligibilityresponse_search

</>

    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)

## detectedissue_search

</>

    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)

## device_search

</>

    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)

## deviceassociation_search

</>

    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)

## devicedefinition_search

</>

    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)

## devicedispense_search

</>

    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)

## devicemetric_search

</>

    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)

## devicerequest_search

</>

    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)

## deviceusage_search

</>

    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)

## diagnosticreport_search

</>

    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)

## documentreference_search

</>

    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)

## encounter_search

</>

    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)

## encounterhistory_search

</>

    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)

## endpoint_search

</>

    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)

## enrollmentrequest_search

</>

    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)

## enrollmentresponse_search

</>

    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)

## episodeofcare_search

</>

    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)

## eventdefinition_search

</>

    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)

## evidence_search

</>

    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)

## evidencereport_search

</>

    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)

## evidencevariable_search

</>

    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)

## examplescenario_search

</>

    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)

## explanationofbenefit_search

</>

    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)

## familymemberhistory_search

</>

    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)

## flag_search

</>

    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)

## formularyitem_search

</>

    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)

## genomicstudy_search

</>

    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)

## goal_search

</>

    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)

## graphdefinition_search

</>

    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)

## group_search

</>

    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)

## guidanceresponse_search

</>

    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)

## healthcareservice_search

</>

    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)

## imagingselection_search

</>

    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)

## imagingstudy_search

</>

    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)

## immunization_search

</>

    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)

## immunizationevaluation_search

</>

    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)

## immunizationrecommendation_search

</>

    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)

## implementationguide_search

</>

    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)

## ingredient_search

</>

    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)

## insuranceplan_search

</>

    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)

## inventoryitem_search

</>

    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)

## inventoryreport_search

</>

    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)

## invoice_search

</>

    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)

## library_search

</>

    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)

## linkage_search

</>

    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)

## listfhir_search

</>

    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)

## location_search

</>

    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)

## manufactureditemdefinition_search

</>

    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)

## measure_search

</>

    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)

## measurereport_search

</>

    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)

## medication_search

</>

    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)

## medicationadministration_search

</>

    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)

## medicationdispense_search

</>

    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)

## medicationknowledge_search

</>

    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)

## medicationrequest_search

</>

    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)

## medicationstatement_search

</>

    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)

## medicinalproductdefinition_search

</>

    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)

## messagedefinition_search

</>

    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)

## messageheader_search

</>

    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)

## molecularsequence_search

</>

    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)

## namingsystem_search

</>

    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)

## nutritionintake_search

</>

    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)

## nutritionorder_search

</>

    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)

## nutritionproduct_search

</>

    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)

## observation_search

</>

    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)

## observationdefinition_search

</>

    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)

## 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)

## operationdefinition_search

</>

    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)

## operationoutcome_search

</>

    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)

## organization_search

</>

    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)

## organizationaffiliation_search

</>

    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)

## packagedproductdefinition_search

</>

    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)

## patient_search

</>

    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)

## paymentnotice_search

</>

    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)

## paymentreconciliation_search

</>

    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)

## permission_search

</>

    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)

## person_search

</>

    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)

## plandefinition_search

</>

    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)

## practitioner_search

</>

    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)

## practitionerrole_search

</>

    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)

## procedure_search

</>

    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)

## provenance_search

</>

    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)

## questionnaire_search

</>

    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)

## questionnaireresponse_search

</>

    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)

## regulatedauthorization_search

</>

    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)

## relatedperson_search

</>

    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)

## requestorchestration_search

</>

    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)

## requirements_search

</>

    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)

## researchstudy_search

</>

    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)

## researchsubject_search

</>

    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)

## riskassessment_search

</>

    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)

## schedule_search

</>

    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)

## 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)

## searchparameter_search

</>

    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)

## servicerequest_search

</>

    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)

## slot_search

</>

    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)

## specimen_search

</>

    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)

## specimendefinition_search

</>

    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)

## structuredefinition_search

</>

    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)

## structuremap_search

</>

    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)

## subscription_search

</>

    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)

## subscriptionstatus_search

</>

    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)

## subscriptiontopic_search

</>

    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)

## substance_search

</>

    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)

## substancedefinition_search

</>

    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)

## substancenucleicacid_search

</>

    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)

## substancepolymer_search

</>

    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)

## substanceprotein_search

</>

    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)

## substancereferenceinformation_search

</>

    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)

## substancesourcematerial_search

</>

    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)

## supplydelivery_search

</>

    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)

## supplyrequest_search

</>

    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)

## task_search

</>

    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)

## terminologycapabilities_search

</>

    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)

## testplan_search

</>

    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)

## testreport_search

</>

    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)

## testscript_search

</>

    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)

## transport_search

</>

    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)

## valueset_search

</>

    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)

## verificationresult_search

</>

    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)

## visionprescription_search

</>

    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)

✨