# coding=utf-8
# --------------------------------------------------------------------------
# Code generated by Microsoft (R) AutoRest Code Generator (autorest: 3.8.3, generator: @autorest/python@5.11.2)
# Changes may cause incorrect behavior and will be lost if the code is regenerated.
# --------------------------------------------------------------------------

import datetime
from typing import IO, List, Optional, Union

from azure.core.exceptions import HttpResponseError
import msrest.serialization

from ._affinda_api_enums import *


class Components1TryetgSchemasResumedataPropertiesWorkexperienceItemsPropertiesOccupationPropertiesClassification(
    msrest.serialization.Model
):
    """Components1TryetgSchemasResumedataPropertiesWorkexperienceItemsPropertiesOccupationPropertiesClassification.

    :ivar title: SOC2020 classification for this job title.
    :vartype title: str
    :ivar minor_group: SOC2020 minor group.
    :vartype minor_group: str
    :ivar sub_major_group: SOC2020 sub major group.
    :vartype sub_major_group: str
    :ivar major_group: SOC2020 major group.
    :vartype major_group: str
    :ivar soc_code: The 4 digit code representing the SOC2020 classification for this job title.
    :vartype soc_code: int
    """

    _attribute_map = {
        "title": {"key": "title", "type": "str"},
        "minor_group": {"key": "minorGroup", "type": "str"},
        "sub_major_group": {"key": "subMajorGroup", "type": "str"},
        "major_group": {"key": "majorGroup", "type": "str"},
        "soc_code": {"key": "socCode", "type": "int"},
    }

    def __init__(
        self,
        *,
        title: Optional[str] = None,
        minor_group: Optional[str] = None,
        sub_major_group: Optional[str] = None,
        major_group: Optional[str] = None,
        soc_code: Optional[int] = None,
        **kwargs,
    ):
        """
        :keyword title: SOC2020 classification for this job title.
        :paramtype title: str
        :keyword minor_group: SOC2020 minor group.
        :paramtype minor_group: str
        :keyword sub_major_group: SOC2020 sub major group.
        :paramtype sub_major_group: str
        :keyword major_group: SOC2020 major group.
        :paramtype major_group: str
        :keyword soc_code: The 4 digit code representing the SOC2020 classification for this job title.
        :paramtype soc_code: int
        """
        super(
            Components1TryetgSchemasResumedataPropertiesWorkexperienceItemsPropertiesOccupationPropertiesClassification,
            self,
        ).__init__(**kwargs)
        self.title = title
        self.minor_group = minor_group
        self.sub_major_group = sub_major_group
        self.major_group = major_group
        self.soc_code = soc_code


class Error(msrest.serialization.Model):
    """Error.

    :ivar error_code:
    :vartype error_code: str
    :ivar error_detail:
    :vartype error_detail: str
    """

    _attribute_map = {
        "error_code": {"key": "errorCode", "type": "str"},
        "error_detail": {"key": "errorDetail", "type": "str"},
    }

    def __init__(
        self, *, error_code: Optional[str] = None, error_detail: Optional[str] = None, **kwargs
    ):
        """
        :keyword error_code:
        :paramtype error_code: str
        :keyword error_detail:
        :paramtype error_detail: str
        """
        super(Error, self).__init__(**kwargs)
        self.error_code = error_code
        self.error_detail = error_detail


class Get200ApplicationJsonPropertiesItemsItem(msrest.serialization.Model):
    """Get200ApplicationJsonPropertiesItemsItem.

    All required parameters must be populated in order to send to Azure.

    :ivar identifier: Required. Unique identifier for the document. If creating a document and left
     blank, one will be automatically generated.
    :vartype identifier: str
    :ivar format_file: Required. URL to a template to apply.
    :vartype format_file: str
    """

    _validation = {
        "identifier": {"required": True},
        "format_file": {"required": True},
    }

    _attribute_map = {
        "identifier": {"key": "identifier", "type": "str"},
        "format_file": {"key": "formatFile", "type": "str"},
    }

    def __init__(self, *, identifier: str, format_file: str, **kwargs):
        """
        :keyword identifier: Required. Unique identifier for the document. If creating a document and
         left blank, one will be automatically generated.
        :paramtype identifier: str
        :keyword format_file: Required. URL to a template to apply.
        :paramtype format_file: str
        """
        super(Get200ApplicationJsonPropertiesItemsItem, self).__init__(**kwargs)
        self.identifier = identifier
        self.format_file = format_file


class GetAllDocumentsResults(msrest.serialization.Model):
    """GetAllDocumentsResults.

    :ivar count: Number of documents in result.
    :vartype count: int
    :ivar next: URL to request next page of results.
    :vartype next: str
    :ivar previous: URL to request previous page of results.
    :vartype previous: str
    :ivar results:
    :vartype results: list[~affinda.models.Meta]
    """

    _attribute_map = {
        "count": {"key": "count", "type": "int"},
        "next": {"key": "next", "type": "str"},
        "previous": {"key": "previous", "type": "str"},
        "results": {"key": "results", "type": "[Meta]"},
    }

    def __init__(
        self,
        *,
        count: Optional[int] = None,
        next: Optional[str] = None,
        previous: Optional[str] = None,
        results: Optional[List["Meta"]] = None,
        **kwargs,
    ):
        """
        :keyword count: Number of documents in result.
        :paramtype count: int
        :keyword next: URL to request next page of results.
        :paramtype next: str
        :keyword previous: URL to request previous page of results.
        :paramtype previous: str
        :keyword results:
        :paramtype results: list[~affinda.models.Meta]
        """
        super(GetAllDocumentsResults, self).__init__(**kwargs)
        self.count = count
        self.next = next
        self.previous = previous
        self.results = results


class GetAllInvoicesResults(msrest.serialization.Model):
    """GetAllInvoicesResults.

    :ivar count: Number of documents in result.
    :vartype count: int
    :ivar next: URL to request next page of results.
    :vartype next: str
    :ivar previous: URL to request previous page of results.
    :vartype previous: str
    :ivar results:
    :vartype results: list[~affinda.models.Meta]
    """

    _attribute_map = {
        "count": {"key": "count", "type": "int"},
        "next": {"key": "next", "type": "str"},
        "previous": {"key": "previous", "type": "str"},
        "results": {"key": "results", "type": "[Meta]"},
    }

    def __init__(
        self,
        *,
        count: Optional[int] = None,
        next: Optional[str] = None,
        previous: Optional[str] = None,
        results: Optional[List["Meta"]] = None,
        **kwargs,
    ):
        """
        :keyword count: Number of documents in result.
        :paramtype count: int
        :keyword next: URL to request next page of results.
        :paramtype next: str
        :keyword previous: URL to request previous page of results.
        :paramtype previous: str
        :keyword results:
        :paramtype results: list[~affinda.models.Meta]
        """
        super(GetAllInvoicesResults, self).__init__(**kwargs)
        self.count = count
        self.next = next
        self.previous = previous
        self.results = results


class Invoice(msrest.serialization.Model):
    """Invoice.

    All required parameters must be populated in order to send to Azure.

    :ivar data: Required.
    :vartype data: ~affinda.models.InvoiceData
    :ivar meta: Required.
    :vartype meta: ~affinda.models.Meta
    :ivar error: Required.
    :vartype error: ~affinda.models.Error
    """

    _validation = {
        "data": {"required": True},
        "meta": {"required": True},
        "error": {"required": True},
    }

    _attribute_map = {
        "data": {"key": "data", "type": "InvoiceData"},
        "meta": {"key": "meta", "type": "Meta"},
        "error": {"key": "error", "type": "Error"},
    }

    def __init__(self, *, data: "InvoiceData", meta: "Meta", error: "Error", **kwargs):
        """
        :keyword data: Required.
        :paramtype data: ~affinda.models.InvoiceData
        :keyword meta: Required.
        :paramtype meta: ~affinda.models.Meta
        :keyword error: Required.
        :paramtype error: ~affinda.models.Error
        """
        super(Invoice, self).__init__(**kwargs)
        self.data = data
        self.meta = meta
        self.error = error


class InvoiceData(msrest.serialization.Model):
    """InvoiceData.

    :ivar invoice_date:
    :vartype invoice_date: str
    :ivar invoice_order_date:
    :vartype invoice_order_date: str
    :ivar payment_date_due:
    :vartype payment_date_due: str
    :ivar payment_amount_base:
    :vartype payment_amount_base: str
    :ivar payment_amount_tax:
    :vartype payment_amount_tax: str
    :ivar payment_amount_total:
    :vartype payment_amount_total: str
    :ivar payment_amount_paid:
    :vartype payment_amount_paid: str
    :ivar payment_amount_due:
    :vartype payment_amount_due: str
    :ivar invoice_number:
    :vartype invoice_number: str
    :ivar invoice_purchase_order_number:
    :vartype invoice_purchase_order_number: str
    :ivar supplier_business_number:
    :vartype supplier_business_number: str
    :ivar customer_number:
    :vartype customer_number: str
    :ivar customer_business_number:
    :vartype customer_business_number: str
    :ivar payment_reference:
    :vartype payment_reference: str
    :ivar bank_account_number:
    :vartype bank_account_number: str
    :ivar supplier_vat:
    :vartype supplier_vat: str
    :ivar customer_vat:
    :vartype customer_vat: str
    :ivar bpay_biller_code:
    :vartype bpay_biller_code: str
    :ivar bpay_reference:
    :vartype bpay_reference: str
    :ivar bank_sort_code:
    :vartype bank_sort_code: str
    :ivar bank_iban:
    :vartype bank_iban: str
    :ivar bank_swift:
    :vartype bank_swift: str
    :ivar bank_bsb:
    :vartype bank_bsb: str
    :ivar customer_contact_name:
    :vartype customer_contact_name: str
    :ivar customer_company_name:
    :vartype customer_company_name: str
    :ivar supplier_company_name:
    :vartype supplier_company_name: str
    :ivar customer_billing_address:
    :vartype customer_billing_address: ~affinda.models.Location
    :ivar customer_delivery_address:
    :vartype customer_delivery_address: ~affinda.models.Location
    :ivar supplier_address:
    :vartype supplier_address: ~affinda.models.Location
    :ivar customer_phone_number:
    :vartype customer_phone_number: str
    :ivar supplier_phone_number:
    :vartype supplier_phone_number: str
    :ivar supplier_fax:
    :vartype supplier_fax: str
    :ivar customer_email:
    :vartype customer_email: str
    :ivar supplier_email:
    :vartype supplier_email: str
    :ivar supplier_website:
    :vartype supplier_website: str
    """

    _attribute_map = {
        "invoice_date": {"key": "invoiceDate", "type": "str"},
        "invoice_order_date": {"key": "invoiceOrderDate", "type": "str"},
        "payment_date_due": {"key": "paymentDateDue", "type": "str"},
        "payment_amount_base": {"key": "paymentAmountBase", "type": "str"},
        "payment_amount_tax": {"key": "paymentAmountTax", "type": "str"},
        "payment_amount_total": {"key": "paymentAmountTotal", "type": "str"},
        "payment_amount_paid": {"key": "paymentAmountPaid", "type": "str"},
        "payment_amount_due": {"key": "paymentAmountDue", "type": "str"},
        "invoice_number": {"key": "invoiceNumber", "type": "str"},
        "invoice_purchase_order_number": {"key": "invoicePurchaseOrderNumber", "type": "str"},
        "supplier_business_number": {"key": "supplierBusinessNumber", "type": "str"},
        "customer_number": {"key": "customerNumber", "type": "str"},
        "customer_business_number": {"key": "customerBusinessNumber", "type": "str"},
        "payment_reference": {"key": "paymentReference", "type": "str"},
        "bank_account_number": {"key": "bankAccountNumber", "type": "str"},
        "supplier_vat": {"key": "supplierVAT", "type": "str"},
        "customer_vat": {"key": "customerVAT", "type": "str"},
        "bpay_biller_code": {"key": "bpayBillerCode", "type": "str"},
        "bpay_reference": {"key": "bpayReference", "type": "str"},
        "bank_sort_code": {"key": "bankSortCode", "type": "str"},
        "bank_iban": {"key": "bankIBAN", "type": "str"},
        "bank_swift": {"key": "bankSwift", "type": "str"},
        "bank_bsb": {"key": "bankBSB", "type": "str"},
        "customer_contact_name": {"key": "customerContactName", "type": "str"},
        "customer_company_name": {"key": "customerCompanyName", "type": "str"},
        "supplier_company_name": {"key": "supplierCompanyName", "type": "str"},
        "customer_billing_address": {"key": "customerBillingAddress", "type": "Location"},
        "customer_delivery_address": {"key": "customerDeliveryAddress", "type": "Location"},
        "supplier_address": {"key": "supplierAddress", "type": "Location"},
        "customer_phone_number": {"key": "customerPhoneNumber", "type": "str"},
        "supplier_phone_number": {"key": "supplierPhoneNumber", "type": "str"},
        "supplier_fax": {"key": "supplierFax", "type": "str"},
        "customer_email": {"key": "customerEmail", "type": "str"},
        "supplier_email": {"key": "supplierEmail", "type": "str"},
        "supplier_website": {"key": "supplierWebsite", "type": "str"},
    }

    def __init__(
        self,
        *,
        invoice_date: Optional[str] = None,
        invoice_order_date: Optional[str] = None,
        payment_date_due: Optional[str] = None,
        payment_amount_base: Optional[str] = None,
        payment_amount_tax: Optional[str] = None,
        payment_amount_total: Optional[str] = None,
        payment_amount_paid: Optional[str] = None,
        payment_amount_due: Optional[str] = None,
        invoice_number: Optional[str] = None,
        invoice_purchase_order_number: Optional[str] = None,
        supplier_business_number: Optional[str] = None,
        customer_number: Optional[str] = None,
        customer_business_number: Optional[str] = None,
        payment_reference: Optional[str] = None,
        bank_account_number: Optional[str] = None,
        supplier_vat: Optional[str] = None,
        customer_vat: Optional[str] = None,
        bpay_biller_code: Optional[str] = None,
        bpay_reference: Optional[str] = None,
        bank_sort_code: Optional[str] = None,
        bank_iban: Optional[str] = None,
        bank_swift: Optional[str] = None,
        bank_bsb: Optional[str] = None,
        customer_contact_name: Optional[str] = None,
        customer_company_name: Optional[str] = None,
        supplier_company_name: Optional[str] = None,
        customer_billing_address: Optional["Location"] = None,
        customer_delivery_address: Optional["Location"] = None,
        supplier_address: Optional["Location"] = None,
        customer_phone_number: Optional[str] = None,
        supplier_phone_number: Optional[str] = None,
        supplier_fax: Optional[str] = None,
        customer_email: Optional[str] = None,
        supplier_email: Optional[str] = None,
        supplier_website: Optional[str] = None,
        **kwargs,
    ):
        """
        :keyword invoice_date:
        :paramtype invoice_date: str
        :keyword invoice_order_date:
        :paramtype invoice_order_date: str
        :keyword payment_date_due:
        :paramtype payment_date_due: str
        :keyword payment_amount_base:
        :paramtype payment_amount_base: str
        :keyword payment_amount_tax:
        :paramtype payment_amount_tax: str
        :keyword payment_amount_total:
        :paramtype payment_amount_total: str
        :keyword payment_amount_paid:
        :paramtype payment_amount_paid: str
        :keyword payment_amount_due:
        :paramtype payment_amount_due: str
        :keyword invoice_number:
        :paramtype invoice_number: str
        :keyword invoice_purchase_order_number:
        :paramtype invoice_purchase_order_number: str
        :keyword supplier_business_number:
        :paramtype supplier_business_number: str
        :keyword customer_number:
        :paramtype customer_number: str
        :keyword customer_business_number:
        :paramtype customer_business_number: str
        :keyword payment_reference:
        :paramtype payment_reference: str
        :keyword bank_account_number:
        :paramtype bank_account_number: str
        :keyword supplier_vat:
        :paramtype supplier_vat: str
        :keyword customer_vat:
        :paramtype customer_vat: str
        :keyword bpay_biller_code:
        :paramtype bpay_biller_code: str
        :keyword bpay_reference:
        :paramtype bpay_reference: str
        :keyword bank_sort_code:
        :paramtype bank_sort_code: str
        :keyword bank_iban:
        :paramtype bank_iban: str
        :keyword bank_swift:
        :paramtype bank_swift: str
        :keyword bank_bsb:
        :paramtype bank_bsb: str
        :keyword customer_contact_name:
        :paramtype customer_contact_name: str
        :keyword customer_company_name:
        :paramtype customer_company_name: str
        :keyword supplier_company_name:
        :paramtype supplier_company_name: str
        :keyword customer_billing_address:
        :paramtype customer_billing_address: ~affinda.models.Location
        :keyword customer_delivery_address:
        :paramtype customer_delivery_address: ~affinda.models.Location
        :keyword supplier_address:
        :paramtype supplier_address: ~affinda.models.Location
        :keyword customer_phone_number:
        :paramtype customer_phone_number: str
        :keyword supplier_phone_number:
        :paramtype supplier_phone_number: str
        :keyword supplier_fax:
        :paramtype supplier_fax: str
        :keyword customer_email:
        :paramtype customer_email: str
        :keyword supplier_email:
        :paramtype supplier_email: str
        :keyword supplier_website:
        :paramtype supplier_website: str
        """
        super(InvoiceData, self).__init__(**kwargs)
        self.invoice_date = invoice_date
        self.invoice_order_date = invoice_order_date
        self.payment_date_due = payment_date_due
        self.payment_amount_base = payment_amount_base
        self.payment_amount_tax = payment_amount_tax
        self.payment_amount_total = payment_amount_total
        self.payment_amount_paid = payment_amount_paid
        self.payment_amount_due = payment_amount_due
        self.invoice_number = invoice_number
        self.invoice_purchase_order_number = invoice_purchase_order_number
        self.supplier_business_number = supplier_business_number
        self.customer_number = customer_number
        self.customer_business_number = customer_business_number
        self.payment_reference = payment_reference
        self.bank_account_number = bank_account_number
        self.supplier_vat = supplier_vat
        self.customer_vat = customer_vat
        self.bpay_biller_code = bpay_biller_code
        self.bpay_reference = bpay_reference
        self.bank_sort_code = bank_sort_code
        self.bank_iban = bank_iban
        self.bank_swift = bank_swift
        self.bank_bsb = bank_bsb
        self.customer_contact_name = customer_contact_name
        self.customer_company_name = customer_company_name
        self.supplier_company_name = supplier_company_name
        self.customer_billing_address = customer_billing_address
        self.customer_delivery_address = customer_delivery_address
        self.supplier_address = supplier_address
        self.customer_phone_number = customer_phone_number
        self.supplier_phone_number = supplier_phone_number
        self.supplier_fax = supplier_fax
        self.customer_email = customer_email
        self.supplier_email = supplier_email
        self.supplier_website = supplier_website


class Location(msrest.serialization.Model):
    """Location.

    All required parameters must be populated in order to send to Azure.

    :ivar formatted:
    :vartype formatted: str
    :ivar postal_code:
    :vartype postal_code: str
    :ivar state:
    :vartype state: str
    :ivar country:
    :vartype country: str
    :ivar country_code: Two letter country code (ISO 3166-1 alpha-2).
    :vartype country_code: str
    :ivar raw_input: Required.
    :vartype raw_input: str
    :ivar street_number:
    :vartype street_number: str
    :ivar street:
    :vartype street: str
    :ivar apartment_number:
    :vartype apartment_number: str
    :ivar city:
    :vartype city: str
    """

    _validation = {
        "raw_input": {"required": True},
    }

    _attribute_map = {
        "formatted": {"key": "formatted", "type": "str"},
        "postal_code": {"key": "postalCode", "type": "str"},
        "state": {"key": "state", "type": "str"},
        "country": {"key": "country", "type": "str"},
        "country_code": {"key": "countryCode", "type": "str"},
        "raw_input": {"key": "rawInput", "type": "str"},
        "street_number": {"key": "streetNumber", "type": "str"},
        "street": {"key": "street", "type": "str"},
        "apartment_number": {"key": "apartmentNumber", "type": "str"},
        "city": {"key": "city", "type": "str"},
    }

    def __init__(
        self,
        *,
        raw_input: str,
        formatted: Optional[str] = None,
        postal_code: Optional[str] = None,
        state: Optional[str] = None,
        country: Optional[str] = None,
        country_code: Optional[str] = None,
        street_number: Optional[str] = None,
        street: Optional[str] = None,
        apartment_number: Optional[str] = None,
        city: Optional[str] = None,
        **kwargs,
    ):
        """
        :keyword formatted:
        :paramtype formatted: str
        :keyword postal_code:
        :paramtype postal_code: str
        :keyword state:
        :paramtype state: str
        :keyword country:
        :paramtype country: str
        :keyword country_code: Two letter country code (ISO 3166-1 alpha-2).
        :paramtype country_code: str
        :keyword raw_input: Required.
        :paramtype raw_input: str
        :keyword street_number:
        :paramtype street_number: str
        :keyword street:
        :paramtype street: str
        :keyword apartment_number:
        :paramtype apartment_number: str
        :keyword city:
        :paramtype city: str
        """
        super(Location, self).__init__(**kwargs)
        self.formatted = formatted
        self.postal_code = postal_code
        self.state = state
        self.country = country
        self.country_code = country_code
        self.raw_input = raw_input
        self.street_number = street_number
        self.street = street
        self.apartment_number = apartment_number
        self.city = city


class Meta(msrest.serialization.Model):
    """Meta.

    All required parameters must be populated in order to send to Azure.

    :ivar identifier: Required. Unique identifier for the document. If creating a document and left
     blank, one will be automatically generated.
    :vartype identifier: str
    :ivar file_name: Optional filename of the file.
    :vartype file_name: str
    :ivar ready: Required. If true, the document has finished processing. Particularly useful if an
     endpoint request specified wait=False, when polling use this variable to determine when to stop
     polling.
    :vartype ready: bool
    :ivar ready_dt: The datetime when the document was ready.
    :vartype ready_dt: ~datetime.datetime
    :ivar failed: Required. If true, some exception was raised during processing. Check the 'error'
     field of the main return object.
    :vartype failed: bool
    :ivar expiry_time: The date/time in ISO-8601 format when the document will be automatically
     deleted.  Defaults to no expiry.
    :vartype expiry_time: str
    """

    _validation = {
        "identifier": {"required": True},
        "ready": {"required": True},
        "failed": {"required": True},
    }

    _attribute_map = {
        "identifier": {"key": "identifier", "type": "str"},
        "file_name": {"key": "fileName", "type": "str"},
        "ready": {"key": "ready", "type": "bool"},
        "ready_dt": {"key": "readyDt", "type": "iso-8601"},
        "failed": {"key": "failed", "type": "bool"},
        "expiry_time": {"key": "expiryTime", "type": "str"},
    }

    def __init__(
        self,
        *,
        identifier: str,
        ready: bool,
        failed: bool,
        file_name: Optional[str] = None,
        ready_dt: Optional[datetime.datetime] = None,
        expiry_time: Optional[str] = None,
        **kwargs,
    ):
        """
        :keyword identifier: Required. Unique identifier for the document. If creating a document and
         left blank, one will be automatically generated.
        :paramtype identifier: str
        :keyword file_name: Optional filename of the file.
        :paramtype file_name: str
        :keyword ready: Required. If true, the document has finished processing. Particularly useful if
         an endpoint request specified wait=False, when polling use this variable to determine when to
         stop polling.
        :paramtype ready: bool
        :keyword ready_dt: The datetime when the document was ready.
        :paramtype ready_dt: ~datetime.datetime
        :keyword failed: Required. If true, some exception was raised during processing. Check the
         'error' field of the main return object.
        :paramtype failed: bool
        :keyword expiry_time: The date/time in ISO-8601 format when the document will be automatically
         deleted.  Defaults to no expiry.
        :paramtype expiry_time: str
        """
        super(Meta, self).__init__(**kwargs)
        self.identifier = identifier
        self.file_name = file_name
        self.ready = ready
        self.ready_dt = ready_dt
        self.failed = failed
        self.expiry_time = expiry_time


class OccupationGroup(msrest.serialization.Model):
    """OccupationGroup.

    All required parameters must be populated in order to send to Azure.

    :ivar code: Required.
    :vartype code: int
    :ivar name: Required.
    :vartype name: str
    :ivar children: Required.
    :vartype children: list[~affinda.models.OccupationGroup]
    """

    _validation = {
        "code": {"required": True},
        "name": {"required": True},
        "children": {"required": True},
    }

    _attribute_map = {
        "code": {"key": "code", "type": "int"},
        "name": {"key": "name", "type": "str"},
        "children": {"key": "children", "type": "[OccupationGroup]"},
    }

    def __init__(self, *, code: int, name: str, children: List["OccupationGroup"], **kwargs):
        """
        :keyword code: Required.
        :paramtype code: int
        :keyword name: Required.
        :paramtype name: str
        :keyword children: Required.
        :paramtype children: list[~affinda.models.OccupationGroup]
        """
        super(OccupationGroup, self).__init__(**kwargs)
        self.code = code
        self.name = name
        self.children = children


class Paths108CfgmIndexGetResponses200ContentApplicationJsonSchemaPropertiesResultsItems(
    msrest.serialization.Model
):
    """Paths108CfgmIndexGetResponses200ContentApplicationJsonSchemaPropertiesResultsItems.

    All required parameters must be populated in order to send to Azure.

    :ivar name: Required.
    :vartype name: str
    """

    _validation = {
        "name": {"required": True},
    }

    _attribute_map = {
        "name": {"key": "name", "type": "str"},
    }

    def __init__(self, *, name: str, **kwargs):
        """
        :keyword name: Required.
        :paramtype name: str
        """
        super(
            Paths108CfgmIndexGetResponses200ContentApplicationJsonSchemaPropertiesResultsItems,
            self,
        ).__init__(**kwargs)
        self.name = name


class Paths1BwrvmkInvoicesPostRequestbodyContentMultipartFormDataSchema(
    msrest.serialization.Model
):
    """Paths1BwrvmkInvoicesPostRequestbodyContentMultipartFormDataSchema.

    :ivar file: File as binary data blob. Supported formats: PDF, DOC, DOCX, TXT, RTF, HTML, PNG,
     JPG.
    :vartype file: IO
    :ivar identifier: Unique identifier for the document. If creating a document and left blank,
     one will be automatically generated.
    :vartype identifier: str
    :ivar file_name: Optional filename of the file.
    :vartype file_name: str
    :ivar url: URL to file to download and process.
    :vartype url: str
    :ivar wait: If "true" (default), will return a response only after processing has completed. If
     "false", will return an empty data object which can be polled at the GET endpoint until
     processing is complete.
    :vartype wait: bool
    :ivar language: Language code in ISO 639-1 format. Must specify zh-cn or zh-tw for Chinese.
    :vartype language: str
    :ivar expiry_time: The date/time in ISO-8601 format when the document will be automatically
     deleted.  Defaults to no expiry.
    :vartype expiry_time: str
    """

    _attribute_map = {
        "file": {"key": "file", "type": "IO"},
        "identifier": {"key": "identifier", "type": "str"},
        "file_name": {"key": "fileName", "type": "str"},
        "url": {"key": "url", "type": "str"},
        "wait": {"key": "wait", "type": "bool"},
        "language": {"key": "language", "type": "str"},
        "expiry_time": {"key": "expiryTime", "type": "str"},
    }

    def __init__(
        self,
        *,
        file: Optional[IO] = None,
        identifier: Optional[str] = None,
        file_name: Optional[str] = None,
        url: Optional[str] = None,
        wait: Optional[bool] = True,
        language: Optional[str] = None,
        expiry_time: Optional[str] = None,
        **kwargs,
    ):
        """
        :keyword file: File as binary data blob. Supported formats: PDF, DOC, DOCX, TXT, RTF, HTML,
         PNG, JPG.
        :paramtype file: IO
        :keyword identifier: Unique identifier for the document. If creating a document and left blank,
         one will be automatically generated.
        :paramtype identifier: str
        :keyword file_name: Optional filename of the file.
        :paramtype file_name: str
        :keyword url: URL to file to download and process.
        :paramtype url: str
        :keyword wait: If "true" (default), will return a response only after processing has completed.
         If "false", will return an empty data object which can be polled at the GET endpoint until
         processing is complete.
        :paramtype wait: bool
        :keyword language: Language code in ISO 639-1 format. Must specify zh-cn or zh-tw for Chinese.
        :paramtype language: str
        :keyword expiry_time: The date/time in ISO-8601 format when the document will be automatically
         deleted.  Defaults to no expiry.
        :paramtype expiry_time: str
        """
        super(Paths1BwrvmkInvoicesPostRequestbodyContentMultipartFormDataSchema, self).__init__(
            **kwargs
        )
        self.file = file
        self.identifier = identifier
        self.file_name = file_name
        self.url = url
        self.wait = wait
        self.language = language
        self.expiry_time = expiry_time


class Paths1Mc0Je6IndexPostResponses201ContentApplicationJsonSchema(msrest.serialization.Model):
    """Paths1Mc0Je6IndexPostResponses201ContentApplicationJsonSchema.

    :ivar name:
    :vartype name: str
    """

    _attribute_map = {
        "name": {"key": "name", "type": "str"},
    }

    def __init__(self, *, name: Optional[str] = None, **kwargs):
        """
        :keyword name:
        :paramtype name: str
        """
        super(Paths1Mc0Je6IndexPostResponses201ContentApplicationJsonSchema, self).__init__(
            **kwargs
        )
        self.name = name


class Paths1UtuacyResumeFormatsGetResponses200ContentApplicationJsonSchema(
    msrest.serialization.Model
):
    """Paths1UtuacyResumeFormatsGetResponses200ContentApplicationJsonSchema.

    :ivar count: Number of documents in result.
    :vartype count: int
    :ivar next: URL to request next page of results.
    :vartype next: str
    :ivar previous: URL to request previous page of results.
    :vartype previous: str
    :ivar results:
    :vartype results: list[~affinda.models.Get200ApplicationJsonPropertiesItemsItem]
    """

    _attribute_map = {
        "count": {"key": "count", "type": "int"},
        "next": {"key": "next", "type": "str"},
        "previous": {"key": "previous", "type": "str"},
        "results": {"key": "results", "type": "[Get200ApplicationJsonPropertiesItemsItem]"},
    }

    def __init__(
        self,
        *,
        count: Optional[int] = None,
        next: Optional[str] = None,
        previous: Optional[str] = None,
        results: Optional[List["Get200ApplicationJsonPropertiesItemsItem"]] = None,
        **kwargs,
    ):
        """
        :keyword count: Number of documents in result.
        :paramtype count: int
        :keyword next: URL to request next page of results.
        :paramtype next: str
        :keyword previous: URL to request previous page of results.
        :paramtype previous: str
        :keyword results:
        :paramtype results: list[~affinda.models.Get200ApplicationJsonPropertiesItemsItem]
        """
        super(Paths1UtuacyResumeFormatsGetResponses200ContentApplicationJsonSchema, self).__init__(
            **kwargs
        )
        self.count = count
        self.next = next
        self.previous = previous
        self.results = results


class Paths6Pypg5IndexGetResponses200ContentApplicationJsonSchema(msrest.serialization.Model):
    """Paths6Pypg5IndexGetResponses200ContentApplicationJsonSchema.

    :ivar count: Number of indexes in result.
    :vartype count: int
    :ivar next: URL to request next page of results.
    :vartype next: str
    :ivar previous: URL to request previous page of results.
    :vartype previous: str
    :ivar results:
    :vartype results:
     list[~affinda.models.Paths108CfgmIndexGetResponses200ContentApplicationJsonSchemaPropertiesResultsItems]
    """

    _attribute_map = {
        "count": {"key": "count", "type": "int"},
        "next": {"key": "next", "type": "str"},
        "previous": {"key": "previous", "type": "str"},
        "results": {
            "key": "results",
            "type": "[Paths108CfgmIndexGetResponses200ContentApplicationJsonSchemaPropertiesResultsItems]",
        },
    }

    def __init__(
        self,
        *,
        count: Optional[int] = None,
        next: Optional[str] = None,
        previous: Optional[str] = None,
        results: Optional[
            List[
                "Paths108CfgmIndexGetResponses200ContentApplicationJsonSchemaPropertiesResultsItems"
            ]
        ] = None,
        **kwargs,
    ):
        """
        :keyword count: Number of indexes in result.
        :paramtype count: int
        :keyword next: URL to request next page of results.
        :paramtype next: str
        :keyword previous: URL to request previous page of results.
        :paramtype previous: str
        :keyword results:
        :paramtype results:
         list[~affinda.models.Paths108CfgmIndexGetResponses200ContentApplicationJsonSchemaPropertiesResultsItems]
        """
        super(Paths6Pypg5IndexGetResponses200ContentApplicationJsonSchema, self).__init__(**kwargs)
        self.count = count
        self.next = next
        self.previous = previous
        self.results = results


class Paths7EskthResumesPostRequestbodyContentMultipartFormDataSchema(msrest.serialization.Model):
    """Paths7EskthResumesPostRequestbodyContentMultipartFormDataSchema.

    :ivar file: File as binary data blob. Supported formats: PDF, DOC, DOCX, TXT, RTF, HTML, PNG,
     JPG.
    :vartype file: IO
    :ivar identifier: Unique identifier for the document. If creating a document and left blank,
     one will be automatically generated.
    :vartype identifier: str
    :ivar file_name: Optional filename of the file.
    :vartype file_name: str
    :ivar url: URL to file to download and process.
    :vartype url: str
    :ivar wait: If "true" (default), will return a response only after processing has completed. If
     "false", will return an empty data object which can be polled at the GET endpoint until
     processing is complete.
    :vartype wait: bool
    :ivar language: Language code in ISO 639-1 format. Must specify zh-cn or zh-tw for Chinese.
    :vartype language: str
    :ivar expiry_time: The date/time in ISO-8601 format when the document will be automatically
     deleted.  Defaults to no expiry.
    :vartype expiry_time: str
    """

    _attribute_map = {
        "file": {"key": "file", "type": "IO"},
        "identifier": {"key": "identifier", "type": "str"},
        "file_name": {"key": "fileName", "type": "str"},
        "url": {"key": "url", "type": "str"},
        "wait": {"key": "wait", "type": "bool"},
        "language": {"key": "language", "type": "str"},
        "expiry_time": {"key": "expiryTime", "type": "str"},
    }

    def __init__(
        self,
        *,
        file: Optional[IO] = None,
        identifier: Optional[str] = None,
        file_name: Optional[str] = None,
        url: Optional[str] = None,
        wait: Optional[bool] = True,
        language: Optional[str] = None,
        expiry_time: Optional[str] = None,
        **kwargs,
    ):
        """
        :keyword file: File as binary data blob. Supported formats: PDF, DOC, DOCX, TXT, RTF, HTML,
         PNG, JPG.
        :paramtype file: IO
        :keyword identifier: Unique identifier for the document. If creating a document and left blank,
         one will be automatically generated.
        :paramtype identifier: str
        :keyword file_name: Optional filename of the file.
        :paramtype file_name: str
        :keyword url: URL to file to download and process.
        :paramtype url: str
        :keyword wait: If "true" (default), will return a response only after processing has completed.
         If "false", will return an empty data object which can be polled at the GET endpoint until
         processing is complete.
        :paramtype wait: bool
        :keyword language: Language code in ISO 639-1 format. Must specify zh-cn or zh-tw for Chinese.
        :paramtype language: str
        :keyword expiry_time: The date/time in ISO-8601 format when the document will be automatically
         deleted.  Defaults to no expiry.
        :paramtype expiry_time: str
        """
        super(Paths7EskthResumesPostRequestbodyContentMultipartFormDataSchema, self).__init__(
            **kwargs
        )
        self.file = file
        self.identifier = identifier
        self.file_name = file_name
        self.url = url
        self.wait = wait
        self.language = language
        self.expiry_time = expiry_time


class Paths8DdhfcRedactedResumesPostRequestbodyContentMultipartFormDataSchema(
    msrest.serialization.Model
):
    """Paths8DdhfcRedactedResumesPostRequestbodyContentMultipartFormDataSchema.

    :ivar file: File as binary data blob. Supported formats: PDF, DOC, DOCX, TXT, RTF, HTML, PNG,
     JPG.
    :vartype file: IO
    :ivar identifier: Unique identifier for the document. If creating a document and left blank,
     one will be automatically generated.
    :vartype identifier: str
    :ivar file_name: Optional filename of the file.
    :vartype file_name: str
    :ivar url: URL to file to download and process.
    :vartype url: str
    :ivar language: Language code in ISO 639-1 format. Must specify zh-cn or zh-tw for Chinese.
    :vartype language: str
    :ivar wait: If "true" (default), will return a response only after processing has completed. If
     "false", will return an empty data object which can be polled at the GET endpoint until
     processing is complete.
    :vartype wait: bool
    :ivar redact_headshot: Whether to redact headshot.
    :vartype redact_headshot: bool
    :ivar redact_personal_details: Whether to redact personal details (e.g. name, address).
    :vartype redact_personal_details: bool
    :ivar redact_work_details: Whether to redact work details (e.g. company names).
    :vartype redact_work_details: bool
    :ivar redact_education_details: Whether to redact education details (e.g. university names).
    :vartype redact_education_details: bool
    :ivar redact_referees: Whether to redact referee details.
    :vartype redact_referees: bool
    :ivar redact_locations: Whether to redact location names.
    :vartype redact_locations: bool
    :ivar redact_dates: Whether to redact dates.
    :vartype redact_dates: bool
    :ivar redact_gender: Whether to redact gender.
    :vartype redact_gender: bool
    :ivar expiry_time: The date/time in ISO-8601 format when the document will be automatically
     deleted.  Defaults to no expiry.
    :vartype expiry_time: str
    """

    _attribute_map = {
        "file": {"key": "file", "type": "IO"},
        "identifier": {"key": "identifier", "type": "str"},
        "file_name": {"key": "fileName", "type": "str"},
        "url": {"key": "url", "type": "str"},
        "language": {"key": "language", "type": "str"},
        "wait": {"key": "wait", "type": "bool"},
        "redact_headshot": {"key": "redactHeadshot", "type": "bool"},
        "redact_personal_details": {"key": "redactPersonalDetails", "type": "bool"},
        "redact_work_details": {"key": "redactWorkDetails", "type": "bool"},
        "redact_education_details": {"key": "redactEducationDetails", "type": "bool"},
        "redact_referees": {"key": "redactReferees", "type": "bool"},
        "redact_locations": {"key": "redactLocations", "type": "bool"},
        "redact_dates": {"key": "redactDates", "type": "bool"},
        "redact_gender": {"key": "redactGender", "type": "bool"},
        "expiry_time": {"key": "expiryTime", "type": "str"},
    }

    def __init__(
        self,
        *,
        file: Optional[IO] = None,
        identifier: Optional[str] = None,
        file_name: Optional[str] = None,
        url: Optional[str] = None,
        language: Optional[str] = None,
        wait: Optional[bool] = True,
        redact_headshot: Optional[bool] = True,
        redact_personal_details: Optional[bool] = True,
        redact_work_details: Optional[bool] = True,
        redact_education_details: Optional[bool] = True,
        redact_referees: Optional[bool] = True,
        redact_locations: Optional[bool] = True,
        redact_dates: Optional[bool] = True,
        redact_gender: Optional[bool] = True,
        expiry_time: Optional[str] = None,
        **kwargs,
    ):
        """
        :keyword file: File as binary data blob. Supported formats: PDF, DOC, DOCX, TXT, RTF, HTML,
         PNG, JPG.
        :paramtype file: IO
        :keyword identifier: Unique identifier for the document. If creating a document and left blank,
         one will be automatically generated.
        :paramtype identifier: str
        :keyword file_name: Optional filename of the file.
        :paramtype file_name: str
        :keyword url: URL to file to download and process.
        :paramtype url: str
        :keyword language: Language code in ISO 639-1 format. Must specify zh-cn or zh-tw for Chinese.
        :paramtype language: str
        :keyword wait: If "true" (default), will return a response only after processing has completed.
         If "false", will return an empty data object which can be polled at the GET endpoint until
         processing is complete.
        :paramtype wait: bool
        :keyword redact_headshot: Whether to redact headshot.
        :paramtype redact_headshot: bool
        :keyword redact_personal_details: Whether to redact personal details (e.g. name, address).
        :paramtype redact_personal_details: bool
        :keyword redact_work_details: Whether to redact work details (e.g. company names).
        :paramtype redact_work_details: bool
        :keyword redact_education_details: Whether to redact education details (e.g. university names).
        :paramtype redact_education_details: bool
        :keyword redact_referees: Whether to redact referee details.
        :paramtype redact_referees: bool
        :keyword redact_locations: Whether to redact location names.
        :paramtype redact_locations: bool
        :keyword redact_dates: Whether to redact dates.
        :paramtype redact_dates: bool
        :keyword redact_gender: Whether to redact gender.
        :paramtype redact_gender: bool
        :keyword expiry_time: The date/time in ISO-8601 format when the document will be automatically
         deleted.  Defaults to no expiry.
        :paramtype expiry_time: str
        """
        super(
            Paths8DdhfcRedactedResumesPostRequestbodyContentMultipartFormDataSchema, self
        ).__init__(**kwargs)
        self.file = file
        self.identifier = identifier
        self.file_name = file_name
        self.url = url
        self.language = language
        self.wait = wait
        self.redact_headshot = redact_headshot
        self.redact_personal_details = redact_personal_details
        self.redact_work_details = redact_work_details
        self.redact_education_details = redact_education_details
        self.redact_referees = redact_referees
        self.redact_locations = redact_locations
        self.redact_dates = redact_dates
        self.redact_gender = redact_gender
        self.expiry_time = expiry_time


class PathsCoo0XpIndexNameDocumentsPostResponses201ContentApplicationJsonSchema(
    msrest.serialization.Model
):
    """PathsCoo0XpIndexNameDocumentsPostResponses201ContentApplicationJsonSchema.

    :ivar document: Unique identifier for the document.
    :vartype document: str
    """

    _attribute_map = {
        "document": {"key": "document", "type": "str"},
    }

    def __init__(self, *, document: Optional[str] = None, **kwargs):
        """
        :keyword document: Unique identifier for the document.
        :paramtype document: str
        """
        super(
            PathsCoo0XpIndexNameDocumentsPostResponses201ContentApplicationJsonSchema, self
        ).__init__(**kwargs)
        self.document = document


class PathsGpptmIndexNameDocumentsPostRequestbodyContentApplicationJsonSchema(
    msrest.serialization.Model
):
    """PathsGpptmIndexNameDocumentsPostRequestbodyContentApplicationJsonSchema.

    :ivar document:
    :vartype document: str
    """

    _attribute_map = {
        "document": {"key": "document", "type": "str"},
    }

    def __init__(self, *, document: Optional[str] = None, **kwargs):
        """
        :keyword document:
        :paramtype document: str
        """
        super(
            PathsGpptmIndexNameDocumentsPostRequestbodyContentApplicationJsonSchema, self
        ).__init__(**kwargs)
        self.document = document


class PathsHryo8IndexNameDocumentsGetResponses200ContentApplicationJsonSchemaPropertiesResultsItems(
    msrest.serialization.Model
):
    """PathsHryo8IndexNameDocumentsGetResponses200ContentApplicationJsonSchemaPropertiesResultsItems.

    :ivar document:
    :vartype document: str
    """

    _attribute_map = {
        "document": {"key": "document", "type": "str"},
    }

    def __init__(self, *, document: Optional[str] = None, **kwargs):
        """
        :keyword document:
        :paramtype document: str
        """
        super(
            PathsHryo8IndexNameDocumentsGetResponses200ContentApplicationJsonSchemaPropertiesResultsItems,
            self,
        ).__init__(**kwargs)
        self.document = document


class PathsRvverlIndexNameDocumentsGetResponses200ContentApplicationJsonSchema(
    msrest.serialization.Model
):
    """PathsRvverlIndexNameDocumentsGetResponses200ContentApplicationJsonSchema.

    :ivar count: Number of indexed documents in result.
    :vartype count: int
    :ivar next: URL to request next page of results.
    :vartype next: str
    :ivar previous: URL to request previous page of results.
    :vartype previous: str
    :ivar results:
    :vartype results:
     list[~affinda.models.PathsHryo8IndexNameDocumentsGetResponses200ContentApplicationJsonSchemaPropertiesResultsItems]
    """

    _attribute_map = {
        "count": {"key": "count", "type": "int"},
        "next": {"key": "next", "type": "str"},
        "previous": {"key": "previous", "type": "str"},
        "results": {
            "key": "results",
            "type": "[PathsHryo8IndexNameDocumentsGetResponses200ContentApplicationJsonSchemaPropertiesResultsItems]",
        },
    }

    def __init__(
        self,
        *,
        count: Optional[int] = None,
        next: Optional[str] = None,
        previous: Optional[str] = None,
        results: Optional[
            List[
                "PathsHryo8IndexNameDocumentsGetResponses200ContentApplicationJsonSchemaPropertiesResultsItems"
            ]
        ] = None,
        **kwargs,
    ):
        """
        :keyword count: Number of indexed documents in result.
        :paramtype count: int
        :keyword next: URL to request next page of results.
        :paramtype next: str
        :keyword previous: URL to request previous page of results.
        :paramtype previous: str
        :keyword results:
        :paramtype results:
         list[~affinda.models.PathsHryo8IndexNameDocumentsGetResponses200ContentApplicationJsonSchemaPropertiesResultsItems]
        """
        super(
            PathsRvverlIndexNameDocumentsGetResponses200ContentApplicationJsonSchema, self
        ).__init__(**kwargs)
        self.count = count
        self.next = next
        self.previous = previous
        self.results = results


class PathsSot11NIndexPostRequestbodyContentMultipartFormDataSchema(msrest.serialization.Model):
    """PathsSot11NIndexPostRequestbodyContentMultipartFormDataSchema.

    :ivar name:
    :vartype name: bool
    """

    _attribute_map = {
        "name": {"key": "name", "type": "bool"},
    }

    def __init__(self, *, name: Optional[bool] = True, **kwargs):
        """
        :keyword name:
        :paramtype name: bool
        """
        super(PathsSot11NIndexPostRequestbodyContentMultipartFormDataSchema, self).__init__(
            **kwargs
        )
        self.name = name


class PathsYzn84IReformattedResumesPostRequestbodyContentMultipartFormDataSchema(
    msrest.serialization.Model
):
    """PathsYzn84IReformattedResumesPostRequestbodyContentMultipartFormDataSchema.

    All required parameters must be populated in order to send to Azure.

    :ivar file: File as binary data blob. Supported formats: PDF, DOC, DOCX, TXT, RTF, HTML, PNG,
     JPG.
    :vartype file: IO
    :ivar identifier: Unique identifier for the document. If creating a document and left blank,
     one will be automatically generated.
    :vartype identifier: str
    :ivar file_name: Optional filename of the file.
    :vartype file_name: str
    :ivar url: URL to file to download and process.
    :vartype url: str
    :ivar language: Language code in ISO 639-1 format. Must specify zh-cn or zh-tw for Chinese.
    :vartype language: str
    :ivar resume_format: Required. Identifier of the format used.
    :vartype resume_format: str
    :ivar wait: If "true" (default), will return a response only after processing has completed. If
     "false", will return an empty data object which can be polled at the GET endpoint until
     processing is complete.
    :vartype wait: bool
    """

    _validation = {
        "resume_format": {"required": True},
    }

    _attribute_map = {
        "file": {"key": "file", "type": "IO"},
        "identifier": {"key": "identifier", "type": "str"},
        "file_name": {"key": "fileName", "type": "str"},
        "url": {"key": "url", "type": "str"},
        "language": {"key": "language", "type": "str"},
        "resume_format": {"key": "resumeFormat", "type": "str"},
        "wait": {"key": "wait", "type": "bool"},
    }

    def __init__(
        self,
        *,
        resume_format: str,
        file: Optional[IO] = None,
        identifier: Optional[str] = None,
        file_name: Optional[str] = None,
        url: Optional[str] = None,
        language: Optional[str] = None,
        wait: Optional[bool] = True,
        **kwargs,
    ):
        """
        :keyword file: File as binary data blob. Supported formats: PDF, DOC, DOCX, TXT, RTF, HTML,
         PNG, JPG.
        :paramtype file: IO
        :keyword identifier: Unique identifier for the document. If creating a document and left blank,
         one will be automatically generated.
        :paramtype identifier: str
        :keyword file_name: Optional filename of the file.
        :paramtype file_name: str
        :keyword url: URL to file to download and process.
        :paramtype url: str
        :keyword language: Language code in ISO 639-1 format. Must specify zh-cn or zh-tw for Chinese.
        :paramtype language: str
        :keyword resume_format: Required. Identifier of the format used.
        :paramtype resume_format: str
        :keyword wait: If "true" (default), will return a response only after processing has completed.
         If "false", will return an empty data object which can be polled at the GET endpoint until
         processing is complete.
        :paramtype wait: bool
        """
        super(
            PathsYzn84IReformattedResumesPostRequestbodyContentMultipartFormDataSchema, self
        ).__init__(**kwargs)
        self.file = file
        self.identifier = identifier
        self.file_name = file_name
        self.url = url
        self.language = language
        self.resume_format = resume_format
        self.wait = wait


class RedactedResume(msrest.serialization.Model):
    """RedactedResume.

    All required parameters must be populated in order to send to Azure.

    :ivar data: Required.
    :vartype data: ~affinda.models.RedactedResumeData
    :ivar meta: Required.
    :vartype meta: ~affinda.models.Meta
    :ivar error: Required.
    :vartype error: ~affinda.models.Error
    """

    _validation = {
        "data": {"required": True},
        "meta": {"required": True},
        "error": {"required": True},
    }

    _attribute_map = {
        "data": {"key": "data", "type": "RedactedResumeData"},
        "meta": {"key": "meta", "type": "Meta"},
        "error": {"key": "error", "type": "Error"},
    }

    def __init__(self, *, data: "RedactedResumeData", meta: "Meta", error: "Error", **kwargs):
        """
        :keyword data: Required.
        :paramtype data: ~affinda.models.RedactedResumeData
        :keyword meta: Required.
        :paramtype meta: ~affinda.models.Meta
        :keyword error: Required.
        :paramtype error: ~affinda.models.Error
        """
        super(RedactedResume, self).__init__(**kwargs)
        self.data = data
        self.meta = meta
        self.error = error


class RedactedResumeData(msrest.serialization.Model):
    """RedactedResumeData.

    :ivar redacted_pdf: URL to redacted PDF.
    :vartype redacted_pdf: str
    """

    _attribute_map = {
        "redacted_pdf": {"key": "redactedPdf", "type": "str"},
    }

    def __init__(self, *, redacted_pdf: Optional[str] = None, **kwargs):
        """
        :keyword redacted_pdf: URL to redacted PDF.
        :paramtype redacted_pdf: str
        """
        super(RedactedResumeData, self).__init__(**kwargs)
        self.redacted_pdf = redacted_pdf


class ReformattedResume(msrest.serialization.Model):
    """ReformattedResume.

    All required parameters must be populated in order to send to Azure.

    :ivar data: Required.
    :vartype data: ~affinda.models.ReformattedResumeData
    :ivar meta: Required.
    :vartype meta: ~affinda.models.Meta
    :ivar error: Required.
    :vartype error: ~affinda.models.Error
    """

    _validation = {
        "data": {"required": True},
        "meta": {"required": True},
        "error": {"required": True},
    }

    _attribute_map = {
        "data": {"key": "data", "type": "ReformattedResumeData"},
        "meta": {"key": "meta", "type": "Meta"},
        "error": {"key": "error", "type": "Error"},
    }

    def __init__(self, *, data: "ReformattedResumeData", meta: "Meta", error: "Error", **kwargs):
        """
        :keyword data: Required.
        :paramtype data: ~affinda.models.ReformattedResumeData
        :keyword meta: Required.
        :paramtype meta: ~affinda.models.Meta
        :keyword error: Required.
        :paramtype error: ~affinda.models.Error
        """
        super(ReformattedResume, self).__init__(**kwargs)
        self.data = data
        self.meta = meta
        self.error = error


class ReformattedResumeData(msrest.serialization.Model):
    """ReformattedResumeData.

    :ivar reformatted_file:
    :vartype reformatted_file: str
    """

    _attribute_map = {
        "reformatted_file": {"key": "reformattedFile", "type": "str"},
    }

    def __init__(self, *, reformatted_file: Optional[str] = None, **kwargs):
        """
        :keyword reformatted_file:
        :paramtype reformatted_file: str
        """
        super(ReformattedResumeData, self).__init__(**kwargs)
        self.reformatted_file = reformatted_file


class RequestError(msrest.serialization.Model):
    """RequestError.

    All required parameters must be populated in order to send to Azure.

    :ivar detail: Required.
    :vartype detail: str
    :ivar status_code: Required.
    :vartype status_code: int
    """

    _validation = {
        "detail": {"required": True},
        "status_code": {"required": True},
    }

    _attribute_map = {
        "detail": {"key": "detail", "type": "str"},
        "status_code": {"key": "statusCode", "type": "int"},
    }

    def __init__(self, *, detail: str, status_code: int, **kwargs):
        """
        :keyword detail: Required.
        :paramtype detail: str
        :keyword status_code: Required.
        :paramtype status_code: int
        """
        super(RequestError, self).__init__(**kwargs)
        self.detail = detail
        self.status_code = status_code


class Resume(msrest.serialization.Model):
    """Resume.

    All required parameters must be populated in order to send to Azure.

    :ivar data: Required.
    :vartype data: ~affinda.models.ResumeData
    :ivar meta: Required.
    :vartype meta: ~affinda.models.Meta
    :ivar error: Required.
    :vartype error: ~affinda.models.Error
    """

    _validation = {
        "data": {"required": True},
        "meta": {"required": True},
        "error": {"required": True},
    }

    _attribute_map = {
        "data": {"key": "data", "type": "ResumeData"},
        "meta": {"key": "meta", "type": "Meta"},
        "error": {"key": "error", "type": "Error"},
    }

    def __init__(self, *, data: "ResumeData", meta: "Meta", error: "Error", **kwargs):
        """
        :keyword data: Required.
        :paramtype data: ~affinda.models.ResumeData
        :keyword meta: Required.
        :paramtype meta: ~affinda.models.Meta
        :keyword error: Required.
        :paramtype error: ~affinda.models.Error
        """
        super(Resume, self).__init__(**kwargs)
        self.data = data
        self.meta = meta
        self.error = error


class ResumeData(msrest.serialization.Model):
    """ResumeData.

    :ivar name:
    :vartype name: ~affinda.models.ResumeDataName
    :ivar phone_numbers:
    :vartype phone_numbers: list[str]
    :ivar websites:
    :vartype websites: list[str]
    :ivar emails:
    :vartype emails: list[str]
    :ivar date_of_birth:
    :vartype date_of_birth: str
    :ivar location:
    :vartype location: ~affinda.models.Location
    :ivar objective:
    :vartype objective: str
    :ivar languages:
    :vartype languages: list[str]
    :ivar summary:
    :vartype summary: str
    :ivar total_years_experience:
    :vartype total_years_experience: int
    :ivar head_shot: base64 encoded string.
    :vartype head_shot: bytearray
    :ivar education:
    :vartype education: list[~affinda.models.ResumeDataEducationItem]
    :ivar profession: Prediction of the candidate's profession based on recent work experience.
    :vartype profession: str
    :ivar linkedin: Linkedin account associated with the candidate.
    :vartype linkedin: str
    :ivar work_experience:
    :vartype work_experience: list[~affinda.models.ResumeDataWorkExperienceItem]
    :ivar skills:
    :vartype skills: list[~affinda.models.ResumeDataSkillsItem]
    :ivar certifications:
    :vartype certifications: list[str]
    :ivar publications:
    :vartype publications: list[str]
    :ivar referees:
    :vartype referees: list[~affinda.models.ResumeDataRefereesItem]
    :ivar sections:
    :vartype sections: list[~affinda.models.ResumeDataSectionsItem]
    :ivar is_resume_probability: Probability that the given document is a resume. Values below 30
     suggest that the document is not a resume.
    :vartype is_resume_probability: int
    :ivar raw_text: All of the raw text of the parsed resume, example is shortened for readiblity.
    :vartype raw_text: str
    """

    _attribute_map = {
        "name": {"key": "name", "type": "ResumeDataName"},
        "phone_numbers": {"key": "phoneNumbers", "type": "[str]"},
        "websites": {"key": "websites", "type": "[str]"},
        "emails": {"key": "emails", "type": "[str]"},
        "date_of_birth": {"key": "dateOfBirth", "type": "str"},
        "location": {"key": "location", "type": "Location"},
        "objective": {"key": "objective", "type": "str"},
        "languages": {"key": "languages", "type": "[str]"},
        "summary": {"key": "summary", "type": "str"},
        "total_years_experience": {"key": "totalYearsExperience", "type": "int"},
        "head_shot": {"key": "headShot", "type": "bytearray"},
        "education": {"key": "education", "type": "[ResumeDataEducationItem]"},
        "profession": {"key": "profession", "type": "str"},
        "linkedin": {"key": "linkedin", "type": "str"},
        "work_experience": {"key": "workExperience", "type": "[ResumeDataWorkExperienceItem]"},
        "skills": {"key": "skills", "type": "[ResumeDataSkillsItem]"},
        "certifications": {"key": "certifications", "type": "[str]"},
        "publications": {"key": "publications", "type": "[str]"},
        "referees": {"key": "referees", "type": "[ResumeDataRefereesItem]"},
        "sections": {"key": "sections", "type": "[ResumeDataSectionsItem]"},
        "is_resume_probability": {"key": "isResumeProbability", "type": "int"},
        "raw_text": {"key": "rawText", "type": "str"},
    }

    def __init__(
        self,
        *,
        name: Optional["ResumeDataName"] = None,
        phone_numbers: Optional[List[str]] = None,
        websites: Optional[List[str]] = None,
        emails: Optional[List[str]] = None,
        date_of_birth: Optional[str] = None,
        location: Optional["Location"] = None,
        objective: Optional[str] = None,
        languages: Optional[List[str]] = None,
        summary: Optional[str] = None,
        total_years_experience: Optional[int] = None,
        head_shot: Optional[bytearray] = None,
        education: Optional[List["ResumeDataEducationItem"]] = None,
        profession: Optional[str] = None,
        linkedin: Optional[str] = None,
        work_experience: Optional[List["ResumeDataWorkExperienceItem"]] = None,
        skills: Optional[List["ResumeDataSkillsItem"]] = None,
        certifications: Optional[List[str]] = None,
        publications: Optional[List[str]] = None,
        referees: Optional[List["ResumeDataRefereesItem"]] = None,
        sections: Optional[List["ResumeDataSectionsItem"]] = None,
        is_resume_probability: Optional[int] = None,
        raw_text: Optional[str] = None,
        **kwargs,
    ):
        """
        :keyword name:
        :paramtype name: ~affinda.models.ResumeDataName
        :keyword phone_numbers:
        :paramtype phone_numbers: list[str]
        :keyword websites:
        :paramtype websites: list[str]
        :keyword emails:
        :paramtype emails: list[str]
        :keyword date_of_birth:
        :paramtype date_of_birth: str
        :keyword location:
        :paramtype location: ~affinda.models.Location
        :keyword objective:
        :paramtype objective: str
        :keyword languages:
        :paramtype languages: list[str]
        :keyword summary:
        :paramtype summary: str
        :keyword total_years_experience:
        :paramtype total_years_experience: int
        :keyword head_shot: base64 encoded string.
        :paramtype head_shot: bytearray
        :keyword education:
        :paramtype education: list[~affinda.models.ResumeDataEducationItem]
        :keyword profession: Prediction of the candidate's profession based on recent work experience.
        :paramtype profession: str
        :keyword linkedin: Linkedin account associated with the candidate.
        :paramtype linkedin: str
        :keyword work_experience:
        :paramtype work_experience: list[~affinda.models.ResumeDataWorkExperienceItem]
        :keyword skills:
        :paramtype skills: list[~affinda.models.ResumeDataSkillsItem]
        :keyword certifications:
        :paramtype certifications: list[str]
        :keyword publications:
        :paramtype publications: list[str]
        :keyword referees:
        :paramtype referees: list[~affinda.models.ResumeDataRefereesItem]
        :keyword sections:
        :paramtype sections: list[~affinda.models.ResumeDataSectionsItem]
        :keyword is_resume_probability: Probability that the given document is a resume. Values below
         30 suggest that the document is not a resume.
        :paramtype is_resume_probability: int
        :keyword raw_text: All of the raw text of the parsed resume, example is shortened for
         readiblity.
        :paramtype raw_text: str
        """
        super(ResumeData, self).__init__(**kwargs)
        self.name = name
        self.phone_numbers = phone_numbers
        self.websites = websites
        self.emails = emails
        self.date_of_birth = date_of_birth
        self.location = location
        self.objective = objective
        self.languages = languages
        self.summary = summary
        self.total_years_experience = total_years_experience
        self.head_shot = head_shot
        self.education = education
        self.profession = profession
        self.linkedin = linkedin
        self.work_experience = work_experience
        self.skills = skills
        self.certifications = certifications
        self.publications = publications
        self.referees = referees
        self.sections = sections
        self.is_resume_probability = is_resume_probability
        self.raw_text = raw_text


class ResumeDataEducationItem(msrest.serialization.Model):
    """ResumeDataEducationItem.

    :ivar organization:
    :vartype organization: str
    :ivar accreditation:
    :vartype accreditation: ~affinda.models.ResumeDataEducationItemAccreditation
    :ivar grade:
    :vartype grade: ~affinda.models.ResumeDataEducationItemGrade
    :ivar location:
    :vartype location: ~affinda.models.Location
    :ivar dates:
    :vartype dates: ~affinda.models.ResumeDataEducationItemDates
    """

    _attribute_map = {
        "organization": {"key": "organization", "type": "str"},
        "accreditation": {"key": "accreditation", "type": "ResumeDataEducationItemAccreditation"},
        "grade": {"key": "grade", "type": "ResumeDataEducationItemGrade"},
        "location": {"key": "location", "type": "Location"},
        "dates": {"key": "dates", "type": "ResumeDataEducationItemDates"},
    }

    def __init__(
        self,
        *,
        organization: Optional[str] = None,
        accreditation: Optional["ResumeDataEducationItemAccreditation"] = None,
        grade: Optional["ResumeDataEducationItemGrade"] = None,
        location: Optional["Location"] = None,
        dates: Optional["ResumeDataEducationItemDates"] = None,
        **kwargs,
    ):
        """
        :keyword organization:
        :paramtype organization: str
        :keyword accreditation:
        :paramtype accreditation: ~affinda.models.ResumeDataEducationItemAccreditation
        :keyword grade:
        :paramtype grade: ~affinda.models.ResumeDataEducationItemGrade
        :keyword location:
        :paramtype location: ~affinda.models.Location
        :keyword dates:
        :paramtype dates: ~affinda.models.ResumeDataEducationItemDates
        """
        super(ResumeDataEducationItem, self).__init__(**kwargs)
        self.organization = organization
        self.accreditation = accreditation
        self.grade = grade
        self.location = location
        self.dates = dates


class ResumeDataEducationItemAccreditation(msrest.serialization.Model):
    """ResumeDataEducationItemAccreditation.

    :ivar education:
    :vartype education: str
    :ivar input_str:
    :vartype input_str: str
    :ivar match_str:
    :vartype match_str: str
    :ivar education_level:
    :vartype education_level: str
    """

    _attribute_map = {
        "education": {"key": "education", "type": "str"},
        "input_str": {"key": "inputStr", "type": "str"},
        "match_str": {"key": "matchStr", "type": "str"},
        "education_level": {"key": "educationLevel", "type": "str"},
    }

    def __init__(
        self,
        *,
        education: Optional[str] = None,
        input_str: Optional[str] = None,
        match_str: Optional[str] = None,
        education_level: Optional[str] = None,
        **kwargs,
    ):
        """
        :keyword education:
        :paramtype education: str
        :keyword input_str:
        :paramtype input_str: str
        :keyword match_str:
        :paramtype match_str: str
        :keyword education_level:
        :paramtype education_level: str
        """
        super(ResumeDataEducationItemAccreditation, self).__init__(**kwargs)
        self.education = education
        self.input_str = input_str
        self.match_str = match_str
        self.education_level = education_level


class ResumeDataEducationItemDates(msrest.serialization.Model):
    """ResumeDataEducationItemDates.

    :ivar completion_date:
    :vartype completion_date: ~datetime.date
    :ivar is_current:
    :vartype is_current: bool
    :ivar start_date:
    :vartype start_date: ~datetime.date
    """

    _attribute_map = {
        "completion_date": {"key": "completionDate", "type": "date"},
        "is_current": {"key": "isCurrent", "type": "bool"},
        "start_date": {"key": "startDate", "type": "date"},
    }

    def __init__(
        self,
        *,
        completion_date: Optional[datetime.date] = None,
        is_current: Optional[bool] = None,
        start_date: Optional[datetime.date] = None,
        **kwargs,
    ):
        """
        :keyword completion_date:
        :paramtype completion_date: ~datetime.date
        :keyword is_current:
        :paramtype is_current: bool
        :keyword start_date:
        :paramtype start_date: ~datetime.date
        """
        super(ResumeDataEducationItemDates, self).__init__(**kwargs)
        self.completion_date = completion_date
        self.is_current = is_current
        self.start_date = start_date


class ResumeDataEducationItemGrade(msrest.serialization.Model):
    """ResumeDataEducationItemGrade.

    :ivar raw:
    :vartype raw: str
    :ivar metric:
    :vartype metric: str
    :ivar value:
    :vartype value: str
    """

    _attribute_map = {
        "raw": {"key": "raw", "type": "str"},
        "metric": {"key": "metric", "type": "str"},
        "value": {"key": "value", "type": "str"},
    }

    def __init__(
        self,
        *,
        raw: Optional[str] = None,
        metric: Optional[str] = None,
        value: Optional[str] = None,
        **kwargs,
    ):
        """
        :keyword raw:
        :paramtype raw: str
        :keyword metric:
        :paramtype metric: str
        :keyword value:
        :paramtype value: str
        """
        super(ResumeDataEducationItemGrade, self).__init__(**kwargs)
        self.raw = raw
        self.metric = metric
        self.value = value


class ResumeDataName(msrest.serialization.Model):
    """ResumeDataName.

    :ivar raw:
    :vartype raw: str
    :ivar first:
    :vartype first: str
    :ivar last:
    :vartype last: str
    :ivar middle:
    :vartype middle: str
    :ivar title:
    :vartype title: str
    """

    _attribute_map = {
        "raw": {"key": "raw", "type": "str"},
        "first": {"key": "first", "type": "str"},
        "last": {"key": "last", "type": "str"},
        "middle": {"key": "middle", "type": "str"},
        "title": {"key": "title", "type": "str"},
    }

    def __init__(
        self,
        *,
        raw: Optional[str] = None,
        first: Optional[str] = None,
        last: Optional[str] = None,
        middle: Optional[str] = None,
        title: Optional[str] = None,
        **kwargs,
    ):
        """
        :keyword raw:
        :paramtype raw: str
        :keyword first:
        :paramtype first: str
        :keyword last:
        :paramtype last: str
        :keyword middle:
        :paramtype middle: str
        :keyword title:
        :paramtype title: str
        """
        super(ResumeDataName, self).__init__(**kwargs)
        self.raw = raw
        self.first = first
        self.last = last
        self.middle = middle
        self.title = title


class ResumeDataRefereesItem(msrest.serialization.Model):
    """ResumeDataRefereesItem.

    :ivar name:
    :vartype name: str
    :ivar text:
    :vartype text: str
    :ivar email:
    :vartype email: str
    :ivar number:
    :vartype number: str
    """

    _attribute_map = {
        "name": {"key": "name", "type": "str"},
        "text": {"key": "text", "type": "str"},
        "email": {"key": "email", "type": "str"},
        "number": {"key": "number", "type": "str"},
    }

    def __init__(
        self,
        *,
        name: Optional[str] = None,
        text: Optional[str] = None,
        email: Optional[str] = None,
        number: Optional[str] = None,
        **kwargs,
    ):
        """
        :keyword name:
        :paramtype name: str
        :keyword text:
        :paramtype text: str
        :keyword email:
        :paramtype email: str
        :keyword number:
        :paramtype number: str
        """
        super(ResumeDataRefereesItem, self).__init__(**kwargs)
        self.name = name
        self.text = text
        self.email = email
        self.number = number


class ResumeDataSectionsItem(msrest.serialization.Model):
    """ResumeDataSectionsItem.

    :ivar section_type:
    :vartype section_type: str
    :ivar bbox:
    :vartype bbox: list[float]
    :ivar page_index:
    :vartype page_index: int
    :ivar text:
    :vartype text: str
    """

    _validation = {
        "bbox": {"max_items": 4, "min_items": 4},
    }

    _attribute_map = {
        "section_type": {"key": "sectionType", "type": "str"},
        "bbox": {"key": "bbox", "type": "[float]"},
        "page_index": {"key": "pageIndex", "type": "int"},
        "text": {"key": "text", "type": "str"},
    }

    def __init__(
        self,
        *,
        section_type: Optional[str] = None,
        bbox: Optional[List[float]] = None,
        page_index: Optional[int] = None,
        text: Optional[str] = None,
        **kwargs,
    ):
        """
        :keyword section_type:
        :paramtype section_type: str
        :keyword bbox:
        :paramtype bbox: list[float]
        :keyword page_index:
        :paramtype page_index: int
        :keyword text:
        :paramtype text: str
        """
        super(ResumeDataSectionsItem, self).__init__(**kwargs)
        self.section_type = section_type
        self.bbox = bbox
        self.page_index = page_index
        self.text = text


class ResumeDataSkillsItem(msrest.serialization.Model):
    """ResumeDataSkillsItem.

    :ivar name:
    :vartype name: str
    :ivar last_used:
    :vartype last_used: str
    :ivar number_of_months:
    :vartype number_of_months: int
    :ivar type:
    :vartype type: str
    :ivar sources:
    :vartype sources: list[~affinda.models.ResumeDataSkillsPropertiesItemsItem]
    """

    _attribute_map = {
        "name": {"key": "name", "type": "str"},
        "last_used": {"key": "lastUsed", "type": "str"},
        "number_of_months": {"key": "numberOfMonths", "type": "int"},
        "type": {"key": "type", "type": "str"},
        "sources": {"key": "sources", "type": "[ResumeDataSkillsPropertiesItemsItem]"},
    }

    def __init__(
        self,
        *,
        name: Optional[str] = None,
        last_used: Optional[str] = None,
        number_of_months: Optional[int] = None,
        type: Optional[str] = None,
        sources: Optional[List["ResumeDataSkillsPropertiesItemsItem"]] = None,
        **kwargs,
    ):
        """
        :keyword name:
        :paramtype name: str
        :keyword last_used:
        :paramtype last_used: str
        :keyword number_of_months:
        :paramtype number_of_months: int
        :keyword type:
        :paramtype type: str
        :keyword sources:
        :paramtype sources: list[~affinda.models.ResumeDataSkillsPropertiesItemsItem]
        """
        super(ResumeDataSkillsItem, self).__init__(**kwargs)
        self.name = name
        self.last_used = last_used
        self.number_of_months = number_of_months
        self.type = type
        self.sources = sources


class ResumeDataSkillsPropertiesItemsItem(msrest.serialization.Model):
    """ResumeDataSkillsPropertiesItemsItem.

    :ivar section:
    :vartype section: str
    :ivar position:
    :vartype position: int
    """

    _attribute_map = {
        "section": {"key": "section", "type": "str"},
        "position": {"key": "position", "type": "int"},
    }

    def __init__(self, *, section: Optional[str] = None, position: Optional[int] = None, **kwargs):
        """
        :keyword section:
        :paramtype section: str
        :keyword position:
        :paramtype position: int
        """
        super(ResumeDataSkillsPropertiesItemsItem, self).__init__(**kwargs)
        self.section = section
        self.position = position


class ResumeDataWorkExperienceItem(msrest.serialization.Model):
    """ResumeDataWorkExperienceItem.

    :ivar job_title:
    :vartype job_title: str
    :ivar organization:
    :vartype organization: str
    :ivar location:
    :vartype location: ~affinda.models.Location
    :ivar job_description:
    :vartype job_description: str
    :ivar dates:
    :vartype dates: ~affinda.models.ResumeDataWorkExperienceItemDates
    :ivar occupation:
    :vartype occupation: ~affinda.models.ResumeDataWorkExperienceItemOccupation
    """

    _attribute_map = {
        "job_title": {"key": "jobTitle", "type": "str"},
        "organization": {"key": "organization", "type": "str"},
        "location": {"key": "location", "type": "Location"},
        "job_description": {"key": "jobDescription", "type": "str"},
        "dates": {"key": "dates", "type": "ResumeDataWorkExperienceItemDates"},
        "occupation": {"key": "occupation", "type": "ResumeDataWorkExperienceItemOccupation"},
    }

    def __init__(
        self,
        *,
        job_title: Optional[str] = None,
        organization: Optional[str] = None,
        location: Optional["Location"] = None,
        job_description: Optional[str] = None,
        dates: Optional["ResumeDataWorkExperienceItemDates"] = None,
        occupation: Optional["ResumeDataWorkExperienceItemOccupation"] = None,
        **kwargs,
    ):
        """
        :keyword job_title:
        :paramtype job_title: str
        :keyword organization:
        :paramtype organization: str
        :keyword location:
        :paramtype location: ~affinda.models.Location
        :keyword job_description:
        :paramtype job_description: str
        :keyword dates:
        :paramtype dates: ~affinda.models.ResumeDataWorkExperienceItemDates
        :keyword occupation:
        :paramtype occupation: ~affinda.models.ResumeDataWorkExperienceItemOccupation
        """
        super(ResumeDataWorkExperienceItem, self).__init__(**kwargs)
        self.job_title = job_title
        self.organization = organization
        self.location = location
        self.job_description = job_description
        self.dates = dates
        self.occupation = occupation


class ResumeDataWorkExperienceItemDates(msrest.serialization.Model):
    """ResumeDataWorkExperienceItemDates.

    :ivar start_date:
    :vartype start_date: ~datetime.date
    :ivar end_date:
    :vartype end_date: ~datetime.date
    :ivar months_in_position:
    :vartype months_in_position: int
    :ivar is_current:
    :vartype is_current: bool
    """

    _attribute_map = {
        "start_date": {"key": "startDate", "type": "date"},
        "end_date": {"key": "endDate", "type": "date"},
        "months_in_position": {"key": "monthsInPosition", "type": "int"},
        "is_current": {"key": "isCurrent", "type": "bool"},
    }

    def __init__(
        self,
        *,
        start_date: Optional[datetime.date] = None,
        end_date: Optional[datetime.date] = None,
        months_in_position: Optional[int] = None,
        is_current: Optional[bool] = None,
        **kwargs,
    ):
        """
        :keyword start_date:
        :paramtype start_date: ~datetime.date
        :keyword end_date:
        :paramtype end_date: ~datetime.date
        :keyword months_in_position:
        :paramtype months_in_position: int
        :keyword is_current:
        :paramtype is_current: bool
        """
        super(ResumeDataWorkExperienceItemDates, self).__init__(**kwargs)
        self.start_date = start_date
        self.end_date = end_date
        self.months_in_position = months_in_position
        self.is_current = is_current


class ResumeDataWorkExperienceItemOccupation(msrest.serialization.Model):
    """ResumeDataWorkExperienceItemOccupation.

    :ivar job_title: The raw (not normalized) job title pulled from the work experience entry.
    :vartype job_title: str
    :ivar job_title_normalized: Mapped onto the EMSI job title taxonomy if a sufficiently close
     match exists.
    :vartype job_title_normalized: str
    :ivar management_level: Possible values include: "Low", "Mid", "Upper".
    :vartype management_level: str or ~affinda.models.ManagementLevel
    :ivar classification:
    :vartype classification:
     ~affinda.models.Components1TryetgSchemasResumedataPropertiesWorkexperienceItemsPropertiesOccupationPropertiesClassification
    """

    _attribute_map = {
        "job_title": {"key": "jobTitle", "type": "str"},
        "job_title_normalized": {"key": "jobTitleNormalized", "type": "str"},
        "management_level": {"key": "managementLevel", "type": "str"},
        "classification": {
            "key": "classification",
            "type": "Components1TryetgSchemasResumedataPropertiesWorkexperienceItemsPropertiesOccupationPropertiesClassification",
        },
    }

    def __init__(
        self,
        *,
        job_title: Optional[str] = None,
        job_title_normalized: Optional[str] = None,
        management_level: Optional[Union[str, "ManagementLevel"]] = None,
        classification: Optional[
            "Components1TryetgSchemasResumedataPropertiesWorkexperienceItemsPropertiesOccupationPropertiesClassification"
        ] = None,
        **kwargs,
    ):
        """
        :keyword job_title: The raw (not normalized) job title pulled from the work experience entry.
        :paramtype job_title: str
        :keyword job_title_normalized: Mapped onto the EMSI job title taxonomy if a sufficiently close
         match exists.
        :paramtype job_title_normalized: str
        :keyword management_level: Possible values include: "Low", "Mid", "Upper".
        :paramtype management_level: str or ~affinda.models.ManagementLevel
        :keyword classification:
        :paramtype classification:
         ~affinda.models.Components1TryetgSchemasResumedataPropertiesWorkexperienceItemsPropertiesOccupationPropertiesClassification
        """
        super(ResumeDataWorkExperienceItemOccupation, self).__init__(**kwargs)
        self.job_title = job_title
        self.job_title_normalized = job_title_normalized
        self.management_level = management_level
        self.classification = classification


class ResumeSearch(msrest.serialization.Model):
    """ResumeSearch.

    :ivar count: Total number of results.
    :vartype count: int
    :ivar next: URL to request next page of results.
    :vartype next: str
    :ivar previous: URL to request previous page of results.
    :vartype previous: str
    :ivar parameters:
    :vartype parameters: ~affinda.models.ResumeSearchParameters
    :ivar results:
    :vartype results: list[~affinda.models.ResumeSearchResult]
    """

    _attribute_map = {
        "count": {"key": "count", "type": "int"},
        "next": {"key": "next", "type": "str"},
        "previous": {"key": "previous", "type": "str"},
        "parameters": {"key": "parameters", "type": "ResumeSearchParameters"},
        "results": {"key": "results", "type": "[ResumeSearchResult]"},
    }

    def __init__(
        self,
        *,
        count: Optional[int] = None,
        next: Optional[str] = None,
        previous: Optional[str] = None,
        parameters: Optional["ResumeSearchParameters"] = None,
        results: Optional[List["ResumeSearchResult"]] = None,
        **kwargs,
    ):
        """
        :keyword count: Total number of results.
        :paramtype count: int
        :keyword next: URL to request next page of results.
        :paramtype next: str
        :keyword previous: URL to request previous page of results.
        :paramtype previous: str
        :keyword parameters:
        :paramtype parameters: ~affinda.models.ResumeSearchParameters
        :keyword results:
        :paramtype results: list[~affinda.models.ResumeSearchResult]
        """
        super(ResumeSearch, self).__init__(**kwargs)
        self.count = count
        self.next = next
        self.previous = previous
        self.parameters = parameters
        self.results = results


class ResumeSearchParameters(msrest.serialization.Model):
    """ResumeSearchParameters.

    All required parameters must be populated in order to send to Azure.

    :ivar indices: Required.
    :vartype indices: list[str]
    :ivar job_description: Unique identifier for the document. If creating a document and left
     blank, one will be automatically generated.
    :vartype job_description: str
    :ivar job_titles:
    :vartype job_titles: list[str]
    :ivar job_titles_current_only:
    :vartype job_titles_current_only: bool
    :ivar job_titles_required:
    :vartype job_titles_required: bool
    :ivar job_titles_weight:
    :vartype job_titles_weight: float
    :ivar years_experience_min:
    :vartype years_experience_min: int
    :ivar years_experience_max:
    :vartype years_experience_max: int
    :ivar years_experience_required:
    :vartype years_experience_required: bool
    :ivar years_experience_weight:
    :vartype years_experience_weight: float
    :ivar locations:
    :vartype locations: list[~affinda.models.ResumeSearchParametersLocationsItem]
    :ivar locations_weight:
    :vartype locations_weight: float
    :ivar locations_required:
    :vartype locations_required: bool
    :ivar skills:
    :vartype skills: list[~affinda.models.ResumeSearchParametersSkillsItem]
    :ivar skills_weight:
    :vartype skills_weight: float
    :ivar languages:
    :vartype languages: list[~affinda.models.ResumeSearchParametersLanguagesItem]
    :ivar languages_weight:
    :vartype languages_weight: float
    :ivar institutions:
    :vartype institutions: list[str]
    :ivar institutions_required:
    :vartype institutions_required: bool
    :ivar degrees:
    :vartype degrees: list[str]
    :ivar degrees_required:
    :vartype degrees_required: bool
    :ivar highest_degree_types:
    :vartype highest_degree_types: list[str or ~affinda.models.EducationLevel]
    :ivar highest_degree_types_required:
    :vartype highest_degree_types_required: bool
    :ivar is_current_student:
    :vartype is_current_student: bool
    :ivar is_current_student_required:
    :vartype is_current_student_required: bool
    :ivar is_recent_graduate:
    :vartype is_recent_graduate: bool
    :ivar is_recent_graduate_required:
    :vartype is_recent_graduate_required: bool
    :ivar education_weight:
    :vartype education_weight: float
    :ivar search_expression:
    :vartype search_expression: str
    :ivar search_expression_required:
    :vartype search_expression_required: bool
    :ivar search_expression_weight:
    :vartype search_expression_weight: float
    :ivar soc_codes:
    :vartype soc_codes: list[int]
    :ivar soc_codes_weight:
    :vartype soc_codes_weight: float
    :ivar soc_codes_required:
    :vartype soc_codes_required: bool
    :ivar management_level: Possible values include: "Low", "Mid", "Upper".
    :vartype management_level: str or ~affinda.models.ManagementLevel
    :ivar management_level_required:
    :vartype management_level_required: bool
    :ivar management_level_weight:
    :vartype management_level_weight: float
    """

    _validation = {
        "indices": {"required": True},
        "job_titles_weight": {"maximum": 1, "minimum": 0},
        "years_experience_weight": {"maximum": 1, "minimum": 0},
        "locations_weight": {"maximum": 1, "minimum": 0},
        "skills_weight": {"maximum": 1, "minimum": 0},
        "languages_weight": {"maximum": 1, "minimum": 0},
        "highest_degree_types": {"unique": True},
        "education_weight": {"maximum": 1, "minimum": 0},
        "search_expression_weight": {"maximum": 1, "minimum": 0},
        "soc_codes_weight": {"maximum": 1, "minimum": 0},
        "management_level_weight": {"maximum": 1, "minimum": 0},
    }

    _attribute_map = {
        "indices": {"key": "indices", "type": "[str]"},
        "job_description": {"key": "jobDescription", "type": "str"},
        "job_titles": {"key": "jobTitles", "type": "[str]"},
        "job_titles_current_only": {"key": "jobTitlesCurrentOnly", "type": "bool"},
        "job_titles_required": {"key": "jobTitlesRequired", "type": "bool"},
        "job_titles_weight": {"key": "jobTitlesWeight", "type": "float"},
        "years_experience_min": {"key": "yearsExperienceMin", "type": "int"},
        "years_experience_max": {"key": "yearsExperienceMax", "type": "int"},
        "years_experience_required": {"key": "yearsExperienceRequired", "type": "bool"},
        "years_experience_weight": {"key": "yearsExperienceWeight", "type": "float"},
        "locations": {"key": "locations", "type": "[ResumeSearchParametersLocationsItem]"},
        "locations_weight": {"key": "locationsWeight", "type": "float"},
        "locations_required": {"key": "locationsRequired", "type": "bool"},
        "skills": {"key": "skills", "type": "[ResumeSearchParametersSkillsItem]"},
        "skills_weight": {"key": "skillsWeight", "type": "float"},
        "languages": {"key": "languages", "type": "[ResumeSearchParametersLanguagesItem]"},
        "languages_weight": {"key": "languagesWeight", "type": "float"},
        "institutions": {"key": "institutions", "type": "[str]"},
        "institutions_required": {"key": "institutionsRequired", "type": "bool"},
        "degrees": {"key": "degrees", "type": "[str]"},
        "degrees_required": {"key": "degreesRequired", "type": "bool"},
        "highest_degree_types": {"key": "highestDegreeTypes", "type": "[str]"},
        "highest_degree_types_required": {"key": "highestDegreeTypesRequired", "type": "bool"},
        "is_current_student": {"key": "isCurrentStudent", "type": "bool"},
        "is_current_student_required": {"key": "isCurrentStudentRequired", "type": "bool"},
        "is_recent_graduate": {"key": "isRecentGraduate", "type": "bool"},
        "is_recent_graduate_required": {"key": "isRecentGraduateRequired", "type": "bool"},
        "education_weight": {"key": "educationWeight", "type": "float"},
        "search_expression": {"key": "searchExpression", "type": "str"},
        "search_expression_required": {"key": "searchExpressionRequired", "type": "bool"},
        "search_expression_weight": {"key": "searchExpressionWeight", "type": "float"},
        "soc_codes": {"key": "socCodes", "type": "[int]"},
        "soc_codes_weight": {"key": "socCodesWeight", "type": "float"},
        "soc_codes_required": {"key": "socCodesRequired", "type": "bool"},
        "management_level": {"key": "managementLevel", "type": "str"},
        "management_level_required": {"key": "managementLevelRequired", "type": "bool"},
        "management_level_weight": {"key": "managementLevelWeight", "type": "float"},
    }

    def __init__(
        self,
        *,
        indices: List[str],
        job_description: Optional[str] = None,
        job_titles: Optional[List[str]] = None,
        job_titles_current_only: Optional[bool] = None,
        job_titles_required: Optional[bool] = None,
        job_titles_weight: Optional[float] = None,
        years_experience_min: Optional[int] = None,
        years_experience_max: Optional[int] = None,
        years_experience_required: Optional[bool] = None,
        years_experience_weight: Optional[float] = None,
        locations: Optional[List["ResumeSearchParametersLocationsItem"]] = None,
        locations_weight: Optional[float] = None,
        locations_required: Optional[bool] = None,
        skills: Optional[List["ResumeSearchParametersSkillsItem"]] = None,
        skills_weight: Optional[float] = None,
        languages: Optional[List["ResumeSearchParametersLanguagesItem"]] = None,
        languages_weight: Optional[float] = None,
        institutions: Optional[List[str]] = None,
        institutions_required: Optional[bool] = None,
        degrees: Optional[List[str]] = None,
        degrees_required: Optional[bool] = None,
        highest_degree_types: Optional[List[Union[str, "EducationLevel"]]] = None,
        highest_degree_types_required: Optional[bool] = None,
        is_current_student: Optional[bool] = None,
        is_current_student_required: Optional[bool] = None,
        is_recent_graduate: Optional[bool] = None,
        is_recent_graduate_required: Optional[bool] = None,
        education_weight: Optional[float] = None,
        search_expression: Optional[str] = None,
        search_expression_required: Optional[bool] = None,
        search_expression_weight: Optional[float] = None,
        soc_codes: Optional[List[int]] = None,
        soc_codes_weight: Optional[float] = None,
        soc_codes_required: Optional[bool] = None,
        management_level: Optional[Union[str, "ManagementLevel"]] = None,
        management_level_required: Optional[bool] = None,
        management_level_weight: Optional[float] = None,
        **kwargs,
    ):
        """
        :keyword indices: Required.
        :paramtype indices: list[str]
        :keyword job_description: Unique identifier for the document. If creating a document and left
         blank, one will be automatically generated.
        :paramtype job_description: str
        :keyword job_titles:
        :paramtype job_titles: list[str]
        :keyword job_titles_current_only:
        :paramtype job_titles_current_only: bool
        :keyword job_titles_required:
        :paramtype job_titles_required: bool
        :keyword job_titles_weight:
        :paramtype job_titles_weight: float
        :keyword years_experience_min:
        :paramtype years_experience_min: int
        :keyword years_experience_max:
        :paramtype years_experience_max: int
        :keyword years_experience_required:
        :paramtype years_experience_required: bool
        :keyword years_experience_weight:
        :paramtype years_experience_weight: float
        :keyword locations:
        :paramtype locations: list[~affinda.models.ResumeSearchParametersLocationsItem]
        :keyword locations_weight:
        :paramtype locations_weight: float
        :keyword locations_required:
        :paramtype locations_required: bool
        :keyword skills:
        :paramtype skills: list[~affinda.models.ResumeSearchParametersSkillsItem]
        :keyword skills_weight:
        :paramtype skills_weight: float
        :keyword languages:
        :paramtype languages: list[~affinda.models.ResumeSearchParametersLanguagesItem]
        :keyword languages_weight:
        :paramtype languages_weight: float
        :keyword institutions:
        :paramtype institutions: list[str]
        :keyword institutions_required:
        :paramtype institutions_required: bool
        :keyword degrees:
        :paramtype degrees: list[str]
        :keyword degrees_required:
        :paramtype degrees_required: bool
        :keyword highest_degree_types:
        :paramtype highest_degree_types: list[str or ~affinda.models.EducationLevel]
        :keyword highest_degree_types_required:
        :paramtype highest_degree_types_required: bool
        :keyword is_current_student:
        :paramtype is_current_student: bool
        :keyword is_current_student_required:
        :paramtype is_current_student_required: bool
        :keyword is_recent_graduate:
        :paramtype is_recent_graduate: bool
        :keyword is_recent_graduate_required:
        :paramtype is_recent_graduate_required: bool
        :keyword education_weight:
        :paramtype education_weight: float
        :keyword search_expression:
        :paramtype search_expression: str
        :keyword search_expression_required:
        :paramtype search_expression_required: bool
        :keyword search_expression_weight:
        :paramtype search_expression_weight: float
        :keyword soc_codes:
        :paramtype soc_codes: list[int]
        :keyword soc_codes_weight:
        :paramtype soc_codes_weight: float
        :keyword soc_codes_required:
        :paramtype soc_codes_required: bool
        :keyword management_level: Possible values include: "Low", "Mid", "Upper".
        :paramtype management_level: str or ~affinda.models.ManagementLevel
        :keyword management_level_required:
        :paramtype management_level_required: bool
        :keyword management_level_weight:
        :paramtype management_level_weight: float
        """
        super(ResumeSearchParameters, self).__init__(**kwargs)
        self.indices = indices
        self.job_description = job_description
        self.job_titles = job_titles
        self.job_titles_current_only = job_titles_current_only
        self.job_titles_required = job_titles_required
        self.job_titles_weight = job_titles_weight
        self.years_experience_min = years_experience_min
        self.years_experience_max = years_experience_max
        self.years_experience_required = years_experience_required
        self.years_experience_weight = years_experience_weight
        self.locations = locations
        self.locations_weight = locations_weight
        self.locations_required = locations_required
        self.skills = skills
        self.skills_weight = skills_weight
        self.languages = languages
        self.languages_weight = languages_weight
        self.institutions = institutions
        self.institutions_required = institutions_required
        self.degrees = degrees
        self.degrees_required = degrees_required
        self.highest_degree_types = highest_degree_types
        self.highest_degree_types_required = highest_degree_types_required
        self.is_current_student = is_current_student
        self.is_current_student_required = is_current_student_required
        self.is_recent_graduate = is_recent_graduate
        self.is_recent_graduate_required = is_recent_graduate_required
        self.education_weight = education_weight
        self.search_expression = search_expression
        self.search_expression_required = search_expression_required
        self.search_expression_weight = search_expression_weight
        self.soc_codes = soc_codes
        self.soc_codes_weight = soc_codes_weight
        self.soc_codes_required = soc_codes_required
        self.management_level = management_level
        self.management_level_required = management_level_required
        self.management_level_weight = management_level_weight


class ResumeSearchParametersLanguagesItem(msrest.serialization.Model):
    """ResumeSearchParametersLanguagesItem.

    :ivar name:
    :vartype name: str
    :ivar required:
    :vartype required: bool
    """

    _attribute_map = {
        "name": {"key": "name", "type": "str"},
        "required": {"key": "required", "type": "bool"},
    }

    def __init__(self, *, name: Optional[str] = None, required: Optional[bool] = None, **kwargs):
        """
        :keyword name:
        :paramtype name: str
        :keyword required:
        :paramtype required: bool
        """
        super(ResumeSearchParametersLanguagesItem, self).__init__(**kwargs)
        self.name = name
        self.required = required


class ResumeSearchParametersLocationsItem(msrest.serialization.Model):
    """ResumeSearchParametersLocationsItem.

    :ivar name:
    :vartype name: str
    :ivar coordinates:
    :vartype coordinates: ~affinda.models.ResumeSearchParametersLocationsItemCoordinates
    :ivar distance:
    :vartype distance: int
    :ivar unit: Possible values include: "km", "mi".
    :vartype unit: str or ~affinda.models.SearchLocationUnit
    """

    _attribute_map = {
        "name": {"key": "name", "type": "str"},
        "coordinates": {
            "key": "coordinates",
            "type": "ResumeSearchParametersLocationsItemCoordinates",
        },
        "distance": {"key": "distance", "type": "int"},
        "unit": {"key": "unit", "type": "str"},
    }

    def __init__(
        self,
        *,
        name: Optional[str] = None,
        coordinates: Optional["ResumeSearchParametersLocationsItemCoordinates"] = None,
        distance: Optional[int] = None,
        unit: Optional[Union[str, "SearchLocationUnit"]] = None,
        **kwargs,
    ):
        """
        :keyword name:
        :paramtype name: str
        :keyword coordinates:
        :paramtype coordinates: ~affinda.models.ResumeSearchParametersLocationsItemCoordinates
        :keyword distance:
        :paramtype distance: int
        :keyword unit: Possible values include: "km", "mi".
        :paramtype unit: str or ~affinda.models.SearchLocationUnit
        """
        super(ResumeSearchParametersLocationsItem, self).__init__(**kwargs)
        self.name = name
        self.coordinates = coordinates
        self.distance = distance
        self.unit = unit


class ResumeSearchParametersLocationsItemCoordinates(msrest.serialization.Model):
    """ResumeSearchParametersLocationsItemCoordinates.

    :ivar latitude:
    :vartype latitude: float
    :ivar longitude:
    :vartype longitude: float
    """

    _attribute_map = {
        "latitude": {"key": "latitude", "type": "float"},
        "longitude": {"key": "longitude", "type": "float"},
    }

    def __init__(
        self, *, latitude: Optional[float] = None, longitude: Optional[float] = None, **kwargs
    ):
        """
        :keyword latitude:
        :paramtype latitude: float
        :keyword longitude:
        :paramtype longitude: float
        """
        super(ResumeSearchParametersLocationsItemCoordinates, self).__init__(**kwargs)
        self.latitude = latitude
        self.longitude = longitude


class ResumeSearchParametersSkillsItem(msrest.serialization.Model):
    """ResumeSearchParametersSkillsItem.

    :ivar name:
    :vartype name: str
    :ivar required:
    :vartype required: bool
    """

    _attribute_map = {
        "name": {"key": "name", "type": "str"},
        "required": {"key": "required", "type": "bool"},
    }

    def __init__(self, *, name: Optional[str] = None, required: Optional[bool] = None, **kwargs):
        """
        :keyword name:
        :paramtype name: str
        :keyword required:
        :paramtype required: bool
        """
        super(ResumeSearchParametersSkillsItem, self).__init__(**kwargs)
        self.name = name
        self.required = required


class ResumeSearchResult(msrest.serialization.Model):
    """ResumeSearchResult.

    All required parameters must be populated in order to send to Azure.

    :ivar identifier: Required. Unique identifier for the document. If creating a document and left
     blank, one will be automatically generated.
    :vartype identifier: str
    :ivar score: Required.
    :vartype score: float
    :ivar pdf: Required.
    :vartype pdf: str
    :ivar name:
    :vartype name: str
    :ivar job_title: Required.
    :vartype job_title: ~affinda.models.ResumeSearchScoreComponent
    :ivar management_level: Required.
    :vartype management_level: ~affinda.models.ResumeSearchScoreComponent
    :ivar experience: Required.
    :vartype experience: ~affinda.models.ResumeSearchScoreComponent
    :ivar skills: Required.
    :vartype skills: ~affinda.models.ResumeSearchScoreComponent
    :ivar languages: Required.
    :vartype languages: ~affinda.models.ResumeSearchScoreComponent
    :ivar location: Required.
    :vartype location: ~affinda.models.ResumeSearchScoreComponent
    :ivar education: Required.
    :vartype education: ~affinda.models.ResumeSearchScoreComponent
    :ivar occupation_group: Required.
    :vartype occupation_group: ~affinda.models.ResumeSearchScoreComponent
    """

    _validation = {
        "identifier": {"required": True},
        "score": {"required": True},
        "pdf": {"required": True},
        "job_title": {"required": True},
        "management_level": {"required": True},
        "experience": {"required": True},
        "skills": {"required": True},
        "languages": {"required": True},
        "location": {"required": True},
        "education": {"required": True},
        "occupation_group": {"required": True},
    }

    _attribute_map = {
        "identifier": {"key": "identifier", "type": "str"},
        "score": {"key": "score", "type": "float"},
        "pdf": {"key": "pdf", "type": "str"},
        "name": {"key": "name", "type": "str"},
        "job_title": {"key": "jobTitle", "type": "ResumeSearchScoreComponent"},
        "management_level": {"key": "managementLevel", "type": "ResumeSearchScoreComponent"},
        "experience": {"key": "experience", "type": "ResumeSearchScoreComponent"},
        "skills": {"key": "skills", "type": "ResumeSearchScoreComponent"},
        "languages": {"key": "languages", "type": "ResumeSearchScoreComponent"},
        "location": {"key": "location", "type": "ResumeSearchScoreComponent"},
        "education": {"key": "education", "type": "ResumeSearchScoreComponent"},
        "occupation_group": {"key": "occupationGroup", "type": "ResumeSearchScoreComponent"},
    }

    def __init__(
        self,
        *,
        identifier: str,
        score: float,
        pdf: str,
        job_title: "ResumeSearchScoreComponent",
        management_level: "ResumeSearchScoreComponent",
        experience: "ResumeSearchScoreComponent",
        skills: "ResumeSearchScoreComponent",
        languages: "ResumeSearchScoreComponent",
        location: "ResumeSearchScoreComponent",
        education: "ResumeSearchScoreComponent",
        occupation_group: "ResumeSearchScoreComponent",
        name: Optional[str] = None,
        **kwargs,
    ):
        """
        :keyword identifier: Required. Unique identifier for the document. If creating a document and
         left blank, one will be automatically generated.
        :paramtype identifier: str
        :keyword score: Required.
        :paramtype score: float
        :keyword pdf: Required.
        :paramtype pdf: str
        :keyword name:
        :paramtype name: str
        :keyword job_title: Required.
        :paramtype job_title: ~affinda.models.ResumeSearchScoreComponent
        :keyword management_level: Required.
        :paramtype management_level: ~affinda.models.ResumeSearchScoreComponent
        :keyword experience: Required.
        :paramtype experience: ~affinda.models.ResumeSearchScoreComponent
        :keyword skills: Required.
        :paramtype skills: ~affinda.models.ResumeSearchScoreComponent
        :keyword languages: Required.
        :paramtype languages: ~affinda.models.ResumeSearchScoreComponent
        :keyword location: Required.
        :paramtype location: ~affinda.models.ResumeSearchScoreComponent
        :keyword education: Required.
        :paramtype education: ~affinda.models.ResumeSearchScoreComponent
        :keyword occupation_group: Required.
        :paramtype occupation_group: ~affinda.models.ResumeSearchScoreComponent
        """
        super(ResumeSearchResult, self).__init__(**kwargs)
        self.identifier = identifier
        self.score = score
        self.pdf = pdf
        self.name = name
        self.job_title = job_title
        self.management_level = management_level
        self.experience = experience
        self.skills = skills
        self.languages = languages
        self.location = location
        self.education = education
        self.occupation_group = occupation_group


class ResumeSearchScoreComponent(msrest.serialization.Model):
    """ResumeSearchScoreComponent.

    All required parameters must be populated in order to send to Azure.

    :ivar label: Required.
    :vartype label: str
    :ivar value:
    :vartype value: str
    :ivar score:
    :vartype score: float
    """

    _validation = {
        "label": {"required": True},
    }

    _attribute_map = {
        "label": {"key": "label", "type": "str"},
        "value": {"key": "value", "type": "str"},
        "score": {"key": "score", "type": "float"},
    }

    def __init__(
        self, *, label: str, value: Optional[str] = None, score: Optional[float] = None, **kwargs
    ):
        """
        :keyword label: Required.
        :paramtype label: str
        :keyword value:
        :paramtype value: str
        :keyword score:
        :paramtype score: float
        """
        super(ResumeSearchScoreComponent, self).__init__(**kwargs)
        self.label = label
        self.value = value
        self.score = score
