text: from __future__ import annotations
  from typing import Optional, TYPE_CHECKING, Union
  
  # noinspection PyPackageRequirements
  from pyspark.sql.types import StructType, DataType
  from spark_auto_mapper_fhir.fhir_types.boolean import FhirBoolean
  from spark_auto_mapper_fhir.fhir_types.list import FhirList
  from spark_auto_mapper_fhir.fhir_types.string import FhirString
  from spark_auto_mapper_fhir.complex_types.meta import Meta
  from spark_auto_mapper_fhir.extensions.extension_base import ExtensionBase
  from spark_auto_mapper_fhir.fhir_types.id import FhirId
  from spark_auto_mapper_fhir.fhir_types.uri import FhirUri
  
  from spark_auto_mapper_fhir.base_types.fhir_resource_base import FhirResourceBase
  from spark_fhir_schemas.r4.resources.schedule import ScheduleSchema
  
  if TYPE_CHECKING:
      pass
      # id_ (id)
      # meta (Meta)
      # implicitRules (uri)
      # language (CommonLanguages)
      from spark_auto_mapper_fhir.value_sets.common_languages import CommonLanguagesCode
  
      # text (Narrative)
      from spark_auto_mapper_fhir.complex_types.narrative import Narrative
  
      # contained (ResourceContainer)
      from spark_auto_mapper_fhir.complex_types.resource_container import (
          ResourceContainer,
      )
  
      # extension (Extension)
      # modifierExtension (Extension)
      # identifier (Identifier)
      from spark_auto_mapper_fhir.complex_types.identifier import Identifier
  
      # active (boolean)
      # serviceCategory (CodeableConcept)
      from spark_auto_mapper_fhir.complex_types.codeable_concept import CodeableConcept
  
      # Import for CodeableConcept for serviceCategory
      from spark_auto_mapper_fhir.value_sets.service_category import ServiceCategoryCode
  
      # End Import for CodeableConcept for serviceCategory
      # serviceType (CodeableConcept)
      # Import for CodeableConcept for serviceType
      from spark_auto_mapper_fhir.value_sets.service_type import ServiceTypeCode
  
      # End Import for CodeableConcept for serviceType
      # specialty (CodeableConcept)
      # Import for CodeableConcept for specialty
      from spark_auto_mapper_fhir.value_sets.practice_setting_code_value_set import (
          PracticeSettingCodeValueSetCode,
      )
  
      # End Import for CodeableConcept for specialty
      # actor (Reference)
      from spark_auto_mapper_fhir.complex_types.reference import Reference
  
      # Imports for References for actor
      from spark_auto_mapper_fhir.resources.patient import Patient
      from spark_auto_mapper_fhir.resources.practitioner import Practitioner
      from spark_auto_mapper_fhir.resources.practitioner_role import PractitionerRole
      from spark_auto_mapper_fhir.resources.related_person import RelatedPerson
      from spark_auto_mapper_fhir.resources.device import Device
      from spark_auto_mapper_fhir.resources.healthcare_service import HealthcareService
      from spark_auto_mapper_fhir.resources.location import Location
  
      # planningHorizon (Period)
      from spark_auto_mapper_fhir.complex_types.period import Period
  
      # comment (string)
  
  
  # This file is auto-generated by generate_classes so do not edit manually
  # noinspection PyPep8Naming
  class Schedule(FhirResourceBase):
      """
      Schedule
      schedule.xsd
          A container for slots of time that may be available for booking appointments.
          If the element is present, it must have either a @value, an @id, or extensions
      """
  
      # noinspection PyPep8Naming
      def __init__(
          self,
          *,
          id_: Optional[FhirId] = None,
          meta: Optional[Meta] = None,
          implicitRules: Optional[FhirUri] = None,
          language: Optional[CommonLanguagesCode] = None,
          text: Optional[Narrative] = None,
          contained: Optional[FhirList[ResourceContainer]] = None,
          extension: Optional[FhirList[ExtensionBase]] = None,
          modifierExtension: Optional[FhirList[ExtensionBase]] = None,
          identifier: Optional[FhirList[Identifier]] = None,
          active: Optional[FhirBoolean] = None,
          serviceCategory: Optional[
              FhirList[CodeableConcept[ServiceCategoryCode]]
          ] = None,
          serviceType: Optional[FhirList[CodeableConcept[ServiceTypeCode]]] = None,
          specialty: Optional[
              FhirList[CodeableConcept[PracticeSettingCodeValueSetCode]]
          ] = None,
          actor: FhirList[
              Reference[
                  Union[
                      Patient,
                      Practitioner,
                      PractitionerRole,
                      RelatedPerson,
                      Device,
                      HealthcareService,
                      Location,
                  ]
              ]
          ],
          planningHorizon: Optional[Period] = None,
          comment: Optional[FhirString] = None,
      ) -> None:
          """
              A container for slots of time that may be available for booking appointments.
              If the element is present, it must have either a @value, an @id, or extensions
  
              :param id_: The logical id of the resource, as used in the URL for the resource. Once
          assigned, this value never changes.
              :param meta: The metadata about the resource. This is content that is maintained by the
          infrastructure. Changes to the content might not always be associated with
          version changes to the resource.
              :param implicitRules: A reference to a set of rules that were followed when the resource was
          constructed, and which must be understood when processing the content. Often,
          this is a reference to an implementation guide that defines the special rules
          along with other profiles etc.
              :param language: The base language in which the resource is written.
              :param text: A human-readable narrative that contains a summary of the resource and can be
          used to represent the content of the resource to a human. The narrative need
          not encode all the structured data, but is required to contain sufficient
          detail to make it "clinically safe" for a human to just read the narrative.
          Resource definitions may define what content should be represented in the
          narrative to ensure clinical safety.
              :param contained: These resources do not have an independent existence apart from the resource
          that contains them - they cannot be identified independently, and nor can they
          have their own independent transaction scope.
              :param extension: May be used to represent additional information that is not part of the basic
          definition of the resource. To make the use of extensions safe and manageable,
          there is a strict set of governance  applied to the definition and use of
          extensions. Though any implementer can define an extension, there is a set of
          requirements that SHALL be met as part of the definition of the extension.
              :param modifierExtension: May be used to represent additional information that is not part of the basic
          definition of the resource and that modifies the understanding of the element
          that contains it and/or the understanding of the containing element's
          descendants. Usually modifier elements provide negation or qualification. To
          make the use of extensions safe and manageable, there is a strict set of
          governance applied to the definition and use of extensions. Though any
          implementer is allowed to define an extension, there is a set of requirements
          that SHALL be met as part of the definition of the extension. Applications
          processing a resource are required to check for modifier extensions.
  
          Modifier extensions SHALL NOT change the meaning of any elements on Resource
          or DomainResource (including cannot change the meaning of modifierExtension
          itself).
              :param identifier: External Ids for this item.
              :param active: Whether this schedule record is in active use or should not be used (such as
          was entered in error).
              :param serviceCategory: A broad categorization of the service that is to be performed during this
          appointment.
              :param serviceType: The specific service that is to be performed during this appointment.
              :param specialty: The specialty of a practitioner that would be required to perform the service
          requested in this appointment.
              :param actor: Slots that reference this schedule resource provide the availability details
          to these referenced resource(s).
              :param planningHorizon: The period of time that the slots that reference this Schedule resource cover
          (even if none exist). These  cover the amount of time that an organization's
          planning horizon; the interval for which they are currently accepting
          appointments. This does not define a "template" for planning outside these
          dates.
              :param comment: Comments on the availability to describe any extended information. Such as
          custom constraints on the slots that may be associated.
          """
          super().__init__(
              resourceType="Schedule",
              id_=id_,
              meta=meta,
              implicitRules=implicitRules,
              language=language,
              text=text,
              contained=contained,
              extension=extension,
              modifierExtension=modifierExtension,
              identifier=identifier,
              active=active,
              serviceCategory=serviceCategory,
              serviceType=serviceType,
              specialty=specialty,
              actor=actor,
              planningHorizon=planningHorizon,
              comment=comment,
          )
  
      def get_schema(
          self, include_extension: bool
      ) -> Optional[Union[StructType, DataType]]:
          return ScheduleSchema.get_schema(include_extension=include_extension)
  