# fhir/r4_httpc

https://hl7.org/fhir/r4 r4 client using httpc

# Types

## Err

</>

    pub type Err {
      ErrHttpc(httpc.HttpError)
      ErrSansio(err: r4_sansio.Err)
    }

### Constructors

-     ErrHttpc(httpc.HttpError)

-     ErrSansio(err: r4_sansio.Err)

# Values

## account_create

</>

    pub fn account_create(
      resource: r4.Account,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Account, Err)

## account_delete

</>

    pub fn account_delete(
      resource: r4.Account,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## account_read

</>

    pub fn account_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Account, Err)

## account_search

</>

    pub fn account_search(
      sp: r4_sansio.SpAccount,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Account), Err)

## account_search_bundled

</>

    pub fn account_search_bundled(
      sp: r4_sansio.SpAccount,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## account_update

</>

    pub fn account_update(
      resource: r4.Account,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Account, Err)

## activitydefinition_create

</>

    pub fn activitydefinition_create(
      resource: r4.Activitydefinition,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Activitydefinition, Err)

## activitydefinition_delete

</>

    pub fn activitydefinition_delete(
      resource: r4.Activitydefinition,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## activitydefinition_read

</>

    pub fn activitydefinition_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Activitydefinition, Err)

## activitydefinition_search

</>

    pub fn activitydefinition_search(
      sp: r4_sansio.SpActivitydefinition,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Activitydefinition), Err)

## activitydefinition_search_bundled

</>

    pub fn activitydefinition_search_bundled(
      sp: r4_sansio.SpActivitydefinition,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## activitydefinition_update

</>

    pub fn activitydefinition_update(
      resource: r4.Activitydefinition,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Activitydefinition, Err)

## adverseevent_create

</>

    pub fn adverseevent_create(
      resource: r4.Adverseevent,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Adverseevent, Err)

## adverseevent_delete

</>

    pub fn adverseevent_delete(
      resource: r4.Adverseevent,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## adverseevent_read

</>

    pub fn adverseevent_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Adverseevent, Err)

## adverseevent_search

</>

    pub fn adverseevent_search(
      sp: r4_sansio.SpAdverseevent,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Adverseevent), Err)

## adverseevent_search_bundled

</>

    pub fn adverseevent_search_bundled(
      sp: r4_sansio.SpAdverseevent,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## adverseevent_update

</>

    pub fn adverseevent_update(
      resource: r4.Adverseevent,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Adverseevent, Err)

## allergyintolerance_create

</>

    pub fn allergyintolerance_create(
      resource: r4.Allergyintolerance,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Allergyintolerance, Err)

## allergyintolerance_delete

</>

    pub fn allergyintolerance_delete(
      resource: r4.Allergyintolerance,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## allergyintolerance_read

</>

    pub fn allergyintolerance_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Allergyintolerance, Err)

## allergyintolerance_search

</>

    pub fn allergyintolerance_search(
      sp: r4_sansio.SpAllergyintolerance,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Allergyintolerance), Err)

## allergyintolerance_search_bundled

</>

    pub fn allergyintolerance_search_bundled(
      sp: r4_sansio.SpAllergyintolerance,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## allergyintolerance_update

</>

    pub fn allergyintolerance_update(
      resource: r4.Allergyintolerance,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Allergyintolerance, Err)

## appointment_create

</>

    pub fn appointment_create(
      resource: r4.Appointment,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Appointment, Err)

## appointment_delete

</>

    pub fn appointment_delete(
      resource: r4.Appointment,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## appointment_read

</>

    pub fn appointment_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Appointment, Err)

## appointment_search

</>

    pub fn appointment_search(
      sp: r4_sansio.SpAppointment,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Appointment), Err)

## appointment_search_bundled

</>

    pub fn appointment_search_bundled(
      sp: r4_sansio.SpAppointment,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## appointment_update

</>

    pub fn appointment_update(
      resource: r4.Appointment,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Appointment, Err)

## appointmentresponse_create

</>

    pub fn appointmentresponse_create(
      resource: r4.Appointmentresponse,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Appointmentresponse, Err)

## appointmentresponse_delete

</>

    pub fn appointmentresponse_delete(
      resource: r4.Appointmentresponse,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## appointmentresponse_read

</>

    pub fn appointmentresponse_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Appointmentresponse, Err)

## appointmentresponse_search

</>

    pub fn appointmentresponse_search(
      sp: r4_sansio.SpAppointmentresponse,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Appointmentresponse), Err)

## appointmentresponse_search_bundled

</>

    pub fn appointmentresponse_search_bundled(
      sp: r4_sansio.SpAppointmentresponse,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## appointmentresponse_update

</>

    pub fn appointmentresponse_update(
      resource: r4.Appointmentresponse,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Appointmentresponse, Err)

## auditevent_create

</>

    pub fn auditevent_create(
      resource: r4.Auditevent,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Auditevent, Err)

## auditevent_delete

</>

    pub fn auditevent_delete(
      resource: r4.Auditevent,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## auditevent_read

</>

    pub fn auditevent_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Auditevent, Err)

## auditevent_search

</>

    pub fn auditevent_search(
      sp: r4_sansio.SpAuditevent,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Auditevent), Err)

## auditevent_search_bundled

</>

    pub fn auditevent_search_bundled(
      sp: r4_sansio.SpAuditevent,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## auditevent_update

</>

    pub fn auditevent_update(
      resource: r4.Auditevent,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Auditevent, Err)

## basic_create

</>

    pub fn basic_create(
      resource: r4.Basic,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Basic, Err)

## basic_delete

</>

    pub fn basic_delete(
      resource: r4.Basic,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## basic_read

</>

    pub fn basic_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Basic, Err)

## basic_search

</>

    pub fn basic_search(
      sp: r4_sansio.SpBasic,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Basic), Err)

## basic_search_bundled

</>

    pub fn basic_search_bundled(
      sp: r4_sansio.SpBasic,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## basic_update

</>

    pub fn basic_update(
      resource: r4.Basic,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Basic, Err)

## binary_create

</>

    pub fn binary_create(
      resource: r4.Binary,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Binary, Err)

## binary_delete

</>

    pub fn binary_delete(
      resource: r4.Binary,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## binary_read

</>

    pub fn binary_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Binary, Err)

## binary_search

</>

    pub fn binary_search(
      sp: r4_sansio.SpBinary,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Binary), Err)

## binary_search_bundled

</>

    pub fn binary_search_bundled(
      sp: r4_sansio.SpBinary,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## binary_update

</>

    pub fn binary_update(
      resource: r4.Binary,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Binary, Err)

## biologicallyderivedproduct_create

</>

    pub fn biologicallyderivedproduct_create(
      resource: r4.Biologicallyderivedproduct,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Biologicallyderivedproduct, Err)

## biologicallyderivedproduct_delete

</>

    pub fn biologicallyderivedproduct_delete(
      resource: r4.Biologicallyderivedproduct,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## biologicallyderivedproduct_read

</>

    pub fn biologicallyderivedproduct_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Biologicallyderivedproduct, Err)

## biologicallyderivedproduct_search

</>

    pub fn biologicallyderivedproduct_search(
      sp: r4_sansio.SpBiologicallyderivedproduct,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Biologicallyderivedproduct), Err)

## biologicallyderivedproduct_search_bundled

</>

    pub fn biologicallyderivedproduct_search_bundled(
      sp: r4_sansio.SpBiologicallyderivedproduct,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## biologicallyderivedproduct_update

</>

    pub fn biologicallyderivedproduct_update(
      resource: r4.Biologicallyderivedproduct,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Biologicallyderivedproduct, Err)

## bodystructure_create

</>

    pub fn bodystructure_create(
      resource: r4.Bodystructure,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bodystructure, Err)

## bodystructure_delete

</>

    pub fn bodystructure_delete(
      resource: r4.Bodystructure,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## bodystructure_read

</>

    pub fn bodystructure_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bodystructure, Err)

## bodystructure_search

</>

    pub fn bodystructure_search(
      sp: r4_sansio.SpBodystructure,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Bodystructure), Err)

## bodystructure_search_bundled

</>

    pub fn bodystructure_search_bundled(
      sp: r4_sansio.SpBodystructure,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## bodystructure_update

</>

    pub fn bodystructure_update(
      resource: r4.Bodystructure,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bodystructure, Err)

## bundle_create

</>

    pub fn bundle_create(
      resource: r4.Bundle,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## bundle_delete

</>

    pub fn bundle_delete(
      resource: r4.Bundle,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## bundle_read

</>

    pub fn bundle_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## bundle_search

</>

    pub fn bundle_search(
      sp: r4_sansio.SpBundle,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Bundle), Err)

## bundle_search_bundled

</>

    pub fn bundle_search_bundled(
      sp: r4_sansio.SpBundle,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## bundle_update

</>

    pub fn bundle_update(
      resource: r4.Bundle,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## capabilitystatement_create

</>

    pub fn capabilitystatement_create(
      resource: r4.Capabilitystatement,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Capabilitystatement, Err)

## capabilitystatement_delete

</>

    pub fn capabilitystatement_delete(
      resource: r4.Capabilitystatement,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## capabilitystatement_read

</>

    pub fn capabilitystatement_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Capabilitystatement, Err)

## capabilitystatement_search

</>

    pub fn capabilitystatement_search(
      sp: r4_sansio.SpCapabilitystatement,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Capabilitystatement), Err)

## capabilitystatement_search_bundled

</>

    pub fn capabilitystatement_search_bundled(
      sp: r4_sansio.SpCapabilitystatement,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## capabilitystatement_update

</>

    pub fn capabilitystatement_update(
      resource: r4.Capabilitystatement,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Capabilitystatement, Err)

## careplan_create

</>

    pub fn careplan_create(
      resource: r4.Careplan,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Careplan, Err)

## careplan_delete

</>

    pub fn careplan_delete(
      resource: r4.Careplan,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## careplan_read

</>

    pub fn careplan_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Careplan, Err)

## careplan_search

</>

    pub fn careplan_search(
      sp: r4_sansio.SpCareplan,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Careplan), Err)

## careplan_search_bundled

</>

    pub fn careplan_search_bundled(
      sp: r4_sansio.SpCareplan,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## careplan_update

</>

    pub fn careplan_update(
      resource: r4.Careplan,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Careplan, Err)

## careteam_create

</>

    pub fn careteam_create(
      resource: r4.Careteam,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Careteam, Err)

## careteam_delete

</>

    pub fn careteam_delete(
      resource: r4.Careteam,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## careteam_read

</>

    pub fn careteam_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Careteam, Err)

## careteam_search

</>

    pub fn careteam_search(
      sp: r4_sansio.SpCareteam,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Careteam), Err)

## careteam_search_bundled

</>

    pub fn careteam_search_bundled(
      sp: r4_sansio.SpCareteam,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## careteam_update

</>

    pub fn careteam_update(
      resource: r4.Careteam,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Careteam, Err)

## catalogentry_create

</>

    pub fn catalogentry_create(
      resource: r4.Catalogentry,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Catalogentry, Err)

## catalogentry_delete

</>

    pub fn catalogentry_delete(
      resource: r4.Catalogentry,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## catalogentry_read

</>

    pub fn catalogentry_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Catalogentry, Err)

## catalogentry_search

</>

    pub fn catalogentry_search(
      sp: r4_sansio.SpCatalogentry,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Catalogentry), Err)

## catalogentry_search_bundled

</>

    pub fn catalogentry_search_bundled(
      sp: r4_sansio.SpCatalogentry,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## catalogentry_update

</>

    pub fn catalogentry_update(
      resource: r4.Catalogentry,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Catalogentry, Err)

## chargeitem_create

</>

    pub fn chargeitem_create(
      resource: r4.Chargeitem,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Chargeitem, Err)

## chargeitem_delete

</>

    pub fn chargeitem_delete(
      resource: r4.Chargeitem,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## chargeitem_read

</>

    pub fn chargeitem_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Chargeitem, Err)

## chargeitem_search

</>

    pub fn chargeitem_search(
      sp: r4_sansio.SpChargeitem,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Chargeitem), Err)

## chargeitem_search_bundled

</>

    pub fn chargeitem_search_bundled(
      sp: r4_sansio.SpChargeitem,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## chargeitem_update

</>

    pub fn chargeitem_update(
      resource: r4.Chargeitem,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Chargeitem, Err)

## chargeitemdefinition_create

</>

    pub fn chargeitemdefinition_create(
      resource: r4.Chargeitemdefinition,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Chargeitemdefinition, Err)

## chargeitemdefinition_delete

</>

    pub fn chargeitemdefinition_delete(
      resource: r4.Chargeitemdefinition,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## chargeitemdefinition_read

</>

    pub fn chargeitemdefinition_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Chargeitemdefinition, Err)

## chargeitemdefinition_search

</>

    pub fn chargeitemdefinition_search(
      sp: r4_sansio.SpChargeitemdefinition,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Chargeitemdefinition), Err)

## chargeitemdefinition_search_bundled

</>

    pub fn chargeitemdefinition_search_bundled(
      sp: r4_sansio.SpChargeitemdefinition,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## chargeitemdefinition_update

</>

    pub fn chargeitemdefinition_update(
      resource: r4.Chargeitemdefinition,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Chargeitemdefinition, Err)

## claim_create

</>

    pub fn claim_create(
      resource: r4.Claim,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Claim, Err)

## claim_delete

</>

    pub fn claim_delete(
      resource: r4.Claim,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## claim_read

</>

    pub fn claim_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Claim, Err)

## claim_search

</>

    pub fn claim_search(
      sp: r4_sansio.SpClaim,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Claim), Err)

## claim_search_bundled

</>

    pub fn claim_search_bundled(
      sp: r4_sansio.SpClaim,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## claim_update

</>

    pub fn claim_update(
      resource: r4.Claim,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Claim, Err)

## claimresponse_create

</>

    pub fn claimresponse_create(
      resource: r4.Claimresponse,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Claimresponse, Err)

## claimresponse_delete

</>

    pub fn claimresponse_delete(
      resource: r4.Claimresponse,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## claimresponse_read

</>

    pub fn claimresponse_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Claimresponse, Err)

## claimresponse_search

</>

    pub fn claimresponse_search(
      sp: r4_sansio.SpClaimresponse,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Claimresponse), Err)

## claimresponse_search_bundled

</>

    pub fn claimresponse_search_bundled(
      sp: r4_sansio.SpClaimresponse,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## claimresponse_update

</>

    pub fn claimresponse_update(
      resource: r4.Claimresponse,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Claimresponse, Err)

## clinicalimpression_create

</>

    pub fn clinicalimpression_create(
      resource: r4.Clinicalimpression,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Clinicalimpression, Err)

## clinicalimpression_delete

</>

    pub fn clinicalimpression_delete(
      resource: r4.Clinicalimpression,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## clinicalimpression_read

</>

    pub fn clinicalimpression_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Clinicalimpression, Err)

## clinicalimpression_search

</>

    pub fn clinicalimpression_search(
      sp: r4_sansio.SpClinicalimpression,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Clinicalimpression), Err)

## clinicalimpression_search_bundled

</>

    pub fn clinicalimpression_search_bundled(
      sp: r4_sansio.SpClinicalimpression,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## clinicalimpression_update

</>

    pub fn clinicalimpression_update(
      resource: r4.Clinicalimpression,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Clinicalimpression, Err)

## codesystem_create

</>

    pub fn codesystem_create(
      resource: r4.Codesystem,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Codesystem, Err)

## codesystem_delete

</>

    pub fn codesystem_delete(
      resource: r4.Codesystem,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## codesystem_read

</>

    pub fn codesystem_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Codesystem, Err)

## codesystem_search

</>

    pub fn codesystem_search(
      sp: r4_sansio.SpCodesystem,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Codesystem), Err)

## codesystem_search_bundled

</>

    pub fn codesystem_search_bundled(
      sp: r4_sansio.SpCodesystem,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## codesystem_update

</>

    pub fn codesystem_update(
      resource: r4.Codesystem,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Codesystem, Err)

## communication_create

</>

    pub fn communication_create(
      resource: r4.Communication,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Communication, Err)

## communication_delete

</>

    pub fn communication_delete(
      resource: r4.Communication,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## communication_read

</>

    pub fn communication_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Communication, Err)

## communication_search

</>

    pub fn communication_search(
      sp: r4_sansio.SpCommunication,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Communication), Err)

## communication_search_bundled

</>

    pub fn communication_search_bundled(
      sp: r4_sansio.SpCommunication,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## communication_update

</>

    pub fn communication_update(
      resource: r4.Communication,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Communication, Err)

## communicationrequest_create

</>

    pub fn communicationrequest_create(
      resource: r4.Communicationrequest,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Communicationrequest, Err)

## communicationrequest_delete

</>

    pub fn communicationrequest_delete(
      resource: r4.Communicationrequest,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## communicationrequest_read

</>

    pub fn communicationrequest_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Communicationrequest, Err)

## communicationrequest_search

</>

    pub fn communicationrequest_search(
      sp: r4_sansio.SpCommunicationrequest,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Communicationrequest), Err)

## communicationrequest_search_bundled

</>

    pub fn communicationrequest_search_bundled(
      sp: r4_sansio.SpCommunicationrequest,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## communicationrequest_update

</>

    pub fn communicationrequest_update(
      resource: r4.Communicationrequest,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Communicationrequest, Err)

## compartmentdefinition_create

</>

    pub fn compartmentdefinition_create(
      resource: r4.Compartmentdefinition,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Compartmentdefinition, Err)

## compartmentdefinition_delete

</>

    pub fn compartmentdefinition_delete(
      resource: r4.Compartmentdefinition,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## compartmentdefinition_read

</>

    pub fn compartmentdefinition_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Compartmentdefinition, Err)

## compartmentdefinition_search

</>

    pub fn compartmentdefinition_search(
      sp: r4_sansio.SpCompartmentdefinition,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Compartmentdefinition), Err)

## compartmentdefinition_search_bundled

</>

    pub fn compartmentdefinition_search_bundled(
      sp: r4_sansio.SpCompartmentdefinition,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## compartmentdefinition_update

</>

    pub fn compartmentdefinition_update(
      resource: r4.Compartmentdefinition,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Compartmentdefinition, Err)

## composition_create

</>

    pub fn composition_create(
      resource: r4.Composition,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Composition, Err)

## composition_delete

</>

    pub fn composition_delete(
      resource: r4.Composition,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## composition_read

</>

    pub fn composition_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Composition, Err)

## composition_search

</>

    pub fn composition_search(
      sp: r4_sansio.SpComposition,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Composition), Err)

## composition_search_bundled

</>

    pub fn composition_search_bundled(
      sp: r4_sansio.SpComposition,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## composition_update

</>

    pub fn composition_update(
      resource: r4.Composition,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Composition, Err)

## conceptmap_create

</>

    pub fn conceptmap_create(
      resource: r4.Conceptmap,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Conceptmap, Err)

## conceptmap_delete

</>

    pub fn conceptmap_delete(
      resource: r4.Conceptmap,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## conceptmap_read

</>

    pub fn conceptmap_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Conceptmap, Err)

## conceptmap_search

</>

    pub fn conceptmap_search(
      sp: r4_sansio.SpConceptmap,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Conceptmap), Err)

## conceptmap_search_bundled

</>

    pub fn conceptmap_search_bundled(
      sp: r4_sansio.SpConceptmap,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## conceptmap_update

</>

    pub fn conceptmap_update(
      resource: r4.Conceptmap,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Conceptmap, Err)

## condition_create

</>

    pub fn condition_create(
      resource: r4.Condition,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Condition, Err)

## condition_delete

</>

    pub fn condition_delete(
      resource: r4.Condition,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## condition_read

</>

    pub fn condition_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Condition, Err)

## condition_search

</>

    pub fn condition_search(
      sp: r4_sansio.SpCondition,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Condition), Err)

## condition_search_bundled

</>

    pub fn condition_search_bundled(
      sp: r4_sansio.SpCondition,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## condition_update

</>

    pub fn condition_update(
      resource: r4.Condition,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Condition, Err)

## consent_create

</>

    pub fn consent_create(
      resource: r4.Consent,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Consent, Err)

## consent_delete

</>

    pub fn consent_delete(
      resource: r4.Consent,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## consent_read

</>

    pub fn consent_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Consent, Err)

## consent_search

</>

    pub fn consent_search(
      sp: r4_sansio.SpConsent,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Consent), Err)

## consent_search_bundled

</>

    pub fn consent_search_bundled(
      sp: r4_sansio.SpConsent,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## consent_update

</>

    pub fn consent_update(
      resource: r4.Consent,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Consent, Err)

## contract_create

</>

    pub fn contract_create(
      resource: r4.Contract,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Contract, Err)

## contract_delete

</>

    pub fn contract_delete(
      resource: r4.Contract,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## contract_read

</>

    pub fn contract_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Contract, Err)

## contract_search

</>

    pub fn contract_search(
      sp: r4_sansio.SpContract,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Contract), Err)

## contract_search_bundled

</>

    pub fn contract_search_bundled(
      sp: r4_sansio.SpContract,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## contract_update

</>

    pub fn contract_update(
      resource: r4.Contract,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Contract, Err)

## coverage_create

</>

    pub fn coverage_create(
      resource: r4.Coverage,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Coverage, Err)

## coverage_delete

</>

    pub fn coverage_delete(
      resource: r4.Coverage,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## coverage_read

</>

    pub fn coverage_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Coverage, Err)

## coverage_search

</>

    pub fn coverage_search(
      sp: r4_sansio.SpCoverage,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Coverage), Err)

## coverage_search_bundled

</>

    pub fn coverage_search_bundled(
      sp: r4_sansio.SpCoverage,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## coverage_update

</>

    pub fn coverage_update(
      resource: r4.Coverage,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Coverage, Err)

## coverageeligibilityrequest_create

</>

    pub fn coverageeligibilityrequest_create(
      resource: r4.Coverageeligibilityrequest,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Coverageeligibilityrequest, Err)

## coverageeligibilityrequest_delete

</>

    pub fn coverageeligibilityrequest_delete(
      resource: r4.Coverageeligibilityrequest,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## coverageeligibilityrequest_read

</>

    pub fn coverageeligibilityrequest_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Coverageeligibilityrequest, Err)

## coverageeligibilityrequest_search

</>

    pub fn coverageeligibilityrequest_search(
      sp: r4_sansio.SpCoverageeligibilityrequest,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Coverageeligibilityrequest), Err)

## coverageeligibilityrequest_search_bundled

</>

    pub fn coverageeligibilityrequest_search_bundled(
      sp: r4_sansio.SpCoverageeligibilityrequest,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## coverageeligibilityrequest_update

</>

    pub fn coverageeligibilityrequest_update(
      resource: r4.Coverageeligibilityrequest,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Coverageeligibilityrequest, Err)

## coverageeligibilityresponse_create

</>

    pub fn coverageeligibilityresponse_create(
      resource: r4.Coverageeligibilityresponse,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Coverageeligibilityresponse, Err)

## coverageeligibilityresponse_delete

</>

    pub fn coverageeligibilityresponse_delete(
      resource: r4.Coverageeligibilityresponse,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## coverageeligibilityresponse_read

</>

    pub fn coverageeligibilityresponse_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Coverageeligibilityresponse, Err)

## coverageeligibilityresponse_search

</>

    pub fn coverageeligibilityresponse_search(
      sp: r4_sansio.SpCoverageeligibilityresponse,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Coverageeligibilityresponse), Err)

## coverageeligibilityresponse_search_bundled

</>

    pub fn coverageeligibilityresponse_search_bundled(
      sp: r4_sansio.SpCoverageeligibilityresponse,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## coverageeligibilityresponse_update

</>

    pub fn coverageeligibilityresponse_update(
      resource: r4.Coverageeligibilityresponse,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Coverageeligibilityresponse, Err)

## detectedissue_create

</>

    pub fn detectedissue_create(
      resource: r4.Detectedissue,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Detectedissue, Err)

## detectedissue_delete

</>

    pub fn detectedissue_delete(
      resource: r4.Detectedissue,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## detectedissue_read

</>

    pub fn detectedissue_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Detectedissue, Err)

## detectedissue_search

</>

    pub fn detectedissue_search(
      sp: r4_sansio.SpDetectedissue,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Detectedissue), Err)

## detectedissue_search_bundled

</>

    pub fn detectedissue_search_bundled(
      sp: r4_sansio.SpDetectedissue,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## detectedissue_update

</>

    pub fn detectedissue_update(
      resource: r4.Detectedissue,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Detectedissue, Err)

## device_create

</>

    pub fn device_create(
      resource: r4.Device,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Device, Err)

## device_delete

</>

    pub fn device_delete(
      resource: r4.Device,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## device_read

</>

    pub fn device_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Device, Err)

## device_search

</>

    pub fn device_search(
      sp: r4_sansio.SpDevice,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Device), Err)

## device_search_bundled

</>

    pub fn device_search_bundled(
      sp: r4_sansio.SpDevice,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## device_update

</>

    pub fn device_update(
      resource: r4.Device,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Device, Err)

## devicedefinition_create

</>

    pub fn devicedefinition_create(
      resource: r4.Devicedefinition,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Devicedefinition, Err)

## devicedefinition_delete

</>

    pub fn devicedefinition_delete(
      resource: r4.Devicedefinition,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## devicedefinition_read

</>

    pub fn devicedefinition_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Devicedefinition, Err)

## devicedefinition_search

</>

    pub fn devicedefinition_search(
      sp: r4_sansio.SpDevicedefinition,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Devicedefinition), Err)

## devicedefinition_search_bundled

</>

    pub fn devicedefinition_search_bundled(
      sp: r4_sansio.SpDevicedefinition,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## devicedefinition_update

</>

    pub fn devicedefinition_update(
      resource: r4.Devicedefinition,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Devicedefinition, Err)

## devicemetric_create

</>

    pub fn devicemetric_create(
      resource: r4.Devicemetric,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Devicemetric, Err)

## devicemetric_delete

</>

    pub fn devicemetric_delete(
      resource: r4.Devicemetric,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## devicemetric_read

</>

    pub fn devicemetric_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Devicemetric, Err)

## devicemetric_search

</>

    pub fn devicemetric_search(
      sp: r4_sansio.SpDevicemetric,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Devicemetric), Err)

## devicemetric_search_bundled

</>

    pub fn devicemetric_search_bundled(
      sp: r4_sansio.SpDevicemetric,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## devicemetric_update

</>

    pub fn devicemetric_update(
      resource: r4.Devicemetric,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Devicemetric, Err)

## devicerequest_create

</>

    pub fn devicerequest_create(
      resource: r4.Devicerequest,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Devicerequest, Err)

## devicerequest_delete

</>

    pub fn devicerequest_delete(
      resource: r4.Devicerequest,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## devicerequest_read

</>

    pub fn devicerequest_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Devicerequest, Err)

## devicerequest_search

</>

    pub fn devicerequest_search(
      sp: r4_sansio.SpDevicerequest,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Devicerequest), Err)

## devicerequest_search_bundled

</>

    pub fn devicerequest_search_bundled(
      sp: r4_sansio.SpDevicerequest,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## devicerequest_update

</>

    pub fn devicerequest_update(
      resource: r4.Devicerequest,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Devicerequest, Err)

## deviceusestatement_create

</>

    pub fn deviceusestatement_create(
      resource: r4.Deviceusestatement,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Deviceusestatement, Err)

## deviceusestatement_delete

</>

    pub fn deviceusestatement_delete(
      resource: r4.Deviceusestatement,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## deviceusestatement_read

</>

    pub fn deviceusestatement_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Deviceusestatement, Err)

## deviceusestatement_search

</>

    pub fn deviceusestatement_search(
      sp: r4_sansio.SpDeviceusestatement,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Deviceusestatement), Err)

## deviceusestatement_search_bundled

</>

    pub fn deviceusestatement_search_bundled(
      sp: r4_sansio.SpDeviceusestatement,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## deviceusestatement_update

</>

    pub fn deviceusestatement_update(
      resource: r4.Deviceusestatement,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Deviceusestatement, Err)

## diagnosticreport_create

</>

    pub fn diagnosticreport_create(
      resource: r4.Diagnosticreport,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Diagnosticreport, Err)

## diagnosticreport_delete

</>

    pub fn diagnosticreport_delete(
      resource: r4.Diagnosticreport,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## diagnosticreport_read

</>

    pub fn diagnosticreport_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Diagnosticreport, Err)

## diagnosticreport_search

</>

    pub fn diagnosticreport_search(
      sp: r4_sansio.SpDiagnosticreport,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Diagnosticreport), Err)

## diagnosticreport_search_bundled

</>

    pub fn diagnosticreport_search_bundled(
      sp: r4_sansio.SpDiagnosticreport,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## diagnosticreport_update

</>

    pub fn diagnosticreport_update(
      resource: r4.Diagnosticreport,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Diagnosticreport, Err)

## documentmanifest_create

</>

    pub fn documentmanifest_create(
      resource: r4.Documentmanifest,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Documentmanifest, Err)

## documentmanifest_delete

</>

    pub fn documentmanifest_delete(
      resource: r4.Documentmanifest,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## documentmanifest_read

</>

    pub fn documentmanifest_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Documentmanifest, Err)

## documentmanifest_search

</>

    pub fn documentmanifest_search(
      sp: r4_sansio.SpDocumentmanifest,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Documentmanifest), Err)

## documentmanifest_search_bundled

</>

    pub fn documentmanifest_search_bundled(
      sp: r4_sansio.SpDocumentmanifest,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## documentmanifest_update

</>

    pub fn documentmanifest_update(
      resource: r4.Documentmanifest,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Documentmanifest, Err)

## documentreference_create

</>

    pub fn documentreference_create(
      resource: r4.Documentreference,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Documentreference, Err)

## documentreference_delete

</>

    pub fn documentreference_delete(
      resource: r4.Documentreference,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## documentreference_read

</>

    pub fn documentreference_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Documentreference, Err)

## documentreference_search

</>

    pub fn documentreference_search(
      sp: r4_sansio.SpDocumentreference,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Documentreference), Err)

## documentreference_search_bundled

</>

    pub fn documentreference_search_bundled(
      sp: r4_sansio.SpDocumentreference,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## documentreference_update

</>

    pub fn documentreference_update(
      resource: r4.Documentreference,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Documentreference, Err)

## effectevidencesynthesis_create

</>

    pub fn effectevidencesynthesis_create(
      resource: r4.Effectevidencesynthesis,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Effectevidencesynthesis, Err)

## effectevidencesynthesis_delete

</>

    pub fn effectevidencesynthesis_delete(
      resource: r4.Effectevidencesynthesis,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## effectevidencesynthesis_read

</>

    pub fn effectevidencesynthesis_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Effectevidencesynthesis, Err)

## effectevidencesynthesis_search

</>

    pub fn effectevidencesynthesis_search(
      sp: r4_sansio.SpEffectevidencesynthesis,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Effectevidencesynthesis), Err)

## effectevidencesynthesis_search_bundled

</>

    pub fn effectevidencesynthesis_search_bundled(
      sp: r4_sansio.SpEffectevidencesynthesis,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## effectevidencesynthesis_update

</>

    pub fn effectevidencesynthesis_update(
      resource: r4.Effectevidencesynthesis,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Effectevidencesynthesis, Err)

## encounter_create

</>

    pub fn encounter_create(
      resource: r4.Encounter,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Encounter, Err)

## encounter_delete

</>

    pub fn encounter_delete(
      resource: r4.Encounter,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## encounter_read

</>

    pub fn encounter_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Encounter, Err)

## encounter_search

</>

    pub fn encounter_search(
      sp: r4_sansio.SpEncounter,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Encounter), Err)

## encounter_search_bundled

</>

    pub fn encounter_search_bundled(
      sp: r4_sansio.SpEncounter,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## encounter_update

</>

    pub fn encounter_update(
      resource: r4.Encounter,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Encounter, Err)

## endpoint_create

</>

    pub fn endpoint_create(
      resource: r4.Endpoint,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Endpoint, Err)

## endpoint_delete

</>

    pub fn endpoint_delete(
      resource: r4.Endpoint,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## endpoint_read

</>

    pub fn endpoint_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Endpoint, Err)

## endpoint_search

</>

    pub fn endpoint_search(
      sp: r4_sansio.SpEndpoint,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Endpoint), Err)

## endpoint_search_bundled

</>

    pub fn endpoint_search_bundled(
      sp: r4_sansio.SpEndpoint,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## endpoint_update

</>

    pub fn endpoint_update(
      resource: r4.Endpoint,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Endpoint, Err)

## enrollmentrequest_create

</>

    pub fn enrollmentrequest_create(
      resource: r4.Enrollmentrequest,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Enrollmentrequest, Err)

## enrollmentrequest_delete

</>

    pub fn enrollmentrequest_delete(
      resource: r4.Enrollmentrequest,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## enrollmentrequest_read

</>

    pub fn enrollmentrequest_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Enrollmentrequest, Err)

## enrollmentrequest_search

</>

    pub fn enrollmentrequest_search(
      sp: r4_sansio.SpEnrollmentrequest,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Enrollmentrequest), Err)

## enrollmentrequest_search_bundled

</>

    pub fn enrollmentrequest_search_bundled(
      sp: r4_sansio.SpEnrollmentrequest,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## enrollmentrequest_update

</>

    pub fn enrollmentrequest_update(
      resource: r4.Enrollmentrequest,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Enrollmentrequest, Err)

## enrollmentresponse_create

</>

    pub fn enrollmentresponse_create(
      resource: r4.Enrollmentresponse,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Enrollmentresponse, Err)

## enrollmentresponse_delete

</>

    pub fn enrollmentresponse_delete(
      resource: r4.Enrollmentresponse,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## enrollmentresponse_read

</>

    pub fn enrollmentresponse_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Enrollmentresponse, Err)

## enrollmentresponse_search

</>

    pub fn enrollmentresponse_search(
      sp: r4_sansio.SpEnrollmentresponse,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Enrollmentresponse), Err)

## enrollmentresponse_search_bundled

</>

    pub fn enrollmentresponse_search_bundled(
      sp: r4_sansio.SpEnrollmentresponse,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## enrollmentresponse_update

</>

    pub fn enrollmentresponse_update(
      resource: r4.Enrollmentresponse,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Enrollmentresponse, Err)

## episodeofcare_create

</>

    pub fn episodeofcare_create(
      resource: r4.Episodeofcare,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Episodeofcare, Err)

## episodeofcare_delete

</>

    pub fn episodeofcare_delete(
      resource: r4.Episodeofcare,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## episodeofcare_read

</>

    pub fn episodeofcare_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Episodeofcare, Err)

## episodeofcare_search

</>

    pub fn episodeofcare_search(
      sp: r4_sansio.SpEpisodeofcare,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Episodeofcare), Err)

## episodeofcare_search_bundled

</>

    pub fn episodeofcare_search_bundled(
      sp: r4_sansio.SpEpisodeofcare,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## episodeofcare_update

</>

    pub fn episodeofcare_update(
      resource: r4.Episodeofcare,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Episodeofcare, Err)

## eventdefinition_create

</>

    pub fn eventdefinition_create(
      resource: r4.Eventdefinition,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Eventdefinition, Err)

## eventdefinition_delete

</>

    pub fn eventdefinition_delete(
      resource: r4.Eventdefinition,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## eventdefinition_read

</>

    pub fn eventdefinition_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Eventdefinition, Err)

## eventdefinition_search

</>

    pub fn eventdefinition_search(
      sp: r4_sansio.SpEventdefinition,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Eventdefinition), Err)

## eventdefinition_search_bundled

</>

    pub fn eventdefinition_search_bundled(
      sp: r4_sansio.SpEventdefinition,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## eventdefinition_update

</>

    pub fn eventdefinition_update(
      resource: r4.Eventdefinition,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Eventdefinition, Err)

## evidence_create

</>

    pub fn evidence_create(
      resource: r4.Evidence,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Evidence, Err)

## evidence_delete

</>

    pub fn evidence_delete(
      resource: r4.Evidence,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## evidence_read

</>

    pub fn evidence_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Evidence, Err)

## evidence_search

</>

    pub fn evidence_search(
      sp: r4_sansio.SpEvidence,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Evidence), Err)

## evidence_search_bundled

</>

    pub fn evidence_search_bundled(
      sp: r4_sansio.SpEvidence,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## evidence_update

</>

    pub fn evidence_update(
      resource: r4.Evidence,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Evidence, Err)

## evidencevariable_create

</>

    pub fn evidencevariable_create(
      resource: r4.Evidencevariable,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Evidencevariable, Err)

## evidencevariable_delete

</>

    pub fn evidencevariable_delete(
      resource: r4.Evidencevariable,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## evidencevariable_read

</>

    pub fn evidencevariable_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Evidencevariable, Err)

## evidencevariable_search

</>

    pub fn evidencevariable_search(
      sp: r4_sansio.SpEvidencevariable,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Evidencevariable), Err)

## evidencevariable_search_bundled

</>

    pub fn evidencevariable_search_bundled(
      sp: r4_sansio.SpEvidencevariable,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## evidencevariable_update

</>

    pub fn evidencevariable_update(
      resource: r4.Evidencevariable,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Evidencevariable, Err)

## examplescenario_create

</>

    pub fn examplescenario_create(
      resource: r4.Examplescenario,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Examplescenario, Err)

## examplescenario_delete

</>

    pub fn examplescenario_delete(
      resource: r4.Examplescenario,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## examplescenario_read

</>

    pub fn examplescenario_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Examplescenario, Err)

## examplescenario_search

</>

    pub fn examplescenario_search(
      sp: r4_sansio.SpExamplescenario,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Examplescenario), Err)

## examplescenario_search_bundled

</>

    pub fn examplescenario_search_bundled(
      sp: r4_sansio.SpExamplescenario,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## examplescenario_update

</>

    pub fn examplescenario_update(
      resource: r4.Examplescenario,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Examplescenario, Err)

## explanationofbenefit_create

</>

    pub fn explanationofbenefit_create(
      resource: r4.Explanationofbenefit,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Explanationofbenefit, Err)

## explanationofbenefit_delete

</>

    pub fn explanationofbenefit_delete(
      resource: r4.Explanationofbenefit,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## explanationofbenefit_read

</>

    pub fn explanationofbenefit_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Explanationofbenefit, Err)

## explanationofbenefit_search

</>

    pub fn explanationofbenefit_search(
      sp: r4_sansio.SpExplanationofbenefit,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Explanationofbenefit), Err)

## explanationofbenefit_search_bundled

</>

    pub fn explanationofbenefit_search_bundled(
      sp: r4_sansio.SpExplanationofbenefit,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## explanationofbenefit_update

</>

    pub fn explanationofbenefit_update(
      resource: r4.Explanationofbenefit,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Explanationofbenefit, Err)

## familymemberhistory_create

</>

    pub fn familymemberhistory_create(
      resource: r4.Familymemberhistory,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Familymemberhistory, Err)

## familymemberhistory_delete

</>

    pub fn familymemberhistory_delete(
      resource: r4.Familymemberhistory,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## familymemberhistory_read

</>

    pub fn familymemberhistory_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Familymemberhistory, Err)

## familymemberhistory_search

</>

    pub fn familymemberhistory_search(
      sp: r4_sansio.SpFamilymemberhistory,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Familymemberhistory), Err)

## familymemberhistory_search_bundled

</>

    pub fn familymemberhistory_search_bundled(
      sp: r4_sansio.SpFamilymemberhistory,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## familymemberhistory_update

</>

    pub fn familymemberhistory_update(
      resource: r4.Familymemberhistory,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Familymemberhistory, Err)

## fhirclient_new

</>

    pub fn fhirclient_new(baseurl: String) -> r4_sansio.FhirClient

## flag_create

</>

    pub fn flag_create(
      resource: r4.Flag,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Flag, Err)

## flag_delete

</>

    pub fn flag_delete(
      resource: r4.Flag,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## flag_read

</>

    pub fn flag_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Flag, Err)

## flag_search

</>

    pub fn flag_search(
      sp: r4_sansio.SpFlag,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Flag), Err)

## flag_search_bundled

</>

    pub fn flag_search_bundled(
      sp: r4_sansio.SpFlag,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## flag_update

</>

    pub fn flag_update(
      resource: r4.Flag,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Flag, Err)

## goal_create

</>

    pub fn goal_create(
      resource: r4.Goal,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Goal, Err)

## goal_delete

</>

    pub fn goal_delete(
      resource: r4.Goal,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## goal_read

</>

    pub fn goal_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Goal, Err)

## goal_search

</>

    pub fn goal_search(
      sp: r4_sansio.SpGoal,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Goal), Err)

## goal_search_bundled

</>

    pub fn goal_search_bundled(
      sp: r4_sansio.SpGoal,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## goal_update

</>

    pub fn goal_update(
      resource: r4.Goal,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Goal, Err)

## graphdefinition_create

</>

    pub fn graphdefinition_create(
      resource: r4.Graphdefinition,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Graphdefinition, Err)

## graphdefinition_delete

</>

    pub fn graphdefinition_delete(
      resource: r4.Graphdefinition,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## graphdefinition_read

</>

    pub fn graphdefinition_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Graphdefinition, Err)

## graphdefinition_search

</>

    pub fn graphdefinition_search(
      sp: r4_sansio.SpGraphdefinition,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Graphdefinition), Err)

## graphdefinition_search_bundled

</>

    pub fn graphdefinition_search_bundled(
      sp: r4_sansio.SpGraphdefinition,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## graphdefinition_update

</>

    pub fn graphdefinition_update(
      resource: r4.Graphdefinition,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Graphdefinition, Err)

## group_create

</>

    pub fn group_create(
      resource: r4.Group,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Group, Err)

## group_delete

</>

    pub fn group_delete(
      resource: r4.Group,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## group_read

</>

    pub fn group_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Group, Err)

## group_search

</>

    pub fn group_search(
      sp: r4_sansio.SpGroup,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Group), Err)

## group_search_bundled

</>

    pub fn group_search_bundled(
      sp: r4_sansio.SpGroup,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## group_update

</>

    pub fn group_update(
      resource: r4.Group,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Group, Err)

## guidanceresponse_create

</>

    pub fn guidanceresponse_create(
      resource: r4.Guidanceresponse,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Guidanceresponse, Err)

## guidanceresponse_delete

</>

    pub fn guidanceresponse_delete(
      resource: r4.Guidanceresponse,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## guidanceresponse_read

</>

    pub fn guidanceresponse_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Guidanceresponse, Err)

## guidanceresponse_search

</>

    pub fn guidanceresponse_search(
      sp: r4_sansio.SpGuidanceresponse,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Guidanceresponse), Err)

## guidanceresponse_search_bundled

</>

    pub fn guidanceresponse_search_bundled(
      sp: r4_sansio.SpGuidanceresponse,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## guidanceresponse_update

</>

    pub fn guidanceresponse_update(
      resource: r4.Guidanceresponse,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Guidanceresponse, Err)

## healthcareservice_create

</>

    pub fn healthcareservice_create(
      resource: r4.Healthcareservice,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Healthcareservice, Err)

## healthcareservice_delete

</>

    pub fn healthcareservice_delete(
      resource: r4.Healthcareservice,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## healthcareservice_read

</>

    pub fn healthcareservice_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Healthcareservice, Err)

## healthcareservice_search

</>

    pub fn healthcareservice_search(
      sp: r4_sansio.SpHealthcareservice,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Healthcareservice), Err)

## healthcareservice_search_bundled

</>

    pub fn healthcareservice_search_bundled(
      sp: r4_sansio.SpHealthcareservice,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## healthcareservice_update

</>

    pub fn healthcareservice_update(
      resource: r4.Healthcareservice,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Healthcareservice, Err)

## imagingstudy_create

</>

    pub fn imagingstudy_create(
      resource: r4.Imagingstudy,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Imagingstudy, Err)

## imagingstudy_delete

</>

    pub fn imagingstudy_delete(
      resource: r4.Imagingstudy,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## imagingstudy_read

</>

    pub fn imagingstudy_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Imagingstudy, Err)

## imagingstudy_search

</>

    pub fn imagingstudy_search(
      sp: r4_sansio.SpImagingstudy,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Imagingstudy), Err)

## imagingstudy_search_bundled

</>

    pub fn imagingstudy_search_bundled(
      sp: r4_sansio.SpImagingstudy,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## imagingstudy_update

</>

    pub fn imagingstudy_update(
      resource: r4.Imagingstudy,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Imagingstudy, Err)

## immunization_create

</>

    pub fn immunization_create(
      resource: r4.Immunization,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Immunization, Err)

## immunization_delete

</>

    pub fn immunization_delete(
      resource: r4.Immunization,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## immunization_read

</>

    pub fn immunization_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Immunization, Err)

## immunization_search

</>

    pub fn immunization_search(
      sp: r4_sansio.SpImmunization,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Immunization), Err)

## immunization_search_bundled

</>

    pub fn immunization_search_bundled(
      sp: r4_sansio.SpImmunization,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## immunization_update

</>

    pub fn immunization_update(
      resource: r4.Immunization,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Immunization, Err)

## immunizationevaluation_create

</>

    pub fn immunizationevaluation_create(
      resource: r4.Immunizationevaluation,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Immunizationevaluation, Err)

## immunizationevaluation_delete

</>

    pub fn immunizationevaluation_delete(
      resource: r4.Immunizationevaluation,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## immunizationevaluation_read

</>

    pub fn immunizationevaluation_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Immunizationevaluation, Err)

## immunizationevaluation_search

</>

    pub fn immunizationevaluation_search(
      sp: r4_sansio.SpImmunizationevaluation,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Immunizationevaluation), Err)

## immunizationevaluation_search_bundled

</>

    pub fn immunizationevaluation_search_bundled(
      sp: r4_sansio.SpImmunizationevaluation,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## immunizationevaluation_update

</>

    pub fn immunizationevaluation_update(
      resource: r4.Immunizationevaluation,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Immunizationevaluation, Err)

## immunizationrecommendation_create

</>

    pub fn immunizationrecommendation_create(
      resource: r4.Immunizationrecommendation,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Immunizationrecommendation, Err)

## immunizationrecommendation_delete

</>

    pub fn immunizationrecommendation_delete(
      resource: r4.Immunizationrecommendation,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## immunizationrecommendation_read

</>

    pub fn immunizationrecommendation_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Immunizationrecommendation, Err)

## immunizationrecommendation_search

</>

    pub fn immunizationrecommendation_search(
      sp: r4_sansio.SpImmunizationrecommendation,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Immunizationrecommendation), Err)

## immunizationrecommendation_search_bundled

</>

    pub fn immunizationrecommendation_search_bundled(
      sp: r4_sansio.SpImmunizationrecommendation,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## immunizationrecommendation_update

</>

    pub fn immunizationrecommendation_update(
      resource: r4.Immunizationrecommendation,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Immunizationrecommendation, Err)

## implementationguide_create

</>

    pub fn implementationguide_create(
      resource: r4.Implementationguide,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Implementationguide, Err)

## implementationguide_delete

</>

    pub fn implementationguide_delete(
      resource: r4.Implementationguide,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## implementationguide_read

</>

    pub fn implementationguide_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Implementationguide, Err)

## implementationguide_search

</>

    pub fn implementationguide_search(
      sp: r4_sansio.SpImplementationguide,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Implementationguide), Err)

## implementationguide_search_bundled

</>

    pub fn implementationguide_search_bundled(
      sp: r4_sansio.SpImplementationguide,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## implementationguide_update

</>

    pub fn implementationguide_update(
      resource: r4.Implementationguide,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Implementationguide, Err)

## insuranceplan_create

</>

    pub fn insuranceplan_create(
      resource: r4.Insuranceplan,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Insuranceplan, Err)

## insuranceplan_delete

</>

    pub fn insuranceplan_delete(
      resource: r4.Insuranceplan,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## insuranceplan_read

</>

    pub fn insuranceplan_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Insuranceplan, Err)

## insuranceplan_search

</>

    pub fn insuranceplan_search(
      sp: r4_sansio.SpInsuranceplan,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Insuranceplan), Err)

## insuranceplan_search_bundled

</>

    pub fn insuranceplan_search_bundled(
      sp: r4_sansio.SpInsuranceplan,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## insuranceplan_update

</>

    pub fn insuranceplan_update(
      resource: r4.Insuranceplan,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Insuranceplan, Err)

## invoice_create

</>

    pub fn invoice_create(
      resource: r4.Invoice,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Invoice, Err)

## invoice_delete

</>

    pub fn invoice_delete(
      resource: r4.Invoice,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## invoice_read

</>

    pub fn invoice_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Invoice, Err)

## invoice_search

</>

    pub fn invoice_search(
      sp: r4_sansio.SpInvoice,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Invoice), Err)

## invoice_search_bundled

</>

    pub fn invoice_search_bundled(
      sp: r4_sansio.SpInvoice,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## invoice_update

</>

    pub fn invoice_update(
      resource: r4.Invoice,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Invoice, Err)

## library_create

</>

    pub fn library_create(
      resource: r4.Library,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Library, Err)

## library_delete

</>

    pub fn library_delete(
      resource: r4.Library,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## library_read

</>

    pub fn library_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Library, Err)

## library_search

</>

    pub fn library_search(
      sp: r4_sansio.SpLibrary,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Library), Err)

## library_search_bundled

</>

    pub fn library_search_bundled(
      sp: r4_sansio.SpLibrary,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## library_update

</>

    pub fn library_update(
      resource: r4.Library,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Library, Err)

## linkage_create

</>

    pub fn linkage_create(
      resource: r4.Linkage,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Linkage, Err)

## linkage_delete

</>

    pub fn linkage_delete(
      resource: r4.Linkage,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## linkage_read

</>

    pub fn linkage_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Linkage, Err)

## linkage_search

</>

    pub fn linkage_search(
      sp: r4_sansio.SpLinkage,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Linkage), Err)

## linkage_search_bundled

</>

    pub fn linkage_search_bundled(
      sp: r4_sansio.SpLinkage,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## linkage_update

</>

    pub fn linkage_update(
      resource: r4.Linkage,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Linkage, Err)

## listfhir_create

</>

    pub fn listfhir_create(
      resource: r4.Listfhir,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Listfhir, Err)

## listfhir_delete

</>

    pub fn listfhir_delete(
      resource: r4.Listfhir,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## listfhir_read

</>

    pub fn listfhir_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Listfhir, Err)

## listfhir_search

</>

    pub fn listfhir_search(
      sp: r4_sansio.SpListfhir,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Listfhir), Err)

## listfhir_search_bundled

</>

    pub fn listfhir_search_bundled(
      sp: r4_sansio.SpListfhir,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## listfhir_update

</>

    pub fn listfhir_update(
      resource: r4.Listfhir,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Listfhir, Err)

## location_create

</>

    pub fn location_create(
      resource: r4.Location,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Location, Err)

## location_delete

</>

    pub fn location_delete(
      resource: r4.Location,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## location_read

</>

    pub fn location_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Location, Err)

## location_search

</>

    pub fn location_search(
      sp: r4_sansio.SpLocation,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Location), Err)

## location_search_bundled

</>

    pub fn location_search_bundled(
      sp: r4_sansio.SpLocation,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## location_update

</>

    pub fn location_update(
      resource: r4.Location,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Location, Err)

## measure_create

</>

    pub fn measure_create(
      resource: r4.Measure,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Measure, Err)

## measure_delete

</>

    pub fn measure_delete(
      resource: r4.Measure,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## measure_read

</>

    pub fn measure_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Measure, Err)

## measure_search

</>

    pub fn measure_search(
      sp: r4_sansio.SpMeasure,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Measure), Err)

## measure_search_bundled

</>

    pub fn measure_search_bundled(
      sp: r4_sansio.SpMeasure,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## measure_update

</>

    pub fn measure_update(
      resource: r4.Measure,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Measure, Err)

## measurereport_create

</>

    pub fn measurereport_create(
      resource: r4.Measurereport,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Measurereport, Err)

## measurereport_delete

</>

    pub fn measurereport_delete(
      resource: r4.Measurereport,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## measurereport_read

</>

    pub fn measurereport_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Measurereport, Err)

## measurereport_search

</>

    pub fn measurereport_search(
      sp: r4_sansio.SpMeasurereport,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Measurereport), Err)

## measurereport_search_bundled

</>

    pub fn measurereport_search_bundled(
      sp: r4_sansio.SpMeasurereport,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## measurereport_update

</>

    pub fn measurereport_update(
      resource: r4.Measurereport,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Measurereport, Err)

## media_create

</>

    pub fn media_create(
      resource: r4.Media,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Media, Err)

## media_delete

</>

    pub fn media_delete(
      resource: r4.Media,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## media_read

</>

    pub fn media_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Media, Err)

## media_search

</>

    pub fn media_search(
      sp: r4_sansio.SpMedia,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Media), Err)

## media_search_bundled

</>

    pub fn media_search_bundled(
      sp: r4_sansio.SpMedia,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## media_update

</>

    pub fn media_update(
      resource: r4.Media,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Media, Err)

## medication_create

</>

    pub fn medication_create(
      resource: r4.Medication,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Medication, Err)

## medication_delete

</>

    pub fn medication_delete(
      resource: r4.Medication,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## medication_read

</>

    pub fn medication_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Medication, Err)

## medication_search

</>

    pub fn medication_search(
      sp: r4_sansio.SpMedication,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Medication), Err)

## medication_search_bundled

</>

    pub fn medication_search_bundled(
      sp: r4_sansio.SpMedication,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## medication_update

</>

    pub fn medication_update(
      resource: r4.Medication,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Medication, Err)

## medicationadministration_create

</>

    pub fn medicationadministration_create(
      resource: r4.Medicationadministration,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Medicationadministration, Err)

## medicationadministration_delete

</>

    pub fn medicationadministration_delete(
      resource: r4.Medicationadministration,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## medicationadministration_read

</>

    pub fn medicationadministration_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Medicationadministration, Err)

## medicationadministration_search

</>

    pub fn medicationadministration_search(
      sp: r4_sansio.SpMedicationadministration,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Medicationadministration), Err)

## medicationadministration_search_bundled

</>

    pub fn medicationadministration_search_bundled(
      sp: r4_sansio.SpMedicationadministration,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## medicationadministration_update

</>

    pub fn medicationadministration_update(
      resource: r4.Medicationadministration,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Medicationadministration, Err)

## medicationdispense_create

</>

    pub fn medicationdispense_create(
      resource: r4.Medicationdispense,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Medicationdispense, Err)

## medicationdispense_delete

</>

    pub fn medicationdispense_delete(
      resource: r4.Medicationdispense,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## medicationdispense_read

</>

    pub fn medicationdispense_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Medicationdispense, Err)

## medicationdispense_search

</>

    pub fn medicationdispense_search(
      sp: r4_sansio.SpMedicationdispense,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Medicationdispense), Err)

## medicationdispense_search_bundled

</>

    pub fn medicationdispense_search_bundled(
      sp: r4_sansio.SpMedicationdispense,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## medicationdispense_update

</>

    pub fn medicationdispense_update(
      resource: r4.Medicationdispense,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Medicationdispense, Err)

## medicationknowledge_create

</>

    pub fn medicationknowledge_create(
      resource: r4.Medicationknowledge,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Medicationknowledge, Err)

## medicationknowledge_delete

</>

    pub fn medicationknowledge_delete(
      resource: r4.Medicationknowledge,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## medicationknowledge_read

</>

    pub fn medicationknowledge_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Medicationknowledge, Err)

## medicationknowledge_search

</>

    pub fn medicationknowledge_search(
      sp: r4_sansio.SpMedicationknowledge,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Medicationknowledge), Err)

## medicationknowledge_search_bundled

</>

    pub fn medicationknowledge_search_bundled(
      sp: r4_sansio.SpMedicationknowledge,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## medicationknowledge_update

</>

    pub fn medicationknowledge_update(
      resource: r4.Medicationknowledge,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Medicationknowledge, Err)

## medicationrequest_create

</>

    pub fn medicationrequest_create(
      resource: r4.Medicationrequest,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Medicationrequest, Err)

## medicationrequest_delete

</>

    pub fn medicationrequest_delete(
      resource: r4.Medicationrequest,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## medicationrequest_read

</>

    pub fn medicationrequest_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Medicationrequest, Err)

## medicationrequest_search

</>

    pub fn medicationrequest_search(
      sp: r4_sansio.SpMedicationrequest,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Medicationrequest), Err)

## medicationrequest_search_bundled

</>

    pub fn medicationrequest_search_bundled(
      sp: r4_sansio.SpMedicationrequest,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## medicationrequest_update

</>

    pub fn medicationrequest_update(
      resource: r4.Medicationrequest,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Medicationrequest, Err)

## medicationstatement_create

</>

    pub fn medicationstatement_create(
      resource: r4.Medicationstatement,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Medicationstatement, Err)

## medicationstatement_delete

</>

    pub fn medicationstatement_delete(
      resource: r4.Medicationstatement,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## medicationstatement_read

</>

    pub fn medicationstatement_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Medicationstatement, Err)

## medicationstatement_search

</>

    pub fn medicationstatement_search(
      sp: r4_sansio.SpMedicationstatement,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Medicationstatement), Err)

## medicationstatement_search_bundled

</>

    pub fn medicationstatement_search_bundled(
      sp: r4_sansio.SpMedicationstatement,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## medicationstatement_update

</>

    pub fn medicationstatement_update(
      resource: r4.Medicationstatement,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Medicationstatement, Err)

## medicinalproduct_create

</>

    pub fn medicinalproduct_create(
      resource: r4.Medicinalproduct,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Medicinalproduct, Err)

## medicinalproduct_delete

</>

    pub fn medicinalproduct_delete(
      resource: r4.Medicinalproduct,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## medicinalproduct_read

</>

    pub fn medicinalproduct_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Medicinalproduct, Err)

## medicinalproduct_search

</>

    pub fn medicinalproduct_search(
      sp: r4_sansio.SpMedicinalproduct,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Medicinalproduct), Err)

## medicinalproduct_search_bundled

</>

    pub fn medicinalproduct_search_bundled(
      sp: r4_sansio.SpMedicinalproduct,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## medicinalproduct_update

</>

    pub fn medicinalproduct_update(
      resource: r4.Medicinalproduct,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Medicinalproduct, Err)

## medicinalproductauthorization_create

</>

    pub fn medicinalproductauthorization_create(
      resource: r4.Medicinalproductauthorization,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Medicinalproductauthorization, Err)

## medicinalproductauthorization_delete

</>

    pub fn medicinalproductauthorization_delete(
      resource: r4.Medicinalproductauthorization,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## medicinalproductauthorization_read

</>

    pub fn medicinalproductauthorization_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Medicinalproductauthorization, Err)

## medicinalproductauthorization_search

</>

    pub fn medicinalproductauthorization_search(
      sp: r4_sansio.SpMedicinalproductauthorization,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Medicinalproductauthorization), Err)

## medicinalproductauthorization_search_bundled

</>

    pub fn medicinalproductauthorization_search_bundled(
      sp: r4_sansio.SpMedicinalproductauthorization,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## medicinalproductauthorization_update

</>

    pub fn medicinalproductauthorization_update(
      resource: r4.Medicinalproductauthorization,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Medicinalproductauthorization, Err)

## medicinalproductcontraindication_create

</>

    pub fn medicinalproductcontraindication_create(
      resource: r4.Medicinalproductcontraindication,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Medicinalproductcontraindication, Err)

## medicinalproductcontraindication_delete

</>

    pub fn medicinalproductcontraindication_delete(
      resource: r4.Medicinalproductcontraindication,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## medicinalproductcontraindication_read

</>

    pub fn medicinalproductcontraindication_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Medicinalproductcontraindication, Err)

## medicinalproductcontraindication_search

</>

    pub fn medicinalproductcontraindication_search(
      sp: r4_sansio.SpMedicinalproductcontraindication,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Medicinalproductcontraindication), Err)

## medicinalproductcontraindication_search_bundled

</>

    pub fn medicinalproductcontraindication_search_bundled(
      sp: r4_sansio.SpMedicinalproductcontraindication,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## medicinalproductcontraindication_update

</>

    pub fn medicinalproductcontraindication_update(
      resource: r4.Medicinalproductcontraindication,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Medicinalproductcontraindication, Err)

## medicinalproductindication_create

</>

    pub fn medicinalproductindication_create(
      resource: r4.Medicinalproductindication,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Medicinalproductindication, Err)

## medicinalproductindication_delete

</>

    pub fn medicinalproductindication_delete(
      resource: r4.Medicinalproductindication,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## medicinalproductindication_read

</>

    pub fn medicinalproductindication_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Medicinalproductindication, Err)

## medicinalproductindication_search

</>

    pub fn medicinalproductindication_search(
      sp: r4_sansio.SpMedicinalproductindication,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Medicinalproductindication), Err)

## medicinalproductindication_search_bundled

</>

    pub fn medicinalproductindication_search_bundled(
      sp: r4_sansio.SpMedicinalproductindication,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## medicinalproductindication_update

</>

    pub fn medicinalproductindication_update(
      resource: r4.Medicinalproductindication,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Medicinalproductindication, Err)

## medicinalproductingredient_create

</>

    pub fn medicinalproductingredient_create(
      resource: r4.Medicinalproductingredient,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Medicinalproductingredient, Err)

## medicinalproductingredient_delete

</>

    pub fn medicinalproductingredient_delete(
      resource: r4.Medicinalproductingredient,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## medicinalproductingredient_read

</>

    pub fn medicinalproductingredient_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Medicinalproductingredient, Err)

## medicinalproductingredient_search

</>

    pub fn medicinalproductingredient_search(
      sp: r4_sansio.SpMedicinalproductingredient,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Medicinalproductingredient), Err)

## medicinalproductingredient_search_bundled

</>

    pub fn medicinalproductingredient_search_bundled(
      sp: r4_sansio.SpMedicinalproductingredient,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## medicinalproductingredient_update

</>

    pub fn medicinalproductingredient_update(
      resource: r4.Medicinalproductingredient,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Medicinalproductingredient, Err)

## medicinalproductinteraction_create

</>

    pub fn medicinalproductinteraction_create(
      resource: r4.Medicinalproductinteraction,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Medicinalproductinteraction, Err)

## medicinalproductinteraction_delete

</>

    pub fn medicinalproductinteraction_delete(
      resource: r4.Medicinalproductinteraction,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## medicinalproductinteraction_read

</>

    pub fn medicinalproductinteraction_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Medicinalproductinteraction, Err)

## medicinalproductinteraction_search

</>

    pub fn medicinalproductinteraction_search(
      sp: r4_sansio.SpMedicinalproductinteraction,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Medicinalproductinteraction), Err)

## medicinalproductinteraction_search_bundled

</>

    pub fn medicinalproductinteraction_search_bundled(
      sp: r4_sansio.SpMedicinalproductinteraction,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## medicinalproductinteraction_update

</>

    pub fn medicinalproductinteraction_update(
      resource: r4.Medicinalproductinteraction,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Medicinalproductinteraction, Err)

## medicinalproductmanufactured_create

</>

    pub fn medicinalproductmanufactured_create(
      resource: r4.Medicinalproductmanufactured,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Medicinalproductmanufactured, Err)

## medicinalproductmanufactured_delete

</>

    pub fn medicinalproductmanufactured_delete(
      resource: r4.Medicinalproductmanufactured,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## medicinalproductmanufactured_read

</>

    pub fn medicinalproductmanufactured_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Medicinalproductmanufactured, Err)

## medicinalproductmanufactured_search

</>

    pub fn medicinalproductmanufactured_search(
      sp: r4_sansio.SpMedicinalproductmanufactured,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Medicinalproductmanufactured), Err)

## medicinalproductmanufactured_search_bundled

</>

    pub fn medicinalproductmanufactured_search_bundled(
      sp: r4_sansio.SpMedicinalproductmanufactured,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## medicinalproductmanufactured_update

</>

    pub fn medicinalproductmanufactured_update(
      resource: r4.Medicinalproductmanufactured,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Medicinalproductmanufactured, Err)

## medicinalproductpackaged_create

</>

    pub fn medicinalproductpackaged_create(
      resource: r4.Medicinalproductpackaged,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Medicinalproductpackaged, Err)

## medicinalproductpackaged_delete

</>

    pub fn medicinalproductpackaged_delete(
      resource: r4.Medicinalproductpackaged,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## medicinalproductpackaged_read

</>

    pub fn medicinalproductpackaged_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Medicinalproductpackaged, Err)

## medicinalproductpackaged_search

</>

    pub fn medicinalproductpackaged_search(
      sp: r4_sansio.SpMedicinalproductpackaged,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Medicinalproductpackaged), Err)

## medicinalproductpackaged_search_bundled

</>

    pub fn medicinalproductpackaged_search_bundled(
      sp: r4_sansio.SpMedicinalproductpackaged,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## medicinalproductpackaged_update

</>

    pub fn medicinalproductpackaged_update(
      resource: r4.Medicinalproductpackaged,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Medicinalproductpackaged, Err)

## medicinalproductpharmaceutical_create

</>

    pub fn medicinalproductpharmaceutical_create(
      resource: r4.Medicinalproductpharmaceutical,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Medicinalproductpharmaceutical, Err)

## medicinalproductpharmaceutical_delete

</>

    pub fn medicinalproductpharmaceutical_delete(
      resource: r4.Medicinalproductpharmaceutical,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## medicinalproductpharmaceutical_read

</>

    pub fn medicinalproductpharmaceutical_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Medicinalproductpharmaceutical, Err)

## medicinalproductpharmaceutical_search

</>

    pub fn medicinalproductpharmaceutical_search(
      sp: r4_sansio.SpMedicinalproductpharmaceutical,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Medicinalproductpharmaceutical), Err)

## medicinalproductpharmaceutical_search_bundled

</>

    pub fn medicinalproductpharmaceutical_search_bundled(
      sp: r4_sansio.SpMedicinalproductpharmaceutical,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## medicinalproductpharmaceutical_update

</>

    pub fn medicinalproductpharmaceutical_update(
      resource: r4.Medicinalproductpharmaceutical,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Medicinalproductpharmaceutical, Err)

## medicinalproductundesirableeffect_create

</>

    pub fn medicinalproductundesirableeffect_create(
      resource: r4.Medicinalproductundesirableeffect,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Medicinalproductundesirableeffect, Err)

## medicinalproductundesirableeffect_delete

</>

    pub fn medicinalproductundesirableeffect_delete(
      resource: r4.Medicinalproductundesirableeffect,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## medicinalproductundesirableeffect_read

</>

    pub fn medicinalproductundesirableeffect_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Medicinalproductundesirableeffect, Err)

## medicinalproductundesirableeffect_search

</>

    pub fn medicinalproductundesirableeffect_search(
      sp: r4_sansio.SpMedicinalproductundesirableeffect,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Medicinalproductundesirableeffect), Err)

## medicinalproductundesirableeffect_search_bundled

</>

    pub fn medicinalproductundesirableeffect_search_bundled(
      sp: r4_sansio.SpMedicinalproductundesirableeffect,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## medicinalproductundesirableeffect_update

</>

    pub fn medicinalproductundesirableeffect_update(
      resource: r4.Medicinalproductundesirableeffect,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Medicinalproductundesirableeffect, Err)

## messagedefinition_create

</>

    pub fn messagedefinition_create(
      resource: r4.Messagedefinition,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Messagedefinition, Err)

## messagedefinition_delete

</>

    pub fn messagedefinition_delete(
      resource: r4.Messagedefinition,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## messagedefinition_read

</>

    pub fn messagedefinition_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Messagedefinition, Err)

## messagedefinition_search

</>

    pub fn messagedefinition_search(
      sp: r4_sansio.SpMessagedefinition,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Messagedefinition), Err)

## messagedefinition_search_bundled

</>

    pub fn messagedefinition_search_bundled(
      sp: r4_sansio.SpMessagedefinition,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## messagedefinition_update

</>

    pub fn messagedefinition_update(
      resource: r4.Messagedefinition,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Messagedefinition, Err)

## messageheader_create

</>

    pub fn messageheader_create(
      resource: r4.Messageheader,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Messageheader, Err)

## messageheader_delete

</>

    pub fn messageheader_delete(
      resource: r4.Messageheader,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## messageheader_read

</>

    pub fn messageheader_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Messageheader, Err)

## messageheader_search

</>

    pub fn messageheader_search(
      sp: r4_sansio.SpMessageheader,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Messageheader), Err)

## messageheader_search_bundled

</>

    pub fn messageheader_search_bundled(
      sp: r4_sansio.SpMessageheader,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## messageheader_update

</>

    pub fn messageheader_update(
      resource: r4.Messageheader,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Messageheader, Err)

## molecularsequence_create

</>

    pub fn molecularsequence_create(
      resource: r4.Molecularsequence,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Molecularsequence, Err)

## molecularsequence_delete

</>

    pub fn molecularsequence_delete(
      resource: r4.Molecularsequence,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## molecularsequence_read

</>

    pub fn molecularsequence_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Molecularsequence, Err)

## molecularsequence_search

</>

    pub fn molecularsequence_search(
      sp: r4_sansio.SpMolecularsequence,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Molecularsequence), Err)

## molecularsequence_search_bundled

</>

    pub fn molecularsequence_search_bundled(
      sp: r4_sansio.SpMolecularsequence,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## molecularsequence_update

</>

    pub fn molecularsequence_update(
      resource: r4.Molecularsequence,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Molecularsequence, Err)

## namingsystem_create

</>

    pub fn namingsystem_create(
      resource: r4.Namingsystem,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Namingsystem, Err)

## namingsystem_delete

</>

    pub fn namingsystem_delete(
      resource: r4.Namingsystem,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## namingsystem_read

</>

    pub fn namingsystem_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Namingsystem, Err)

## namingsystem_search

</>

    pub fn namingsystem_search(
      sp: r4_sansio.SpNamingsystem,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Namingsystem), Err)

## namingsystem_search_bundled

</>

    pub fn namingsystem_search_bundled(
      sp: r4_sansio.SpNamingsystem,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## namingsystem_update

</>

    pub fn namingsystem_update(
      resource: r4.Namingsystem,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Namingsystem, Err)

## nutritionorder_create

</>

    pub fn nutritionorder_create(
      resource: r4.Nutritionorder,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Nutritionorder, Err)

## nutritionorder_delete

</>

    pub fn nutritionorder_delete(
      resource: r4.Nutritionorder,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## nutritionorder_read

</>

    pub fn nutritionorder_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Nutritionorder, Err)

## nutritionorder_search

</>

    pub fn nutritionorder_search(
      sp: r4_sansio.SpNutritionorder,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Nutritionorder), Err)

## nutritionorder_search_bundled

</>

    pub fn nutritionorder_search_bundled(
      sp: r4_sansio.SpNutritionorder,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## nutritionorder_update

</>

    pub fn nutritionorder_update(
      resource: r4.Nutritionorder,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Nutritionorder, Err)

## observation_create

</>

    pub fn observation_create(
      resource: r4.Observation,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Observation, Err)

## observation_delete

</>

    pub fn observation_delete(
      resource: r4.Observation,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## observation_read

</>

    pub fn observation_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Observation, Err)

## observation_search

</>

    pub fn observation_search(
      sp: r4_sansio.SpObservation,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Observation), Err)

## observation_search_bundled

</>

    pub fn observation_search_bundled(
      sp: r4_sansio.SpObservation,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## observation_update

</>

    pub fn observation_update(
      resource: r4.Observation,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Observation, Err)

## observationdefinition_create

</>

    pub fn observationdefinition_create(
      resource: r4.Observationdefinition,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Observationdefinition, Err)

## observationdefinition_delete

</>

    pub fn observationdefinition_delete(
      resource: r4.Observationdefinition,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## observationdefinition_read

</>

    pub fn observationdefinition_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Observationdefinition, Err)

## observationdefinition_search

</>

    pub fn observationdefinition_search(
      sp: r4_sansio.SpObservationdefinition,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Observationdefinition), Err)

## observationdefinition_search_bundled

</>

    pub fn observationdefinition_search_bundled(
      sp: r4_sansio.SpObservationdefinition,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## observationdefinition_update

</>

    pub fn observationdefinition_update(
      resource: r4.Observationdefinition,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Observationdefinition, Err)

## operationdefinition_create

</>

    pub fn operationdefinition_create(
      resource: r4.Operationdefinition,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationdefinition, Err)

## operationdefinition_delete

</>

    pub fn operationdefinition_delete(
      resource: r4.Operationdefinition,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## operationdefinition_read

</>

    pub fn operationdefinition_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationdefinition, Err)

## operationdefinition_search

</>

    pub fn operationdefinition_search(
      sp: r4_sansio.SpOperationdefinition,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Operationdefinition), Err)

## operationdefinition_search_bundled

</>

    pub fn operationdefinition_search_bundled(
      sp: r4_sansio.SpOperationdefinition,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## operationdefinition_update

</>

    pub fn operationdefinition_update(
      resource: r4.Operationdefinition,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationdefinition, Err)

## operationoutcome_create

</>

    pub fn operationoutcome_create(
      resource: r4.Operationoutcome,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## operationoutcome_delete

</>

    pub fn operationoutcome_delete(
      resource: r4.Operationoutcome,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## operationoutcome_read

</>

    pub fn operationoutcome_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## operationoutcome_search

</>

    pub fn operationoutcome_search(
      sp: r4_sansio.SpOperationoutcome,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Operationoutcome), Err)

## operationoutcome_search_bundled

</>

    pub fn operationoutcome_search_bundled(
      sp: r4_sansio.SpOperationoutcome,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## operationoutcome_update

</>

    pub fn operationoutcome_update(
      resource: r4.Operationoutcome,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## organization_create

</>

    pub fn organization_create(
      resource: r4.Organization,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Organization, Err)

## organization_delete

</>

    pub fn organization_delete(
      resource: r4.Organization,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## organization_read

</>

    pub fn organization_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Organization, Err)

## organization_search

</>

    pub fn organization_search(
      sp: r4_sansio.SpOrganization,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Organization), Err)

## organization_search_bundled

</>

    pub fn organization_search_bundled(
      sp: r4_sansio.SpOrganization,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## organization_update

</>

    pub fn organization_update(
      resource: r4.Organization,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Organization, Err)

## organizationaffiliation_create

</>

    pub fn organizationaffiliation_create(
      resource: r4.Organizationaffiliation,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Organizationaffiliation, Err)

## organizationaffiliation_delete

</>

    pub fn organizationaffiliation_delete(
      resource: r4.Organizationaffiliation,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## organizationaffiliation_read

</>

    pub fn organizationaffiliation_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Organizationaffiliation, Err)

## organizationaffiliation_search

</>

    pub fn organizationaffiliation_search(
      sp: r4_sansio.SpOrganizationaffiliation,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Organizationaffiliation), Err)

## organizationaffiliation_search_bundled

</>

    pub fn organizationaffiliation_search_bundled(
      sp: r4_sansio.SpOrganizationaffiliation,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## organizationaffiliation_update

</>

    pub fn organizationaffiliation_update(
      resource: r4.Organizationaffiliation,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Organizationaffiliation, Err)

## patient_create

</>

    pub fn patient_create(
      resource: r4.Patient,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Patient, Err)

## patient_delete

</>

    pub fn patient_delete(
      resource: r4.Patient,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## patient_read

</>

    pub fn patient_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Patient, Err)

## patient_search

</>

    pub fn patient_search(
      sp: r4_sansio.SpPatient,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Patient), Err)

## patient_search_bundled

</>

    pub fn patient_search_bundled(
      sp: r4_sansio.SpPatient,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## patient_update

</>

    pub fn patient_update(
      resource: r4.Patient,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Patient, Err)

## paymentnotice_create

</>

    pub fn paymentnotice_create(
      resource: r4.Paymentnotice,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Paymentnotice, Err)

## paymentnotice_delete

</>

    pub fn paymentnotice_delete(
      resource: r4.Paymentnotice,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## paymentnotice_read

</>

    pub fn paymentnotice_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Paymentnotice, Err)

## paymentnotice_search

</>

    pub fn paymentnotice_search(
      sp: r4_sansio.SpPaymentnotice,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Paymentnotice), Err)

## paymentnotice_search_bundled

</>

    pub fn paymentnotice_search_bundled(
      sp: r4_sansio.SpPaymentnotice,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## paymentnotice_update

</>

    pub fn paymentnotice_update(
      resource: r4.Paymentnotice,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Paymentnotice, Err)

## paymentreconciliation_create

</>

    pub fn paymentreconciliation_create(
      resource: r4.Paymentreconciliation,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Paymentreconciliation, Err)

## paymentreconciliation_delete

</>

    pub fn paymentreconciliation_delete(
      resource: r4.Paymentreconciliation,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## paymentreconciliation_read

</>

    pub fn paymentreconciliation_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Paymentreconciliation, Err)

## paymentreconciliation_search

</>

    pub fn paymentreconciliation_search(
      sp: r4_sansio.SpPaymentreconciliation,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Paymentreconciliation), Err)

## paymentreconciliation_search_bundled

</>

    pub fn paymentreconciliation_search_bundled(
      sp: r4_sansio.SpPaymentreconciliation,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## paymentreconciliation_update

</>

    pub fn paymentreconciliation_update(
      resource: r4.Paymentreconciliation,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Paymentreconciliation, Err)

## person_create

</>

    pub fn person_create(
      resource: r4.Person,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Person, Err)

## person_delete

</>

    pub fn person_delete(
      resource: r4.Person,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## person_read

</>

    pub fn person_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Person, Err)

## person_search

</>

    pub fn person_search(
      sp: r4_sansio.SpPerson,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Person), Err)

## person_search_bundled

</>

    pub fn person_search_bundled(
      sp: r4_sansio.SpPerson,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## person_update

</>

    pub fn person_update(
      resource: r4.Person,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Person, Err)

## plandefinition_create

</>

    pub fn plandefinition_create(
      resource: r4.Plandefinition,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Plandefinition, Err)

## plandefinition_delete

</>

    pub fn plandefinition_delete(
      resource: r4.Plandefinition,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## plandefinition_read

</>

    pub fn plandefinition_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Plandefinition, Err)

## plandefinition_search

</>

    pub fn plandefinition_search(
      sp: r4_sansio.SpPlandefinition,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Plandefinition), Err)

## plandefinition_search_bundled

</>

    pub fn plandefinition_search_bundled(
      sp: r4_sansio.SpPlandefinition,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## plandefinition_update

</>

    pub fn plandefinition_update(
      resource: r4.Plandefinition,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Plandefinition, Err)

## practitioner_create

</>

    pub fn practitioner_create(
      resource: r4.Practitioner,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Practitioner, Err)

## practitioner_delete

</>

    pub fn practitioner_delete(
      resource: r4.Practitioner,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## practitioner_read

</>

    pub fn practitioner_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Practitioner, Err)

## practitioner_search

</>

    pub fn practitioner_search(
      sp: r4_sansio.SpPractitioner,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Practitioner), Err)

## practitioner_search_bundled

</>

    pub fn practitioner_search_bundled(
      sp: r4_sansio.SpPractitioner,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## practitioner_update

</>

    pub fn practitioner_update(
      resource: r4.Practitioner,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Practitioner, Err)

## practitionerrole_create

</>

    pub fn practitionerrole_create(
      resource: r4.Practitionerrole,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Practitionerrole, Err)

## practitionerrole_delete

</>

    pub fn practitionerrole_delete(
      resource: r4.Practitionerrole,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## practitionerrole_read

</>

    pub fn practitionerrole_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Practitionerrole, Err)

## practitionerrole_search

</>

    pub fn practitionerrole_search(
      sp: r4_sansio.SpPractitionerrole,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Practitionerrole), Err)

## practitionerrole_search_bundled

</>

    pub fn practitionerrole_search_bundled(
      sp: r4_sansio.SpPractitionerrole,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## practitionerrole_update

</>

    pub fn practitionerrole_update(
      resource: r4.Practitionerrole,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Practitionerrole, Err)

## procedure_create

</>

    pub fn procedure_create(
      resource: r4.Procedure,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Procedure, Err)

## procedure_delete

</>

    pub fn procedure_delete(
      resource: r4.Procedure,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## procedure_read

</>

    pub fn procedure_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Procedure, Err)

## procedure_search

</>

    pub fn procedure_search(
      sp: r4_sansio.SpProcedure,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Procedure), Err)

## procedure_search_bundled

</>

    pub fn procedure_search_bundled(
      sp: r4_sansio.SpProcedure,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## procedure_update

</>

    pub fn procedure_update(
      resource: r4.Procedure,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Procedure, Err)

## provenance_create

</>

    pub fn provenance_create(
      resource: r4.Provenance,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Provenance, Err)

## provenance_delete

</>

    pub fn provenance_delete(
      resource: r4.Provenance,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## provenance_read

</>

    pub fn provenance_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Provenance, Err)

## provenance_search

</>

    pub fn provenance_search(
      sp: r4_sansio.SpProvenance,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Provenance), Err)

## provenance_search_bundled

</>

    pub fn provenance_search_bundled(
      sp: r4_sansio.SpProvenance,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## provenance_update

</>

    pub fn provenance_update(
      resource: r4.Provenance,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Provenance, Err)

## questionnaire_create

</>

    pub fn questionnaire_create(
      resource: r4.Questionnaire,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Questionnaire, Err)

## questionnaire_delete

</>

    pub fn questionnaire_delete(
      resource: r4.Questionnaire,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## questionnaire_read

</>

    pub fn questionnaire_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Questionnaire, Err)

## questionnaire_search

</>

    pub fn questionnaire_search(
      sp: r4_sansio.SpQuestionnaire,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Questionnaire), Err)

## questionnaire_search_bundled

</>

    pub fn questionnaire_search_bundled(
      sp: r4_sansio.SpQuestionnaire,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## questionnaire_update

</>

    pub fn questionnaire_update(
      resource: r4.Questionnaire,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Questionnaire, Err)

## questionnaireresponse_create

</>

    pub fn questionnaireresponse_create(
      resource: r4.Questionnaireresponse,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Questionnaireresponse, Err)

## questionnaireresponse_delete

</>

    pub fn questionnaireresponse_delete(
      resource: r4.Questionnaireresponse,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## questionnaireresponse_read

</>

    pub fn questionnaireresponse_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Questionnaireresponse, Err)

## questionnaireresponse_search

</>

    pub fn questionnaireresponse_search(
      sp: r4_sansio.SpQuestionnaireresponse,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Questionnaireresponse), Err)

## questionnaireresponse_search_bundled

</>

    pub fn questionnaireresponse_search_bundled(
      sp: r4_sansio.SpQuestionnaireresponse,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## questionnaireresponse_update

</>

    pub fn questionnaireresponse_update(
      resource: r4.Questionnaireresponse,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Questionnaireresponse, Err)

## relatedperson_create

</>

    pub fn relatedperson_create(
      resource: r4.Relatedperson,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Relatedperson, Err)

## relatedperson_delete

</>

    pub fn relatedperson_delete(
      resource: r4.Relatedperson,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## relatedperson_read

</>

    pub fn relatedperson_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Relatedperson, Err)

## relatedperson_search

</>

    pub fn relatedperson_search(
      sp: r4_sansio.SpRelatedperson,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Relatedperson), Err)

## relatedperson_search_bundled

</>

    pub fn relatedperson_search_bundled(
      sp: r4_sansio.SpRelatedperson,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## relatedperson_update

</>

    pub fn relatedperson_update(
      resource: r4.Relatedperson,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Relatedperson, Err)

## requestgroup_create

</>

    pub fn requestgroup_create(
      resource: r4.Requestgroup,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Requestgroup, Err)

## requestgroup_delete

</>

    pub fn requestgroup_delete(
      resource: r4.Requestgroup,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## requestgroup_read

</>

    pub fn requestgroup_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Requestgroup, Err)

## requestgroup_search

</>

    pub fn requestgroup_search(
      sp: r4_sansio.SpRequestgroup,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Requestgroup), Err)

## requestgroup_search_bundled

</>

    pub fn requestgroup_search_bundled(
      sp: r4_sansio.SpRequestgroup,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## requestgroup_update

</>

    pub fn requestgroup_update(
      resource: r4.Requestgroup,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Requestgroup, Err)

## researchdefinition_create

</>

    pub fn researchdefinition_create(
      resource: r4.Researchdefinition,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Researchdefinition, Err)

## researchdefinition_delete

</>

    pub fn researchdefinition_delete(
      resource: r4.Researchdefinition,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## researchdefinition_read

</>

    pub fn researchdefinition_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Researchdefinition, Err)

## researchdefinition_search

</>

    pub fn researchdefinition_search(
      sp: r4_sansio.SpResearchdefinition,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Researchdefinition), Err)

## researchdefinition_search_bundled

</>

    pub fn researchdefinition_search_bundled(
      sp: r4_sansio.SpResearchdefinition,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## researchdefinition_update

</>

    pub fn researchdefinition_update(
      resource: r4.Researchdefinition,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Researchdefinition, Err)

## researchelementdefinition_create

</>

    pub fn researchelementdefinition_create(
      resource: r4.Researchelementdefinition,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Researchelementdefinition, Err)

## researchelementdefinition_delete

</>

    pub fn researchelementdefinition_delete(
      resource: r4.Researchelementdefinition,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## researchelementdefinition_read

</>

    pub fn researchelementdefinition_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Researchelementdefinition, Err)

## researchelementdefinition_search

</>

    pub fn researchelementdefinition_search(
      sp: r4_sansio.SpResearchelementdefinition,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Researchelementdefinition), Err)

## researchelementdefinition_search_bundled

</>

    pub fn researchelementdefinition_search_bundled(
      sp: r4_sansio.SpResearchelementdefinition,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## researchelementdefinition_update

</>

    pub fn researchelementdefinition_update(
      resource: r4.Researchelementdefinition,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Researchelementdefinition, Err)

## researchstudy_create

</>

    pub fn researchstudy_create(
      resource: r4.Researchstudy,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Researchstudy, Err)

## researchstudy_delete

</>

    pub fn researchstudy_delete(
      resource: r4.Researchstudy,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## researchstudy_read

</>

    pub fn researchstudy_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Researchstudy, Err)

## researchstudy_search

</>

    pub fn researchstudy_search(
      sp: r4_sansio.SpResearchstudy,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Researchstudy), Err)

## researchstudy_search_bundled

</>

    pub fn researchstudy_search_bundled(
      sp: r4_sansio.SpResearchstudy,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## researchstudy_update

</>

    pub fn researchstudy_update(
      resource: r4.Researchstudy,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Researchstudy, Err)

## researchsubject_create

</>

    pub fn researchsubject_create(
      resource: r4.Researchsubject,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Researchsubject, Err)

## researchsubject_delete

</>

    pub fn researchsubject_delete(
      resource: r4.Researchsubject,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## researchsubject_read

</>

    pub fn researchsubject_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Researchsubject, Err)

## researchsubject_search

</>

    pub fn researchsubject_search(
      sp: r4_sansio.SpResearchsubject,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Researchsubject), Err)

## researchsubject_search_bundled

</>

    pub fn researchsubject_search_bundled(
      sp: r4_sansio.SpResearchsubject,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## researchsubject_update

</>

    pub fn researchsubject_update(
      resource: r4.Researchsubject,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Researchsubject, Err)

## riskassessment_create

</>

    pub fn riskassessment_create(
      resource: r4.Riskassessment,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Riskassessment, Err)

## riskassessment_delete

</>

    pub fn riskassessment_delete(
      resource: r4.Riskassessment,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## riskassessment_read

</>

    pub fn riskassessment_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Riskassessment, Err)

## riskassessment_search

</>

    pub fn riskassessment_search(
      sp: r4_sansio.SpRiskassessment,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Riskassessment), Err)

## riskassessment_search_bundled

</>

    pub fn riskassessment_search_bundled(
      sp: r4_sansio.SpRiskassessment,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## riskassessment_update

</>

    pub fn riskassessment_update(
      resource: r4.Riskassessment,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Riskassessment, Err)

## riskevidencesynthesis_create

</>

    pub fn riskevidencesynthesis_create(
      resource: r4.Riskevidencesynthesis,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Riskevidencesynthesis, Err)

## riskevidencesynthesis_delete

</>

    pub fn riskevidencesynthesis_delete(
      resource: r4.Riskevidencesynthesis,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## riskevidencesynthesis_read

</>

    pub fn riskevidencesynthesis_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Riskevidencesynthesis, Err)

## riskevidencesynthesis_search

</>

    pub fn riskevidencesynthesis_search(
      sp: r4_sansio.SpRiskevidencesynthesis,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Riskevidencesynthesis), Err)

## riskevidencesynthesis_search_bundled

</>

    pub fn riskevidencesynthesis_search_bundled(
      sp: r4_sansio.SpRiskevidencesynthesis,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## riskevidencesynthesis_update

</>

    pub fn riskevidencesynthesis_update(
      resource: r4.Riskevidencesynthesis,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Riskevidencesynthesis, Err)

## schedule_create

</>

    pub fn schedule_create(
      resource: r4.Schedule,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Schedule, Err)

## schedule_delete

</>

    pub fn schedule_delete(
      resource: r4.Schedule,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## schedule_read

</>

    pub fn schedule_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Schedule, Err)

## schedule_search

</>

    pub fn schedule_search(
      sp: r4_sansio.SpSchedule,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Schedule), Err)

## schedule_search_bundled

</>

    pub fn schedule_search_bundled(
      sp: r4_sansio.SpSchedule,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## schedule_update

</>

    pub fn schedule_update(
      resource: r4.Schedule,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Schedule, Err)

## searchparameter_create

</>

    pub fn searchparameter_create(
      resource: r4.Searchparameter,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Searchparameter, Err)

## searchparameter_delete

</>

    pub fn searchparameter_delete(
      resource: r4.Searchparameter,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## searchparameter_read

</>

    pub fn searchparameter_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Searchparameter, Err)

## searchparameter_search

</>

    pub fn searchparameter_search(
      sp: r4_sansio.SpSearchparameter,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Searchparameter), Err)

## searchparameter_search_bundled

</>

    pub fn searchparameter_search_bundled(
      sp: r4_sansio.SpSearchparameter,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## searchparameter_update

</>

    pub fn searchparameter_update(
      resource: r4.Searchparameter,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Searchparameter, Err)

## servicerequest_create

</>

    pub fn servicerequest_create(
      resource: r4.Servicerequest,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Servicerequest, Err)

## servicerequest_delete

</>

    pub fn servicerequest_delete(
      resource: r4.Servicerequest,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## servicerequest_read

</>

    pub fn servicerequest_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Servicerequest, Err)

## servicerequest_search

</>

    pub fn servicerequest_search(
      sp: r4_sansio.SpServicerequest,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Servicerequest), Err)

## servicerequest_search_bundled

</>

    pub fn servicerequest_search_bundled(
      sp: r4_sansio.SpServicerequest,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## servicerequest_update

</>

    pub fn servicerequest_update(
      resource: r4.Servicerequest,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Servicerequest, Err)

## slot_create

</>

    pub fn slot_create(
      resource: r4.Slot,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Slot, Err)

## slot_delete

</>

    pub fn slot_delete(
      resource: r4.Slot,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## slot_read

</>

    pub fn slot_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Slot, Err)

## slot_search

</>

    pub fn slot_search(
      sp: r4_sansio.SpSlot,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Slot), Err)

## slot_search_bundled

</>

    pub fn slot_search_bundled(
      sp: r4_sansio.SpSlot,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## slot_update

</>

    pub fn slot_update(
      resource: r4.Slot,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Slot, Err)

## specimen_create

</>

    pub fn specimen_create(
      resource: r4.Specimen,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Specimen, Err)

## specimen_delete

</>

    pub fn specimen_delete(
      resource: r4.Specimen,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## specimen_read

</>

    pub fn specimen_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Specimen, Err)

## specimen_search

</>

    pub fn specimen_search(
      sp: r4_sansio.SpSpecimen,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Specimen), Err)

## specimen_search_bundled

</>

    pub fn specimen_search_bundled(
      sp: r4_sansio.SpSpecimen,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## specimen_update

</>

    pub fn specimen_update(
      resource: r4.Specimen,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Specimen, Err)

## specimendefinition_create

</>

    pub fn specimendefinition_create(
      resource: r4.Specimendefinition,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Specimendefinition, Err)

## specimendefinition_delete

</>

    pub fn specimendefinition_delete(
      resource: r4.Specimendefinition,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## specimendefinition_read

</>

    pub fn specimendefinition_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Specimendefinition, Err)

## specimendefinition_search

</>

    pub fn specimendefinition_search(
      sp: r4_sansio.SpSpecimendefinition,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Specimendefinition), Err)

## specimendefinition_search_bundled

</>

    pub fn specimendefinition_search_bundled(
      sp: r4_sansio.SpSpecimendefinition,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## specimendefinition_update

</>

    pub fn specimendefinition_update(
      resource: r4.Specimendefinition,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Specimendefinition, Err)

## structuredefinition_create

</>

    pub fn structuredefinition_create(
      resource: r4.Structuredefinition,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Structuredefinition, Err)

## structuredefinition_delete

</>

    pub fn structuredefinition_delete(
      resource: r4.Structuredefinition,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## structuredefinition_read

</>

    pub fn structuredefinition_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Structuredefinition, Err)

## structuredefinition_search

</>

    pub fn structuredefinition_search(
      sp: r4_sansio.SpStructuredefinition,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Structuredefinition), Err)

## structuredefinition_search_bundled

</>

    pub fn structuredefinition_search_bundled(
      sp: r4_sansio.SpStructuredefinition,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## structuredefinition_update

</>

    pub fn structuredefinition_update(
      resource: r4.Structuredefinition,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Structuredefinition, Err)

## structuremap_create

</>

    pub fn structuremap_create(
      resource: r4.Structuremap,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Structuremap, Err)

## structuremap_delete

</>

    pub fn structuremap_delete(
      resource: r4.Structuremap,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## structuremap_read

</>

    pub fn structuremap_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Structuremap, Err)

## structuremap_search

</>

    pub fn structuremap_search(
      sp: r4_sansio.SpStructuremap,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Structuremap), Err)

## structuremap_search_bundled

</>

    pub fn structuremap_search_bundled(
      sp: r4_sansio.SpStructuremap,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## structuremap_update

</>

    pub fn structuremap_update(
      resource: r4.Structuremap,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Structuremap, Err)

## subscription_create

</>

    pub fn subscription_create(
      resource: r4.Subscription,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Subscription, Err)

## subscription_delete

</>

    pub fn subscription_delete(
      resource: r4.Subscription,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## subscription_read

</>

    pub fn subscription_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Subscription, Err)

## subscription_search

</>

    pub fn subscription_search(
      sp: r4_sansio.SpSubscription,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Subscription), Err)

## subscription_search_bundled

</>

    pub fn subscription_search_bundled(
      sp: r4_sansio.SpSubscription,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## subscription_update

</>

    pub fn subscription_update(
      resource: r4.Subscription,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Subscription, Err)

## substance_create

</>

    pub fn substance_create(
      resource: r4.Substance,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Substance, Err)

## substance_delete

</>

    pub fn substance_delete(
      resource: r4.Substance,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## substance_read

</>

    pub fn substance_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Substance, Err)

## substance_search

</>

    pub fn substance_search(
      sp: r4_sansio.SpSubstance,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Substance), Err)

## substance_search_bundled

</>

    pub fn substance_search_bundled(
      sp: r4_sansio.SpSubstance,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## substance_update

</>

    pub fn substance_update(
      resource: r4.Substance,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Substance, Err)

## substancenucleicacid_create

</>

    pub fn substancenucleicacid_create(
      resource: r4.Substancenucleicacid,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Substancenucleicacid, Err)

## substancenucleicacid_delete

</>

    pub fn substancenucleicacid_delete(
      resource: r4.Substancenucleicacid,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## substancenucleicacid_read

</>

    pub fn substancenucleicacid_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Substancenucleicacid, Err)

## substancenucleicacid_search

</>

    pub fn substancenucleicacid_search(
      sp: r4_sansio.SpSubstancenucleicacid,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Substancenucleicacid), Err)

## substancenucleicacid_search_bundled

</>

    pub fn substancenucleicacid_search_bundled(
      sp: r4_sansio.SpSubstancenucleicacid,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## substancenucleicacid_update

</>

    pub fn substancenucleicacid_update(
      resource: r4.Substancenucleicacid,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Substancenucleicacid, Err)

## substancepolymer_create

</>

    pub fn substancepolymer_create(
      resource: r4.Substancepolymer,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Substancepolymer, Err)

## substancepolymer_delete

</>

    pub fn substancepolymer_delete(
      resource: r4.Substancepolymer,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## substancepolymer_read

</>

    pub fn substancepolymer_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Substancepolymer, Err)

## substancepolymer_search

</>

    pub fn substancepolymer_search(
      sp: r4_sansio.SpSubstancepolymer,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Substancepolymer), Err)

## substancepolymer_search_bundled

</>

    pub fn substancepolymer_search_bundled(
      sp: r4_sansio.SpSubstancepolymer,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## substancepolymer_update

</>

    pub fn substancepolymer_update(
      resource: r4.Substancepolymer,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Substancepolymer, Err)

## substanceprotein_create

</>

    pub fn substanceprotein_create(
      resource: r4.Substanceprotein,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Substanceprotein, Err)

## substanceprotein_delete

</>

    pub fn substanceprotein_delete(
      resource: r4.Substanceprotein,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## substanceprotein_read

</>

    pub fn substanceprotein_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Substanceprotein, Err)

## substanceprotein_search

</>

    pub fn substanceprotein_search(
      sp: r4_sansio.SpSubstanceprotein,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Substanceprotein), Err)

## substanceprotein_search_bundled

</>

    pub fn substanceprotein_search_bundled(
      sp: r4_sansio.SpSubstanceprotein,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## substanceprotein_update

</>

    pub fn substanceprotein_update(
      resource: r4.Substanceprotein,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Substanceprotein, Err)

## substancereferenceinformation_create

</>

    pub fn substancereferenceinformation_create(
      resource: r4.Substancereferenceinformation,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Substancereferenceinformation, Err)

## substancereferenceinformation_delete

</>

    pub fn substancereferenceinformation_delete(
      resource: r4.Substancereferenceinformation,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## substancereferenceinformation_read

</>

    pub fn substancereferenceinformation_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Substancereferenceinformation, Err)

## substancereferenceinformation_search

</>

    pub fn substancereferenceinformation_search(
      sp: r4_sansio.SpSubstancereferenceinformation,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Substancereferenceinformation), Err)

## substancereferenceinformation_search_bundled

</>

    pub fn substancereferenceinformation_search_bundled(
      sp: r4_sansio.SpSubstancereferenceinformation,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## substancereferenceinformation_update

</>

    pub fn substancereferenceinformation_update(
      resource: r4.Substancereferenceinformation,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Substancereferenceinformation, Err)

## substancesourcematerial_create

</>

    pub fn substancesourcematerial_create(
      resource: r4.Substancesourcematerial,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Substancesourcematerial, Err)

## substancesourcematerial_delete

</>

    pub fn substancesourcematerial_delete(
      resource: r4.Substancesourcematerial,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## substancesourcematerial_read

</>

    pub fn substancesourcematerial_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Substancesourcematerial, Err)

## substancesourcematerial_search

</>

    pub fn substancesourcematerial_search(
      sp: r4_sansio.SpSubstancesourcematerial,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Substancesourcematerial), Err)

## substancesourcematerial_search_bundled

</>

    pub fn substancesourcematerial_search_bundled(
      sp: r4_sansio.SpSubstancesourcematerial,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## substancesourcematerial_update

</>

    pub fn substancesourcematerial_update(
      resource: r4.Substancesourcematerial,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Substancesourcematerial, Err)

## substancespecification_create

</>

    pub fn substancespecification_create(
      resource: r4.Substancespecification,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Substancespecification, Err)

## substancespecification_delete

</>

    pub fn substancespecification_delete(
      resource: r4.Substancespecification,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## substancespecification_read

</>

    pub fn substancespecification_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Substancespecification, Err)

## substancespecification_search

</>

    pub fn substancespecification_search(
      sp: r4_sansio.SpSubstancespecification,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Substancespecification), Err)

## substancespecification_search_bundled

</>

    pub fn substancespecification_search_bundled(
      sp: r4_sansio.SpSubstancespecification,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## substancespecification_update

</>

    pub fn substancespecification_update(
      resource: r4.Substancespecification,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Substancespecification, Err)

## supplydelivery_create

</>

    pub fn supplydelivery_create(
      resource: r4.Supplydelivery,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Supplydelivery, Err)

## supplydelivery_delete

</>

    pub fn supplydelivery_delete(
      resource: r4.Supplydelivery,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## supplydelivery_read

</>

    pub fn supplydelivery_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Supplydelivery, Err)

## supplydelivery_search

</>

    pub fn supplydelivery_search(
      sp: r4_sansio.SpSupplydelivery,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Supplydelivery), Err)

## supplydelivery_search_bundled

</>

    pub fn supplydelivery_search_bundled(
      sp: r4_sansio.SpSupplydelivery,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## supplydelivery_update

</>

    pub fn supplydelivery_update(
      resource: r4.Supplydelivery,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Supplydelivery, Err)

## supplyrequest_create

</>

    pub fn supplyrequest_create(
      resource: r4.Supplyrequest,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Supplyrequest, Err)

## supplyrequest_delete

</>

    pub fn supplyrequest_delete(
      resource: r4.Supplyrequest,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## supplyrequest_read

</>

    pub fn supplyrequest_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Supplyrequest, Err)

## supplyrequest_search

</>

    pub fn supplyrequest_search(
      sp: r4_sansio.SpSupplyrequest,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Supplyrequest), Err)

## supplyrequest_search_bundled

</>

    pub fn supplyrequest_search_bundled(
      sp: r4_sansio.SpSupplyrequest,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## supplyrequest_update

</>

    pub fn supplyrequest_update(
      resource: r4.Supplyrequest,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Supplyrequest, Err)

## task_create

</>

    pub fn task_create(
      resource: r4.Task,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Task, Err)

## task_delete

</>

    pub fn task_delete(
      resource: r4.Task,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## task_read

</>

    pub fn task_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Task, Err)

## task_search

</>

    pub fn task_search(
      sp: r4_sansio.SpTask,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Task), Err)

## task_search_bundled

</>

    pub fn task_search_bundled(
      sp: r4_sansio.SpTask,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## task_update

</>

    pub fn task_update(
      resource: r4.Task,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Task, Err)

## terminologycapabilities_create

</>

    pub fn terminologycapabilities_create(
      resource: r4.Terminologycapabilities,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Terminologycapabilities, Err)

## terminologycapabilities_delete

</>

    pub fn terminologycapabilities_delete(
      resource: r4.Terminologycapabilities,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## terminologycapabilities_read

</>

    pub fn terminologycapabilities_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Terminologycapabilities, Err)

## terminologycapabilities_search

</>

    pub fn terminologycapabilities_search(
      sp: r4_sansio.SpTerminologycapabilities,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Terminologycapabilities), Err)

## terminologycapabilities_search_bundled

</>

    pub fn terminologycapabilities_search_bundled(
      sp: r4_sansio.SpTerminologycapabilities,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## terminologycapabilities_update

</>

    pub fn terminologycapabilities_update(
      resource: r4.Terminologycapabilities,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Terminologycapabilities, Err)

## testreport_create

</>

    pub fn testreport_create(
      resource: r4.Testreport,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Testreport, Err)

## testreport_delete

</>

    pub fn testreport_delete(
      resource: r4.Testreport,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## testreport_read

</>

    pub fn testreport_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Testreport, Err)

## testreport_search

</>

    pub fn testreport_search(
      sp: r4_sansio.SpTestreport,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Testreport), Err)

## testreport_search_bundled

</>

    pub fn testreport_search_bundled(
      sp: r4_sansio.SpTestreport,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## testreport_update

</>

    pub fn testreport_update(
      resource: r4.Testreport,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Testreport, Err)

## testscript_create

</>

    pub fn testscript_create(
      resource: r4.Testscript,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Testscript, Err)

## testscript_delete

</>

    pub fn testscript_delete(
      resource: r4.Testscript,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## testscript_read

</>

    pub fn testscript_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Testscript, Err)

## testscript_search

</>

    pub fn testscript_search(
      sp: r4_sansio.SpTestscript,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Testscript), Err)

## testscript_search_bundled

</>

    pub fn testscript_search_bundled(
      sp: r4_sansio.SpTestscript,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## testscript_update

</>

    pub fn testscript_update(
      resource: r4.Testscript,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Testscript, Err)

## valueset_create

</>

    pub fn valueset_create(
      resource: r4.Valueset,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Valueset, Err)

## valueset_delete

</>

    pub fn valueset_delete(
      resource: r4.Valueset,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## valueset_read

</>

    pub fn valueset_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Valueset, Err)

## valueset_search

</>

    pub fn valueset_search(
      sp: r4_sansio.SpValueset,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Valueset), Err)

## valueset_search_bundled

</>

    pub fn valueset_search_bundled(
      sp: r4_sansio.SpValueset,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## valueset_update

</>

    pub fn valueset_update(
      resource: r4.Valueset,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Valueset, Err)

## verificationresult_create

</>

    pub fn verificationresult_create(
      resource: r4.Verificationresult,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Verificationresult, Err)

## verificationresult_delete

</>

    pub fn verificationresult_delete(
      resource: r4.Verificationresult,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## verificationresult_read

</>

    pub fn verificationresult_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Verificationresult, Err)

## verificationresult_search

</>

    pub fn verificationresult_search(
      sp: r4_sansio.SpVerificationresult,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Verificationresult), Err)

## verificationresult_search_bundled

</>

    pub fn verificationresult_search_bundled(
      sp: r4_sansio.SpVerificationresult,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## verificationresult_update

</>

    pub fn verificationresult_update(
      resource: r4.Verificationresult,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Verificationresult, Err)

## visionprescription_create

</>

    pub fn visionprescription_create(
      resource: r4.Visionprescription,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Visionprescription, Err)

## visionprescription_delete

</>

    pub fn visionprescription_delete(
      resource: r4.Visionprescription,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Operationoutcome, Err)

## visionprescription_read

</>

    pub fn visionprescription_read(
      id: String,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Visionprescription, Err)

## visionprescription_search

</>

    pub fn visionprescription_search(
      sp: r4_sansio.SpVisionprescription,
      client: r4_sansio.FhirClient,
    ) -> Result(List(r4.Visionprescription), Err)

## visionprescription_search_bundled

</>

    pub fn visionprescription_search_bundled(
      sp: r4_sansio.SpVisionprescription,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Bundle, Err)

## visionprescription_update

</>

    pub fn visionprescription_update(
      resource: r4.Visionprescription,
      client: r4_sansio.FhirClient,
    ) -> Result(r4.Visionprescription, Err)

✨