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

import datetime
from typing import Any, Dict, List, Optional, TYPE_CHECKING, Union

from .. import _serialization

if TYPE_CHECKING:
    # pylint: disable=unused-import,ungrouped-imports
    from .. import models as _models


class BaseProfile(_serialization.Model):
    """Representation of a base profile which is used to build profiles from.

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

    :ivar version: The version of the base profile. As time passes new base profile versions will
     be introduced. It is recommended to use the latest one. Required.
    :vartype version: str
    :ivar id: The unique identifier of the base profile. You can use this as a reference to create
     a new profile from this base profile. Required.
    :vartype id: str
    :ivar device: Required.
    :vartype device: ~kameleo.local_api_client.models.Device
    :ivar os: Required.
    :vartype os: ~kameleo.local_api_client.models.Os
    :ivar browser: Required.
    :vartype browser: ~kameleo.local_api_client.models.Browser
    :ivar language: Language of the base profile. Using ISO 639-1 language codes. Required.
    :vartype language: str
    :ivar resolution: The screen size of the device in pixels. Required.
    :vartype resolution: str
    :ivar fonts: A list of font types included in the profile. Required.
    :vartype fonts: list[str]
    :ivar webgl_meta: Required.
    :vartype webgl_meta: ~kameleo.local_api_client.models.WebglMeta
    """

    _validation = {
        "version": {"required": True},
        "id": {"required": True},
        "device": {"required": True},
        "os": {"required": True},
        "browser": {"required": True},
        "language": {"required": True},
        "resolution": {"required": True},
        "fonts": {"required": True},
        "webgl_meta": {"required": True},
    }

    _attribute_map = {
        "version": {"key": "version", "type": "str"},
        "id": {"key": "id", "type": "str"},
        "device": {"key": "device", "type": "Device"},
        "os": {"key": "os", "type": "Os"},
        "browser": {"key": "browser", "type": "Browser"},
        "language": {"key": "language", "type": "str"},
        "resolution": {"key": "resolution", "type": "str"},
        "fonts": {"key": "fonts", "type": "[str]"},
        "webgl_meta": {"key": "webglMeta", "type": "WebglMeta"},
    }

    def __init__(
        self,
        *,
        version: str,
        id: str,  # pylint: disable=redefined-builtin
        device: "_models.Device",
        os: "_models.Os",
        browser: "_models.Browser",
        language: str,
        resolution: str,
        fonts: List[str],
        webgl_meta: "_models.WebglMeta",
        **kwargs: Any
    ) -> None:
        """
        :keyword version: The version of the base profile. As time passes new base profile versions
         will be introduced. It is recommended to use the latest one. Required.
        :paramtype version: str
        :keyword id: The unique identifier of the base profile. You can use this as a reference to
         create a new profile from this base profile. Required.
        :paramtype id: str
        :keyword device: Required.
        :paramtype device: ~kameleo.local_api_client.models.Device
        :keyword os: Required.
        :paramtype os: ~kameleo.local_api_client.models.Os
        :keyword browser: Required.
        :paramtype browser: ~kameleo.local_api_client.models.Browser
        :keyword language: Language of the base profile. Using ISO 639-1 language codes. Required.
        :paramtype language: str
        :keyword resolution: The screen size of the device in pixels. Required.
        :paramtype resolution: str
        :keyword fonts: A list of font types included in the profile. Required.
        :paramtype fonts: list[str]
        :keyword webgl_meta: Required.
        :paramtype webgl_meta: ~kameleo.local_api_client.models.WebglMeta
        """
        super().__init__(**kwargs)
        self.version = version
        self.id = id
        self.device = device
        self.os = os
        self.browser = browser
        self.language = language
        self.resolution = resolution
        self.fonts = fonts
        self.webgl_meta = webgl_meta


class BaseProfilePreview(_serialization.Model):
    """A preview object of a searched base profile. This contains some information about the base
    profile that will help you choose the right one.

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

    :ivar id: The unique identifier of the base profile. You can use this as a reference to create
     a new profile from this base profile. Required.
    :vartype id: str
    :ivar device: Required.
    :vartype device: ~kameleo.local_api_client.models.Device
    :ivar os: Required.
    :vartype os: ~kameleo.local_api_client.models.Os
    :ivar browser: Required.
    :vartype browser: ~kameleo.local_api_client.models.Browser
    :ivar language: Language of the base profile. Using ISO 639-1 language codes. Required.
    :vartype language: str
    """

    _validation = {
        "id": {"required": True},
        "device": {"required": True},
        "os": {"required": True},
        "browser": {"required": True},
        "language": {"required": True},
    }

    _attribute_map = {
        "id": {"key": "id", "type": "str"},
        "device": {"key": "device", "type": "Device"},
        "os": {"key": "os", "type": "Os"},
        "browser": {"key": "browser", "type": "Browser"},
        "language": {"key": "language", "type": "str"},
    }

    def __init__(
        self,
        *,
        id: str,  # pylint: disable=redefined-builtin
        device: "_models.Device",
        os: "_models.Os",
        browser: "_models.Browser",
        language: str,
        **kwargs: Any
    ) -> None:
        """
        :keyword id: The unique identifier of the base profile. You can use this as a reference to
         create a new profile from this base profile. Required.
        :paramtype id: str
        :keyword device: Required.
        :paramtype device: ~kameleo.local_api_client.models.Device
        :keyword os: Required.
        :paramtype os: ~kameleo.local_api_client.models.Os
        :keyword browser: Required.
        :paramtype browser: ~kameleo.local_api_client.models.Browser
        :keyword language: Language of the base profile. Using ISO 639-1 language codes. Required.
        :paramtype language: str
        """
        super().__init__(**kwargs)
        self.id = id
        self.device = device
        self.os = os
        self.browser = browser
        self.language = language


class BaseProfileSearchParameters(_serialization.Model):
    """Provides possible values for base profile filtering. For example it tells what os languages are
    available.

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

    :ivar device_types: List of possible device types. Possible values are 'desktop', 'mobile'.
     Required.
    :vartype device_types: list[str]
    :ivar os_families: List of possible os families. Possible values are 'windows', 'macos',
     'linux', 'android', 'ios'. Required.
    :vartype os_families: list[str]
    :ivar browser_products: List of possible browser products. Possible values are 'chrome',
     'firefox', 'edge', 'safari'. Required.
    :vartype browser_products: list[str]
    :ivar languages: List of possible os languages. It using the ISO 639-1 language code format.
     Required.
    :vartype languages: list[str]
    """

    _validation = {
        "device_types": {"required": True},
        "os_families": {"required": True},
        "browser_products": {"required": True},
        "languages": {"required": True},
    }

    _attribute_map = {
        "device_types": {"key": "deviceTypes", "type": "[str]"},
        "os_families": {"key": "osFamilies", "type": "[str]"},
        "browser_products": {"key": "browserProducts", "type": "[str]"},
        "languages": {"key": "languages", "type": "[str]"},
    }

    def __init__(
        self,
        *,
        device_types: List[str],
        os_families: List[str],
        browser_products: List[str],
        languages: List[str],
        **kwargs: Any
    ) -> None:
        """
        :keyword device_types: List of possible device types. Possible values are 'desktop', 'mobile'.
         Required.
        :paramtype device_types: list[str]
        :keyword os_families: List of possible os families. Possible values are 'windows', 'macos',
         'linux', 'android', 'ios'. Required.
        :paramtype os_families: list[str]
        :keyword browser_products: List of possible browser products. Possible values are 'chrome',
         'firefox', 'edge', 'safari'. Required.
        :paramtype browser_products: list[str]
        :keyword languages: List of possible os languages. It using the ISO 639-1 language code format.
         Required.
        :paramtype languages: list[str]
        """
        super().__init__(**kwargs)
        self.device_types = device_types
        self.os_families = os_families
        self.browser_products = browser_products
        self.languages = languages


class Browser(_serialization.Model):
    """Browser.

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

    :ivar product: Product of the browser. Possible values are 'chrome', 'firefox', 'edge',
     'safari'. Required.
    :vartype product: str
    :ivar major: Major version of the browser. Required.
    :vartype major: int
    :ivar version: Exact version of the browser. Required.
    :vartype version: str
    """

    _validation = {
        "product": {"required": True},
        "major": {"required": True},
        "version": {"required": True},
    }

    _attribute_map = {
        "product": {"key": "product", "type": "str"},
        "major": {"key": "major", "type": "int"},
        "version": {"key": "version", "type": "str"},
    }

    def __init__(self, *, product: str, major: int, version: str, **kwargs: Any) -> None:
        """
        :keyword product: Product of the browser. Possible values are 'chrome', 'firefox', 'edge',
         'safari'. Required.
        :paramtype product: str
        :keyword major: Major version of the browser. Required.
        :paramtype major: int
        :keyword version: Exact version of the browser. Required.
        :paramtype version: str
        """
        super().__init__(**kwargs)
        self.product = product
        self.major = major
        self.version = version


class BrowserCookie(_serialization.Model):  # pylint: disable=too-many-instance-attributes
    """Representation of a cookie.

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

    :ivar domain: The domain attribute signifies the domain for which the cookie is valid and can
     be submitted with every request for this domain or its subdomains. If this attribute is not
     specified, then the hostname of the originating server is used as the default value. Required.
    :vartype domain: str
    :ivar name: The name for the Cookie. Required.
    :vartype name: str
    :ivar path: The path attribute indicates a URL path that must exist in the requested URL in
     order to send the Cookie header. The %x2F ("/") character is considered a directory separator,
     and subdirectories match as well. Required.
    :vartype path: str
    :ivar value: The value of the Cookie. Required.
    :vartype value: str
    :ivar host_only: Host Only cookie means that the cookie should be handled by the browser to the
     server only to the same host/server that firstly sent it to the browser. Required.
    :vartype host_only: bool
    :ivar http_only: When this attribute is set, client-side scripts are not allowed to access the
     cookie. Required.
    :vartype http_only: bool
    :ivar secure: A cookie with the Secure attribute is sent to the server only with an encrypted
     request over the HTTPS protocol, never with unsecured HTTP, and therefore can't easily be
     accessed by a man-in-the-middle attacker. Insecure sites (with http: in the URL) can't set
     cookies with the Secure attribute. Required.
    :vartype secure: bool
    :ivar same_site: The sameSite attribute lets servers require that a cookie shouldn't be sent
     with cross-origin requests (where Site is defined by the registrable domain), which provides
     some protection against cross-site request forgery attacks (CSRF).
     It takes three possible values: Strict, Lax, and None.With Strict, the cookie is sent only to
     the same site as the one that originated it; Lax is similar, with an exception for when the
     user navigates to a URL from an external site, such as by following a link; None has no
     restrictions on cross-site requests. Required.
    :vartype same_site: str
    :ivar expiration_date: This unix timestamp formatted attribute is used to set persistent
     cookies. It signifies how long the browser should use the persistent cookie and when the cookie
     should be deleted.
     If this attribute is not specified, then the lifetime of the cookie is the same as that of
     browser session, i.e.it will be a non-persistent cookie.
    :vartype expiration_date: int
    :ivar session: Session cookies are deleted when the current session ends. The browser defines
     when the "current session" ends, and some browsers use session restoring when restarting, which
     can cause session cookies to last indefinitely long.
    :vartype session: bool
    :ivar store_id: The ID of the cookie store containing this cookie.
    :vartype store_id: str
    """

    _validation = {
        "domain": {"required": True},
        "name": {"required": True},
        "path": {"required": True},
        "value": {"required": True},
        "host_only": {"required": True},
        "http_only": {"required": True},
        "secure": {"required": True},
        "same_site": {"required": True},
    }

    _attribute_map = {
        "domain": {"key": "domain", "type": "str"},
        "name": {"key": "name", "type": "str"},
        "path": {"key": "path", "type": "str"},
        "value": {"key": "value", "type": "str"},
        "host_only": {"key": "hostOnly", "type": "bool"},
        "http_only": {"key": "httpOnly", "type": "bool"},
        "secure": {"key": "secure", "type": "bool"},
        "same_site": {"key": "sameSite", "type": "str"},
        "expiration_date": {"key": "expirationDate", "type": "int"},
        "session": {"key": "session", "type": "bool"},
        "store_id": {"key": "storeId", "type": "str"},
    }

    def __init__(
        self,
        *,
        domain: str,
        name: str,
        path: str,
        value: str,
        host_only: bool,
        http_only: bool,
        secure: bool,
        same_site: str,
        expiration_date: Optional[int] = None,
        session: Optional[bool] = None,
        store_id: Optional[str] = None,
        **kwargs: Any
    ) -> None:
        """
        :keyword domain: The domain attribute signifies the domain for which the cookie is valid and
         can be submitted with every request for this domain or its subdomains. If this attribute is not
         specified, then the hostname of the originating server is used as the default value. Required.
        :paramtype domain: str
        :keyword name: The name for the Cookie. Required.
        :paramtype name: str
        :keyword path: The path attribute indicates a URL path that must exist in the requested URL in
         order to send the Cookie header. The %x2F ("/") character is considered a directory separator,
         and subdirectories match as well. Required.
        :paramtype path: str
        :keyword value: The value of the Cookie. Required.
        :paramtype value: str
        :keyword host_only: Host Only cookie means that the cookie should be handled by the browser to
         the server only to the same host/server that firstly sent it to the browser. Required.
        :paramtype host_only: bool
        :keyword http_only: When this attribute is set, client-side scripts are not allowed to access
         the cookie. Required.
        :paramtype http_only: bool
        :keyword secure: A cookie with the Secure attribute is sent to the server only with an
         encrypted request over the HTTPS protocol, never with unsecured HTTP, and therefore can't
         easily be accessed by a man-in-the-middle attacker. Insecure sites (with http: in the URL)
         can't set cookies with the Secure attribute. Required.
        :paramtype secure: bool
        :keyword same_site: The sameSite attribute lets servers require that a cookie shouldn't be sent
         with cross-origin requests (where Site is defined by the registrable domain), which provides
         some protection against cross-site request forgery attacks (CSRF).
         It takes three possible values: Strict, Lax, and None.With Strict, the cookie is sent only to
         the same site as the one that originated it; Lax is similar, with an exception for when the
         user navigates to a URL from an external site, such as by following a link; None has no
         restrictions on cross-site requests. Required.
        :paramtype same_site: str
        :keyword expiration_date: This unix timestamp formatted attribute is used to set persistent
         cookies. It signifies how long the browser should use the persistent cookie and when the cookie
         should be deleted.
         If this attribute is not specified, then the lifetime of the cookie is the same as that of
         browser session, i.e.it will be a non-persistent cookie.
        :paramtype expiration_date: int
        :keyword session: Session cookies are deleted when the current session ends. The browser
         defines when the "current session" ends, and some browsers use session restoring when
         restarting, which can cause session cookies to last indefinitely long.
        :paramtype session: bool
        :keyword store_id: The ID of the cookie store containing this cookie.
        :paramtype store_id: str
        """
        super().__init__(**kwargs)
        self.domain = domain
        self.name = name
        self.path = path
        self.value = value
        self.host_only = host_only
        self.http_only = http_only
        self.secure = secure
        self.same_site = same_site
        self.expiration_date = expiration_date
        self.session = session
        self.store_id = store_id


class CookieRequest(_serialization.Model):
    """CookieRequest.

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

    :ivar domain: The domain attribute signifies the domain for which the cookie is valid and can
     be submitted with every request for this domain or its subdomains. If this attribute is not
     specified, then the hostname of the originating server is used as the default value. Required.
    :vartype domain: str
    :ivar name: The name for the Cookie. Required.
    :vartype name: str
    :ivar path: The path attribute indicates a URL path that must exist in the requested URL in
     order to send the Cookie header. The %x2F ("/") character is considered a directory separator,
     and subdirectories match as well. Required.
    :vartype path: str
    :ivar value: The value of the Cookie. Required.
    :vartype value: str
    :ivar host_only: Host Only cookie means that the cookie should be handled by the browser to the
     server only to the same host/server that firstly sent it to the browser.
    :vartype host_only: bool
    :ivar http_only: When this attribute is set, client-side scripts are not allowed to access the
     cookie.
    :vartype http_only: bool
    :ivar secure: A cookie with the Secure attribute is sent to the server only with an encrypted
     request over the HTTPS protocol, never with unsecured HTTP, and therefore can't easily be
     accessed by a man-in-the-middle attacker. Insecure sites (with http: in the URL) can't set
     cookies with the Secure attribute.
    :vartype secure: bool
    :ivar same_site: The sameSite attribute lets servers require that a cookie shouldn't be sent
     with cross-origin requests (where Site is defined by the registrable domain), which provides
     some protection against cross-site request forgery attacks (CSRF).
     It takes three possible values: Strict, Lax, and None.With Strict, the cookie is sent only to
     the same site as the one that originated it; Lax is similar, with an exception for when the
     user navigates to a URL from an external site, such as by following a link; None has no
     restrictions on cross-site requests.
    :vartype same_site: str
    :ivar expiration_date: This attribute is used to set persistent cookies. It signifies how long
     the browser should use the persistent cookie and when the cookie should be deleted.
     If this attribute is not specified, then the lifetime of the cookie is the same as that of
     browser session, i.e.it will be a non-persistent cookie.
    :vartype expiration_date: int
    """

    _validation = {
        "domain": {"required": True, "min_length": 1},
        "name": {"required": True},
        "path": {"required": True, "min_length": 1},
        "value": {"required": True},
    }

    _attribute_map = {
        "domain": {"key": "domain", "type": "str"},
        "name": {"key": "name", "type": "str"},
        "path": {"key": "path", "type": "str"},
        "value": {"key": "value", "type": "str"},
        "host_only": {"key": "hostOnly", "type": "bool"},
        "http_only": {"key": "httpOnly", "type": "bool"},
        "secure": {"key": "secure", "type": "bool"},
        "same_site": {"key": "sameSite", "type": "str"},
        "expiration_date": {"key": "expirationDate", "type": "int"},
    }

    def __init__(
        self,
        *,
        domain: str,
        name: str,
        path: str,
        value: str,
        host_only: Optional[bool] = None,
        http_only: Optional[bool] = None,
        secure: Optional[bool] = None,
        same_site: Optional[str] = None,
        expiration_date: Optional[int] = None,
        **kwargs: Any
    ) -> None:
        """
        :keyword domain: The domain attribute signifies the domain for which the cookie is valid and
         can be submitted with every request for this domain or its subdomains. If this attribute is not
         specified, then the hostname of the originating server is used as the default value. Required.
        :paramtype domain: str
        :keyword name: The name for the Cookie. Required.
        :paramtype name: str
        :keyword path: The path attribute indicates a URL path that must exist in the requested URL in
         order to send the Cookie header. The %x2F ("/") character is considered a directory separator,
         and subdirectories match as well. Required.
        :paramtype path: str
        :keyword value: The value of the Cookie. Required.
        :paramtype value: str
        :keyword host_only: Host Only cookie means that the cookie should be handled by the browser to
         the server only to the same host/server that firstly sent it to the browser.
        :paramtype host_only: bool
        :keyword http_only: When this attribute is set, client-side scripts are not allowed to access
         the cookie.
        :paramtype http_only: bool
        :keyword secure: A cookie with the Secure attribute is sent to the server only with an
         encrypted request over the HTTPS protocol, never with unsecured HTTP, and therefore can't
         easily be accessed by a man-in-the-middle attacker. Insecure sites (with http: in the URL)
         can't set cookies with the Secure attribute.
        :paramtype secure: bool
        :keyword same_site: The sameSite attribute lets servers require that a cookie shouldn't be sent
         with cross-origin requests (where Site is defined by the registrable domain), which provides
         some protection against cross-site request forgery attacks (CSRF).
         It takes three possible values: Strict, Lax, and None.With Strict, the cookie is sent only to
         the same site as the one that originated it; Lax is similar, with an exception for when the
         user navigates to a URL from an external site, such as by following a link; None has no
         restrictions on cross-site requests.
        :paramtype same_site: str
        :keyword expiration_date: This attribute is used to set persistent cookies. It signifies how
         long the browser should use the persistent cookie and when the cookie should be deleted.
         If this attribute is not specified, then the lifetime of the cookie is the same as that of
         browser session, i.e.it will be a non-persistent cookie.
        :paramtype expiration_date: int
        """
        super().__init__(**kwargs)
        self.domain = domain
        self.name = name
        self.path = path
        self.value = value
        self.host_only = host_only
        self.http_only = http_only
        self.secure = secure
        self.same_site = same_site
        self.expiration_date = expiration_date


class CreateProfileRequest(_serialization.Model):  # pylint: disable=too-many-instance-attributes
    """CreateProfileRequest.

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

    :ivar base_profile_id: The unique identifier of the base profile. This references the base
     profile which should be used to build the new profile. Required.
    :vartype base_profile_id: str
    :ivar name: Sets a human readable name for the profile. The value obtained by file name for
     existing profiles. For new profiles the value is generated by random.
    :vartype name: str
    :ivar tags: Use tags to categorize profiles by labeling them accordingly.
    :vartype tags: list[str]
    :ivar canvas: Specifies how the canvas will be spoofed. Possible values:
     'intelligent': Use intelligent canvas spoofing. This will result non-unique canvas
     fingerprints.
     'noise': Add some noise to canvas generation.
     'block': Completely block the 2D API.
     'off': Turn off the spoofing, use the original settings. Required. Known values are:
     "intelligent", "noise", "block", and "off".
    :vartype canvas: str or ~kameleo.local_api_client.models.CanvasSpoofingType
    :ivar webgl: Specifies how the WebGL will be spoofed. Possible values:
     'noise': Add some noise to the WebGL generation
     'block': Completely block the 3D API
     'off': Turn off the spoofing, use the original settings. Required. Known values are: "noise",
     "block", and "off".
    :vartype webgl: str or ~kameleo.local_api_client.models.WebglSpoofingType
    :ivar webgl_meta: Required.
    :vartype webgl_meta:
     ~kameleo.local_api_client.models.WebglMetaSpoofingTypeWebglMetaSpoofingOptionsMultiLevelChoice
    :ivar audio: Specifies how the audio will be spoofed. Possible values:
     'noise': Add some noise to the Audio generation
     'block': Completely block the Audio API
     'off': Turn off the spoofing, use the original settings. Required. Known values are: "off",
     "noise", and "block".
    :vartype audio: str or ~kameleo.local_api_client.models.AudioSpoofingType
    :ivar timezone: Required.
    :vartype timezone:
     ~kameleo.local_api_client.models.TimezoneSpoofingTypeTimezoneMultiLevelChoice
    :ivar geolocation: Required.
    :vartype geolocation:
     ~kameleo.local_api_client.models.GeolocationSpoofingTypeGeolocationSpoofingOptionsMultiLevelChoice
    :ivar proxy: Required.
    :vartype proxy: ~kameleo.local_api_client.models.ProxyConnectionTypeServerMultiLevelChoice
    :ivar web_rtc: Required.
    :vartype web_rtc:
     ~kameleo.local_api_client.models.WebRtcSpoofingTypeWebRtcSpoofingOptionsMultiLevelChoice
    :ivar fonts: Required.
    :vartype fonts: ~kameleo.local_api_client.models.FontSpoofingTypeFontIListMultiLevelChoice
    :ivar screen: Required.
    :vartype screen: ~kameleo.local_api_client.models.ScreenSpoofingTypeScreenSizeMultiLevelChoice
    :ivar hardware_concurrency:
    :vartype hardware_concurrency:
     ~kameleo.local_api_client.models.HardwareConcurrencySpoofingTypeInt32NullableMultiLevelChoice
    :ivar device_memory:
    :vartype device_memory:
     ~kameleo.local_api_client.models.DeviceMemorySpoofingTypeDoubleNullableMultiLevelChoice
    :ivar start_page: This website will be opened in the browser when the profile launches.
    :vartype start_page: str
    :ivar password_manager: Defines whether the browser can save login credentials. Possible values
     are:
     'enabled': Credential saving is allowed.
     'disabled': Credential saving is blocked. Required. Known values are: "enabled" and
     "disabled".
    :vartype password_manager: str or ~kameleo.local_api_client.models.PasswordManagerType
    :ivar extensions: A list of abolute paths from where the profile should load extensions or
     addons when starting the browser. For chrome and edge use CRX3 format extensions. For firefox
     use signed xpi format addons.
    :vartype extensions: list[str]
    :ivar notes: A free text including any notes written by the user.
    :vartype notes: str
    :ivar storage: Known values are: "local" and "cloud".
    :vartype storage: str or ~kameleo.local_api_client.models.ProfileStorageLocation
    :ivar launcher: This setting determines which browser engine is launched when a profile is
     started. This can be modified only before the first start. Possible values for Desktop
     profiles: 'automatic'. Possible values for Mobile profiles: 'chromium', 'external'.
    :vartype launcher: str
    """

    _validation = {
        "base_profile_id": {"required": True, "min_length": 1},
        "canvas": {"required": True},
        "webgl": {"required": True},
        "webgl_meta": {"required": True},
        "audio": {"required": True},
        "timezone": {"required": True},
        "geolocation": {"required": True},
        "proxy": {"required": True},
        "web_rtc": {"required": True},
        "fonts": {"required": True},
        "screen": {"required": True},
        "password_manager": {"required": True},
    }

    _attribute_map = {
        "base_profile_id": {"key": "baseProfileId", "type": "str"},
        "name": {"key": "name", "type": "str"},
        "tags": {"key": "tags", "type": "[str]"},
        "canvas": {"key": "canvas", "type": "str"},
        "webgl": {"key": "webgl", "type": "str"},
        "webgl_meta": {"key": "webglMeta", "type": "WebglMetaSpoofingTypeWebglMetaSpoofingOptionsMultiLevelChoice"},
        "audio": {"key": "audio", "type": "str"},
        "timezone": {"key": "timezone", "type": "TimezoneSpoofingTypeTimezoneMultiLevelChoice"},
        "geolocation": {
            "key": "geolocation",
            "type": "GeolocationSpoofingTypeGeolocationSpoofingOptionsMultiLevelChoice",
        },
        "proxy": {"key": "proxy", "type": "ProxyConnectionTypeServerMultiLevelChoice"},
        "web_rtc": {"key": "webRtc", "type": "WebRtcSpoofingTypeWebRtcSpoofingOptionsMultiLevelChoice"},
        "fonts": {"key": "fonts", "type": "FontSpoofingTypeFontIListMultiLevelChoice"},
        "screen": {"key": "screen", "type": "ScreenSpoofingTypeScreenSizeMultiLevelChoice"},
        "hardware_concurrency": {
            "key": "hardwareConcurrency",
            "type": "HardwareConcurrencySpoofingTypeInt32NullableMultiLevelChoice",
        },
        "device_memory": {"key": "deviceMemory", "type": "DeviceMemorySpoofingTypeDoubleNullableMultiLevelChoice"},
        "start_page": {"key": "startPage", "type": "str"},
        "password_manager": {"key": "passwordManager", "type": "str"},
        "extensions": {"key": "extensions", "type": "[str]"},
        "notes": {"key": "notes", "type": "str"},
        "storage": {"key": "storage", "type": "str"},
        "launcher": {"key": "launcher", "type": "str"},
    }

    def __init__(
        self,
        *,
        base_profile_id: str,
        canvas: Union[str, "_models.CanvasSpoofingType"],
        webgl: Union[str, "_models.WebglSpoofingType"],
        webgl_meta: "_models.WebglMetaSpoofingTypeWebglMetaSpoofingOptionsMultiLevelChoice",
        audio: Union[str, "_models.AudioSpoofingType"],
        timezone: "_models.TimezoneSpoofingTypeTimezoneMultiLevelChoice",
        geolocation: "_models.GeolocationSpoofingTypeGeolocationSpoofingOptionsMultiLevelChoice",
        proxy: "_models.ProxyConnectionTypeServerMultiLevelChoice",
        web_rtc: "_models.WebRtcSpoofingTypeWebRtcSpoofingOptionsMultiLevelChoice",
        fonts: "_models.FontSpoofingTypeFontIListMultiLevelChoice",
        screen: "_models.ScreenSpoofingTypeScreenSizeMultiLevelChoice",
        password_manager: Union[str, "_models.PasswordManagerType"],
        name: Optional[str] = None,
        tags: Optional[List[str]] = None,
        hardware_concurrency: Optional["_models.HardwareConcurrencySpoofingTypeInt32NullableMultiLevelChoice"] = None,
        device_memory: Optional["_models.DeviceMemorySpoofingTypeDoubleNullableMultiLevelChoice"] = None,
        start_page: Optional[str] = None,
        extensions: Optional[List[str]] = None,
        notes: Optional[str] = None,
        storage: Optional[Union[str, "_models.ProfileStorageLocation"]] = None,
        launcher: Optional[str] = None,
        **kwargs: Any
    ) -> None:
        """
        :keyword base_profile_id: The unique identifier of the base profile. This references the base
         profile which should be used to build the new profile. Required.
        :paramtype base_profile_id: str
        :keyword name: Sets a human readable name for the profile. The value obtained by file name for
         existing profiles. For new profiles the value is generated by random.
        :paramtype name: str
        :keyword tags: Use tags to categorize profiles by labeling them accordingly.
        :paramtype tags: list[str]
        :keyword canvas: Specifies how the canvas will be spoofed. Possible values:
         'intelligent': Use intelligent canvas spoofing. This will result non-unique canvas
         fingerprints.
         'noise': Add some noise to canvas generation.
         'block': Completely block the 2D API.
         'off': Turn off the spoofing, use the original settings. Required. Known values are:
         "intelligent", "noise", "block", and "off".
        :paramtype canvas: str or ~kameleo.local_api_client.models.CanvasSpoofingType
        :keyword webgl: Specifies how the WebGL will be spoofed. Possible values:
         'noise': Add some noise to the WebGL generation
         'block': Completely block the 3D API
         'off': Turn off the spoofing, use the original settings. Required. Known values are: "noise",
         "block", and "off".
        :paramtype webgl: str or ~kameleo.local_api_client.models.WebglSpoofingType
        :keyword webgl_meta: Required.
        :paramtype webgl_meta:
         ~kameleo.local_api_client.models.WebglMetaSpoofingTypeWebglMetaSpoofingOptionsMultiLevelChoice
        :keyword audio: Specifies how the audio will be spoofed. Possible values:
         'noise': Add some noise to the Audio generation
         'block': Completely block the Audio API
         'off': Turn off the spoofing, use the original settings. Required. Known values are: "off",
         "noise", and "block".
        :paramtype audio: str or ~kameleo.local_api_client.models.AudioSpoofingType
        :keyword timezone: Required.
        :paramtype timezone:
         ~kameleo.local_api_client.models.TimezoneSpoofingTypeTimezoneMultiLevelChoice
        :keyword geolocation: Required.
        :paramtype geolocation:
         ~kameleo.local_api_client.models.GeolocationSpoofingTypeGeolocationSpoofingOptionsMultiLevelChoice
        :keyword proxy: Required.
        :paramtype proxy: ~kameleo.local_api_client.models.ProxyConnectionTypeServerMultiLevelChoice
        :keyword web_rtc: Required.
        :paramtype web_rtc:
         ~kameleo.local_api_client.models.WebRtcSpoofingTypeWebRtcSpoofingOptionsMultiLevelChoice
        :keyword fonts: Required.
        :paramtype fonts: ~kameleo.local_api_client.models.FontSpoofingTypeFontIListMultiLevelChoice
        :keyword screen: Required.
        :paramtype screen:
         ~kameleo.local_api_client.models.ScreenSpoofingTypeScreenSizeMultiLevelChoice
        :keyword hardware_concurrency:
        :paramtype hardware_concurrency:
         ~kameleo.local_api_client.models.HardwareConcurrencySpoofingTypeInt32NullableMultiLevelChoice
        :keyword device_memory:
        :paramtype device_memory:
         ~kameleo.local_api_client.models.DeviceMemorySpoofingTypeDoubleNullableMultiLevelChoice
        :keyword start_page: This website will be opened in the browser when the profile launches.
        :paramtype start_page: str
        :keyword password_manager: Defines whether the browser can save login credentials. Possible
         values are:
         'enabled': Credential saving is allowed.
         'disabled': Credential saving is blocked. Required. Known values are: "enabled" and
         "disabled".
        :paramtype password_manager: str or ~kameleo.local_api_client.models.PasswordManagerType
        :keyword extensions: A list of abolute paths from where the profile should load extensions or
         addons when starting the browser. For chrome and edge use CRX3 format extensions. For firefox
         use signed xpi format addons.
        :paramtype extensions: list[str]
        :keyword notes: A free text including any notes written by the user.
        :paramtype notes: str
        :keyword storage: Known values are: "local" and "cloud".
        :paramtype storage: str or ~kameleo.local_api_client.models.ProfileStorageLocation
        :keyword launcher: This setting determines which browser engine is launched when a profile is
         started. This can be modified only before the first start. Possible values for Desktop
         profiles: 'automatic'. Possible values for Mobile profiles: 'chromium', 'external'.
        :paramtype launcher: str
        """
        super().__init__(**kwargs)
        self.base_profile_id = base_profile_id
        self.name = name
        self.tags = tags
        self.canvas = canvas
        self.webgl = webgl
        self.webgl_meta = webgl_meta
        self.audio = audio
        self.timezone = timezone
        self.geolocation = geolocation
        self.proxy = proxy
        self.web_rtc = web_rtc
        self.fonts = fonts
        self.screen = screen
        self.hardware_concurrency = hardware_concurrency
        self.device_memory = device_memory
        self.start_page = start_page
        self.password_manager = password_manager
        self.extensions = extensions
        self.notes = notes
        self.storage = storage
        self.launcher = launcher


class Device(_serialization.Model):
    """Device.

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

    :ivar type: Type of the device. Possible values are: 'desktop', 'mobile'. Required.
    :vartype type: str
    :ivar name: Name of the device. This is only available for mobile profiles.
    :vartype name: str
    """

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

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

    def __init__(self, *, type: str, name: Optional[str] = None, **kwargs: Any) -> None:
        """
        :keyword type: Type of the device. Possible values are: 'desktop', 'mobile'. Required.
        :paramtype type: str
        :keyword name: Name of the device. This is only available for mobile profiles.
        :paramtype name: str
        """
        super().__init__(**kwargs)
        self.type = type
        self.name = name


class DeviceMemorySpoofingTypeDoubleNullableMultiLevelChoice(_serialization.Model):
    """DeviceMemorySpoofingTypeDoubleNullableMultiLevelChoice.

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

    :ivar value: Specifies how the deviceMemory will be spoofed. Possible values:
     'automatic': Automatically set the values based on the Base Profile.
     'manual': Manually set the value in the profile. Valid values: 0.25, 0.5, 1, 2, 4, 8.
     'off': Turn off the spoofing, use the original settings. Required. Known values are:
     "automatic", "manual", and "off".
    :vartype value: str or ~kameleo.local_api_client.models.DeviceMemorySpoofingType
    :ivar extra:
    :vartype extra: float
    """

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

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

    def __init__(
        self, *, value: Union[str, "_models.DeviceMemorySpoofingType"], extra: Optional[float] = None, **kwargs: Any
    ) -> None:
        """
        :keyword value: Specifies how the deviceMemory will be spoofed. Possible values:
         'automatic': Automatically set the values based on the Base Profile.
         'manual': Manually set the value in the profile. Valid values: 0.25, 0.5, 1, 2, 4, 8.
         'off': Turn off the spoofing, use the original settings. Required. Known values are:
         "automatic", "manual", and "off".
        :paramtype value: str or ~kameleo.local_api_client.models.DeviceMemorySpoofingType
        :keyword extra:
        :paramtype extra: float
        """
        super().__init__(**kwargs)
        self.value = value
        self.extra = extra


class ExportProfileRequest(_serialization.Model):
    """Defines the target location for profile export.

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

    :ivar path: Specifies the file path for exporting the profile. Required.
    :vartype path: str
    """

    _validation = {
        "path": {"required": True, "min_length": 1},
    }

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

    def __init__(self, *, path: str, **kwargs: Any) -> None:
        """
        :keyword path: Specifies the file path for exporting the profile. Required.
        :paramtype path: str
        """
        super().__init__(**kwargs)
        self.path = path


class FontSpoofingTypeFontIListMultiLevelChoice(_serialization.Model):
    """FontSpoofingTypeFontIListMultiLevelChoice.

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

    :ivar value: Specifies how the fonts will be spoofed. Possible values:
     'enabled': Enable fonts spoofing. A list can be provided to override the fonts coming from the
     base profile.
     'disable': Disable fonts spoofing. Required. Known values are: "enabled" and "disabled".
    :vartype value: str or ~kameleo.local_api_client.models.FontSpoofingType
    :ivar extra:
    :vartype extra: list[str]
    """

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

    _attribute_map = {
        "value": {"key": "value", "type": "str"},
        "extra": {"key": "extra", "type": "[str]"},
    }

    def __init__(
        self, *, value: Union[str, "_models.FontSpoofingType"], extra: Optional[List[str]] = None, **kwargs: Any
    ) -> None:
        """
        :keyword value: Specifies how the fonts will be spoofed. Possible values:
         'enabled': Enable fonts spoofing. A list can be provided to override the fonts coming from the
         base profile.
         'disable': Disable fonts spoofing. Required. Known values are: "enabled" and "disabled".
        :paramtype value: str or ~kameleo.local_api_client.models.FontSpoofingType
        :keyword extra:
        :paramtype extra: list[str]
        """
        super().__init__(**kwargs)
        self.value = value
        self.extra = extra


class GeolocationSpoofingOptions(_serialization.Model):
    """When the Geolocation spoofing is set to manual these extra settings will be used as well.

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

    :ivar latitude: From -90 to 90. Required.
    :vartype latitude: float
    :ivar longitude: From -180 to 180. Required.
    :vartype longitude: float
    """

    _validation = {
        "latitude": {"required": True},
        "longitude": {"required": True},
    }

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

    def __init__(self, *, latitude: float, longitude: float, **kwargs: Any) -> None:
        """
        :keyword latitude: From -90 to 90. Required.
        :paramtype latitude: float
        :keyword longitude: From -180 to 180. Required.
        :paramtype longitude: float
        """
        super().__init__(**kwargs)
        self.latitude = latitude
        self.longitude = longitude


class GeolocationSpoofingTypeGeolocationSpoofingOptionsMultiLevelChoice(_serialization.Model):
    """GeolocationSpoofingTypeGeolocationSpoofingOptionsMultiLevelChoice.

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

    :ivar value: Specifies how the geolocation will be spoofed. Possible values:
     'automatic': Automatically set the values based on the IP address
     'manual': Manually set the longitude and latitude in the profile
     'block': Completely block the Geolocation API
     'off': Turn off the spoofing, use the original settings. Required. Known values are:
     "automatic", "manual", "block", and "off".
    :vartype value: str or ~kameleo.local_api_client.models.GeolocationSpoofingType
    :ivar extra: When the Geolocation spoofing is set to manual these extra settings will be used
     as well.
    :vartype extra: ~kameleo.local_api_client.models.GeolocationSpoofingOptions
    """

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

    _attribute_map = {
        "value": {"key": "value", "type": "str"},
        "extra": {"key": "extra", "type": "GeolocationSpoofingOptions"},
    }

    def __init__(
        self,
        *,
        value: Union[str, "_models.GeolocationSpoofingType"],
        extra: Optional["_models.GeolocationSpoofingOptions"] = None,
        **kwargs: Any
    ) -> None:
        """
        :keyword value: Specifies how the geolocation will be spoofed. Possible values:
         'automatic': Automatically set the values based on the IP address
         'manual': Manually set the longitude and latitude in the profile
         'block': Completely block the Geolocation API
         'off': Turn off the spoofing, use the original settings. Required. Known values are:
         "automatic", "manual", "block", and "off".
        :paramtype value: str or ~kameleo.local_api_client.models.GeolocationSpoofingType
        :keyword extra: When the Geolocation spoofing is set to manual these extra settings will be
         used as well.
        :paramtype extra: ~kameleo.local_api_client.models.GeolocationSpoofingOptions
        """
        super().__init__(**kwargs)
        self.value = value
        self.extra = extra


class HardwareConcurrencySpoofingTypeInt32NullableMultiLevelChoice(_serialization.Model):
    """HardwareConcurrencySpoofingTypeInt32NullableMultiLevelChoice.

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

    :ivar value: Specifies how the hardwareConcurrency will be spoofed. Possible values:
     'automatic': Automatically set the values based on the Base Profile.
     'manual': Manually set the value in the profile. Valid values: 1, 2, 4, 8, 12, 16.
     'off': Turn off the spoofing, use the original settings. Required. Known values are:
     "automatic", "manual", and "off".
    :vartype value: str or ~kameleo.local_api_client.models.HardwareConcurrencySpoofingType
    :ivar extra:
    :vartype extra: int
    """

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

    _attribute_map = {
        "value": {"key": "value", "type": "str"},
        "extra": {"key": "extra", "type": "int"},
    }

    def __init__(
        self,
        *,
        value: Union[str, "_models.HardwareConcurrencySpoofingType"],
        extra: Optional[int] = None,
        **kwargs: Any
    ) -> None:
        """
        :keyword value: Specifies how the hardwareConcurrency will be spoofed. Possible values:
         'automatic': Automatically set the values based on the Base Profile.
         'manual': Manually set the value in the profile. Valid values: 1, 2, 4, 8, 12, 16.
         'off': Turn off the spoofing, use the original settings. Required. Known values are:
         "automatic", "manual", and "off".
        :paramtype value: str or ~kameleo.local_api_client.models.HardwareConcurrencySpoofingType
        :keyword extra:
        :paramtype extra: int
        """
        super().__init__(**kwargs)
        self.value = value
        self.extra = extra


class ImportProfileRequest(_serialization.Model):
    """Specifies the source location for profile import.

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

    :ivar path: The file path from which the profile will be imported. Required.
    :vartype path: str
    """

    _validation = {
        "path": {"required": True, "min_length": 1},
    }

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

    def __init__(self, *, path: str, **kwargs: Any) -> None:
        """
        :keyword path: The file path from which the profile will be imported. Required.
        :paramtype path: str
        """
        super().__init__(**kwargs)
        self.path = path


class Os(_serialization.Model):
    """Os.

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

    :ivar family: Specifies the operating system family. Possible values are 'windows', 'macos',
     'linux', 'android', 'ios'. Required.
    :vartype family: str
    :ivar version: The specific version of the OS. For example it helps you determine the exact
     version of the macOS. Required.
    :vartype version: str
    :ivar platform: The OS's platform, indicating the processor architecture (e.g., 64-bit,
     32-bit). Required.
    :vartype platform: str
    """

    _validation = {
        "family": {"required": True},
        "version": {"required": True},
        "platform": {"required": True},
    }

    _attribute_map = {
        "family": {"key": "family", "type": "str"},
        "version": {"key": "version", "type": "str"},
        "platform": {"key": "platform", "type": "str"},
    }

    def __init__(self, *, family: str, version: str, platform: str, **kwargs: Any) -> None:
        """
        :keyword family: Specifies the operating system family. Possible values are 'windows', 'macos',
         'linux', 'android', 'ios'. Required.
        :paramtype family: str
        :keyword version: The specific version of the OS. For example it helps you determine the exact
         version of the macOS. Required.
        :paramtype version: str
        :keyword platform: The OS's platform, indicating the processor architecture (e.g., 64-bit,
         32-bit). Required.
        :paramtype platform: str
        """
        super().__init__(**kwargs)
        self.family = family
        self.version = version
        self.platform = platform


class Preference(_serialization.Model):
    """Represents a Key-Value pair where Value can be a string or a boolean or an integer.

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

    :ivar key: Key of the preference. Required.
    :vartype key: str
    :ivar value: Value of the preference. It can a string or a boolean or an integer. Required.
    :vartype value: any
    """

    _validation = {
        "key": {"required": True},
        "value": {"required": True},
    }

    _attribute_map = {
        "key": {"key": "key", "type": "str"},
        "value": {"key": "value", "type": "object"},
    }

    def __init__(self, *, key: str, value: Any, **kwargs: Any) -> None:
        """
        :keyword key: Key of the preference. Required.
        :paramtype key: str
        :keyword value: Value of the preference. It can a string or a boolean or an integer. Required.
        :paramtype value: any
        """
        super().__init__(**kwargs)
        self.key = key
        self.value = value


class ProblemResponse(_serialization.Model):
    """ProblemResponse.

    :ivar code:
    :vartype code: int
    :ivar error: Dictionary of
     <components·18zhilc·schemas·problemresponse·properties·error·additionalproperties>.
    :vartype error: dict[str, list[str]]
    """

    _attribute_map = {
        "code": {"key": "code", "type": "int"},
        "error": {"key": "error", "type": "{[str]}"},
    }

    def __init__(
        self, *, code: Optional[int] = None, error: Optional[Dict[str, List[str]]] = None, **kwargs: Any
    ) -> None:
        """
        :keyword code:
        :paramtype code: int
        :keyword error: Dictionary of
         <components·18zhilc·schemas·problemresponse·properties·error·additionalproperties>.
        :paramtype error: dict[str, list[str]]
        """
        super().__init__(**kwargs)
        self.code = code
        self.error = error


class ProfilePreview(_serialization.Model):  # pylint: disable=too-many-instance-attributes
    """A preview about the profile with some of its properties.

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

    :ivar id: A unique identifier of the profile. Required.
    :vartype id: str
    :ivar name: The name of the profile. Required.
    :vartype name: str
    :ivar tags: Profile tags. Required.
    :vartype tags: list[str]
    :ivar proxy: Required.
    :vartype proxy: ~kameleo.local_api_client.models.ProxyConnectionTypeServerMultiLevelChoice
    :ivar created_at: Date when the profile was created. Required.
    :vartype created_at: ~datetime.datetime
    :ivar device: Required.
    :vartype device: ~kameleo.local_api_client.models.Device
    :ivar os: Required.
    :vartype os: ~kameleo.local_api_client.models.Os
    :ivar browser: Required.
    :vartype browser: ~kameleo.local_api_client.models.Browser
    :ivar language: Language of the profile. This is derived from the base profile. Using ISO 639-1
     language codes. Required.
    :vartype language: str
    :ivar launcher: This setting determines which browser engine is launched when a profile is
     started. This can be modified only before the first start. Possible values for Desktop
     profiles: 'automatic'. Possible values for Mobile profiles: 'chromium', 'external'. Required.
    :vartype launcher: str
    :ivar status: Status information about the profile. Required.
    :vartype status: ~kameleo.local_api_client.models.StatusResponse
    :ivar storage: Known values are: "local" and "cloud".
    :vartype storage: str or ~kameleo.local_api_client.models.ProfileStorageLocation
    """

    _validation = {
        "id": {"required": True},
        "name": {"required": True},
        "tags": {"required": True},
        "proxy": {"required": True},
        "created_at": {"required": True},
        "device": {"required": True},
        "os": {"required": True},
        "browser": {"required": True},
        "language": {"required": True},
        "launcher": {"required": True},
        "status": {"required": True},
    }

    _attribute_map = {
        "id": {"key": "id", "type": "str"},
        "name": {"key": "name", "type": "str"},
        "tags": {"key": "tags", "type": "[str]"},
        "proxy": {"key": "proxy", "type": "ProxyConnectionTypeServerMultiLevelChoice"},
        "created_at": {"key": "createdAt", "type": "iso-8601"},
        "device": {"key": "device", "type": "Device"},
        "os": {"key": "os", "type": "Os"},
        "browser": {"key": "browser", "type": "Browser"},
        "language": {"key": "language", "type": "str"},
        "launcher": {"key": "launcher", "type": "str"},
        "status": {"key": "status", "type": "StatusResponse"},
        "storage": {"key": "storage", "type": "str"},
    }

    def __init__(
        self,
        *,
        id: str,  # pylint: disable=redefined-builtin
        name: str,
        tags: List[str],
        proxy: "_models.ProxyConnectionTypeServerMultiLevelChoice",
        created_at: datetime.datetime,
        device: "_models.Device",
        os: "_models.Os",
        browser: "_models.Browser",
        language: str,
        launcher: str,
        status: "_models.StatusResponse",
        storage: Optional[Union[str, "_models.ProfileStorageLocation"]] = None,
        **kwargs: Any
    ) -> None:
        """
        :keyword id: A unique identifier of the profile. Required.
        :paramtype id: str
        :keyword name: The name of the profile. Required.
        :paramtype name: str
        :keyword tags: Profile tags. Required.
        :paramtype tags: list[str]
        :keyword proxy: Required.
        :paramtype proxy: ~kameleo.local_api_client.models.ProxyConnectionTypeServerMultiLevelChoice
        :keyword created_at: Date when the profile was created. Required.
        :paramtype created_at: ~datetime.datetime
        :keyword device: Required.
        :paramtype device: ~kameleo.local_api_client.models.Device
        :keyword os: Required.
        :paramtype os: ~kameleo.local_api_client.models.Os
        :keyword browser: Required.
        :paramtype browser: ~kameleo.local_api_client.models.Browser
        :keyword language: Language of the profile. This is derived from the base profile. Using ISO
         639-1 language codes. Required.
        :paramtype language: str
        :keyword launcher: This setting determines which browser engine is launched when a profile is
         started. This can be modified only before the first start. Possible values for Desktop
         profiles: 'automatic'. Possible values for Mobile profiles: 'chromium', 'external'. Required.
        :paramtype launcher: str
        :keyword status: Status information about the profile. Required.
        :paramtype status: ~kameleo.local_api_client.models.StatusResponse
        :keyword storage: Known values are: "local" and "cloud".
        :paramtype storage: str or ~kameleo.local_api_client.models.ProfileStorageLocation
        """
        super().__init__(**kwargs)
        self.id = id
        self.name = name
        self.tags = tags
        self.proxy = proxy
        self.created_at = created_at
        self.device = device
        self.os = os
        self.browser = browser
        self.language = language
        self.launcher = launcher
        self.status = status
        self.storage = storage


class ProfileResponse(_serialization.Model):  # pylint: disable=too-many-instance-attributes
    """ProfileResponse.

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

    :ivar id: A unique identifier of the profile. Required.
    :vartype id: str
    :ivar name: Profile name property. The value obtained by file name for existing profiles. For
     new profiles the value is generated by a random name generator. Required.
    :vartype name: str
    :ivar tags: Profile tags. Required.
    :vartype tags: list[str]
    :ivar created_at: Date when the profile was created. Required.
    :vartype created_at: ~datetime.datetime
    :ivar base_profile: Representation of a base profile which is used to build profiles from.
     Required.
    :vartype base_profile: ~kameleo.local_api_client.models.BaseProfile
    :ivar canvas: Specifies how the canvas will be spoofed. Possible values:
     'intelligent': Use intelligent canvas spoofing. This will result non-unique canvas
     fingerprints.
     'noise': Add some noise to canvas generation.
     'block': Completely block the 2D API.
     'off': Turn off the spoofing, use the original settings. Required. Known values are:
     "intelligent", "noise", "block", and "off".
    :vartype canvas: str or ~kameleo.local_api_client.models.CanvasSpoofingType
    :ivar webgl: Specifies how the WebGL will be spoofed. Possible values:
     'noise': Add some noise to the WebGL generation
     'block': Completely block the 3D API
     'off': Turn off the spoofing, use the original settings. Required. Known values are: "noise",
     "block", and "off".
    :vartype webgl: str or ~kameleo.local_api_client.models.WebglSpoofingType
    :ivar webgl_meta: Required.
    :vartype webgl_meta:
     ~kameleo.local_api_client.models.WebglMetaSpoofingTypeWebglMetaSpoofingOptionsMultiLevelChoice
    :ivar audio: Specifies how the audio will be spoofed. Possible values:
     'noise': Add some noise to the Audio generation
     'block': Completely block the Audio API
     'off': Turn off the spoofing, use the original settings. Required. Known values are: "off",
     "noise", and "block".
    :vartype audio: str or ~kameleo.local_api_client.models.AudioSpoofingType
    :ivar timezone: Required.
    :vartype timezone:
     ~kameleo.local_api_client.models.TimezoneSpoofingTypeTimezoneMultiLevelChoice
    :ivar geolocation: Required.
    :vartype geolocation:
     ~kameleo.local_api_client.models.GeolocationSpoofingTypeGeolocationSpoofingOptionsMultiLevelChoice
    :ivar proxy: Required.
    :vartype proxy: ~kameleo.local_api_client.models.ProxyConnectionTypeServerMultiLevelChoice
    :ivar web_rtc: Required.
    :vartype web_rtc:
     ~kameleo.local_api_client.models.WebRtcSpoofingTypeWebRtcSpoofingOptionsMultiLevelChoice
    :ivar fonts: Required.
    :vartype fonts: ~kameleo.local_api_client.models.FontSpoofingTypeFontIListMultiLevelChoice
    :ivar screen: Required.
    :vartype screen: ~kameleo.local_api_client.models.ScreenSpoofingTypeScreenSizeMultiLevelChoice
    :ivar hardware_concurrency: Required.
    :vartype hardware_concurrency:
     ~kameleo.local_api_client.models.HardwareConcurrencySpoofingTypeInt32NullableMultiLevelChoice
    :ivar device_memory: Required.
    :vartype device_memory:
     ~kameleo.local_api_client.models.DeviceMemorySpoofingTypeDoubleNullableMultiLevelChoice
    :ivar start_page: This website will be opened in the browser when the profile launches.
     Required.
    :vartype start_page: str
    :ivar password_manager: Defines whether the browser can save login credentials. Possible values
     are:
     'enabled': Credential saving is allowed.
     'disabled': Credential saving is blocked. Required. Known values are: "enabled" and
     "disabled".
    :vartype password_manager: str or ~kameleo.local_api_client.models.PasswordManagerType
    :ivar extensions: A list of extensions or addons that will be loaded to the profile when the
     profile is started. For chrome and edge use CRX3 format extensions. For firefox use signed xpi
     format addons. Required.
    :vartype extensions: list[str]
    :ivar notes: A free text including any notes written by the user. Required.
    :vartype notes: str
    :ivar launcher: This setting determines which browser engine is launched when a profile is
     started. This can be modified only before the first start. Possible values for Desktop
     profiles: 'automatic'. Possible values for Mobile profiles: 'chromium', 'external'. Required.
    :vartype launcher: str
    :ivar status: Status information about the profile. Required.
    :vartype status: ~kameleo.local_api_client.models.StatusResponse
    :ivar storage: Known values are: "local" and "cloud".
    :vartype storage: str or ~kameleo.local_api_client.models.ProfileStorageLocation
    """

    _validation = {
        "id": {"required": True},
        "name": {"required": True},
        "tags": {"required": True},
        "created_at": {"required": True},
        "base_profile": {"required": True},
        "canvas": {"required": True},
        "webgl": {"required": True},
        "webgl_meta": {"required": True},
        "audio": {"required": True},
        "timezone": {"required": True},
        "geolocation": {"required": True},
        "proxy": {"required": True},
        "web_rtc": {"required": True},
        "fonts": {"required": True},
        "screen": {"required": True},
        "hardware_concurrency": {"required": True},
        "device_memory": {"required": True},
        "start_page": {"required": True},
        "password_manager": {"required": True},
        "extensions": {"required": True},
        "notes": {"required": True},
        "launcher": {"required": True},
        "status": {"required": True},
    }

    _attribute_map = {
        "id": {"key": "id", "type": "str"},
        "name": {"key": "name", "type": "str"},
        "tags": {"key": "tags", "type": "[str]"},
        "created_at": {"key": "createdAt", "type": "iso-8601"},
        "base_profile": {"key": "baseProfile", "type": "BaseProfile"},
        "canvas": {"key": "canvas", "type": "str"},
        "webgl": {"key": "webgl", "type": "str"},
        "webgl_meta": {"key": "webglMeta", "type": "WebglMetaSpoofingTypeWebglMetaSpoofingOptionsMultiLevelChoice"},
        "audio": {"key": "audio", "type": "str"},
        "timezone": {"key": "timezone", "type": "TimezoneSpoofingTypeTimezoneMultiLevelChoice"},
        "geolocation": {
            "key": "geolocation",
            "type": "GeolocationSpoofingTypeGeolocationSpoofingOptionsMultiLevelChoice",
        },
        "proxy": {"key": "proxy", "type": "ProxyConnectionTypeServerMultiLevelChoice"},
        "web_rtc": {"key": "webRtc", "type": "WebRtcSpoofingTypeWebRtcSpoofingOptionsMultiLevelChoice"},
        "fonts": {"key": "fonts", "type": "FontSpoofingTypeFontIListMultiLevelChoice"},
        "screen": {"key": "screen", "type": "ScreenSpoofingTypeScreenSizeMultiLevelChoice"},
        "hardware_concurrency": {
            "key": "hardwareConcurrency",
            "type": "HardwareConcurrencySpoofingTypeInt32NullableMultiLevelChoice",
        },
        "device_memory": {"key": "deviceMemory", "type": "DeviceMemorySpoofingTypeDoubleNullableMultiLevelChoice"},
        "start_page": {"key": "startPage", "type": "str"},
        "password_manager": {"key": "passwordManager", "type": "str"},
        "extensions": {"key": "extensions", "type": "[str]"},
        "notes": {"key": "notes", "type": "str"},
        "launcher": {"key": "launcher", "type": "str"},
        "status": {"key": "status", "type": "StatusResponse"},
        "storage": {"key": "storage", "type": "str"},
    }

    def __init__(  # pylint: disable=too-many-locals
        self,
        *,
        id: str,  # pylint: disable=redefined-builtin
        name: str,
        tags: List[str],
        created_at: datetime.datetime,
        base_profile: "_models.BaseProfile",
        canvas: Union[str, "_models.CanvasSpoofingType"],
        webgl: Union[str, "_models.WebglSpoofingType"],
        webgl_meta: "_models.WebglMetaSpoofingTypeWebglMetaSpoofingOptionsMultiLevelChoice",
        audio: Union[str, "_models.AudioSpoofingType"],
        timezone: "_models.TimezoneSpoofingTypeTimezoneMultiLevelChoice",
        geolocation: "_models.GeolocationSpoofingTypeGeolocationSpoofingOptionsMultiLevelChoice",
        proxy: "_models.ProxyConnectionTypeServerMultiLevelChoice",
        web_rtc: "_models.WebRtcSpoofingTypeWebRtcSpoofingOptionsMultiLevelChoice",
        fonts: "_models.FontSpoofingTypeFontIListMultiLevelChoice",
        screen: "_models.ScreenSpoofingTypeScreenSizeMultiLevelChoice",
        hardware_concurrency: "_models.HardwareConcurrencySpoofingTypeInt32NullableMultiLevelChoice",
        device_memory: "_models.DeviceMemorySpoofingTypeDoubleNullableMultiLevelChoice",
        start_page: str,
        password_manager: Union[str, "_models.PasswordManagerType"],
        extensions: List[str],
        notes: str,
        launcher: str,
        status: "_models.StatusResponse",
        storage: Optional[Union[str, "_models.ProfileStorageLocation"]] = None,
        **kwargs: Any
    ) -> None:
        """
        :keyword id: A unique identifier of the profile. Required.
        :paramtype id: str
        :keyword name: Profile name property. The value obtained by file name for existing profiles.
         For new profiles the value is generated by a random name generator. Required.
        :paramtype name: str
        :keyword tags: Profile tags. Required.
        :paramtype tags: list[str]
        :keyword created_at: Date when the profile was created. Required.
        :paramtype created_at: ~datetime.datetime
        :keyword base_profile: Representation of a base profile which is used to build profiles from.
         Required.
        :paramtype base_profile: ~kameleo.local_api_client.models.BaseProfile
        :keyword canvas: Specifies how the canvas will be spoofed. Possible values:
         'intelligent': Use intelligent canvas spoofing. This will result non-unique canvas
         fingerprints.
         'noise': Add some noise to canvas generation.
         'block': Completely block the 2D API.
         'off': Turn off the spoofing, use the original settings. Required. Known values are:
         "intelligent", "noise", "block", and "off".
        :paramtype canvas: str or ~kameleo.local_api_client.models.CanvasSpoofingType
        :keyword webgl: Specifies how the WebGL will be spoofed. Possible values:
         'noise': Add some noise to the WebGL generation
         'block': Completely block the 3D API
         'off': Turn off the spoofing, use the original settings. Required. Known values are: "noise",
         "block", and "off".
        :paramtype webgl: str or ~kameleo.local_api_client.models.WebglSpoofingType
        :keyword webgl_meta: Required.
        :paramtype webgl_meta:
         ~kameleo.local_api_client.models.WebglMetaSpoofingTypeWebglMetaSpoofingOptionsMultiLevelChoice
        :keyword audio: Specifies how the audio will be spoofed. Possible values:
         'noise': Add some noise to the Audio generation
         'block': Completely block the Audio API
         'off': Turn off the spoofing, use the original settings. Required. Known values are: "off",
         "noise", and "block".
        :paramtype audio: str or ~kameleo.local_api_client.models.AudioSpoofingType
        :keyword timezone: Required.
        :paramtype timezone:
         ~kameleo.local_api_client.models.TimezoneSpoofingTypeTimezoneMultiLevelChoice
        :keyword geolocation: Required.
        :paramtype geolocation:
         ~kameleo.local_api_client.models.GeolocationSpoofingTypeGeolocationSpoofingOptionsMultiLevelChoice
        :keyword proxy: Required.
        :paramtype proxy: ~kameleo.local_api_client.models.ProxyConnectionTypeServerMultiLevelChoice
        :keyword web_rtc: Required.
        :paramtype web_rtc:
         ~kameleo.local_api_client.models.WebRtcSpoofingTypeWebRtcSpoofingOptionsMultiLevelChoice
        :keyword fonts: Required.
        :paramtype fonts: ~kameleo.local_api_client.models.FontSpoofingTypeFontIListMultiLevelChoice
        :keyword screen: Required.
        :paramtype screen:
         ~kameleo.local_api_client.models.ScreenSpoofingTypeScreenSizeMultiLevelChoice
        :keyword hardware_concurrency: Required.
        :paramtype hardware_concurrency:
         ~kameleo.local_api_client.models.HardwareConcurrencySpoofingTypeInt32NullableMultiLevelChoice
        :keyword device_memory: Required.
        :paramtype device_memory:
         ~kameleo.local_api_client.models.DeviceMemorySpoofingTypeDoubleNullableMultiLevelChoice
        :keyword start_page: This website will be opened in the browser when the profile launches.
         Required.
        :paramtype start_page: str
        :keyword password_manager: Defines whether the browser can save login credentials. Possible
         values are:
         'enabled': Credential saving is allowed.
         'disabled': Credential saving is blocked. Required. Known values are: "enabled" and
         "disabled".
        :paramtype password_manager: str or ~kameleo.local_api_client.models.PasswordManagerType
        :keyword extensions: A list of extensions or addons that will be loaded to the profile when the
         profile is started. For chrome and edge use CRX3 format extensions. For firefox use signed xpi
         format addons. Required.
        :paramtype extensions: list[str]
        :keyword notes: A free text including any notes written by the user. Required.
        :paramtype notes: str
        :keyword launcher: This setting determines which browser engine is launched when a profile is
         started. This can be modified only before the first start. Possible values for Desktop
         profiles: 'automatic'. Possible values for Mobile profiles: 'chromium', 'external'. Required.
        :paramtype launcher: str
        :keyword status: Status information about the profile. Required.
        :paramtype status: ~kameleo.local_api_client.models.StatusResponse
        :keyword storage: Known values are: "local" and "cloud".
        :paramtype storage: str or ~kameleo.local_api_client.models.ProfileStorageLocation
        """
        super().__init__(**kwargs)
        self.id = id
        self.name = name
        self.tags = tags
        self.created_at = created_at
        self.base_profile = base_profile
        self.canvas = canvas
        self.webgl = webgl
        self.webgl_meta = webgl_meta
        self.audio = audio
        self.timezone = timezone
        self.geolocation = geolocation
        self.proxy = proxy
        self.web_rtc = web_rtc
        self.fonts = fonts
        self.screen = screen
        self.hardware_concurrency = hardware_concurrency
        self.device_memory = device_memory
        self.start_page = start_page
        self.password_manager = password_manager
        self.extensions = extensions
        self.notes = notes
        self.launcher = launcher
        self.status = status
        self.storage = storage


class ProxyConnectionTypeServerMultiLevelChoice(_serialization.Model):
    """ProxyConnectionTypeServerMultiLevelChoice.

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

    :ivar value: Proxy connection settings of the profiles. Possible values:
     'none': Direct connection without any proxy.
     'http': Use a HTTP proxy for upstream communication.
     'socks5': Use a SOCKS5 proxy for upstream communication.
     'ssh': Use an SSH connection for upstream communication. Basically a SOCKS5 proxy created at
     the given SSH host. Required. Known values are: "none", "http", "socks5", and "ssh".
    :vartype value: str or ~kameleo.local_api_client.models.ProxyConnectionType
    :ivar extra: Represents a server connection. It can be used as a proxy server connection as
     well.
    :vartype extra: ~kameleo.local_api_client.models.Server
    """

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

    _attribute_map = {
        "value": {"key": "value", "type": "str"},
        "extra": {"key": "extra", "type": "Server"},
    }

    def __init__(
        self,
        *,
        value: Union[str, "_models.ProxyConnectionType"],
        extra: Optional["_models.Server"] = None,
        **kwargs: Any
    ) -> None:
        """
        :keyword value: Proxy connection settings of the profiles. Possible values:
         'none': Direct connection without any proxy.
         'http': Use a HTTP proxy for upstream communication.
         'socks5': Use a SOCKS5 proxy for upstream communication.
         'ssh': Use an SSH connection for upstream communication. Basically a SOCKS5 proxy created at
         the given SSH host. Required. Known values are: "none", "http", "socks5", and "ssh".
        :paramtype value: str or ~kameleo.local_api_client.models.ProxyConnectionType
        :keyword extra: Represents a server connection. It can be used as a proxy server connection as
         well.
        :paramtype extra: ~kameleo.local_api_client.models.Server
        """
        super().__init__(**kwargs)
        self.value = value
        self.extra = extra


class QuotaStatistics(_serialization.Model):
    """QuotaStatistics.

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

    :ivar current_usage: Indicates the current count of profiles accessible to the user, always a
     non-negative value. Required.
    :vartype current_usage: int
    :ivar maximum_limit: Indicates the maximum permitted profile count for the user, with null
     implying no limit. Required.
    :vartype maximum_limit: int
    """

    _validation = {
        "current_usage": {"required": True},
        "maximum_limit": {"required": True},
    }

    _attribute_map = {
        "current_usage": {"key": "currentUsage", "type": "int"},
        "maximum_limit": {"key": "maximumLimit", "type": "int"},
    }

    def __init__(self, *, current_usage: int, maximum_limit: int, **kwargs: Any) -> None:
        """
        :keyword current_usage: Indicates the current count of profiles accessible to the user, always
         a non-negative value. Required.
        :paramtype current_usage: int
        :keyword maximum_limit: Indicates the maximum permitted profile count for the user, with null
         implying no limit. Required.
        :paramtype maximum_limit: int
        """
        super().__init__(**kwargs)
        self.current_usage = current_usage
        self.maximum_limit = maximum_limit


class ScreenSpoofingTypeScreenSizeMultiLevelChoice(_serialization.Model):
    """ScreenSpoofingTypeScreenSizeMultiLevelChoice.

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

    :ivar value: Specifies how the screen will be spoofed. Possible values:
     'automatic': Automatically override the screen resolution based on the Base Profile.
     'manual': Manually override the screen resolution.
     'off': Turn off the spoofing, use the original settings. Required. Known values are:
     "automatic", "manual", and "off".
    :vartype value: str or ~kameleo.local_api_client.models.ScreenSpoofingType
    :ivar extra: The screen size of the device in pixels. For example: 1920x1080.
    :vartype extra: str
    """

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

    _attribute_map = {
        "value": {"key": "value", "type": "str"},
        "extra": {"key": "extra", "type": "str"},
    }

    def __init__(
        self, *, value: Union[str, "_models.ScreenSpoofingType"], extra: Optional[str] = None, **kwargs: Any
    ) -> None:
        """
        :keyword value: Specifies how the screen will be spoofed. Possible values:
         'automatic': Automatically override the screen resolution based on the Base Profile.
         'manual': Manually override the screen resolution.
         'off': Turn off the spoofing, use the original settings. Required. Known values are:
         "automatic", "manual", and "off".
        :paramtype value: str or ~kameleo.local_api_client.models.ScreenSpoofingType
        :keyword extra: The screen size of the device in pixels. For example: 1920x1080.
        :paramtype extra: str
        """
        super().__init__(**kwargs)
        self.value = value
        self.extra = extra


class Server(_serialization.Model):
    """Represents a server connection. It can be used as a proxy server connection as well.

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

    :ivar host: Gets or sets the hostname where the service is provided from. Required.
    :vartype host: str
    :ivar port: Gets or sets the port where the service is provided from. Required.
    :vartype port: int
    :ivar id: Gets or sets the identity information provided for the service. This could be a
     custom id or username or anything which identifies a resource on the remote service. Use it as
     a proxy username. This field is optional.
    :vartype id: str
    :ivar secret: Gets or sets the shared secret between the client and the service provider. Use
     it as a proxy password. This field is optional.
    :vartype secret: str
    """

    _validation = {
        "host": {"required": True},
        "port": {"required": True},
    }

    _attribute_map = {
        "host": {"key": "host", "type": "str"},
        "port": {"key": "port", "type": "int"},
        "id": {"key": "id", "type": "str"},
        "secret": {"key": "secret", "type": "str"},
    }

    def __init__(
        self,
        *,
        host: str,
        port: int,
        id: Optional[str] = None,  # pylint: disable=redefined-builtin
        secret: Optional[str] = None,
        **kwargs: Any
    ) -> None:
        """
        :keyword host: Gets or sets the hostname where the service is provided from. Required.
        :paramtype host: str
        :keyword port: Gets or sets the port where the service is provided from. Required.
        :paramtype port: int
        :keyword id: Gets or sets the identity information provided for the service. This could be a
         custom id or username or anything which identifies a resource on the remote service. Use it as
         a proxy username. This field is optional.
        :paramtype id: str
        :keyword secret: Gets or sets the shared secret between the client and the service provider.
         Use it as a proxy password. This field is optional.
        :paramtype secret: str
        """
        super().__init__(**kwargs)
        self.host = host
        self.port = port
        self.id = id
        self.secret = secret


class StatusResponse(_serialization.Model):
    """Status information about the profile.

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

    :ivar persistence_state: Indicates the current save state of a profile, including cloud sync
     status. Possible values:
     'unsaved': The profile is not saved
     'saved': The profile is saved and current
     'syncing': The profile is currently synchronizing with the cloud. Required. Known values are:
     "unsaved", "saved", and "syncing".
    :vartype persistence_state: str or ~kameleo.local_api_client.models.ProfilePersistenceState
    :ivar lifetime_state: Represents the lifetime states of a profile, indicating which actions
     can be performed with the associated browser engine at each state. Possible values are:


     * Unknown: State of the profile is undefined.
     * Created: Profile is created; the associated browser engine is not started.
     * Starting: The associated browser engine is starting.
     * Running: The associated browser engine is currently running.
     * Terminating: The associated browser engine is in the process of terminating.
     * Terminated: The associated browser engine is not running but has been started at least once.
     Required. Known values are: "created", "starting", "running", "terminating", "terminated",
     "locked", and "unknown".
    :vartype lifetime_state: str or ~kameleo.local_api_client.models.ProfileLifetimeState
    :ivar external_spoofing_engine_port: In case of running profiles which use an external browser
     this shows the connection port (for mobile profiles as well).
    :vartype external_spoofing_engine_port: int
    """

    _validation = {
        "persistence_state": {"required": True},
        "lifetime_state": {"required": True},
    }

    _attribute_map = {
        "persistence_state": {"key": "persistenceState", "type": "str"},
        "lifetime_state": {"key": "lifetimeState", "type": "str"},
        "external_spoofing_engine_port": {"key": "externalSpoofingEnginePort", "type": "int"},
    }

    def __init__(
        self,
        *,
        persistence_state: Union[str, "_models.ProfilePersistenceState"],
        lifetime_state: Union[str, "_models.ProfileLifetimeState"],
        external_spoofing_engine_port: Optional[int] = None,
        **kwargs: Any
    ) -> None:
        """
        :keyword persistence_state: Indicates the current save state of a profile, including cloud sync
         status. Possible values:
         'unsaved': The profile is not saved
         'saved': The profile is saved and current
         'syncing': The profile is currently synchronizing with the cloud. Required. Known values are:
         "unsaved", "saved", and "syncing".
        :paramtype persistence_state: str or ~kameleo.local_api_client.models.ProfilePersistenceState
        :keyword lifetime_state: Represents the lifetime states of a profile, indicating which actions
         can be performed with the associated browser engine at each state. Possible values are:


         * Unknown: State of the profile is undefined.
         * Created: Profile is created; the associated browser engine is not started.
         * Starting: The associated browser engine is starting.
         * Running: The associated browser engine is currently running.
         * Terminating: The associated browser engine is in the process of terminating.
         * Terminated: The associated browser engine is not running but has been started at least once.
         Required. Known values are: "created", "starting", "running", "terminating", "terminated",
         "locked", and "unknown".
        :paramtype lifetime_state: str or ~kameleo.local_api_client.models.ProfileLifetimeState
        :keyword external_spoofing_engine_port: In case of running profiles which use an external
         browser this shows the connection port (for mobile profiles as well).
        :paramtype external_spoofing_engine_port: int
        """
        super().__init__(**kwargs)
        self.persistence_state = persistence_state
        self.lifetime_state = lifetime_state
        self.external_spoofing_engine_port = external_spoofing_engine_port


class TimezoneSpoofingTypeTimezoneMultiLevelChoice(_serialization.Model):
    """TimezoneSpoofingTypeTimezoneMultiLevelChoice.

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

    :ivar value: Specifies how the timezone will be spoofed. Possble values:
     'automatic': Timezone is automatically set by the IP
     'manual': Timezone is manually overridden in the profile
     'off': Turn off the spoofing, use the original settings. Required. Known values are:
     "automatic", "manual", and "off".
    :vartype value: str or ~kameleo.local_api_client.models.TimezoneSpoofingType
    :ivar extra: When the Timezone spoofing is set to manual the timezone in Iana format is
     required. For example: America/Grenada.
    :vartype extra: str
    """

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

    _attribute_map = {
        "value": {"key": "value", "type": "str"},
        "extra": {"key": "extra", "type": "str"},
    }

    def __init__(
        self, *, value: Union[str, "_models.TimezoneSpoofingType"], extra: Optional[str] = None, **kwargs: Any
    ) -> None:
        """
        :keyword value: Specifies how the timezone will be spoofed. Possble values:
         'automatic': Timezone is automatically set by the IP
         'manual': Timezone is manually overridden in the profile
         'off': Turn off the spoofing, use the original settings. Required. Known values are:
         "automatic", "manual", and "off".
        :paramtype value: str or ~kameleo.local_api_client.models.TimezoneSpoofingType
        :keyword extra: When the Timezone spoofing is set to manual the timezone in Iana format is
         required. For example: America/Grenada.
        :paramtype extra: str
        """
        super().__init__(**kwargs)
        self.value = value
        self.extra = extra


class UpdateProfileRequest(_serialization.Model):  # pylint: disable=too-many-instance-attributes
    """UpdateProfileRequest.

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

    :ivar canvas: Specifies how the canvas will be spoofed. Possible values:
     'intelligent': Use intelligent canvas spoofing. This will result non-unique canvas
     fingerprints.
     'noise': Add some noise to canvas generation.
     'block': Completely block the 2D API.
     'off': Turn off the spoofing, use the original settings. Required. Known values are:
     "intelligent", "noise", "block", and "off".
    :vartype canvas: str or ~kameleo.local_api_client.models.CanvasSpoofingType
    :ivar webgl: Specifies how the WebGL will be spoofed. Possible values:
     'noise': Add some noise to the WebGL generation
     'block': Completely block the 3D API
     'off': Turn off the spoofing, use the original settings. Required. Known values are: "noise",
     "block", and "off".
    :vartype webgl: str or ~kameleo.local_api_client.models.WebglSpoofingType
    :ivar webgl_meta: Required.
    :vartype webgl_meta:
     ~kameleo.local_api_client.models.WebglMetaSpoofingTypeWebglMetaSpoofingOptionsMultiLevelChoice
    :ivar audio: Specifies how the audio will be spoofed. Possible values:
     'noise': Add some noise to the Audio generation
     'block': Completely block the Audio API
     'off': Turn off the spoofing, use the original settings. Required. Known values are: "off",
     "noise", and "block".
    :vartype audio: str or ~kameleo.local_api_client.models.AudioSpoofingType
    :ivar timezone: Required.
    :vartype timezone:
     ~kameleo.local_api_client.models.TimezoneSpoofingTypeTimezoneMultiLevelChoice
    :ivar geolocation: Required.
    :vartype geolocation:
     ~kameleo.local_api_client.models.GeolocationSpoofingTypeGeolocationSpoofingOptionsMultiLevelChoice
    :ivar proxy: Required.
    :vartype proxy: ~kameleo.local_api_client.models.ProxyConnectionTypeServerMultiLevelChoice
    :ivar web_rtc: Required.
    :vartype web_rtc:
     ~kameleo.local_api_client.models.WebRtcSpoofingTypeWebRtcSpoofingOptionsMultiLevelChoice
    :ivar fonts: Required.
    :vartype fonts: ~kameleo.local_api_client.models.FontSpoofingTypeFontIListMultiLevelChoice
    :ivar screen: Required.
    :vartype screen: ~kameleo.local_api_client.models.ScreenSpoofingTypeScreenSizeMultiLevelChoice
    :ivar hardware_concurrency: Required.
    :vartype hardware_concurrency:
     ~kameleo.local_api_client.models.HardwareConcurrencySpoofingTypeInt32NullableMultiLevelChoice
    :ivar device_memory:
    :vartype device_memory:
     ~kameleo.local_api_client.models.DeviceMemorySpoofingTypeDoubleNullableMultiLevelChoice
    :ivar start_page: This website will be opened in the browser when the profile launches.
    :vartype start_page: str
    :ivar password_manager: Defines whether the browser can save login credentials. Possible values
     are:
     'enabled': Credential saving is allowed.
     'disabled': Credential saving is blocked. Required. Known values are: "enabled" and
     "disabled".
    :vartype password_manager: str or ~kameleo.local_api_client.models.PasswordManagerType
    :ivar extensions: A list of extensions or addons should be loaded to the browser when starting
     the profile. For extensions that are added now, it should be an absolute path.
     For extensions already added to the profile in a previous update, the name is only enough.
     For chrome and edge use CRX3 format extensions. For firefox use signed xpi format addons.
    :vartype extensions: list[str]
    :ivar notes: A free text including any notes written by the user.
    :vartype notes: str
    :ivar name: Profile name property. The value obtained by file name for existing profiles. For
     new profiles the value is generated by a random name generator. Required.
    :vartype name: str
    :ivar tags: Profile tags.
    :vartype tags: list[str]
    :ivar storage: Known values are: "local" and "cloud".
    :vartype storage: str or ~kameleo.local_api_client.models.ProfileStorageLocation
    :ivar launcher: This setting determines which browser engine is launched when a profile is
     started. This can be modified only before the first start. Possible values for Desktop
     profiles: 'automatic'. Possible values for Mobile profiles: 'chromium', 'external'.
    :vartype launcher: str
    """

    _validation = {
        "canvas": {"required": True},
        "webgl": {"required": True},
        "webgl_meta": {"required": True},
        "audio": {"required": True},
        "timezone": {"required": True},
        "geolocation": {"required": True},
        "proxy": {"required": True},
        "web_rtc": {"required": True},
        "fonts": {"required": True},
        "screen": {"required": True},
        "hardware_concurrency": {"required": True},
        "password_manager": {"required": True},
        "name": {"required": True, "min_length": 1},
    }

    _attribute_map = {
        "canvas": {"key": "canvas", "type": "str"},
        "webgl": {"key": "webgl", "type": "str"},
        "webgl_meta": {"key": "webglMeta", "type": "WebglMetaSpoofingTypeWebglMetaSpoofingOptionsMultiLevelChoice"},
        "audio": {"key": "audio", "type": "str"},
        "timezone": {"key": "timezone", "type": "TimezoneSpoofingTypeTimezoneMultiLevelChoice"},
        "geolocation": {
            "key": "geolocation",
            "type": "GeolocationSpoofingTypeGeolocationSpoofingOptionsMultiLevelChoice",
        },
        "proxy": {"key": "proxy", "type": "ProxyConnectionTypeServerMultiLevelChoice"},
        "web_rtc": {"key": "webRtc", "type": "WebRtcSpoofingTypeWebRtcSpoofingOptionsMultiLevelChoice"},
        "fonts": {"key": "fonts", "type": "FontSpoofingTypeFontIListMultiLevelChoice"},
        "screen": {"key": "screen", "type": "ScreenSpoofingTypeScreenSizeMultiLevelChoice"},
        "hardware_concurrency": {
            "key": "hardwareConcurrency",
            "type": "HardwareConcurrencySpoofingTypeInt32NullableMultiLevelChoice",
        },
        "device_memory": {"key": "deviceMemory", "type": "DeviceMemorySpoofingTypeDoubleNullableMultiLevelChoice"},
        "start_page": {"key": "startPage", "type": "str"},
        "password_manager": {"key": "passwordManager", "type": "str"},
        "extensions": {"key": "extensions", "type": "[str]"},
        "notes": {"key": "notes", "type": "str"},
        "name": {"key": "name", "type": "str"},
        "tags": {"key": "tags", "type": "[str]"},
        "storage": {"key": "storage", "type": "str"},
        "launcher": {"key": "launcher", "type": "str"},
    }

    def __init__(
        self,
        *,
        canvas: Union[str, "_models.CanvasSpoofingType"],
        webgl: Union[str, "_models.WebglSpoofingType"],
        webgl_meta: "_models.WebglMetaSpoofingTypeWebglMetaSpoofingOptionsMultiLevelChoice",
        audio: Union[str, "_models.AudioSpoofingType"],
        timezone: "_models.TimezoneSpoofingTypeTimezoneMultiLevelChoice",
        geolocation: "_models.GeolocationSpoofingTypeGeolocationSpoofingOptionsMultiLevelChoice",
        proxy: "_models.ProxyConnectionTypeServerMultiLevelChoice",
        web_rtc: "_models.WebRtcSpoofingTypeWebRtcSpoofingOptionsMultiLevelChoice",
        fonts: "_models.FontSpoofingTypeFontIListMultiLevelChoice",
        screen: "_models.ScreenSpoofingTypeScreenSizeMultiLevelChoice",
        hardware_concurrency: "_models.HardwareConcurrencySpoofingTypeInt32NullableMultiLevelChoice",
        password_manager: Union[str, "_models.PasswordManagerType"],
        name: str,
        device_memory: Optional["_models.DeviceMemorySpoofingTypeDoubleNullableMultiLevelChoice"] = None,
        start_page: Optional[str] = None,
        extensions: Optional[List[str]] = None,
        notes: Optional[str] = None,
        tags: Optional[List[str]] = None,
        storage: Optional[Union[str, "_models.ProfileStorageLocation"]] = None,
        launcher: Optional[str] = None,
        **kwargs: Any
    ) -> None:
        """
        :keyword canvas: Specifies how the canvas will be spoofed. Possible values:
         'intelligent': Use intelligent canvas spoofing. This will result non-unique canvas
         fingerprints.
         'noise': Add some noise to canvas generation.
         'block': Completely block the 2D API.
         'off': Turn off the spoofing, use the original settings. Required. Known values are:
         "intelligent", "noise", "block", and "off".
        :paramtype canvas: str or ~kameleo.local_api_client.models.CanvasSpoofingType
        :keyword webgl: Specifies how the WebGL will be spoofed. Possible values:
         'noise': Add some noise to the WebGL generation
         'block': Completely block the 3D API
         'off': Turn off the spoofing, use the original settings. Required. Known values are: "noise",
         "block", and "off".
        :paramtype webgl: str or ~kameleo.local_api_client.models.WebglSpoofingType
        :keyword webgl_meta: Required.
        :paramtype webgl_meta:
         ~kameleo.local_api_client.models.WebglMetaSpoofingTypeWebglMetaSpoofingOptionsMultiLevelChoice
        :keyword audio: Specifies how the audio will be spoofed. Possible values:
         'noise': Add some noise to the Audio generation
         'block': Completely block the Audio API
         'off': Turn off the spoofing, use the original settings. Required. Known values are: "off",
         "noise", and "block".
        :paramtype audio: str or ~kameleo.local_api_client.models.AudioSpoofingType
        :keyword timezone: Required.
        :paramtype timezone:
         ~kameleo.local_api_client.models.TimezoneSpoofingTypeTimezoneMultiLevelChoice
        :keyword geolocation: Required.
        :paramtype geolocation:
         ~kameleo.local_api_client.models.GeolocationSpoofingTypeGeolocationSpoofingOptionsMultiLevelChoice
        :keyword proxy: Required.
        :paramtype proxy: ~kameleo.local_api_client.models.ProxyConnectionTypeServerMultiLevelChoice
        :keyword web_rtc: Required.
        :paramtype web_rtc:
         ~kameleo.local_api_client.models.WebRtcSpoofingTypeWebRtcSpoofingOptionsMultiLevelChoice
        :keyword fonts: Required.
        :paramtype fonts: ~kameleo.local_api_client.models.FontSpoofingTypeFontIListMultiLevelChoice
        :keyword screen: Required.
        :paramtype screen:
         ~kameleo.local_api_client.models.ScreenSpoofingTypeScreenSizeMultiLevelChoice
        :keyword hardware_concurrency: Required.
        :paramtype hardware_concurrency:
         ~kameleo.local_api_client.models.HardwareConcurrencySpoofingTypeInt32NullableMultiLevelChoice
        :keyword device_memory:
        :paramtype device_memory:
         ~kameleo.local_api_client.models.DeviceMemorySpoofingTypeDoubleNullableMultiLevelChoice
        :keyword start_page: This website will be opened in the browser when the profile launches.
        :paramtype start_page: str
        :keyword password_manager: Defines whether the browser can save login credentials. Possible
         values are:
         'enabled': Credential saving is allowed.
         'disabled': Credential saving is blocked. Required. Known values are: "enabled" and
         "disabled".
        :paramtype password_manager: str or ~kameleo.local_api_client.models.PasswordManagerType
        :keyword extensions: A list of extensions or addons should be loaded to the browser when
         starting the profile. For extensions that are added now, it should be an absolute path.
         For extensions already added to the profile in a previous update, the name is only enough.
         For chrome and edge use CRX3 format extensions. For firefox use signed xpi format addons.
        :paramtype extensions: list[str]
        :keyword notes: A free text including any notes written by the user.
        :paramtype notes: str
        :keyword name: Profile name property. The value obtained by file name for existing profiles.
         For new profiles the value is generated by a random name generator. Required.
        :paramtype name: str
        :keyword tags: Profile tags.
        :paramtype tags: list[str]
        :keyword storage: Known values are: "local" and "cloud".
        :paramtype storage: str or ~kameleo.local_api_client.models.ProfileStorageLocation
        :keyword launcher: This setting determines which browser engine is launched when a profile is
         started. This can be modified only before the first start. Possible values for Desktop
         profiles: 'automatic'. Possible values for Mobile profiles: 'chromium', 'external'.
        :paramtype launcher: str
        """
        super().__init__(**kwargs)
        self.canvas = canvas
        self.webgl = webgl
        self.webgl_meta = webgl_meta
        self.audio = audio
        self.timezone = timezone
        self.geolocation = geolocation
        self.proxy = proxy
        self.web_rtc = web_rtc
        self.fonts = fonts
        self.screen = screen
        self.hardware_concurrency = hardware_concurrency
        self.device_memory = device_memory
        self.start_page = start_page
        self.password_manager = password_manager
        self.extensions = extensions
        self.notes = notes
        self.name = name
        self.tags = tags
        self.storage = storage
        self.launcher = launcher


class UserInfoResponse(_serialization.Model):
    """UserInfoResponse.

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

    :ivar user_id: The guid of the user. Required.
    :vartype user_id: str
    :ivar email: The email address of the authenticated user. Required.
    :vartype email: str
    :ivar email_confirmed: A boolean value indicating whether the email address is confirmed.
     Required.
    :vartype email_confirmed: bool
    :ivar subscription_end: The end date of the authenticated user's current subscription.
     Required.
    :vartype subscription_end: ~datetime.datetime
    :ivar capabilities: The capabilities that the authenticated user owns thanks to his current
     subscription. Required.
    :vartype capabilities: list[str]
    :ivar grace_period: A boolean value indicates whether the subscription is in a grace period and
     should be renewed immediately. Required.
    :vartype grace_period: bool
    :ivar last_app_login: The last date when the user authenticated by the app. Required.
    :vartype last_app_login: ~datetime.datetime
    :ivar workspace_folder: The user's workspace folder path where the profiles are stored.
     Required.
    :vartype workspace_folder: str
    :ivar local_storage: Required.
    :vartype local_storage: ~kameleo.local_api_client.models.QuotaStatistics
    :ivar cloud_storage: Required.
    :vartype cloud_storage: ~kameleo.local_api_client.models.QuotaStatistics
    """

    _validation = {
        "user_id": {"required": True},
        "email": {"required": True},
        "email_confirmed": {"required": True},
        "subscription_end": {"required": True},
        "capabilities": {"required": True},
        "grace_period": {"required": True},
        "last_app_login": {"required": True},
        "workspace_folder": {"required": True},
        "local_storage": {"required": True},
        "cloud_storage": {"required": True},
    }

    _attribute_map = {
        "user_id": {"key": "userId", "type": "str"},
        "email": {"key": "email", "type": "str"},
        "email_confirmed": {"key": "emailConfirmed", "type": "bool"},
        "subscription_end": {"key": "subscriptionEnd", "type": "iso-8601"},
        "capabilities": {"key": "capabilities", "type": "[str]"},
        "grace_period": {"key": "gracePeriod", "type": "bool"},
        "last_app_login": {"key": "lastAppLogin", "type": "iso-8601"},
        "workspace_folder": {"key": "workspaceFolder", "type": "str"},
        "local_storage": {"key": "localStorage", "type": "QuotaStatistics"},
        "cloud_storage": {"key": "cloudStorage", "type": "QuotaStatistics"},
    }

    def __init__(
        self,
        *,
        user_id: str,
        email: str,
        email_confirmed: bool,
        subscription_end: datetime.datetime,
        capabilities: List[str],
        grace_period: bool,
        last_app_login: datetime.datetime,
        workspace_folder: str,
        local_storage: "_models.QuotaStatistics",
        cloud_storage: "_models.QuotaStatistics",
        **kwargs: Any
    ) -> None:
        """
        :keyword user_id: The guid of the user. Required.
        :paramtype user_id: str
        :keyword email: The email address of the authenticated user. Required.
        :paramtype email: str
        :keyword email_confirmed: A boolean value indicating whether the email address is confirmed.
         Required.
        :paramtype email_confirmed: bool
        :keyword subscription_end: The end date of the authenticated user's current subscription.
         Required.
        :paramtype subscription_end: ~datetime.datetime
        :keyword capabilities: The capabilities that the authenticated user owns thanks to his current
         subscription. Required.
        :paramtype capabilities: list[str]
        :keyword grace_period: A boolean value indicates whether the subscription is in a grace period
         and should be renewed immediately. Required.
        :paramtype grace_period: bool
        :keyword last_app_login: The last date when the user authenticated by the app. Required.
        :paramtype last_app_login: ~datetime.datetime
        :keyword workspace_folder: The user's workspace folder path where the profiles are stored.
         Required.
        :paramtype workspace_folder: str
        :keyword local_storage: Required.
        :paramtype local_storage: ~kameleo.local_api_client.models.QuotaStatistics
        :keyword cloud_storage: Required.
        :paramtype cloud_storage: ~kameleo.local_api_client.models.QuotaStatistics
        """
        super().__init__(**kwargs)
        self.user_id = user_id
        self.email = email
        self.email_confirmed = email_confirmed
        self.subscription_end = subscription_end
        self.capabilities = capabilities
        self.grace_period = grace_period
        self.last_app_login = last_app_login
        self.workspace_folder = workspace_folder
        self.local_storage = local_storage
        self.cloud_storage = cloud_storage


class WebDriverSettings(_serialization.Model):
    """Additional arguments, options and preferences that can be passed to the started WebDriver and
    browser.

    :ivar arguments: Command line switches that can be passed to the browser at startup. It is
     applicable for both chromium based browsers and for firefox.
    :vartype arguments: list[str]
    :ivar preferences: List of preferences for browsers that can be passed at startup. In case of
     Chromium based options it will be a user profile preference. In case of Firefox profiles it
     will be a preference.
    :vartype preferences: list[~kameleo.local_api_client.models.Preference]
    :ivar additional_options: List of additional Kameleo options that can be passed at startup. It
     applies to all desktop profiles. See Kameleo Help Center for available options.
    :vartype additional_options: list[~kameleo.local_api_client.models.Preference]
    """

    _attribute_map = {
        "arguments": {"key": "arguments", "type": "[str]"},
        "preferences": {"key": "preferences", "type": "[Preference]"},
        "additional_options": {"key": "additionalOptions", "type": "[Preference]"},
    }

    def __init__(
        self,
        *,
        arguments: Optional[List[str]] = None,
        preferences: Optional[List["_models.Preference"]] = None,
        additional_options: Optional[List["_models.Preference"]] = None,
        **kwargs: Any
    ) -> None:
        """
        :keyword arguments: Command line switches that can be passed to the browser at startup. It is
         applicable for both chromium based browsers and for firefox.
        :paramtype arguments: list[str]
        :keyword preferences: List of preferences for browsers that can be passed at startup. In case
         of Chromium based options it will be a user profile preference. In case of Firefox profiles it
         will be a preference.
        :paramtype preferences: list[~kameleo.local_api_client.models.Preference]
        :keyword additional_options: List of additional Kameleo options that can be passed at startup.
         It applies to all desktop profiles. See Kameleo Help Center for available options.
        :paramtype additional_options: list[~kameleo.local_api_client.models.Preference]
        """
        super().__init__(**kwargs)
        self.arguments = arguments
        self.preferences = preferences
        self.additional_options = additional_options


class WebglMeta(_serialization.Model):
    """WebglMeta.

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

    :ivar vendor: The UnmaskedVendor field from WebGL context. Required.
    :vartype vendor: str
    :ivar renderer: The UnmaskedRenderer field from WebGL context.
    :vartype renderer: str
    """

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

    _attribute_map = {
        "vendor": {"key": "vendor", "type": "str"},
        "renderer": {"key": "renderer", "type": "str"},
    }

    def __init__(self, *, vendor: str, renderer: Optional[str] = None, **kwargs: Any) -> None:
        """
        :keyword vendor: The UnmaskedVendor field from WebGL context. Required.
        :paramtype vendor: str
        :keyword renderer: The UnmaskedRenderer field from WebGL context.
        :paramtype renderer: str
        """
        super().__init__(**kwargs)
        self.vendor = vendor
        self.renderer = renderer


class WebglMetaSpoofingOptions(_serialization.Model):
    """When the WebGL Meta spoofing is used, these settings can override the values in the base
    profile.

    :ivar vendor: Unmasked vendor.
    :vartype vendor: str
    :ivar renderer: Unmasked renderer.
    :vartype renderer: str
    """

    _attribute_map = {
        "vendor": {"key": "vendor", "type": "str"},
        "renderer": {"key": "renderer", "type": "str"},
    }

    def __init__(self, *, vendor: Optional[str] = None, renderer: Optional[str] = None, **kwargs: Any) -> None:
        """
        :keyword vendor: Unmasked vendor.
        :paramtype vendor: str
        :keyword renderer: Unmasked renderer.
        :paramtype renderer: str
        """
        super().__init__(**kwargs)
        self.vendor = vendor
        self.renderer = renderer


class WebglMetaSpoofingTypeWebglMetaSpoofingOptionsMultiLevelChoice(_serialization.Model):
    """WebglMetaSpoofingTypeWebglMetaSpoofingOptionsMultiLevelChoice.

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

    :ivar value: Specifies how the WebGL vendor and renderer will be spoofed. Possible values:
     'automatic': The vendor and renderer values comes from the base profile.
     'manual': Manually set the vendor and renderer values.
     'off': Turn off the spoofing, use the original settings. Required. Known values are:
     "automatic", "manual", and "off".
    :vartype value: str or ~kameleo.local_api_client.models.WebglMetaSpoofingType
    :ivar extra: When the WebGL Meta spoofing is used, these settings can override the values in
     the base profile.
    :vartype extra: ~kameleo.local_api_client.models.WebglMetaSpoofingOptions
    """

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

    _attribute_map = {
        "value": {"key": "value", "type": "str"},
        "extra": {"key": "extra", "type": "WebglMetaSpoofingOptions"},
    }

    def __init__(
        self,
        *,
        value: Union[str, "_models.WebglMetaSpoofingType"],
        extra: Optional["_models.WebglMetaSpoofingOptions"] = None,
        **kwargs: Any
    ) -> None:
        """
        :keyword value: Specifies how the WebGL vendor and renderer will be spoofed. Possible values:
         'automatic': The vendor and renderer values comes from the base profile.
         'manual': Manually set the vendor and renderer values.
         'off': Turn off the spoofing, use the original settings. Required. Known values are:
         "automatic", "manual", and "off".
        :paramtype value: str or ~kameleo.local_api_client.models.WebglMetaSpoofingType
        :keyword extra: When the WebGL Meta spoofing is used, these settings can override the values in
         the base profile.
        :paramtype extra: ~kameleo.local_api_client.models.WebglMetaSpoofingOptions
        """
        super().__init__(**kwargs)
        self.value = value
        self.extra = extra


class WebRtcSpoofingOptions(_serialization.Model):
    """When the WebRTC spoofing is set to manual these extra settings will be used as well.

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

    :ivar private_ip: The WebRTC local IP address of the machine. It can be an obfuscated value as
     well. Required.
    :vartype private_ip: str
    :ivar public_ip: The WebRTC public IP address of the machine. Required.
    :vartype public_ip: str
    """

    _validation = {
        "private_ip": {"required": True},
        "public_ip": {"required": True},
    }

    _attribute_map = {
        "private_ip": {"key": "privateIp", "type": "str"},
        "public_ip": {"key": "publicIp", "type": "str"},
    }

    def __init__(self, *, private_ip: str, public_ip: str, **kwargs: Any) -> None:
        """
        :keyword private_ip: The WebRTC local IP address of the machine. It can be an obfuscated value
         as well. Required.
        :paramtype private_ip: str
        :keyword public_ip: The WebRTC public IP address of the machine. Required.
        :paramtype public_ip: str
        """
        super().__init__(**kwargs)
        self.private_ip = private_ip
        self.public_ip = public_ip


class WebRtcSpoofingTypeWebRtcSpoofingOptionsMultiLevelChoice(_serialization.Model):
    """WebRtcSpoofingTypeWebRtcSpoofingOptionsMultiLevelChoice.

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

    :ivar value: Specifies how the WebRTC will be spoofed. Possible values:
     'automatic': Automatically set the webRTC public IP by the IP, and generates a random private
     IP like '2d2f78e7-1b1e-4345-a21b-07c904c98394.local'
     'manual': Manually override the webRTC public IP and private IP in the profile
     'block': Block the WebRTC functionality
     'off': Turn off the spoofing, use the original settings. Required. Known values are:
     "automatic", "manual", "block", and "off".
    :vartype value: str or ~kameleo.local_api_client.models.WebRtcSpoofingType
    :ivar extra: When the WebRTC spoofing is set to manual these extra settings will be used as
     well.
    :vartype extra: ~kameleo.local_api_client.models.WebRtcSpoofingOptions
    """

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

    _attribute_map = {
        "value": {"key": "value", "type": "str"},
        "extra": {"key": "extra", "type": "WebRtcSpoofingOptions"},
    }

    def __init__(
        self,
        *,
        value: Union[str, "_models.WebRtcSpoofingType"],
        extra: Optional["_models.WebRtcSpoofingOptions"] = None,
        **kwargs: Any
    ) -> None:
        """
        :keyword value: Specifies how the WebRTC will be spoofed. Possible values:
         'automatic': Automatically set the webRTC public IP by the IP, and generates a random private
         IP like '2d2f78e7-1b1e-4345-a21b-07c904c98394.local'
         'manual': Manually override the webRTC public IP and private IP in the profile
         'block': Block the WebRTC functionality
         'off': Turn off the spoofing, use the original settings. Required. Known values are:
         "automatic", "manual", "block", and "off".
        :paramtype value: str or ~kameleo.local_api_client.models.WebRtcSpoofingType
        :keyword extra: When the WebRTC spoofing is set to manual these extra settings will be used as
         well.
        :paramtype extra: ~kameleo.local_api_client.models.WebRtcSpoofingOptions
        """
        super().__init__(**kwargs)
        self.value = value
        self.extra = extra
