# church_of_jesus_christ_api package

## Submodules

## church_of_jesus_christ_api.church_of_jesus_christ_api module

The module that implements ChurchOfJesusChristAPI. This module allows the user to get data from churchofjesuschrist.org.

class church_of_jesus_christ_api.church_of_jesus_christ_api.ChurchOfJesusChristAPI(username: str, password: str, proxies: dict[str, str] = None, verify_SSL: bool = None, timeout_sec: int = None)

  Bases: `object`

  A class used to interact with features found on churchofjesuschrist.org, such as getting member data, calling information, reports, etc.

  convert_date_to_string_using_default_date_if_none(val, default)
  download_member_photo(uuid: str = None, timeout_sec: int = None) → bytes | None

    Returns the raw bytes for a member’s photo in JPEG format

    Parameters

    uuid: str

      The given member’s uuid

    timeout_secint

      Number of seconds to wait for a response when making a request

    Returns

    The raw bytes for the member’s photo, if available. None if no photo is available, throws an exception if an error occurs

  get_action_and_interviews(unit: int = None, timeout_sec: int = None) → Dict[str, Any] | List[Any]

    Returns the unit action and interview list

    Parameters

    unitint

      Number of the church unit for which to retrieve the report

    timeout_secint

      Number of seconds to wait for a response when making a request

    Returns

        {
          data: [
            {
              items: [
                {
                  age: int,
                  birthdate: str,
                  birthdateFormatted: str,
                  email: NoneType,
                  gender: str,
                  husband: NoneType,
                  interviewDate: NoneType,
                  interviewDateDisplay: NoneType,
                  name: str,
                  personId: str,
                  phoneNumber: str,
                  status: str,
                  statusDisplay: str,
                  suggestedAction: str,
                  suggestedActionDisplay: str,
                  unitName: str,
                  unitNumber: int,
                  wife: NoneType
                }
              ],
              sectionTypeKey: str,
              tab: str
            }
          ]
        }

  get_assigned_missionaries(unit: int = None, timeout_sec: int = None) → Dict[str, Any] | List[Any]

    Returns a list of the missionaries currently assigned to serve in the unit

    Parameters unit : int

    > Number of the church unit for which to retrieve the report

    timeout_secint

      Number of seconds to wait for a response when making a request

    Returns

        [
          {
            accountable: bool,
            actualAge: NoneType,
            actualAgeInMonths: NoneType,
            age: NoneType,
            birthDate: NoneType,
            birthDateFormatted: str,
            birthDateSort: NoneType,
            birthDayFormatted: NoneType,
            birthDaySort: NoneType,
            email: str,
            formattedMrn: NoneType,
            gender: NoneType,
            genderCode: NoneType,
            genderLabelShort: str,
            id: int,
            missionOfficeAddress: NoneType,
            missionUnitName: str,
            missionUnitNumber: int,
            mrn: NoneType,
            name: str,
            nameOrder: NoneType,
            nonMember: bool,
            notAccountable: bool,
            outOfUnitMember: bool,
            phone: str,
            priesthood: NoneType,
            priesthoodCode: NoneType,
            priesthoodType: NoneType,
            setApart: bool,
            spokenName: NoneType,
            sustainedDate: NoneType,
            unitName: NoneType,
            unitNumber: NoneType,
            urlAddressSearch: NoneType,
            visible: NoneType
          }
        ]

  get_attendance(unit: int = None, timeout_sec: int = None) → Dict[str, Any] | List[Any]

    Returns the attendance list for the last 5 weeks

    Parameters

    unitint

      Number of the church unit for which to retrieve the report

    timeout_secint

      Number of seconds to wait for a response when making a request

    Returns

        {
          allAvailableDates: [
            {
              epochSeconds: int,
              isoYearMonthDay: str,
              loaded: bool,
              localeMonthDay: str
            }
          ],
          attendanceData: {
            attendees: [
              {
                cmisId: int,
                displayName: str,
                entries: [
                  {
                    date: {
                      epochSeconds: int,
                      isoYearMonthDay: str,
                      loaded: bool,
                      localeMonthDay: str
                    },
                    isMarkedAttended: bool,
                    markedAttended: bool
                  }
                ],
                gender: str,
                sortName: str,
                unitOrgsCombined: [
                  str
                ],
                uuid: str
              }
            ],
            visitorCategories: [
              {
                countsByDate: {
                  2024-06-16: int,
                  2024-06-23: int,
                  2024-06-30: int,
                  2024-07-07: int,
                  2024-07-14: int
                },
                displayName: str,
                name: str
              }
            ]
          },
          dates: [
            {
              epochSeconds: int,
              isoYearMonthDay: str,
              loaded: bool,
              localeMonthDay: str
            }
          ]
        }

  get_attendance_date_range(start_date: date = None, end_date: date = None, unit: int = None, timeout_sec: int = None) → Dict[str, Any] | List[Any]

    Returns the attendance list for a given date range (default 1 year ago to today)

    Parameters

    start_date: datetime.date

      The start date after which attendance will be retrieved

    end_date: datetime.date

      The end date after which attendance will no longer be retrieved

    unitint

      Number of the church unit for which to retrieve the report

    timeout_secint

      Number of seconds to wait for a response when making a request

    Returns

        {
          allAvailableDates: NoneType,
          attendanceData: {
            attendees: [
              {
                cmisId: NoneType,
                displayName: NoneType,
                entries: [
                  {
                    date: {
                      epochSeconds: int,
                      isoYearMonthDay: str,
                      loaded: bool,
                      localeMonthDay: str
                    },
                    isMarkedAttended: bool,
                    markedAttended: bool
                  }
                ],
                gender: NoneType,
                sortName: NoneType,
                unitOrgsCombined: NoneType,
                uuid: str
              }
            ],
            visitorCategories: [
              {
                countsByDate: {
                  2023-07-09: int,
                  2023-07-16: int,
                  2023-07-23: int,
                  2023-07-30: int,
                  2023-08-06: int,
                  2023-08-13: int,
                  2023-08-20: int,
                  2023-08-27: int,
                  2023-09-03: int,
                  2023-09-10: int,
                  2023-09-17: int,
                  2023-09-24: int,
                  2023-10-01: int,
                  2023-10-08: int,
                  2023-10-15: int,
                  2023-10-22: int,
                  2023-10-29: int,
                  2023-11-05: int,
                  2023-11-12: int,
                  2023-11-19: int,
                  2023-11-26: int,
                  2023-12-03: int,
                  2023-12-10: int,
                  2023-12-17: int,
                  2023-12-24: int,
                  2023-12-31: int,
                  2024-01-07: int,
                  2024-01-14: int,
                  2024-01-21: int,
                  2024-01-28: int,
                  2024-02-04: int,
                  2024-02-11: int,
                  2024-02-18: int,
                  2024-02-25: int,
                  2024-03-03: int,
                  2024-03-10: int,
                  2024-03-17: int,
                  2024-03-24: int,
                  2024-03-31: int,
                  2024-04-07: int,
                  2024-04-14: int,
                  2024-04-21: int,
                  2024-04-28: int,
                  2024-05-05: int,
                  2024-05-12: int,
                  2024-05-19: int,
                  2024-05-26: int,
                  2024-06-02: int,
                  2024-06-09: int,
                  2024-06-16: int,
                  2024-06-23: int,
                  2024-06-30: int,
                  2024-07-07: int,
                  2024-07-14: int
                },
                displayName: str,
                name: str
              }
            ]
          },
          dates: NoneType
        }

  get_birthdays(unit: int = None, timeout_sec: int = None) → Dict[str, Any] | List[Any]

    Returns the unit birthday list

    Parameters

    unitint

      Number of the church unit for which to retrieve the report

    timeout_secint

      Number of seconds to wait for a response when making a request

    Returns

        [
          {
            birthdays: [
              {
                accountable: bool,
                actualAge: int,
                actualAgeInMonths: int,
                address: str,
                age: int,
                birthDate: str,
                birthDateFormatted: str,
                birthDateSort: str,
                birthDayAge: int,
                birthDayFormatted: str,
                birthDaySort: str,
                dayInteger: int,
                displayBirthdate: str,
                email: NoneType,
                formattedMrn: NoneType,
                gender: str,
                genderCode: int,
                genderLabelShort: str,
                id: int,
                monthInteger: int,
                mrn: NoneType,
                name: str,
                nameOrder: NoneType,
                nonMember: bool,
                notAccountable: bool,
                outOfUnitMember: bool,
                phone: str,
                priesthood: NoneType,
                priesthoodCode: NoneType,
                priesthoodType: NoneType,
                setApart: bool,
                spokenName: str,
                sustainedDate: NoneType,
                unitName: str,
                unitNumber: int,
                visible: NoneType
              }
            ]
          }
        ]

  get_covenant_path_progress(unit: int = None, timeout_sec: int = None) → Dict[str, Any] | List[Any]

    Returns the unit covenant path progress record. Includes information about new members and non-members being taught by the missionaries

    Parameters

    unitint

      Number of the church unit for which to retrieve the report

    timeout_secint

      Number of seconds to wait for a response when making a request

    Returns

        {
          investigatorList: list,
          newMemberList: list,
          parentUnit: bool,
          readOnly: bool
        }

  get_directory(unit: int = None, timeout_sec: int = None) → Dict[str, Any] | List[Any]

    Returns the unit directory of households

    Parameters

    unitint

      Number of the church unit for which to retrieve the report

    timeout_secint

      Number of seconds to wait for a response when making a request

    Returns

        [
          {
            address: str,
            coordinates: {
              latitude: float,
              longitude: float
            },
            editable: bool,
            members: [
              {
                countryId: int,
                displayName: str,
                editable: bool,
                email: {
                  email: str
                },
                givenName: str,
                head: bool,
                householdUuid: str,
                name: str,
                phone: {
                  country: int,
                  e164: str,
                  number: str
                },
                privacy: {
                  birthDate: str,
                  email: str,
                  phone: str,
                  photo: str
                },
                surname: str,
                unitNumber: int,
                uuid: str
              }
            ],
            movable: bool,
            name: str,
            privacy: {
              address: str,
              coordinates: str,
              photo: str
            },
            surname: str,
            unitNumber: int,
            uuid: str,
            verified: bool
          }
        ]

  get_family_history_report(unit: int = None, timeout_sec: int = None) → Dict[str, Any] | List[Any]

    Returns the unit family history report

    Parameters

    unitint

      Number of the church unit for which to retrieve the report

    timeout_secint

      Number of seconds to wait for a response when making a request

    Returns

        {
          error: bool,
          participationReports: {
            addedAncestor: [
              {
                label: NoneType,
                membersAddingAncestor: int,
                monthEndDate: str,
                monthEndDisplayLabel: str,
                title: str
              }
            ],
            addedMemory: [
              {
                label: NoneType,
                membersAddingMemory: int,
                monthEndDate: str,
                monthEndDisplayLabel: str,
                title: str
              }
            ],
            loggingIn: [
              {
                label: NoneType,
                membersLoggingIn: int,
                monthEndDate: str,
                monthEndDisplayLabel: str,
                title: NoneType
              }
            ],
            membersWhoIndexed: [
              {
                label: NoneType,
                membersIndexing: int,
                monthEndDate: str,
                monthEndDisplayLabel: str,
                title: str
              }
            ],
            percentageFourGen: [
              {
                label: NoneType,
                monthEndDate: str,
                monthEndDisplayLabel: str,
                percent: float,
                title: NoneType
              }
            ],
            yearsInReport: [
              str
            ]
          },
          reportDate: str,
          submitterTrendReport: {
            trendData: [
              {
                label: str,
                months: [
                  {
                    month: int,
                    submitters: int
                  }
                ],
                year: int
              }
            ],
            ytdDiffYearOverYear: int
          },
          ytdSubmittersReports: {
            monthEndDate: str,
            summary: {
              adultPercentage: str,
              adultSubmitters: int,
              convertPercentage: str,
              convertSubmitters: int,
              percentSubmitting: float,
              totalAdults: int,
              totalConverts: int,
              totalMembersSubmitting: int,
              totalPercentage: str,
              totalPotentialSubmitters: int,
              totalYouth: int,
              totalYsa: int,
              unitName: str,
              unitNumber: int,
              youthPercentage: str,
              youthSubmitters: int,
              ysaSubmitters: int,
              ysasPercentage: str
            },
            unitTotals: [
              {
                adultPercentage: str,
                adultSubmitters: int,
                convertPercentage: str,
                convertSubmitters: int,
                percentSubmitting: float,
                totalAdults: int,
                totalConverts: int,
                totalMembersSubmitting: int,
                totalPercentage: str,
                totalPotentialSubmitters: int,
                totalYouth: int,
                totalYsa: int,
                unitName: str,
                unitNumber: int,
                youthPercentage: str,
                youthSubmitters: int,
                ysaSubmitters: int,
                ysasPercentage: str
              }
            ]
          }
        }

  get_full_time_missionaries(unit: int = None, timeout_sec: int = None) → Dict[str, Any] | List[Any]

    Returns a list of the members from the unit currently serving missions

    Parameters unit : int

    > Number of the church unit for which to retrieve the report

    timeout_secint

      Number of seconds to wait for a response when making a request

    Returns

        [
          {
            email: str,
            endDate: str,
            member: {
              accountable: bool,
              actualAge: int,
              actualAgeInMonths: int,
              age: int,
              birthDate: str,
              birthDateFormatted: str,
              birthDateSort: str,
              birthDayFormatted: str,
              birthDaySort: str,
              email: str,
              formattedMrn: NoneType,
              gender: str,
              genderCode: int,
              genderLabelShort: str,
              id: int,
              missionOfficeAddress: NoneType,
              missionUnitName: NoneType,
              missionUnitNumber: NoneType,
              mrn: NoneType,
              name: str,
              nameOrder: NoneType,
              nonMember: bool,
              notAccountable: bool,
              outOfUnitMember: bool,
              phone: str,
              priesthood: NoneType,
              priesthoodCode: NoneType,
              priesthoodType: NoneType,
              setApart: bool,
              spokenName: NoneType,
              sustainedDate: NoneType,
              unitName: NoneType,
              unitNumber: NoneType,
              urlAddressSearch: NoneType,
              visible: NoneType
            },
            missionName: str,
            missionOfficeAddress: NoneType,
            missionUnitNumber: int,
            missionaryHomeUnitName: str,
            missionaryHomeUnitNumber: int,
            missionaryIndividualId: int,
            missionaryName: str,
            myPlanComplete: NoneType,
            myPlanSharing: NoneType,
            myPlanUrl: NoneType,
            seniorMissionary: bool,
            startDate: str,
            status: str,
            urlAddressSearch: NoneType
          }
        ]

  get_group_members(unit: int = None, org_id: int = None, timeout_sec: int = None) → Dict[str, Any] | List[Any]

    Returns the members of a given group, as used by the LCR message/email application

    Parameters

    unitint

      Number of the church unit for which to retrieve the report

    org_idint

      Number of the suborganization of the unit for which to retrieve the members list.

    timeout_secint

      Number of seconds to wait for a response when making a request

    Returns

        {
          members: [
            {
              calling: NoneType,
              cmisIndividualId: int,
              emailAddress: str,
              mrn: NoneType,
              name: str,
              positionDisplayOrder: NoneType,
              unitName: NoneType,
              unsubscribedFromEmail: bool,
              validAddress: bool
            }
          ],
          showCallings: bool,
          showUnitName: bool
        }

  get_key_indicators(unit: int = None, timeout_sec: int = None) → Dict[str, Any] | List[Any]

    Returns the unit key indicators

    Parameters

    unitint

      Number of the church unit for which to retrieve the report

    timeout_secint

      Number of seconds to wait for a response when making a request

    Returns

        {
          quarters: [
            str
          ],
          statistics: [
            {
              label: str,
              name: str,
              stats: [
                int
              ]
            }
          ]
        }

  get_member_callings_and_classes(member_id: int = None, timeout_sec: int = None) → Dict[str, Any] | List[Any]

    Returns the callings and class assignments for the given member

    Parameters

    member_idint

      ID of the member for which to retrieve information

    timeout_secint

      Number of seconds to wait for a response when making a request

    Returns

        {
          authorizedToEditCallings: bool,
          authorizedToEditClassAssignments: bool,
          classAssignments: [
            {
              adultClass: bool,
              classId: int,
              className: str,
              classTypeId: int,
              defaultClass: bool,
              defaultClassTypeId: int,
              group: str,
              individualId: int,
              organization: str
            }
          ],
          householdCallings: [
            {
              activeDate: str,
              allowApprove: bool,
              allowMultiple: bool,
              allowNew: bool,
              allowVacant: bool,
              approvalRequest: bool,
              autoReleasedPositionTypeIds: NoneType,
              canHaveResponsibilities: bool,
              contactEmail: str,
              contactInfoEditable: bool,
              contactMailingAddr: NoneType,
              contactMobilePhone: NoneType,
              contactWorkPhone: NoneType,
              custom: bool,
              customNameChanged: bool,
              dualAuthPass: NoneType,
              dualAuthUser: NoneType,
              editable: bool,
              errors: {},
              expectedEndDate: NoneType,
              hasContactInfo: bool,
              hidden: bool,
              memberEmail: NoneType,
              memberId: int,
              memberName: str,
              memberNameOrder: int,
              memberPhone: NoneType,
              memberUnitName: NoneType,
              memberUnitNumber: NoneType,
              missionName: NoneType,
              missionUnitNumber: NoneType,
              missionary: bool,
              missionaryHomeUnitName: NoneType,
              mrn: NoneType,
              nameVerificationForMrn: NoneType,
              newSubOrgId: NoneType,
              ordainDate: NoneType,
              ordainedByPersonId: NoneType,
              ordainedByPersonMrn: NoneType,
              ordainedByPersonName: NoneType,
              organization: str,
              otherAllowedSubOrgs: [
                {
                  children: list,
                  classGroup: str,
                  defaultOrgTypeIds: [
                    int
                  ],
                  firstTypeId: int,
                  gender: NoneType,
                  isClass: bool,
                  isCombined: bool,
                  isRealClass: bool,
                  isSplit: bool,
                  name: str,
                  orgTypeIds: [
                    int
                  ],
                  parentName: str,
                  subOrgId: int,
                  unitNumber: int,
                  userCanEditCallings: bool
                }
              ],
              parentOrganization: NoneType,
              pendingCalling: bool,
              pendingDelete: bool,
              pendingDualAuth: bool,
              position: str,
              positionDisplayOrder: int,
              positionId: int,
              positionTypeEnum: str,
              positionTypeId: int,
              previouslyOrdained: bool,
              releaseDate: NoneType,
              releasePositionIds: NoneType,
              requiresBishopOrdination: bool,
              requiresDualAuthorization: bool,
              requiresSetApartDateAndPerson: bool,
              responsibilities: NoneType,
              sequence: int,
              setApart: bool,
              setApartByPersonId: NoneType,
              setApartByPersonMrn: NoneType,
              setApartByPersonName: NoneType,
              setApartDate: str,
              showUnitCard: bool,
              subOrgId: int,
              subOrgTypeId: int,
              unitName: str,
              unitNumber: int,
              unpublished: bool,
              userCanEdit: bool,
              userCanEditContactInfoOnly: bool,
              userCannotEditPreviousOrdination: bool,
              vacant: bool
            }
          ],
          individualCallings: [
            {
              activeDate: str,
              allowApprove: bool,
              allowMultiple: bool,
              allowNew: bool,
              allowVacant: bool,
              approvalRequest: bool,
              autoReleasedPositionTypeIds: NoneType,
              canHaveResponsibilities: bool,
              contactEmail: str,
              contactInfoEditable: bool,
              contactMailingAddr: NoneType,
              contactMobilePhone: NoneType,
              contactWorkPhone: NoneType,
              custom: bool,
              customNameChanged: bool,
              dualAuthPass: NoneType,
              dualAuthUser: NoneType,
              editable: bool,
              errors: {},
              expectedEndDate: NoneType,
              hasContactInfo: bool,
              hidden: bool,
              memberEmail: str,
              memberId: int,
              memberName: str,
              memberNameOrder: int,
              memberPhone: NoneType,
              memberUnitName: NoneType,
              memberUnitNumber: NoneType,
              missionName: NoneType,
              missionUnitNumber: NoneType,
              missionary: bool,
              missionaryHomeUnitName: NoneType,
              mrn: NoneType,
              nameVerificationForMrn: NoneType,
              newSubOrgId: NoneType,
              ordainDate: NoneType,
              ordainedByPersonId: NoneType,
              ordainedByPersonMrn: NoneType,
              ordainedByPersonName: NoneType,
              organization: str,
              otherAllowedSubOrgs: [
                {
                  children: list,
                  classGroup: NoneType,
                  defaultOrgTypeIds: [
                    int
                  ],
                  firstTypeId: int,
                  gender: NoneType,
                  isClass: bool,
                  isCombined: bool,
                  isRealClass: bool,
                  isSplit: bool,
                  name: str,
                  orgTypeIds: [
                    int
                  ],
                  parentName: str,
                  subOrgId: int,
                  unitNumber: int,
                  userCanEditCallings: bool
                }
              ],
              parentOrganization: NoneType,
              pendingCalling: bool,
              pendingDelete: bool,
              pendingDualAuth: bool,
              position: str,
              positionDisplayOrder: int,
              positionId: int,
              positionTypeEnum: str,
              positionTypeId: int,
              previouslyOrdained: bool,
              releaseDate: NoneType,
              releasePositionIds: NoneType,
              requiresBishopOrdination: bool,
              requiresDualAuthorization: bool,
              requiresSetApartDateAndPerson: bool,
              responsibilities: NoneType,
              sequence: int,
              setApart: bool,
              setApartByPersonId: NoneType,
              setApartByPersonMrn: NoneType,
              setApartByPersonName: NoneType,
              setApartDate: NoneType,
              showUnitCard: bool,
              subOrgId: int,
              subOrgTypeId: int,
              unitName: str,
              unitNumber: int,
              unpublished: bool,
              userCanEdit: bool,
              userCanEditContactInfoOnly: bool,
              userCannotEditPreviousOrdination: bool,
              vacant: bool
            }
          ],
          subOrgsForPotentialNewCallings: [
            {
              children: list,
              classGroup: NoneType,
              defaultOrgTypeIds: [
                int
              ],
              firstTypeId: int,
              gender: NoneType,
              isClass: bool,
              isCombined: bool,
              isRealClass: bool,
              isSplit: bool,
              name: str,
              orgTypeIds: [
                int
              ],
              parentName: str,
              subOrgId: int,
              unitNumber: int,
              userCanEditCallings: bool
            }
          ]
        }

  get_member_list(unit: int = None, timeout_sec: int = None) → Dict[str, Any] | List[Any]

    Returns the unit member list

    Parameters

    unitint

      Number of the church unit for which to retrieve the report

    timeout_secint

      Number of seconds to wait for a response when making a request

    Returns

        [
          {
            address: {
              addressLines: [
                str
              ],
              formatted1: NoneType,
              formatted2: NoneType,
              formatted3: NoneType,
              formatted4: NoneType,
              formatted5: NoneType,
              formatted6: NoneType,
              formattedAll: list,
              formattedLine1: str,
              formattedLine2: str,
              formattedLine3: NoneType,
              formattedLine4: NoneType,
              useType: NoneType
            },
            age: int,
            birth: {
              country: NoneType,
              date: {
                calc: str,
                date: str,
                display: str
              },
              monthDay: {
                calc: str,
                date: str,
                display: str
              },
              place: NoneType
            },
            convert: bool,
            email: str,
            emails: [
              {
                email: str,
                ownerType: NoneType,
                useType: NoneType
              }
            ],
            formattedAddress: str,
            houseHoldMemberNameForList: str,
            householdAnchorPersonUuid: str,
            householdMember: {
              household: {
                address: {
                  addressLines: [
                    str
                  ],
                  formatted1: NoneType,
                  formatted2: NoneType,
                  formatted3: NoneType,
                  formatted4: NoneType,
                  formatted5: NoneType,
                  formatted6: NoneType,
                  formattedAll: list,
                  formattedLine1: str,
                  formattedLine2: str,
                  formattedLine3: NoneType,
                  formattedLine4: NoneType,
                  useType: NoneType
                },
                anchorPerson: {
                  legacyCmisId: int,
                  uuid: str
                },
                directoryPreferredLocal: str,
                emails: NoneType,
                familyNameLocal: str,
                phones: NoneType,
                unit: {
                  addressUnknown: NoneType,
                  adminUnit: NoneType,
                  cdolLink: NoneType,
                  children: NoneType,
                  nameLatin: NoneType,
                  nameLocal: str,
                  parentUnit: NoneType,
                  positions: NoneType,
                  unitNumber: int,
                  unitType: NoneType,
                  uuid: NoneType
                },
                uuid: str
              },
              householdRole: str,
              membershipUnitFlag: bool
            },
            householdNameDirectoryLocal: str,
            householdNameFamilyLocal: str,
            householdRole: str,
            householdUuid: str,
            households: NoneType,
            isAdult: bool,
            isHead: bool,
            isMember: bool,
            isOutOfUnitMember: bool,
            isProspectiveElder: bool,
            isSingleAdult: bool,
            isSpouse: bool,
            isYoungSingleAdult: bool,
            legacyCmisId: int,
            member: bool,
            membershipUnit: NoneType,
            mrn: NoneType,
            nameFamilyPreferredLocal: str,
            nameFormats: {
              certificateChurchOfficerLocal: NoneType,
              certificateOfficialLocal: NoneType,
              familyPreferredLocal: str,
              givenPreferredLocal: str,
              listOfficial: NoneType,
              listPreferred: NoneType,
              listPreferredLocal: str,
              spokenPreferredLocal: NoneType
            },
            nameGivenPreferredLocal: str,
            nameListPreferredLocal: str,
            nameOrder: int,
            outOfUnitMember: bool,
            personStatusFlags: {
              adult: bool,
              convert: bool,
              deceased: bool,
              hasPatriarchalBlessing: bool,
              member: bool,
              prospectiveElder: bool,
              singleAdult: bool,
              youngSingleAdult: bool
            },
            personUuid: str,
            phoneNumber: str,
            phones: [
              {
                internationalFormat: NoneType,
                number: str,
                ownerType: NoneType,
                useType: NoneType
              }
            ],
            positions: NoneType,
            priesthoodOffice: str,
            priesthoodTeacherOrAbove: bool,
            sex: str,
            unitName: str,
            unitNumber: int,
            unitOrgsCombined: [
              str
            ],
            uuid: str,
            wamPolicy: NoneType,
            youthBasedOnAge: bool
          }
        ]

  get_member_service(member_id: int = None, timeout_sec: int = None) → Dict[str, Any] | List[Any]

    Returns member’s service assignments

    Parameters

    member_idint

      ID of the member for which to retrieve information

    timeout_secint

      Number of seconds to wait for a response when making a request

    Returns

        {
          authorizedToAddEndowment: bool,
          authorizedToEditMelchizedekPriesthood: bool,
          authorizedToPrintCertificates: bool,
          authorizedToPrintMelchizedekPriesthood: bool,
          authorizedToUpdateContactInfo: bool,
          authorizedToUpdateRecord: bool,
          authorizedToViewAnnotations: bool,
          authorizedToViewHTVT: bool,
          authorizedToViewRecord: bool,
          authorizedToViewReportBasic: bool,
          boundaryException: NoneType,
          canChangeMoveRestriction: bool,
          consentFormId: NoneType,
          consentFormMediaType: NoneType,
          family: {
            children: list,
            hohMrn: NoneType,
            marriage: {
              authorizedToViewNonMemberSpouse: bool,
              country: NoneType,
              countryId: NoneType,
              date: NoneType,
              errors: {},
              individualId: int,
              legalNameGroup: NoneType,
              madeHeadOfHousehold: bool,
              marriageId: str,
              marriageTerminated: bool,
              marriageTerminationCause: NoneType,
              memberStatus: NoneType,
              memberType: NoneType,
              mrn: str,
              nonMemberSpouseNameBirthdateNotEditable: bool,
              place: NoneType,
              preferredNameGroup: NoneType,
              restorationOfBlessingsRequired: bool,
              sealedToPriorSpouse: bool,
              sealingDate: NoneType,
              sealingTemple: NoneType,
              showTempleInfo: bool,
              spouse: {
                age: int,
                allPriesthoodOrdinations: NoneType,
                birthDate: str,
                deathDate: NoneType,
                deceased: bool,
                displayBirthDate: str,
                displayMrn: NoneType,
                gender: str,
                headOfHousehold: bool,
                id: int,
                inAuthorizedUnit: bool,
                inHousehold: bool,
                linkedRecord: bool,
                listName: str,
                maidenName: str,
                maidenOrLegalName: str,
                member: bool,
                mrn: NoneType,
                name: str,
                nameGroup: NoneType,
                noMrnInitiated: bool,
                pendingId: NoneType,
                preferredOrLegalName: str,
                priesthood: NoneType,
                priesthoodCode: NoneType,
                priesthoodType: NoneType,
                relationship: str,
                relationshipDisplay: str,
                spokenName: NoneType,
                unitNumber: int,
                unknown: bool
              },
              spouseDeceased: bool,
              spouseEditable: bool,
              spouseId: int,
              spouseInDifferentWardBranch: bool,
              spouseMember: bool,
              spouseMrn: NoneType,
              spouseUnitNumber: int,
              templeId: NoneType,
              terminationDate: NoneType,
              updateName: NoneType,
              updateRequests: NoneType,
              warnings: {}
            },
            parents: NoneType
          },
          household: {
            errors: {},
            familyNameGroup: {
              autoRomanize: bool,
              formattedLatin: str,
              formattedLocal: str,
              name1: {
                family: str,
                given: NoneType,
                label: str,
                labelKey: NoneType,
                suffix: NoneType,
                translitSource: bool,
                writingSystem: str
              },
              name2: NoneType,
              name3: NoneType
            },
            hohMrn: NoneType,
            members: [
              {
                age: int,
                allPriesthoodOrdinations: NoneType,
                birthDate: str,
                deathDate: NoneType,
                deceased: bool,
                displayBirthDate: str,
                displayMrn: NoneType,
                gender: str,
                headOfHousehold: bool,
                id: int,
                inAuthorizedUnit: bool,
                inHousehold: bool,
                linkedRecord: bool,
                listName: str,
                maidenName: NoneType,
                maidenOrLegalName: str,
                member: bool,
                mrn: NoneType,
                name: str,
                nameGroup: NoneType,
                noMrnInitiated: bool,
                pendingId: NoneType,
                preferredOrLegalName: str,
                priesthood: NoneType,
                priesthoodCode: NoneType,
                priesthoodType: NoneType,
                relationship: str,
                relationshipDisplay: str,
                spokenName: NoneType,
                unitNumber: int,
                unknown: bool
              }
            ]
          },
          individual: {
            actualAge: int,
            actualAgeInMonths: int,
            adultAgeOrMarried: bool,
            age: int,
            ageAsOfDec31: int,
            ageAsOfDec31NextYear: NoneType,
            birthCountry: NoneType,
            birthCountryId: NoneType,
            birthDate: str,
            birthDateDisplay: str,
            birthPlace: NoneType,
            canHaveCalling: bool,
            canHaveHTAssignment: bool,
            canHaveMaidenName: bool,
            canHaveVTAssignment: bool,
            confidentialEvents: NoneType,
            email: str,
            endowed: bool,
            errors: {},
            formattedHouseholdCoupleName: str,
            formattedMrn: NoneType,
            gender: str,
            hasOutOfUnitRecord: bool,
            hasPatriarchalBlessing: bool,
            head: bool,
            headInUnit: bool,
            hohId: int,
            hohName: str,
            hqMoveRestriction: bool,
            id: int,
            legalNameGroup: {
              autoRomanize: bool,
              formattedLatin: str,
              formattedLocal: str,
              name1: {
                family: str,
                given: str,
                label: str,
                labelKey: NoneType,
                suffix: NoneType,
                translitSource: bool,
                writingSystem: str
              },
              name2: NoneType,
              name3: NoneType
            },
            maidenNameGroup: {
              autoRomanize: bool,
              formattedLatin: NoneType,
              formattedLocal: NoneType,
              name1: {
                family: NoneType,
                given: NoneType,
                label: str,
                labelKey: NoneType,
                suffix: NoneType,
                translitSource: bool,
                writingSystem: str
              },
              name2: NoneType,
              name3: NoneType
            },
            mailingAddress: {
              city: NoneType,
              country: NoneType,
              district: NoneType,
              formattedLines: NoneType,
              geocodeToUnits: bool,
              lat: NoneType,
              lng: NoneType,
              membershipUpdateRequestAccepted: bool,
              postalCode: NoneType,
              standardized: NoneType,
              state: NoneType,
              street1: NoneType,
              street2: NoneType,
              units: NoneType
            },
            mailingSameAsResidential: bool,
            missionCountry: NoneType,
            missionCountryId: NoneType,
            missionLanguage: NoneType,
            missionLanguageId: NoneType,
            moveDate: NoneType,
            moveDateDuration: NoneType,
            moveRestriction: bool,
            moveRestrictionDate: NoneType,
            mrn: NoneType,
            name: str,
            nameUpdateReason: NoneType,
            notAccountable: bool,
            outOfUnit: bool,
            phone: str,
            preferredNameGroup: {
              autoRomanize: bool,
              formattedLatin: str,
              formattedLocal: str,
              name1: {
                family: str,
                given: str,
                label: str,
                labelKey: NoneType,
                suffix: NoneType,
                translitSource: bool,
                writingSystem: str
              },
              name2: NoneType,
              name3: NoneType
            },
            priesthood: str,
            priesthoodCode: int,
            primaryUnitName: str,
            primaryUnitNumber: NoneType,
            priorUnitName: NoneType,
            priorUnitNumber: NoneType,
            priorUnits: NoneType,
            recommendStatus: NoneType,
            residentialAddress: {
              city: str,
              country: int,
              district: NoneType,
              formattedLines: [
                str
              ],
              geocodeToUnits: bool,
              lat: float,
              lng: float,
              membershipUpdateRequestAccepted: bool,
              postalCode: str,
              standardized: NoneType,
              state: int,
              street1: str,
              street2: NoneType,
              units: NoneType
            },
            restorationOfBlessingsRequired: bool,
            sealedToSpouse: bool,
            spouseId: int,
            spouseInUnit: bool,
            spouseName: str,
            templeRecStatuses: NoneType,
            unitName: str,
            unitNumber: str,
            unsubscribedFromEmail: bool,
            updateRequests: NoneType,
            warnings: {}
          },
          individualName: str,
          membershipUpdateRequests: NoneType,
          ordinances: {
            allOrdinances: [
              {
                bic: bool,
                date: NoneType,
                note: NoneType,
                occurred: bool,
                ordinanceName: str,
                ordinanceType: str,
                templeId: NoneType,
                updateRequestExists: bool
              }
            ],
            baptism: {
              bic: bool,
              date: NoneType,
              note: NoneType,
              occurred: bool,
              ordinanceName: str,
              ordinanceType: str,
              templeId: NoneType,
              updateRequestExists: bool
            },
            bic: {
              bic: bool,
              date: NoneType,
              note: NoneType,
              occurred: bool,
              ordinanceName: str,
              ordinanceType: str,
              templeId: NoneType,
              updateRequestExists: bool
            },
            confirmation: {
              bic: bool,
              date: NoneType,
              note: NoneType,
              occurred: bool,
              ordinanceName: str,
              ordinanceType: str,
              templeId: NoneType,
              updateRequestExists: bool
            },
            endowment: {
              bic: bool,
              date: NoneType,
              note: NoneType,
              occurred: bool,
              ordinanceName: str,
              ordinanceType: str,
              templeId: NoneType,
              updateRequestExists: bool
            },
            errors: {},
            hasEditableFields: bool,
            ordinanceFields: [
              str
            ],
            priesthoods: {
              apostle: NoneType,
              deacon: NoneType,
              elder: {
                aaronic: bool,
                bic: bool,
                date: NoneType,
                melchizedek: bool,
                note: NoneType,
                occurred: bool,
                ordinanceName: str,
                ordinanceType: str,
                priesthoodType: NoneType,
                templeId: NoneType,
                updateRequestExists: bool
              },
              highPriest: NoneType,
              priest: NoneType,
              priesthoods: [
                {
                  aaronic: bool,
                  bic: bool,
                  date: NoneType,
                  melchizedek: bool,
                  note: NoneType,
                  occurred: bool,
                  ordinanceName: str,
                  ordinanceType: str,
                  priesthoodType: NoneType,
                  templeId: NoneType,
                  updateRequestExists: bool
                }
              ],
              seventy: NoneType,
              teacher: NoneType,
              unknown: NoneType
            },
            restorationOfBlessings: bool,
            sealedToParents: NoneType,
            sealedToSpouse: {
              bic: bool,
              date: NoneType,
              note: NoneType,
              occurred: bool,
              ordinanceName: str,
              ordinanceType: str,
              templeId: NoneType,
              updateRequestExists: bool
            },
            updateRequests: NoneType,
            warnings: {}
          },
          outOfUnitMember: bool,
          recommend: NoneType,
          stakeOrDistrictUser: bool,
          unitLocaleData: {
            addressFields: [
              str
            ],
            hasLatinWritingSystem: bool,
            name1WritingSystem: str,
            name2WritingSystem: NoneType
          },
          withinStewardship: bool
        }

  get_members_with_callings(unit: int = None, timeout_sec: int = None) → Dict[str, Any] | List[Any]

    Returns the unit list of members with callings

    Parameters

    unitint

      Number of the church unit for which to retrieve the report

    timeout_secint

      Number of seconds to wait for a response when making a request

    Returns

        [
          {
            activeCalender: str,
            activeDate: str,
            age: int,
            birthDate: str,
            birthDateSort: str,
            birthdDateDisplay: str,
            custom: bool,
            customSubOrgName: NoneType,
            displaySequence: NoneType,
            district: bool,
            email: str,
            errors: {},
            gender: str,
            id: int,
            leaderHomePhone: NoneType,
            leaderWorkPhone: NoneType,
            memberUnitName: str,
            memberUnitNumber: int,
            mrn: str,
            name: str,
            nameOrder: int,
            organization: str,
            outOfUnit: bool,
            parentSubOrgId: int,
            phone: str,
            position: str,
            positionId: int,
            positionTypeId: NoneType,
            priesthood: NoneType,
            setApart: bool,
            setApartCalender: str,
            setApartDate: str,
            spokenName: str,
            stake: bool,
            standardPosition: bool,
            subOrgId: int,
            subOrgType: str,
            subOrgTypeId: int,
            sustainedDate: str,
            unitName: str,
            unitNumber: int
          }
        ]

  get_members_without_callings(unit: int = None, timeout_sec: int = None) → Dict[str, Any] | List[Any]

    Returns the unit list of members without callings

    Parameters

    unitint

      Number of the church unit for which to retrieve the report

    timeout_secint

      Number of seconds to wait for a response when making a request

    Returns

        [
          {
            accountable: bool,
            actualAge: int,
            actualAgeInMonths: int,
            age: int,
            birthDate: str,
            birthDateFormatted: str,
            birthDateSort: str,
            birthDayFormatted: str,
            birthDaySort: str,
            email: str,
            formattedMrn: NoneType,
            gender: str,
            genderCode: int,
            genderLabelShort: str,
            id: int,
            mrn: NoneType,
            name: str,
            nameOrder: NoneType,
            nonMember: bool,
            notAccountable: bool,
            outOfUnitMember: bool,
            phone: str,
            priesthood: NoneType,
            priesthoodCode: NoneType,
            priesthoodType: NoneType,
            setApart: bool,
            spokenName: str,
            sustainedDate: NoneType,
            unitName: str,
            unitNumber: int,
            visible: NoneType
          }
        ]

  get_ministering(unit: int = None, timeout_sec: int = None) → Dict[str, Any] | List[Any]

    Returns the unit ministering assignments

    Parameters

    unitint

      Number of the church unit for which to retrieve the report

    timeout_secint

      Number of seconds to wait for a response when making a request

    Returns

        {
          households: [
            {
              hasReliefSocietyMember: bool,
              headOfHouseholdCmisId: int,
              headOfHouseholdUuid: str,
              householdName: str,
              householdSortOrder: int,
              ministeringBrothers: [
                {
                  age: int,
                  assignType: str,
                  interviews: [
                    {
                      date: str,
                      id: str,
                      month: int,
                      timestamp: str,
                      year: int
                    }
                  ],
                  name: str,
                  nameOrder: int,
                  nameSort: str,
                  personUuid: str,
                  priesthoodOffice: str,
                  unitOrgId: str,
                  youthBasedOnAge: bool
                }
              ],
              ministeringSisters: list,
              unitName: str,
              unitNumber: int
            }
          ],
          individuals: [
            {
              assignments: [
                {
                  age: int,
                  legacyCmisId: int,
                  name: str,
                  nameOrder: int,
                  personUuid: str,
                  youthBasedOnAge: bool
                }
              ],
              companions: [
                {
                  age: int,
                  legacyCmisId: int,
                  name: str,
                  nameOrder: int,
                  personUuid: str,
                  youthBasedOnAge: bool
                }
              ],
              legacyCmisId: int,
              name: str,
              nameOrder: int,
              personUuid: str,
              unitOrgTypeId: int,
              youthBasedOnAge: bool
            }
          ]
        }

  get_ministering_full(unit: int = None, timeout_sec: int = None) → Dict[str, Any] | List[Any]

    Returns the unit ministering assignments as well as interview information

    Parameters

    unitint

      Number of the church unit for which to retrieve the report

    timeout_secint

      Number of seconds to wait for a response when making a request

    Returns

        {
          elders: [
            {
              companionships: [
                {
                  assignmentErrors: list,
                  assignmentWarnings: list,
                  assignments: [
                    {
                      age: int,
                      assignType: str,
                      legacyCmisId: int,
                      name: str,
                      nameSort: str,
                      personUuid: str,
                      youthBasedOnAge: bool
                    }
                  ],
                  id: str,
                  ministerErrors: list,
                  ministerWarnings: list,
                  ministers: [
                    {
                      age: int,
                      assignType: str,
                      email: str,
                      interviews: [
                        {
                          date: str,
                          id: str,
                          month: int,
                          timestamp: str,
                          year: int
                        }
                      ],
                      legacyCmisId: int,
                      name: str,
                      nameSort: str,
                      personUuid: str,
                      priesthoodOffice: str,
                      unitOrgId: str,
                      youthBasedOnAge: bool
                    }
                  ],
                  recentlyChangedDate: str,
                  recentlyChangedDateInMilliseconds: int
                }
              ],
              districtName: str,
              districtUuid: str,
              supervisorLegacyCmisId: int,
              supervisorName: str,
              supervisorPersonUuid: str
            }
          ],
          eldersQuorumSupervisors: [
            {
              name: str,
              personUuid: str,
              youthBasedOnAge: bool
            }
          ],
          error: bool,
          interviewViewAccess: bool,
          reliefSociety: [
            {
              companionships: [
                {
                  assignmentErrors: list,
                  assignmentWarnings: list,
                  assignments: [
                    {
                      age: int,
                      assignType: str,
                      legacyCmisId: int,
                      name: str,
                      nameSort: str,
                      personUuid: str,
                      youthBasedOnAge: bool
                    }
                  ],
                  id: str,
                  ministerErrors: list,
                  ministerWarnings: list,
                  ministers: [
                    {
                      age: int,
                      assignType: str,
                      email: str,
                      interviews: [
                        {
                          date: str,
                          id: str,
                          month: int,
                          timestamp: str,
                          year: int
                        }
                      ],
                      legacyCmisId: int,
                      name: str,
                      nameSort: str,
                      personUuid: str,
                      unitOrgId: str,
                      youthBasedOnAge: bool
                    }
                  ],
                  recentlyChangedDate: str,
                  recentlyChangedDateInMilliseconds: int
                }
              ],
              districtName: str,
              districtUuid: str,
              supervisorLegacyCmisId: int,
              supervisorName: str,
              supervisorPersonUuid: str
            }
          ],
          reliefSocietySupervisors: [
            {
              name: str,
              personUuid: str,
              youthBasedOnAge: bool
            }
          ],
          unitOrgs: [
            {
              children: NoneType,
              isClass: bool,
              unitNumber: NoneType,
              unitOrgName: str,
              unitOrgTypeIds: [
                int
              ],
              unitOrgUuid: str,
              unitUuid: NoneType
            }
          ]
        }

  get_moved_in(unit: int = None, timeout_sec: int = None) → Dict[str, Any] | List[Any]

    Returns the unit list of recently moved in members

    Parameters

    unitint

      Number of the church unit for which to retrieve the report

    timeout_secint

      Number of seconds to wait for a response when making a request

    Returns

        [
          {
            address: str,
            addressUnknown: bool,
            age: int,
            birthdate: str,
            birthdateCalc: str,
            gender: str,
            genderLabelShort: str,
            householdPosition: str,
            householdPositionEnum: str,
            householdUuid: str,
            id: int,
            locale: str,
            moveDate: str,
            moveDateCalc: str,
            moveDateOrder: int,
            name: str,
            nameOrder: int,
            phone: str,
            priesthood: NoneType,
            priorUnitName: str,
            priorUnitNumber: str,
            textAddress: str,
            unitName: str
          }
        ]

  get_moved_out(unit: int = None, timeout_sec: int = None) → Dict[str, Any] | List[Any]

    Returns the unit list of recently moved out members

    Parameters

    unitint

      Number of the church unit for which to retrieve the report

    timeout_secint

      Number of seconds to wait for a response when making a request

    Returns

        [
          {
            addressUnknown: bool,
            birthDate: str,
            deceased: bool,
            moveDate: str,
            moveDateOrder: int,
            name: str,
            nameOrder: int,
            nextUnitName: NoneType,
            nextUnitNumber: NoneType,
            priorUnit: NoneType
          }
        ]

  get_out_of_unit_callings(unit: int = None, timeout_sec: int = None) → Dict[str, Any] | List[Any]

    Returns the unit list of members with callings out of unit

    Parameters

    unitint

      Number of the church unit for which to retrieve the report

    timeout_secint

      Number of seconds to wait for a response when making a request

    Returns

        {
          LIVING_INSIDE: [
            {
              activeCalender: str,
              activeDate: str,
              age: int,
              birthDate: str,
              birthDateSort: str,
              birthdDateDisplay: str,
              custom: bool,
              customSubOrgName: NoneType,
              displaySequence: int,
              district: bool,
              email: str,
              errors: {},
              gender: str,
              id: int,
              leaderHomePhone: NoneType,
              leaderWorkPhone: NoneType,
              memberUnitName: str,
              memberUnitNumber: int,
              mrn: str,
              name: str,
              nameOrder: int,
              organization: str,
              outOfUnit: bool,
              parentSubOrgId: NoneType,
              phone: str,
              position: str,
              positionId: int,
              positionTypeId: int,
              priesthood: NoneType,
              setApart: bool,
              setApartCalender: str,
              setApartDate: str,
              spokenName: str,
              stake: bool,
              standardPosition: bool,
              subOrgId: int,
              subOrgType: str,
              subOrgTypeId: int,
              sustainedDate: str,
              unitName: str,
              unitNumber: int
            }
          ],
          LIVING_OUTSIDE: list
        }

  get_quarterly_reports(unit: int = None, timeout_sec: int = None) → Dict[str, Any] | List[Any]

    Returns all available unit quarterly reports

    Parameters

    unitint

      Number of the church unit for which to retrieve the report

    timeout_secint

      Number of seconds to wait for a response when making a request

    Returns

        {
          2014: {
            4: {
              childUnits: NoneType,
              converts: list,
              dueDate: str,
              editable: bool,
              errors: {},
              initialSubmitDate: str,
              lastSaveDate: str,
              overdue: bool,
              quarter: int,
              sections: [
                {
                  label: str,
                  nameResourceId: str,
                  rows: [
                    {
                      actualListType: str,
                      actualValue: int,
                      calculated: bool,
                      childUnitNumber: NoneType,
                      childUnitRows: NoneType,
                      editable: bool,
                      helpLabel: str,
                      helpResourceId: str,
                      label: str,
                      lineReference: NoneType,
                      nameResourceId: str,
                      number: int,
                      potentialListType: str,
                      potentialValue: int,
                      propertyName: NoneType,
                      updatedActualValue: NoneType,
                      valueStr: NoneType,
                      year1Percent: str,
                      year5Percent: str
                    }
                  ]
                }
              ],
              submitted: bool,
              unitNumber: int,
              version: str,
              year: int
            }
          },
          2015: {
            4: {
              childUnits: NoneType,
              converts: list,
              dueDate: str,
              editable: bool,
              errors: {},
              initialSubmitDate: str,
              lastSaveDate: str,
              overdue: bool,
              quarter: int,
              sections: [
                {
                  label: str,
                  nameResourceId: str,
                  rows: [
                    {
                      actualListType: str,
                      actualValue: int,
                      calculated: bool,
                      childUnitNumber: NoneType,
                      childUnitRows: NoneType,
                      editable: bool,
                      helpLabel: str,
                      helpResourceId: str,
                      label: str,
                      lineReference: NoneType,
                      nameResourceId: str,
                      number: int,
                      potentialListType: str,
                      potentialValue: int,
                      propertyName: NoneType,
                      updatedActualValue: NoneType,
                      valueStr: NoneType,
                      year1Percent: str,
                      year5Percent: str
                    }
                  ]
                }
              ],
              submitted: bool,
              unitNumber: int,
              version: str,
              year: int
            }
          },
          2016: {
            4: {
              childUnits: NoneType,
              converts: list,
              dueDate: str,
              editable: bool,
              errors: {},
              initialSubmitDate: str,
              lastSaveDate: str,
              overdue: bool,
              quarter: int,
              sections: [
                {
                  label: str,
                  nameResourceId: str,
                  rows: [
                    {
                      actualListType: str,
                      actualValue: int,
                      calculated: bool,
                      childUnitNumber: NoneType,
                      childUnitRows: NoneType,
                      editable: bool,
                      helpLabel: str,
                      helpResourceId: str,
                      label: str,
                      lineReference: NoneType,
                      nameResourceId: str,
                      number: int,
                      potentialListType: str,
                      potentialValue: int,
                      propertyName: NoneType,
                      updatedActualValue: NoneType,
                      valueStr: NoneType,
                      year1Percent: str,
                      year5Percent: str
                    }
                  ]
                }
              ],
              submitted: bool,
              unitNumber: int,
              version: str,
              year: int
            }
          },
          2017: {
            4: {
              childUnits: NoneType,
              converts: list,
              dueDate: str,
              editable: bool,
              errors: {},
              initialSubmitDate: str,
              lastSaveDate: str,
              overdue: bool,
              quarter: int,
              sections: [
                {
                  label: str,
                  nameResourceId: str,
                  rows: [
                    {
                      actualListType: str,
                      actualValue: int,
                      calculated: bool,
                      childUnitNumber: NoneType,
                      childUnitRows: NoneType,
                      editable: bool,
                      helpLabel: str,
                      helpResourceId: str,
                      label: str,
                      lineReference: NoneType,
                      nameResourceId: str,
                      number: int,
                      potentialListType: str,
                      potentialValue: int,
                      propertyName: NoneType,
                      updatedActualValue: NoneType,
                      valueStr: NoneType,
                      year1Percent: str,
                      year5Percent: str
                    }
                  ]
                }
              ],
              submitted: bool,
              unitNumber: int,
              version: str,
              year: int
            }
          },
          2018: {
            4: {
              childUnits: NoneType,
              converts: [
                {
                  accountable: bool,
                  actualAge: int,
                  actualAgeInMonths: int,
                  age: int,
                  attendMeetings: bool,
                  birthDate: str,
                  birthDateFormatted: str,
                  birthDateSort: str,
                  birthDayFormatted: str,
                  birthDaySort: str,
                  email: NoneType,
                  formattedMrn: NoneType,
                  gender: str,
                  genderCode: int,
                  genderLabelShort: str,
                  hasCalling: bool,
                  id: int,
                  inAuthorizedUnit: bool,
                  mrn: NoneType,
                  name: str,
                  nameOrder: NoneType,
                  nonMember: bool,
                  notAccountable: bool,
                  outOfUnitMember: bool,
                  phone: NoneType,
                  priesthood: NoneType,
                  priesthoodCode: int,
                  priesthoodType: NoneType,
                  quarterlyReportUnitNumber: int,
                  setApart: bool,
                  spokenName: str,
                  sustainedDate: NoneType,
                  unitName: NoneType,
                  unitNumber: NoneType,
                  visible: NoneType
                }
              ],
              dueDate: str,
              editable: bool,
              errors: {},
              initialSubmitDate: str,
              lastSaveDate: str,
              overdue: bool,
              quarter: int,
              sections: [
                {
                  label: str,
                  nameResourceId: str,
                  rows: [
                    {
                      actualListType: str,
                      actualValue: int,
                      calculated: bool,
                      childUnitNumber: NoneType,
                      childUnitRows: NoneType,
                      editable: bool,
                      helpLabel: str,
                      helpResourceId: str,
                      label: str,
                      lineReference: NoneType,
                      nameResourceId: str,
                      number: int,
                      potentialListType: str,
                      potentialValue: int,
                      propertyName: NoneType,
                      updatedActualValue: NoneType,
                      valueStr: NoneType,
                      year1Percent: str,
                      year5Percent: str
                    }
                  ]
                }
              ],
              submitted: bool,
              unitNumber: int,
              version: str,
              year: int
            }
          },
          2019: {
            4: {
              childUnits: NoneType,
              converts: list,
              dueDate: str,
              editable: bool,
              errors: {},
              initialSubmitDate: str,
              lastSaveDate: str,
              overdue: bool,
              quarter: int,
              sections: [
                {
                  label: str,
                  nameResourceId: str,
                  rows: [
                    {
                      actualListType: str,
                      actualValue: int,
                      calculated: bool,
                      childUnitNumber: NoneType,
                      childUnitRows: NoneType,
                      editable: bool,
                      helpLabel: str,
                      helpResourceId: str,
                      label: str,
                      lineReference: NoneType,
                      nameResourceId: str,
                      number: int,
                      potentialListType: str,
                      potentialValue: int,
                      propertyName: NoneType,
                      updatedActualValue: NoneType,
                      valueStr: NoneType,
                      year1Percent: str,
                      year5Percent: str
                    }
                  ]
                }
              ],
              submitted: bool,
              unitNumber: int,
              version: str,
              year: int
            }
          },
          2020: {
            4: {
              childUnits: NoneType,
              converts: list,
              dueDate: str,
              editable: bool,
              errors: {},
              initialSubmitDate: str,
              lastSaveDate: str,
              overdue: bool,
              quarter: int,
              sections: [
                {
                  label: str,
                  nameResourceId: str,
                  rows: [
                    {
                      actualListType: str,
                      actualValue: int,
                      calculated: bool,
                      childUnitNumber: NoneType,
                      childUnitRows: NoneType,
                      editable: bool,
                      helpLabel: str,
                      helpResourceId: str,
                      label: str,
                      lineReference: NoneType,
                      nameResourceId: str,
                      number: int,
                      potentialListType: str,
                      potentialValue: int,
                      propertyName: NoneType,
                      updatedActualValue: NoneType,
                      valueStr: NoneType,
                      year1Percent: str,
                      year5Percent: str
                    }
                  ]
                }
              ],
              submitted: bool,
              unitNumber: int,
              version: str,
              year: int
            }
          },
          2021: {
            4: {
              childUnits: NoneType,
              converts: list,
              dueDate: str,
              editable: bool,
              errors: {},
              initialSubmitDate: str,
              lastSaveDate: str,
              overdue: bool,
              quarter: int,
              sections: [
                {
                  label: str,
                  nameResourceId: str,
                  rows: [
                    {
                      actualListType: str,
                      actualValue: int,
                      calculated: bool,
                      childUnitNumber: NoneType,
                      childUnitRows: NoneType,
                      editable: bool,
                      helpLabel: str,
                      helpResourceId: str,
                      label: str,
                      lineReference: NoneType,
                      nameResourceId: str,
                      number: int,
                      potentialListType: str,
                      potentialValue: int,
                      propertyName: NoneType,
                      updatedActualValue: NoneType,
                      valueStr: NoneType,
                      year1Percent: str,
                      year5Percent: str
                    }
                  ]
                }
              ],
              submitted: bool,
              unitNumber: int,
              version: str,
              year: int
            }
          },
          2022: {
            4: {
              childUnits: NoneType,
              converts: list,
              dueDate: str,
              editable: bool,
              errors: {},
              initialSubmitDate: str,
              lastSaveDate: str,
              overdue: bool,
              quarter: int,
              sections: [
                {
                  label: str,
                  nameResourceId: str,
                  rows: [
                    {
                      actualListType: str,
                      actualValue: int,
                      calculated: bool,
                      childUnitNumber: NoneType,
                      childUnitRows: NoneType,
                      editable: bool,
                      helpLabel: str,
                      helpResourceId: str,
                      label: str,
                      lineReference: NoneType,
                      nameResourceId: str,
                      number: int,
                      potentialListType: str,
                      potentialValue: int,
                      propertyName: NoneType,
                      updatedActualValue: NoneType,
                      valueStr: NoneType,
                      year1Percent: str,
                      year5Percent: str
                    }
                  ]
                }
              ],
              submitted: bool,
              unitNumber: int,
              version: str,
              year: int
            }
          },
          2023: {
            4: {
              childUnits: NoneType,
              converts: [
                {
                  accountable: bool,
                  actualAge: int,
                  actualAgeInMonths: int,
                  age: int,
                  attendMeetings: bool,
                  birthDate: str,
                  birthDateFormatted: str,
                  birthDateSort: str,
                  birthDayFormatted: str,
                  birthDaySort: str,
                  email: NoneType,
                  formattedMrn: NoneType,
                  gender: str,
                  genderCode: int,
                  genderLabelShort: str,
                  hasCalling: NoneType,
                  id: int,
                  inAuthorizedUnit: bool,
                  mrn: NoneType,
                  name: str,
                  nameOrder: NoneType,
                  nonMember: bool,
                  notAccountable: bool,
                  outOfUnitMember: bool,
                  phone: NoneType,
                  priesthood: NoneType,
                  priesthoodCode: NoneType,
                  priesthoodType: NoneType,
                  quarterlyReportUnitNumber: int,
                  setApart: bool,
                  spokenName: str,
                  sustainedDate: NoneType,
                  unitName: NoneType,
                  unitNumber: NoneType,
                  visible: NoneType
                }
              ],
              dueDate: str,
              editable: bool,
              errors: {},
              initialSubmitDate: str,
              lastSaveDate: str,
              overdue: bool,
              quarter: int,
              sections: [
                {
                  label: str,
                  nameResourceId: str,
                  rows: [
                    {
                      actualListType: str,
                      actualValue: int,
                      calculated: bool,
                      childUnitNumber: NoneType,
                      childUnitRows: NoneType,
                      editable: bool,
                      helpLabel: str,
                      helpResourceId: str,
                      label: str,
                      lineReference: NoneType,
                      nameResourceId: str,
                      number: int,
                      potentialListType: str,
                      potentialValue: int,
                      propertyName: NoneType,
                      updatedActualValue: NoneType,
                      valueStr: NoneType,
                      year1Percent: str,
                      year5Percent: str
                    }
                  ]
                }
              ],
              submitted: bool,
              unitNumber: int,
              version: str,
              year: int
            }
          },
          2024: {
            2: {
              childUnits: NoneType,
              converts: list,
              dueDate: str,
              editable: bool,
              errors: {},
              initialSubmitDate: NoneType,
              lastSaveDate: NoneType,
              overdue: bool,
              quarter: int,
              sections: [
                {
                  label: str,
                  nameResourceId: str,
                  rows: [
                    {
                      actualListType: str,
                      actualValue: int,
                      calculated: bool,
                      childUnitNumber: NoneType,
                      childUnitRows: NoneType,
                      editable: bool,
                      helpLabel: str,
                      helpResourceId: str,
                      label: str,
                      lineReference: NoneType,
                      nameResourceId: str,
                      number: int,
                      potentialListType: str,
                      potentialValue: int,
                      propertyName: NoneType,
                      updatedActualValue: NoneType,
                      valueStr: NoneType,
                      year1Percent: str,
                      year5Percent: str
                    }
                  ]
                }
              ],
              submitted: bool,
              unitNumber: int,
              version: str,
              year: int
            }
          }
        }

  get_seminary_and_institute_quarterly_attendance(unit: int = None, timeout_sec: int = None) → Dict[str, Any] | List[Any]

    Returns all availabe seminary/institute quarterly attendance reports

    Parameters

    unitint

      Number of the church unit for which to retrieve the report

    timeout_secint

      Number of seconds to wait for a response when making a request

    Returns

        {
          2014: {
            4: {
              isStakeTotals: bool,
              quarter: int,
              sections: [
                {
                  comment: str,
                  id: int,
                  name: str,
                  rows: [
                    {
                      actual: int,
                      id: int,
                      name: str,
                      percent: int,
                      potential: int,
                      tooltip: str,
                      value: NoneType,
                      valueIsActual: bool,
                      valueIsPercent: bool,
                      valueIsPotential: bool
                    }
                  ],
                  subSections: list
                }
              ],
              unitAbbreviation: NoneType,
              unitName: str,
              unitNumber: int,
              year: int,
              yearQuarterDisplay: str
            }
          },
          2015: {
            4: {
              isStakeTotals: bool,
              quarter: int,
              sections: [
                {
                  comment: str,
                  id: int,
                  name: str,
                  rows: [
                    {
                      actual: int,
                      id: int,
                      name: str,
                      percent: int,
                      potential: int,
                      tooltip: str,
                      value: NoneType,
                      valueIsActual: bool,
                      valueIsPercent: bool,
                      valueIsPotential: bool
                    }
                  ],
                  subSections: list
                }
              ],
              unitAbbreviation: NoneType,
              unitName: str,
              unitNumber: int,
              year: int,
              yearQuarterDisplay: str
            }
          },
          2016: {
            4: {
              isStakeTotals: bool,
              quarter: int,
              sections: [
                {
                  comment: str,
                  id: int,
                  name: str,
                  rows: [
                    {
                      actual: int,
                      id: int,
                      name: str,
                      percent: int,
                      potential: int,
                      tooltip: str,
                      value: NoneType,
                      valueIsActual: bool,
                      valueIsPercent: bool,
                      valueIsPotential: bool
                    }
                  ],
                  subSections: list
                }
              ],
              unitAbbreviation: NoneType,
              unitName: str,
              unitNumber: int,
              year: int,
              yearQuarterDisplay: str
            }
          },
          2017: {
            4: {
              isStakeTotals: bool,
              quarter: int,
              sections: [
                {
                  comment: str,
                  id: int,
                  name: str,
                  rows: [
                    {
                      actual: int,
                      id: int,
                      name: str,
                      percent: int,
                      potential: int,
                      tooltip: str,
                      value: NoneType,
                      valueIsActual: bool,
                      valueIsPercent: bool,
                      valueIsPotential: bool
                    }
                  ],
                  subSections: list
                }
              ],
              unitAbbreviation: NoneType,
              unitName: str,
              unitNumber: int,
              year: int,
              yearQuarterDisplay: str
            }
          },
          2018: {
            4: {
              isStakeTotals: bool,
              quarter: int,
              sections: [
                {
                  comment: str,
                  id: int,
                  name: str,
                  rows: [
                    {
                      actual: int,
                      id: int,
                      name: str,
                      percent: int,
                      potential: int,
                      tooltip: str,
                      value: NoneType,
                      valueIsActual: bool,
                      valueIsPercent: bool,
                      valueIsPotential: bool
                    }
                  ],
                  subSections: list
                }
              ],
              unitAbbreviation: NoneType,
              unitName: str,
              unitNumber: int,
              year: int,
              yearQuarterDisplay: str
            }
          },
          2019: {
            4: {
              isStakeTotals: bool,
              quarter: int,
              sections: [
                {
                  comment: str,
                  id: int,
                  name: str,
                  rows: [
                    {
                      actual: int,
                      id: int,
                      name: str,
                      percent: int,
                      potential: int,
                      tooltip: str,
                      value: NoneType,
                      valueIsActual: bool,
                      valueIsPercent: bool,
                      valueIsPotential: bool
                    }
                  ],
                  subSections: list
                }
              ],
              unitAbbreviation: NoneType,
              unitName: str,
              unitNumber: int,
              year: int,
              yearQuarterDisplay: str
            }
          },
          2020: {
            4: {
              isStakeTotals: bool,
              quarter: int,
              sections: [
                {
                  comment: str,
                  id: int,
                  name: str,
                  rows: [
                    {
                      actual: int,
                      id: int,
                      name: str,
                      percent: int,
                      potential: int,
                      tooltip: str,
                      value: NoneType,
                      valueIsActual: bool,
                      valueIsPercent: bool,
                      valueIsPotential: bool
                    }
                  ],
                  subSections: list
                }
              ],
              unitAbbreviation: NoneType,
              unitName: str,
              unitNumber: int,
              year: int,
              yearQuarterDisplay: str
            }
          },
          2021: {
            4: {
              isStakeTotals: bool,
              quarter: int,
              sections: [
                {
                  comment: str,
                  id: int,
                  name: str,
                  rows: [
                    {
                      actual: int,
                      id: int,
                      name: str,
                      percent: int,
                      potential: int,
                      tooltip: str,
                      value: NoneType,
                      valueIsActual: bool,
                      valueIsPercent: bool,
                      valueIsPotential: bool
                    }
                  ],
                  subSections: list
                }
              ],
              unitAbbreviation: NoneType,
              unitName: str,
              unitNumber: int,
              year: int,
              yearQuarterDisplay: str
            }
          },
          2022: {
            4: {
              isStakeTotals: bool,
              quarter: int,
              sections: [
                {
                  comment: str,
                  id: int,
                  name: str,
                  rows: [
                    {
                      actual: int,
                      id: int,
                      name: str,
                      percent: int,
                      potential: int,
                      tooltip: str,
                      value: NoneType,
                      valueIsActual: bool,
                      valueIsPercent: bool,
                      valueIsPotential: bool
                    }
                  ],
                  subSections: list
                }
              ],
              unitAbbreviation: NoneType,
              unitName: str,
              unitNumber: int,
              year: int,
              yearQuarterDisplay: str
            }
          },
          2023: {
            4: {
              isStakeTotals: bool,
              quarter: int,
              sections: [
                {
                  comment: str,
                  id: int,
                  name: str,
                  rows: [
                    {
                      actual: int,
                      id: int,
                      name: str,
                      percent: int,
                      potential: int,
                      tooltip: str,
                      value: NoneType,
                      valueIsActual: bool,
                      valueIsPercent: bool,
                      valueIsPotential: bool
                    }
                  ],
                  subSections: list
                }
              ],
              unitAbbreviation: NoneType,
              unitName: str,
              unitNumber: int,
              year: int,
              yearQuarterDisplay: str
            }
          },
          2024: {
            3: {
              isStakeTotals: bool,
              quarter: int,
              sections: [
                {
                  comment: str,
                  id: int,
                  name: str,
                  rows: [
                    {
                      actual: int,
                      id: int,
                      name: str,
                      percent: int,
                      potential: int,
                      tooltip: str,
                      value: NoneType,
                      valueIsActual: bool,
                      valueIsPercent: bool,
                      valueIsPotential: bool
                    }
                  ],
                  subSections: list
                }
              ],
              unitAbbreviation: NoneType,
              unitName: str,
              unitNumber: int,
              year: int,
              yearQuarterDisplay: str
            }
          }
        }

  get_suborganization(org_id: int = None, unit: int = None, timeout_sec: int = None) → Dict[str, Any] | List[Any]

    Returns information for a given suborganization of a unit

    Parameters org_id : int

    > Number of the suborganization of the unit for which to retrieve the report. Defaults to the class assignment for gendered class (Elders’ Quorum, Relief Society, etc.).

    unitint

      Number of the church unit for which to retrieve the report

    timeout_secint

      Number of seconds to wait for a response when making a request

    Returns

        {
          addableSubOrgTypes: NoneType,
          adultClass: bool,
          callings: list,
          canHaveMembers: bool,
          canShowWithNoCallings: bool,
          children: [
            {
              addableSubOrgTypes: NoneType,
              adultClass: bool,
              callings: [
                {
                  activeDate: str,
                  allowApprove: bool,
                  allowMultiple: bool,
                  allowNew: bool,
                  allowVacant: bool,
                  approvalRequest: bool,
                  autoReleasedPositionTypeIds: NoneType,
                  canHaveResponsibilities: bool,
                  contactEmail: str,
                  contactInfoEditable: bool,
                  contactMailingAddr: NoneType,
                  contactMobilePhone: NoneType,
                  contactWorkPhone: NoneType,
                  custom: bool,
                  customNameChanged: bool,
                  dualAuthPass: NoneType,
                  dualAuthUser: NoneType,
                  editable: bool,
                  errors: {},
                  expectedEndDate: NoneType,
                  hasContactInfo: bool,
                  hidden: bool,
                  memberEmail: str,
                  memberId: int,
                  memberName: str,
                  memberNameOrder: int,
                  memberPhone: str,
                  memberUnitName: str,
                  memberUnitNumber: int,
                  missionName: NoneType,
                  missionUnitNumber: NoneType,
                  missionary: bool,
                  missionaryHomeUnitName: NoneType,
                  mrn: NoneType,
                  nameVerificationForMrn: NoneType,
                  newSubOrgId: NoneType,
                  ordainDate: NoneType,
                  ordainedByPersonId: NoneType,
                  ordainedByPersonMrn: NoneType,
                  ordainedByPersonName: NoneType,
                  organization: str,
                  otherAllowedSubOrgs: [
                    {
                      children: list,
                      classGroup: NoneType,
                      defaultOrgTypeIds: [
                        int
                      ],
                      firstTypeId: int,
                      gender: NoneType,
                      isClass: bool,
                      isCombined: bool,
                      isRealClass: bool,
                      isSplit: bool,
                      name: str,
                      orgTypeIds: [
                        int
                      ],
                      parentName: str,
                      subOrgId: int,
                      unitNumber: int,
                      userCanEditCallings: bool
                    }
                  ],
                  parentOrganization: NoneType,
                  pendingCalling: bool,
                  pendingDelete: bool,
                  pendingDualAuth: bool,
                  position: str,
                  positionDisplayOrder: int,
                  positionId: int,
                  positionTypeEnum: str,
                  positionTypeId: int,
                  previouslyOrdained: bool,
                  releaseDate: NoneType,
                  releasePositionIds: NoneType,
                  requiresBishopOrdination: bool,
                  requiresDualAuthorization: bool,
                  requiresSetApartDateAndPerson: bool,
                  responsibilities: NoneType,
                  sequence: int,
                  setApart: bool,
                  setApartByPersonId: NoneType,
                  setApartByPersonMrn: NoneType,
                  setApartByPersonName: NoneType,
                  setApartDate: str,
                  showUnitCard: bool,
                  subOrgId: int,
                  subOrgTypeId: int,
                  unitName: NoneType,
                  unitNumber: int,
                  unpublished: bool,
                  userCanEdit: bool,
                  userCanEditContactInfoOnly: bool,
                  userCannotEditPreviousOrdination: bool,
                  vacant: bool
                }
              ],
              canHaveMembers: bool,
              canShowWithNoCallings: bool,
              children: list,
              classGroup: NoneType,
              classes: NoneType,
              classesCollapsed: bool,
              customOrgName: NoneType,
              customPositionsAllowed: bool,
              defaultOrgName: str,
              displayOrder: int,
              enableHT: bool,
              enableVT: bool,
              filterOffices: list,
              firstOrgType: str,
              firstOrgTypeId: int,
              firstOrgTypeName: NoneType,
              gender: NoneType,
              hasAnyAllowMultiple: bool,
              hasCustomCallings: bool,
              highCouncilOrDistrictCouncil: bool,
              instance: int,
              isSplit: bool,
              leadershipSubOrgId: NoneType,
              members: list,
              mergeableSubOrgTypeIds: list,
              missionaries: bool,
              multipleAllowed: bool,
              name: str,
              nameEditable: bool,
              orgTypeIds: [
                int
              ],
              other: bool,
              parentName: str,
              parentSubOrgId: int,
              positionTypeIdsThatCanHaveResponsibilities: list,
              priesthood: bool,
              relatedSubOrgName: NoneType,
              required: bool,
              resetable: bool,
              room: NoneType,
              size: NoneType,
              splitOrCombinedClassNotice: NoneType,
              subOrgId: int,
              supportsAttendanceRoll: bool,
              totalInstances: int,
              unitNumber: int,
              unitType: int,
              userCanEditCallings: bool,
              userCanEditClassAssignments: bool,
              userCanSeeBasicInfo: bool
            }
          ],
          classGroup: str,
          classes: NoneType,
          classesCollapsed: bool,
          customOrgName: NoneType,
          customPositionsAllowed: bool,
          defaultOrgName: str,
          displayOrder: int,
          enableHT: bool,
          enableVT: bool,
          filterOffices: [
            {
              codes: [
                int
              ],
              name: str
            }
          ],
          firstOrgType: str,
          firstOrgTypeId: int,
          firstOrgTypeName: NoneType,
          gender: str,
          hasAnyAllowMultiple: bool,
          hasCustomCallings: bool,
          highCouncilOrDistrictCouncil: bool,
          instance: int,
          isSplit: bool,
          leadershipSubOrgId: NoneType,
          members: [
            {
              accountable: bool,
              actualAge: int,
              actualAgeInMonths: int,
              address: str,
              adultAgeOrMarried: bool,
              age: int,
              birthDate: str,
              birthDateFormatted: str,
              birthDateSort: str,
              birthDayFormatted: str,
              birthDaySort: str,
              defaultClass: bool,
              defaultClassTypeId: int,
              eligibleForHomeTeachingAssignment: bool,
              email: str,
              endowed: bool,
              formattedMrn: NoneType,
              gender: str,
              genderCode: int,
              genderLabelShort: str,
              htvtAssignments: NoneType,
              htvtCompanions: NoneType,
              id: int,
              mrn: NoneType,
              name: str,
              nameOrder: int,
              nonMember: bool,
              notAccountable: bool,
              outOfUnitMember: bool,
              phone: str,
              priesthood: NoneType,
              priesthoodCode: int,
              priesthoodType: NoneType,
              sealedToSpouse: bool,
              setApart: bool,
              spokenName: str,
              sustainedDate: NoneType,
              unitName: str,
              unitNumber: int,
              visible: NoneType
            }
          ],
          mergeableSubOrgTypeIds: list,
          missionaries: bool,
          multipleAllowed: bool,
          name: str,
          nameEditable: bool,
          orgTypeIds: [
            int
          ],
          other: bool,
          parentName: str,
          parentSubOrgId: NoneType,
          positionTypeIdsThatCanHaveResponsibilities: list,
          priesthood: bool,
          relatedSubOrgName: NoneType,
          required: bool,
          resetable: bool,
          room: NoneType,
          size: NoneType,
          splitOrCombinedClassNotice: NoneType,
          subOrgId: int,
          supportsAttendanceRoll: bool,
          totalInstances: int,
          unitNumber: int,
          unitType: int,
          userCanEditCallings: bool,
          userCanEditClassAssignments: bool,
          userCanSeeBasicInfo: bool
        }

  get_temple_recommend_status(unit: int = None, timeout_sec: int = None) → Dict[str, Any] | List[Any]

    Returns the temple recommend status

    Parameters

    unitint

      Number of the church unit for which to retrieve the report

    timeout_secint

      Number of seconds to wait for a response when making a request

    Returns

        {
          reportData: [
            {
              endowmentDisplay: NoneType,
              endowmentSort: NoneType,
              expiredDisplay: str,
              expiredSort: str,
              genderDisplay: str,
              recommendReportLine: {
                age: int,
                baptized: bool,
                editable: bool,
                endowmentDate: NoneType,
                expirationDate: str,
                gender: str,
                issuable: bool,
                mediaType: str,
                memberName: str,
                missionary: bool,
                mrn: str,
                phoneNumber: str,
                priesthood: NoneType,
                recommendNumber: int,
                recommendStatus: str,
                recommendType: str,
                unitName: str,
                unitNumber: int
              },
              statusDisplay: str,
              statusExtended: str,
              statusFilter: str,
              typeDisplay: str,
              unitFilter: NoneType,
              youth: bool
            }
          ],
          statusFilterOptions: [
            {
              label: str,
              value: str
            }
          ],
          typeFilterOptions: [
            {
              label: str,
              value: str
            }
          ]
        }

  get_unit_groups(timeout_sec: int = None) → Dict[str, Any] | List[Any]

    Returns the unit groups, as used by the email/message application

    Parameters

    timeout_secint

      Number of seconds to wait for a response when making a request

    Returns

        [
          {
            categoryName: str,
            groups: [
              {
                groupName: str,
                subOrgId: int
              }
            ]
          }
        ]

  get_unit_organizations(unit: int = None, timeout_sec: int = None) → Dict[str, Any] | List[Any]

    Returns the unit calling/leadership organization structure

    Parameters

    unitint

      Number of the church unit for which to retrieve the report

    timeout_secint

      Number of seconds to wait for a response when making a request

    Returns

        [
          {
            addableSubOrgTypes: NoneType,
            adultClass: bool,
            callings: [
              {
                activeDate: str,
                allowApprove: bool,
                allowMultiple: bool,
                allowNew: bool,
                allowVacant: bool,
                approvalRequest: bool,
                autoReleasedPositionTypeIds: NoneType,
                canHaveResponsibilities: bool,
                contactEmail: str,
                contactInfoEditable: bool,
                contactMailingAddr: {
                  city: str,
                  country: int,
                  district: NoneType,
                  formattedLines: list,
                  geocodeToUnits: bool,
                  lat: NoneType,
                  lng: NoneType,
                  membershipUpdateRequestAccepted: bool,
                  postalCode: str,
                  standardized: NoneType,
                  state: int,
                  street1: str,
                  street2: NoneType,
                  units: NoneType
                },
                contactMobilePhone: str,
                contactWorkPhone: NoneType,
                custom: bool,
                customNameChanged: bool,
                dualAuthPass: NoneType,
                dualAuthUser: NoneType,
                editable: bool,
                errors: {},
                expectedEndDate: NoneType,
                hasContactInfo: bool,
                hidden: bool,
                memberEmail: str,
                memberId: int,
                memberName: str,
                memberNameOrder: int,
                memberPhone: str,
                memberUnitName: str,
                memberUnitNumber: int,
                missionName: NoneType,
                missionUnitNumber: NoneType,
                missionary: bool,
                missionaryHomeUnitName: NoneType,
                mrn: NoneType,
                nameVerificationForMrn: NoneType,
                newSubOrgId: NoneType,
                ordainDate: str,
                ordainedByPersonId: int,
                ordainedByPersonMrn: str,
                ordainedByPersonName: str,
                organization: str,
                otherAllowedSubOrgs: [
                  {
                    children: list,
                    classGroup: NoneType,
                    defaultOrgTypeIds: [
                      int
                    ],
                    firstTypeId: int,
                    gender: NoneType,
                    isClass: bool,
                    isCombined: bool,
                    isRealClass: bool,
                    isSplit: bool,
                    name: str,
                    orgTypeIds: [
                      int
                    ],
                    parentName: NoneType,
                    subOrgId: int,
                    unitNumber: int,
                    userCanEditCallings: bool
                  }
                ],
                parentOrganization: NoneType,
                pendingCalling: bool,
                pendingDelete: bool,
                pendingDualAuth: bool,
                position: str,
                positionDisplayOrder: int,
                positionId: int,
                positionTypeEnum: str,
                positionTypeId: int,
                previouslyOrdained: bool,
                releaseDate: NoneType,
                releasePositionIds: NoneType,
                requiresBishopOrdination: bool,
                requiresDualAuthorization: bool,
                requiresSetApartDateAndPerson: bool,
                responsibilities: NoneType,
                sequence: int,
                setApart: bool,
                setApartByPersonId: int,
                setApartByPersonMrn: str,
                setApartByPersonName: str,
                setApartDate: str,
                showUnitCard: bool,
                subOrgId: int,
                subOrgTypeId: int,
                unitName: NoneType,
                unitNumber: int,
                unpublished: bool,
                userCanEdit: bool,
                userCanEditContactInfoOnly: bool,
                userCannotEditPreviousOrdination: bool,
                vacant: bool
              }
            ],
            canHaveMembers: bool,
            canShowWithNoCallings: bool,
            children: list,
            classGroup: NoneType,
            classes: NoneType,
            classesCollapsed: bool,
            customOrgName: NoneType,
            customPositionsAllowed: bool,
            defaultOrgName: str,
            displayOrder: int,
            enableHT: bool,
            enableVT: bool,
            filterOffices: list,
            firstOrgType: str,
            firstOrgTypeId: int,
            firstOrgTypeName: NoneType,
            gender: NoneType,
            hasAnyAllowMultiple: bool,
            hasCustomCallings: bool,
            highCouncilOrDistrictCouncil: bool,
            instance: int,
            isSplit: bool,
            leadershipSubOrgId: NoneType,
            members: list,
            mergeableSubOrgTypeIds: list,
            missionaries: bool,
            multipleAllowed: bool,
            name: str,
            nameEditable: bool,
            orgTypeIds: [
              int
            ],
            other: bool,
            parentName: str,
            parentSubOrgId: NoneType,
            positionTypeIdsThatCanHaveResponsibilities: list,
            priesthood: bool,
            relatedSubOrgName: NoneType,
            required: bool,
            resetable: bool,
            room: NoneType,
            size: NoneType,
            splitOrCombinedClassNotice: NoneType,
            subOrgId: int,
            supportsAttendanceRoll: bool,
            totalInstances: int,
            unitNumber: int,
            unitType: int,
            userCanEditCallings: bool,
            userCanEditClassAssignments: bool,
            userCanSeeBasicInfo: bool
          }
        ]

  get_unit_statistics(unit: int = None, timeout_sec: int = None) → Dict[str, Any] | List[Any]

    Returns the unit statistics

    Parameters

    unitint

      Number of the church unit for which to retrieve the report

    timeout_secint

      Number of seconds to wait for a response when making a request

    Returns

        {
          adultFemaleRecentConverts: int,
          adultFemaleRecentConvertsIndividualIds: list,
          adultMaleRecentConverts: int,
          adultMaleRecentConvertsIndividualIds: list,
          adults: int,
          adultsIndividualIds: [
            int
          ],
          baptizedNotConfirmed: int,
          baptizedNotConfirmedIndividualIds: list,
          beehive: int,
          beehiveIndividualIds: [
            int
          ],
          children: int,
          childrenAge8to11RecentConverts: int,
          childrenAge8to11RecentConvertsIndividualIds: list,
          childrenIndividualIds: [
            int
          ],
          deacons: int,
          deaconsIndividualIds: [
            int
          ],
          elders: int,
          eldersIndividualIds: [
            int
          ],
          endowedAdults: int,
          endowedAdultsIndividualIds: list,
          endowedWithRecommend: int,
          endowedWithRecommendIndividualIds: list,
          endowedWithoutRecommend: int,
          endowedWithoutRecommendIndividualIds: list,
          highPriests: int,
          highPriestsIndividualIds: [
            int
          ],
          households: int,
          householdsIndividualIds: [
            int
          ],
          householdsWithChildren: int,
          householdsWithChildrenIndividualIds: [
            int
          ],
          householdsWithSingleParentAndYouthOrChildren: int,
          householdsWithSingleParentAndYouthOrChildrenIndividualIds: [
            int
          ],
          householdsWithYouth: int,
          householdsWithYouthIndividualIds: [
            int
          ],
          householdsWithoutMelchizedekPriesthoodHolder: int,
          householdsWithoutMelchizedekPriesthoodHolderIndividualIds: [
            int
          ],
          individualsNotIncluded: int,
          individualsNotIncludedIndividualIds: [
            int
          ],
          infants: int,
          infantsIndividualIds: [
            int
          ],
          invalidBirthdate: int,
          invalidBirthdateIndividualIds: list,
          laurels: int,
          laurelsIndividualIds: [
            int
          ],
          marriedAdults: int,
          marriedAdultsIndividualIds: [
            int
          ],
          membersOfRecordAge9OrOlder: int,
          membersOfRecordAge9OrOlderIndividualIds: [
            int
          ],
          men: int,
          menIndividualIds: [
            int
          ],
          miaMaids: int,
          miaMaidsIndividualIds: [
            int
          ],
          ordainedRecentConverts: int,
          ordainedRecentConvertsIndividualIds: list,
          priests: int,
          priestsIndividualIds: [
            int
          ],
          prospectiveElders: int,
          prospectiveEldersIndividualIds: [
            int
          ],
          recentConverts: int,
          recentConvertsEligibleForOrdination: int,
          recentConvertsEligibleForOrdinationIndividualIds: list,
          recentConvertsIndividualIds: list,
          shortUnitName: NoneType,
          singleAdults: int,
          singleAdultsIndividualIds: [
            int
          ],
          teachers: int,
          teachersIndividualIds: [
            int
          ],
          totalMembers: int,
          totalMembersIndividualIds: [
            int
          ],
          unitName: NoneType,
          unitNumber: int,
          unitType: NoneType,
          unordainedRecentConverts: int,
          unordainedRecentConvertsIndividualIds: list,
          women: int,
          womenIndividualIds: [
            int
          ],
          youngMen: int,
          youngMenIndividualIds: [
            int
          ],
          youngMenRecentConverts: int,
          youngMenRecentConvertsIndividualIds: list,
          youngSingleAdults: int,
          youngSingleAdultsIndividualIds: [
            int
          ],
          youngWomen: int,
          youngWomen12_13: int,
          youngWomen12_13IndividualIds: [
            int
          ],
          youngWomen14_15: int,
          youngWomen14_15IndividualIds: [
            int
          ],
          youngWomen16_17: int,
          youngWomen16_17IndividualIds: [
            int
          ],
          youngWomenIndividualIds: [
            int
          ],
          youngWomenRecentConverts: int,
          youngWomenRecentConvertsIndividualIds: list
        }

  get_units(parent_unit: int = None, timeout_sec: int = None) → Dict[str, Any] | List[Any]

    Returns a list of child units for the given parent unit

    Parameters

    parent_unitint

      Number of the church unit for which to retrieve a list of child units

    timeout_secint

      Number of seconds to wait for a response when making a request

    Returns

        {
          childUnits: [
            {
              name: str,
              unitNumber: int,
              unitType: str
            }
          ],
          name: str,
          unitNumber: int,
          unitType: str
        }

  property org_id
  property session

    Returns the requests session being used by the API.

  property user_details

    Returns the details of the user logged into this session

    Returns

        {
          emails: [
            {
              email: str,
              privacy: str,
              useType: str
            }
          ],
          households: [
            {
              household: {
                addresses: [
                  {
                    postalCode: str
                  }
                ]
              }
            }
          ],
          legacyCmisId: str,
          membershipUnit: {
            areaUnit: [
              {
                unitNumber: str
              }
            ],
            country: {
              name: str,
              nameLatin: str,
              nameLocal: str
            },
            nameLocal: str,
            parentUnit: {
              nameLocal: str,
              unitNumber: str,
              unitType: {
                id: str,
                name: str
              }
            },
            templeUnit: [
              {
                nameLatin: str,
                nameLocal: str,
                unitNumber: str,
                uuid: str
              }
            ],
            unitNumber: str,
            unitType: {
              id: str,
              name: str
            },
            wardClerk: [
              {
                person: {
                  emails: [
                    {
                      email: str,
                      privacy: str,
                      useType: str
                    }
                  ]
                }
              }
            ]
          },
          nameFormats: {
            familyPreferred: str,
            givenPreferred: str,
            listPreferred: str,
            mailPreferred: str,
            spokenPreferred: str
          },
          positions: [
            {
              positionType: {
                id: str,
                name: str
              }
            }
          ],
          uuid: str
        }

## Module contents