// automatically generated by the FlatBuffers compiler, do not modify
// @generated
extern crate alloc;


#[allow(unused_imports, dead_code)]
pub mod de {

#[allow(unused_imports, dead_code)]
pub mod gesundheit {


pub enum AdresseOffset {}
#[derive(Copy, Clone, PartialEq)]

/// Vollständige Adresse einer Praxis.
pub struct Adresse<'a> {
  pub _tab: ::flatbuffers::Table<'a>,
}

impl<'a> ::flatbuffers::Follow<'a> for Adresse<'a> {
  type Inner = Adresse<'a>;
  #[inline]
  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
    Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
  }
}

impl<'a> Adresse<'a> {
  pub const VT_STRASSE: ::flatbuffers::VOffsetT = 4;
  pub const VT_HAUSNUMMER: ::flatbuffers::VOffsetT = 6;
  pub const VT_PLZ: ::flatbuffers::VOffsetT = 8;
  pub const VT_ORT: ::flatbuffers::VOffsetT = 10;
  pub const VT_LAND: ::flatbuffers::VOffsetT = 12;

  #[inline]
  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
    Adresse { _tab: table }
  }
  #[allow(unused_mut)]
  pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>(
    _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
    args: &'args AdresseArgs<'args>
  ) -> ::flatbuffers::WIPOffset<Adresse<'bldr>> {
    let mut builder = AdresseBuilder::new(_fbb);
    if let Some(x) = args.land { builder.add_land(x); }
    if let Some(x) = args.ort { builder.add_ort(x); }
    if let Some(x) = args.plz { builder.add_plz(x); }
    if let Some(x) = args.hausnummer { builder.add_hausnummer(x); }
    if let Some(x) = args.strasse { builder.add_strasse(x); }
    builder.finish()
  }


  /// Straßenname (ohne Hausnummer)
  #[inline]
  pub fn strasse(&self) -> &'a str {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(Adresse::VT_STRASSE, None).unwrap()}
  }
  /// Hausnummer (optional, da manche Praxen keine haben)
  #[inline]
  pub fn hausnummer(&self) -> Option<&'a str> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(Adresse::VT_HAUSNUMMER, None)}
  }
  /// Postleitzahl
  #[inline]
  pub fn plz(&self) -> &'a str {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(Adresse::VT_PLZ, None).unwrap()}
  }
  /// Stadt/Ort
  #[inline]
  pub fn ort(&self) -> &'a str {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(Adresse::VT_ORT, None).unwrap()}
  }
  /// ISO 3166-1 alpha-2 Ländercode
  /// Standard: "DE" für Deutschland
  #[inline]
  pub fn land(&self) -> &'a str {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(Adresse::VT_LAND, Some(&"DE")).unwrap()}
  }
}

impl ::flatbuffers::Verifiable for Adresse<'_> {
  #[inline]
  fn run_verifier(
    v: &mut ::flatbuffers::Verifier, pos: usize
  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
    v.visit_table(pos)?
     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("strasse", Self::VT_STRASSE, true)?
     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("hausnummer", Self::VT_HAUSNUMMER, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("plz", Self::VT_PLZ, true)?
     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("ort", Self::VT_ORT, true)?
     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("land", Self::VT_LAND, false)?
     .finish();
    Ok(())
  }
}
pub struct AdresseArgs<'a> {
    pub strasse: Option<::flatbuffers::WIPOffset<&'a str>>,
    pub hausnummer: Option<::flatbuffers::WIPOffset<&'a str>>,
    pub plz: Option<::flatbuffers::WIPOffset<&'a str>>,
    pub ort: Option<::flatbuffers::WIPOffset<&'a str>>,
    pub land: Option<::flatbuffers::WIPOffset<&'a str>>,
}
impl<'a> Default for AdresseArgs<'a> {
  #[inline]
  fn default() -> Self {
    AdresseArgs {
      strasse: None, // required field
      hausnummer: None,
      plz: None, // required field
      ort: None, // required field
      land: None,
    }
  }
}

pub struct AdresseBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
  fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
  start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
}
impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> AdresseBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_strasse(&mut self, strasse: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Adresse::VT_STRASSE, strasse);
  }
  #[inline]
  pub fn add_hausnummer(&mut self, hausnummer: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Adresse::VT_HAUSNUMMER, hausnummer);
  }
  #[inline]
  pub fn add_plz(&mut self, plz: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Adresse::VT_PLZ, plz);
  }
  #[inline]
  pub fn add_ort(&mut self, ort: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Adresse::VT_ORT, ort);
  }
  #[inline]
  pub fn add_land(&mut self, land: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Adresse::VT_LAND, land);
  }
  #[inline]
  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> AdresseBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    AdresseBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> ::flatbuffers::WIPOffset<Adresse<'a>> {
    let o = self.fbb_.end_table(self.start_);
    self.fbb_.required(o, Adresse::VT_STRASSE,"strasse");
    self.fbb_.required(o, Adresse::VT_PLZ,"plz");
    self.fbb_.required(o, Adresse::VT_ORT,"ort");
    ::flatbuffers::WIPOffset::new(o.value())
  }
}

impl ::core::fmt::Debug for Adresse<'_> {
  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
    let mut ds = f.debug_struct("Adresse");
      ds.field("strasse", &self.strasse());
      ds.field("hausnummer", &self.hausnummer());
      ds.field("plz", &self.plz());
      ds.field("ort", &self.ort());
      ds.field("land", &self.land());
      ds.finish()
  }
}
pub enum PraxisOffset {}
#[derive(Copy, Clone, PartialEq)]

/// Haupttabelle für eine Gesundheitspraxis.
///
/// Pflichtfelder:
///   - name: Name der behandelnden Person
///   - bezeichnung: Berufsbezeichnung
///   - adresse: Vollständige Adresse
///
/// Beispiel:
///   name = "Dr. Anna Schmidt"
///   bezeichnung = "Zahnärztin"
///   praxisname = "Praxis Schmidt"
pub struct Praxis<'a> {
  pub _tab: ::flatbuffers::Table<'a>,
}

impl<'a> ::flatbuffers::Follow<'a> for Praxis<'a> {
  type Inner = Praxis<'a>;
  #[inline]
  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
    Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
  }
}

impl<'a> Praxis<'a> {
  pub const VT_NAME: ::flatbuffers::VOffsetT = 4;
  pub const VT_BEZEICHNUNG: ::flatbuffers::VOffsetT = 6;
  pub const VT_PRAXISNAME: ::flatbuffers::VOffsetT = 8;
  pub const VT_ADRESSE: ::flatbuffers::VOffsetT = 10;
  pub const VT_TELEFON: ::flatbuffers::VOffsetT = 12;
  pub const VT_EMAIL: ::flatbuffers::VOffsetT = 14;
  pub const VT_WEBSITE: ::flatbuffers::VOffsetT = 16;
  pub const VT_SCHWERPUNKTE: ::flatbuffers::VOffsetT = 18;
  pub const VT_THERAPIEFORMEN: ::flatbuffers::VOffsetT = 20;
  pub const VT_QUALIFIKATIONEN: ::flatbuffers::VOffsetT = 22;
  pub const VT_TERMINBUCHUNG_URL: ::flatbuffers::VOffsetT = 24;
  pub const VT_OEFFNUNGSZEITEN: ::flatbuffers::VOffsetT = 26;
  pub const VT_PRIVATPATIENTEN: ::flatbuffers::VOffsetT = 28;
  pub const VT_KASSENPATIENTEN: ::flatbuffers::VOffsetT = 30;
  pub const VT_SPRACHEN: ::flatbuffers::VOffsetT = 32;
  pub const VT_KURZBESCHREIBUNG: ::flatbuffers::VOffsetT = 34;

  #[inline]
  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
    Praxis { _tab: table }
  }
  #[allow(unused_mut)]
  pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>(
    _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
    args: &'args PraxisArgs<'args>
  ) -> ::flatbuffers::WIPOffset<Praxis<'bldr>> {
    let mut builder = PraxisBuilder::new(_fbb);
    if let Some(x) = args.kurzbeschreibung { builder.add_kurzbeschreibung(x); }
    if let Some(x) = args.sprachen { builder.add_sprachen(x); }
    if let Some(x) = args.oeffnungszeiten { builder.add_oeffnungszeiten(x); }
    if let Some(x) = args.terminbuchung_url { builder.add_terminbuchung_url(x); }
    if let Some(x) = args.qualifikationen { builder.add_qualifikationen(x); }
    if let Some(x) = args.therapieformen { builder.add_therapieformen(x); }
    if let Some(x) = args.schwerpunkte { builder.add_schwerpunkte(x); }
    if let Some(x) = args.website { builder.add_website(x); }
    if let Some(x) = args.email { builder.add_email(x); }
    if let Some(x) = args.telefon { builder.add_telefon(x); }
    if let Some(x) = args.adresse { builder.add_adresse(x); }
    if let Some(x) = args.praxisname { builder.add_praxisname(x); }
    if let Some(x) = args.bezeichnung { builder.add_bezeichnung(x); }
    if let Some(x) = args.name { builder.add_name(x); }
    builder.add_kassenpatienten(args.kassenpatienten);
    builder.add_privatpatienten(args.privatpatienten);
    builder.finish()
  }


  /// Name der Person (z.B. "Dr. Anna Schmidt")
  #[inline]
  pub fn name(&self) -> &'a str {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(Praxis::VT_NAME, None).unwrap()}
  }
  /// Berufsbezeichnung (z.B. "Heilpraktikerin", "Zahnärztin")
  #[inline]
  pub fn bezeichnung(&self) -> &'a str {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(Praxis::VT_BEZEICHNUNG, None).unwrap()}
  }
  /// Name der Praxis (falls anders als Personenname)
  #[inline]
  pub fn praxisname(&self) -> Option<&'a str> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(Praxis::VT_PRAXISNAME, None)}
  }
  /// Vollständige Adresse
  #[inline]
  pub fn adresse(&self) -> Adresse<'a> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<Adresse>>(Praxis::VT_ADRESSE, None).unwrap()}
  }
  /// Telefonnummer im internationalen Format (+49 ...)
  #[inline]
  pub fn telefon(&self) -> Option<&'a str> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(Praxis::VT_TELEFON, None)}
  }
  /// E-Mail-Adresse
  #[inline]
  pub fn email(&self) -> Option<&'a str> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(Praxis::VT_EMAIL, None)}
  }
  /// Website-URL
  #[inline]
  pub fn website(&self) -> Option<&'a str> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(Praxis::VT_WEBSITE, None)}
  }
  /// Medizinische Schwerpunkte
  /// z.B. ["Funktionelle Medizin", "Darm & Mikrobiom"]
  #[inline]
  pub fn schwerpunkte(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>>>(Praxis::VT_SCHWERPUNKTE, None)}
  }
  /// Angebotene Therapieformen
  /// z.B. ["IHHT Training", "Osteopathie", "Infusionstherapie"]
  #[inline]
  pub fn therapieformen(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>>>(Praxis::VT_THERAPIEFORMEN, None)}
  }
  /// Qualifikationen und Zertifizierungen
  /// z.B. ["Heilpraktikerin", "Osteopathin", "Physiotherapeutin"]
  #[inline]
  pub fn qualifikationen(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>>>(Praxis::VT_QUALIFIKATIONEN, None)}
  }
  /// URL oder Telefonnummer für Terminbuchung
  /// z.B. "https://doctolib.de/..." oder "tel:+49123456"
  #[inline]
  pub fn terminbuchung_url(&self) -> Option<&'a str> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(Praxis::VT_TERMINBUCHUNG_URL, None)}
  }
  /// Öffnungszeiten als Freitext
  /// z.B. "Mo-Fr 9-17 Uhr" oder "Nach Vereinbarung"
  #[inline]
  pub fn oeffnungszeiten(&self) -> Option<&'a str> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(Praxis::VT_OEFFNUNGSZEITEN, None)}
  }
  /// Behandelt Privatpatienten?
  #[inline]
  pub fn privatpatienten(&self) -> bool {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<bool>(Praxis::VT_PRIVATPATIENTEN, Some(false)).unwrap()}
  }
  /// Behandelt Kassenpatienten?
  #[inline]
  pub fn kassenpatienten(&self) -> bool {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<bool>(Praxis::VT_KASSENPATIENTEN, Some(false)).unwrap()}
  }
  /// Gesprochene Sprachen
  /// z.B. ["Deutsch", "Englisch"]
  #[inline]
  pub fn sprachen(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>>>(Praxis::VT_SPRACHEN, None)}
  }
  /// Kurzbeschreibung für KI-Zusammenfassungen
  /// Max. 500 Zeichen empfohlen
  #[inline]
  pub fn kurzbeschreibung(&self) -> Option<&'a str> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(Praxis::VT_KURZBESCHREIBUNG, None)}
  }
}

impl ::flatbuffers::Verifiable for Praxis<'_> {
  #[inline]
  fn run_verifier(
    v: &mut ::flatbuffers::Verifier, pos: usize
  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
    v.visit_table(pos)?
     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("name", Self::VT_NAME, true)?
     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("bezeichnung", Self::VT_BEZEICHNUNG, true)?
     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("praxisname", Self::VT_PRAXISNAME, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<Adresse>>("adresse", Self::VT_ADRESSE, true)?
     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("telefon", Self::VT_TELEFON, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("email", Self::VT_EMAIL, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("website", Self::VT_WEBSITE, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<&'_ str>>>>("schwerpunkte", Self::VT_SCHWERPUNKTE, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<&'_ str>>>>("therapieformen", Self::VT_THERAPIEFORMEN, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<&'_ str>>>>("qualifikationen", Self::VT_QUALIFIKATIONEN, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("terminbuchung_url", Self::VT_TERMINBUCHUNG_URL, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("oeffnungszeiten", Self::VT_OEFFNUNGSZEITEN, false)?
     .visit_field::<bool>("privatpatienten", Self::VT_PRIVATPATIENTEN, false)?
     .visit_field::<bool>("kassenpatienten", Self::VT_KASSENPATIENTEN, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<&'_ str>>>>("sprachen", Self::VT_SPRACHEN, false)?
     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("kurzbeschreibung", Self::VT_KURZBESCHREIBUNG, false)?
     .finish();
    Ok(())
  }
}
pub struct PraxisArgs<'a> {
    pub name: Option<::flatbuffers::WIPOffset<&'a str>>,
    pub bezeichnung: Option<::flatbuffers::WIPOffset<&'a str>>,
    pub praxisname: Option<::flatbuffers::WIPOffset<&'a str>>,
    pub adresse: Option<::flatbuffers::WIPOffset<Adresse<'a>>>,
    pub telefon: Option<::flatbuffers::WIPOffset<&'a str>>,
    pub email: Option<::flatbuffers::WIPOffset<&'a str>>,
    pub website: Option<::flatbuffers::WIPOffset<&'a str>>,
    pub schwerpunkte: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>>>,
    pub therapieformen: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>>>,
    pub qualifikationen: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>>>,
    pub terminbuchung_url: Option<::flatbuffers::WIPOffset<&'a str>>,
    pub oeffnungszeiten: Option<::flatbuffers::WIPOffset<&'a str>>,
    pub privatpatienten: bool,
    pub kassenpatienten: bool,
    pub sprachen: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>>>,
    pub kurzbeschreibung: Option<::flatbuffers::WIPOffset<&'a str>>,
}
impl<'a> Default for PraxisArgs<'a> {
  #[inline]
  fn default() -> Self {
    PraxisArgs {
      name: None, // required field
      bezeichnung: None, // required field
      praxisname: None,
      adresse: None, // required field
      telefon: None,
      email: None,
      website: None,
      schwerpunkte: None,
      therapieformen: None,
      qualifikationen: None,
      terminbuchung_url: None,
      oeffnungszeiten: None,
      privatpatienten: false,
      kassenpatienten: false,
      sprachen: None,
      kurzbeschreibung: None,
    }
  }
}

pub struct PraxisBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
  fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
  start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
}
impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> PraxisBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_name(&mut self, name: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Praxis::VT_NAME, name);
  }
  #[inline]
  pub fn add_bezeichnung(&mut self, bezeichnung: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Praxis::VT_BEZEICHNUNG, bezeichnung);
  }
  #[inline]
  pub fn add_praxisname(&mut self, praxisname: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Praxis::VT_PRAXISNAME, praxisname);
  }
  #[inline]
  pub fn add_adresse(&mut self, adresse: ::flatbuffers::WIPOffset<Adresse<'b >>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<Adresse>>(Praxis::VT_ADRESSE, adresse);
  }
  #[inline]
  pub fn add_telefon(&mut self, telefon: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Praxis::VT_TELEFON, telefon);
  }
  #[inline]
  pub fn add_email(&mut self, email: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Praxis::VT_EMAIL, email);
  }
  #[inline]
  pub fn add_website(&mut self, website: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Praxis::VT_WEBSITE, website);
  }
  #[inline]
  pub fn add_schwerpunkte(&mut self, schwerpunkte: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset<&'b  str>>>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Praxis::VT_SCHWERPUNKTE, schwerpunkte);
  }
  #[inline]
  pub fn add_therapieformen(&mut self, therapieformen: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset<&'b  str>>>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Praxis::VT_THERAPIEFORMEN, therapieformen);
  }
  #[inline]
  pub fn add_qualifikationen(&mut self, qualifikationen: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset<&'b  str>>>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Praxis::VT_QUALIFIKATIONEN, qualifikationen);
  }
  #[inline]
  pub fn add_terminbuchung_url(&mut self, terminbuchung_url: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Praxis::VT_TERMINBUCHUNG_URL, terminbuchung_url);
  }
  #[inline]
  pub fn add_oeffnungszeiten(&mut self, oeffnungszeiten: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Praxis::VT_OEFFNUNGSZEITEN, oeffnungszeiten);
  }
  #[inline]
  pub fn add_privatpatienten(&mut self, privatpatienten: bool) {
    self.fbb_.push_slot::<bool>(Praxis::VT_PRIVATPATIENTEN, privatpatienten, false);
  }
  #[inline]
  pub fn add_kassenpatienten(&mut self, kassenpatienten: bool) {
    self.fbb_.push_slot::<bool>(Praxis::VT_KASSENPATIENTEN, kassenpatienten, false);
  }
  #[inline]
  pub fn add_sprachen(&mut self, sprachen: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset<&'b  str>>>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Praxis::VT_SPRACHEN, sprachen);
  }
  #[inline]
  pub fn add_kurzbeschreibung(&mut self, kurzbeschreibung: ::flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Praxis::VT_KURZBESCHREIBUNG, kurzbeschreibung);
  }
  #[inline]
  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> PraxisBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    PraxisBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> ::flatbuffers::WIPOffset<Praxis<'a>> {
    let o = self.fbb_.end_table(self.start_);
    self.fbb_.required(o, Praxis::VT_NAME,"name");
    self.fbb_.required(o, Praxis::VT_BEZEICHNUNG,"bezeichnung");
    self.fbb_.required(o, Praxis::VT_ADRESSE,"adresse");
    ::flatbuffers::WIPOffset::new(o.value())
  }
}

impl ::core::fmt::Debug for Praxis<'_> {
  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
    let mut ds = f.debug_struct("Praxis");
      ds.field("name", &self.name());
      ds.field("bezeichnung", &self.bezeichnung());
      ds.field("praxisname", &self.praxisname());
      ds.field("adresse", &self.adresse());
      ds.field("telefon", &self.telefon());
      ds.field("email", &self.email());
      ds.field("website", &self.website());
      ds.field("schwerpunkte", &self.schwerpunkte());
      ds.field("therapieformen", &self.therapieformen());
      ds.field("qualifikationen", &self.qualifikationen());
      ds.field("terminbuchung_url", &self.terminbuchung_url());
      ds.field("oeffnungszeiten", &self.oeffnungszeiten());
      ds.field("privatpatienten", &self.privatpatienten());
      ds.field("kassenpatienten", &self.kassenpatienten());
      ds.field("sprachen", &self.sprachen());
      ds.field("kurzbeschreibung", &self.kurzbeschreibung());
      ds.finish()
  }
}
#[inline]
/// Verifies that a buffer of bytes contains a `Praxis`
/// and returns it.
/// Note that verification is still experimental and may not
/// catch every error, or be maximally performant. For the
/// previous, unchecked, behavior use
/// `root_as_praxis_unchecked`.
pub fn root_as_praxis(buf: &[u8]) -> Result<Praxis<'_>, ::flatbuffers::InvalidFlatbuffer> {
  ::flatbuffers::root::<Praxis>(buf)
}
#[inline]
/// Verifies that a buffer of bytes contains a size prefixed
/// `Praxis` and returns it.
/// Note that verification is still experimental and may not
/// catch every error, or be maximally performant. For the
/// previous, unchecked, behavior use
/// `size_prefixed_root_as_praxis_unchecked`.
pub fn size_prefixed_root_as_praxis(buf: &[u8]) -> Result<Praxis<'_>, ::flatbuffers::InvalidFlatbuffer> {
  ::flatbuffers::size_prefixed_root::<Praxis>(buf)
}
#[inline]
/// Verifies, with the given options, that a buffer of bytes
/// contains a `Praxis` and returns it.
/// Note that verification is still experimental and may not
/// catch every error, or be maximally performant. For the
/// previous, unchecked, behavior use
/// `root_as_praxis_unchecked`.
pub fn root_as_praxis_with_opts<'b, 'o>(
  opts: &'o ::flatbuffers::VerifierOptions,
  buf: &'b [u8],
) -> Result<Praxis<'b>, ::flatbuffers::InvalidFlatbuffer> {
  ::flatbuffers::root_with_opts::<Praxis<'b>>(opts, buf)
}
#[inline]
/// Verifies, with the given verifier options, that a buffer of
/// bytes contains a size prefixed `Praxis` and returns
/// it. Note that verification is still experimental and may not
/// catch every error, or be maximally performant. For the
/// previous, unchecked, behavior use
/// `root_as_praxis_unchecked`.
pub fn size_prefixed_root_as_praxis_with_opts<'b, 'o>(
  opts: &'o ::flatbuffers::VerifierOptions,
  buf: &'b [u8],
) -> Result<Praxis<'b>, ::flatbuffers::InvalidFlatbuffer> {
  ::flatbuffers::size_prefixed_root_with_opts::<Praxis<'b>>(opts, buf)
}
#[inline]
/// Assumes, without verification, that a buffer of bytes contains a Praxis and returns it.
/// # Safety
/// Callers must trust the given bytes do indeed contain a valid `Praxis`.
pub unsafe fn root_as_praxis_unchecked(buf: &[u8]) -> Praxis<'_> {
  unsafe { ::flatbuffers::root_unchecked::<Praxis>(buf) }
}
#[inline]
/// Assumes, without verification, that a buffer of bytes contains a size prefixed Praxis and returns it.
/// # Safety
/// Callers must trust the given bytes do indeed contain a valid size prefixed `Praxis`.
pub unsafe fn size_prefixed_root_as_praxis_unchecked(buf: &[u8]) -> Praxis<'_> {
  unsafe { ::flatbuffers::size_prefixed_root_unchecked::<Praxis>(buf) }
}
#[inline]
pub fn finish_praxis_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>(
    fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
    root: ::flatbuffers::WIPOffset<Praxis<'a>>) {
  fbb.finish(root, None);
}

#[inline]
pub fn finish_size_prefixed_praxis_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>(fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, root: ::flatbuffers::WIPOffset<Praxis<'a>>) {
  fbb.finish_size_prefixed(root, None);
}
}  // pub mod gesundheit
}  // pub mod de

