Module smartapp.api.models.smartapp

Classes

class Configuration (**data: Any)

Create a new model by parsing and validating input data from keyword arguments.

Raises ValidationError if the input data cannot be parsed to form a valid model.

Expand source code

class Configuration(LifecycleBase):
    configurationData: ConfigurationData

Ancestors

• LifecycleBase
• pydantic.main.BaseModel
• pydantic.utils.Representation

Class variables

var configurationData : ConfigurationData

class ConfigurationData (**data: Any)

Create a new model by parsing and validating input data from keyword arguments.

Raises ValidationError if the input data cannot be parsed to form a valid model.

Expand source code

class ConfigurationData(BaseModel):
    installedAppId: Optional[str]
    phase:          Optional[Phase]
    pageId:         Optional[str]
    previousPageId: Optional[str]
    config:         Optional[smartthings.ConfigMap]
    permissions:    Optional[List[str]]
    settings:       Optional[Settings]
    initialize:     Optional[InitializeData]
    page:           Optional[PageData]

Ancestors

• pydantic.main.BaseModel
• pydantic.utils.Representation

Subclasses

• pydantic.main.ConfigurationData

Class variables

var config : Optional[smartapp.api.models.smartthings.ConfigMap]

var initialize : Optional[InitializeData]

var installedAppId : Optional[str]

var page : Optional[PageData]

var pageId : Optional[str]

var permissions : Optional[List[str]]

var phase : Optional[Phase]

var previousPageId : Optional[str]

var settings : Optional[Settings]

class Confirmation (**data: Any)

Create a new model by parsing and validating input data from keyword arguments.

Raises ValidationError if the input data cannot be parsed to form a valid model.

Expand source code

class Confirmation(LifecycleBase):
    confirmationData: ConfirmationData

Ancestors

• LifecycleBase
• pydantic.main.BaseModel
• pydantic.utils.Representation

Class variables

var confirmationData : ConfirmationData

class ConfirmationData (**data: Any)

Create a new model by parsing and validating input data from keyword arguments.

Raises ValidationError if the input data cannot be parsed to form a valid model.

Expand source code

class ConfirmationData(BaseModel):
    appId: str
    confirmationUrl: str

Ancestors

• pydantic.main.BaseModel
• pydantic.utils.Representation

Subclasses

• pydantic.main.ConfirmationData

Class variables

var appId : str

var confirmationUrl : str

class DeviceEvent (**data: Any)

Create a new model by parsing and validating input data from keyword arguments.

Raises ValidationError if the input data cannot be parsed to form a valid model.

Expand source code

class DeviceEvent(BaseModel):
    deviceId: str
    event:    smartthings.DeviceStateEvent

Ancestors

• pydantic.main.BaseModel
• pydantic.utils.Representation

Class variables

var deviceId : str

var event : smartapp.api.models.smartthings.DeviceStateEvent

class Event (**data: Any)

Create a new model by parsing and validating input data from keyword arguments.

Raises ValidationError if the input data cannot be parsed to form a valid model.

Expand source code

class Event(LifecycleBase):
    eventData:    EventData
    settings:     Optional[Settings]

Ancestors

• LifecycleBase
• pydantic.main.BaseModel
• pydantic.utils.Representation

Class variables

var eventData : EventData

var settings : Optional[Settings]

class EventData (**data: Any)

Create a new model by parsing and validating input data from keyword arguments.

Raises ValidationError if the input data cannot be parsed to form a valid model.

Expand source code

class EventData(BaseModel):
    authToken:           Optional[str]
    installedApp:        Optional[InstalledApp]
    events:              Optional[List[LifecycleEvent]]

Ancestors

• pydantic.main.BaseModel
• pydantic.utils.Representation

Subclasses

• pydantic.main.EventData

Class variables

var authToken : Optional[str]

var events : Optional[List[LifecycleEvent]]

var installedApp : Optional[InstalledApp]

class EventType (value, names=None, *, module=None, qualname=None, type=None, start=1)

An enumeration.

Expand source code

class EventType(Enum):
    DEVICE_COMMANDS_EVENT         = 'DEVICE_COMMANDS_EVENT'
    DEVICE_EVENT                  = 'DEVICE_EVENT'
    DEVICE_HEALTH_EVENT           = 'DEVICE_HEALTH_EVENT'
    DEVICE_LIFECYCLE_EVENT        = 'DEVICE_LIFECYCLE_EVENT'
    HUB_HEALTH_EVENT              = 'HUB_HEALTH_EVENT'
    MODE_EVENT                    = 'MODE_EVENT'
    SCENE_LIFECYCLE_EVENT         = 'SCENE_LIFECYCLE_EVENT'
    SECURITY_ARM_STATE_EVENT      = 'SECURITY_ARM_STATE_EVENT'
    TIMER_EVENT                   = 'TIMER_EVENT'
    INSTALLED_APP_LIFECYCLE_EVENT = 'INSTALLED_APP_LIFECYCLE_EVENT'
    WEATHER_EVENT                 = 'WEATHER_EVENT'

Ancestors

• enum.Enum

Class variables

var DEVICE_COMMANDS_EVENT

var DEVICE_EVENT

var DEVICE_HEALTH_EVENT

var DEVICE_LIFECYCLE_EVENT

var HUB_HEALTH_EVENT

var INSTALLED_APP_LIFECYCLE_EVENT

var MODE_EVENT

var SCENE_LIFECYCLE_EVENT

var SECURITY_ARM_STATE_EVENT

var TIMER_EVENT

var WEATHER_EVENT

class InitializeData (**data: Any)

Create a new model by parsing and validating input data from keyword arguments.

Raises ValidationError if the input data cannot be parsed to form a valid model.

Expand source code

class InitializeData(BaseModel):
    name:           str
    description:    str
    id:             str
    permissions:    Permissions
    firstPageId:    str

Ancestors

• pydantic.main.BaseModel
• pydantic.utils.Representation

Subclasses

• pydantic.main.InitializeData

Class variables

var description : str

var firstPageId : str

var id : str

var name : str

var permissions : List[str]

class Install (**data: Any)

Create a new model by parsing and validating input data from keyword arguments.

Raises ValidationError if the input data cannot be parsed to form a valid model.

Expand source code

class Install(LifecycleBase):
    installData: InstallData

Ancestors

• LifecycleBase
• pydantic.main.BaseModel
• pydantic.utils.Representation

Class variables

var installData : InstallData

class InstallData (**data: Any)

Create a new model by parsing and validating input data from keyword arguments.

Raises ValidationError if the input data cannot be parsed to form a valid model.

Expand source code

class InstallData(BaseModel):
    authToken:    Optional[str]
    refreshToken: Optional[str]
    installedApp: Optional[InstalledApp]

Ancestors

• pydantic.main.BaseModel
• pydantic.utils.Representation

Subclasses

• pydantic.main.InstallData

Class variables

var authToken : Optional[str]

var installedApp : Optional[InstalledApp]

var refreshToken : Optional[str]

class InstalledApp (**data: Any)

Create a new model by parsing and validating input data from keyword arguments.

Raises ValidationError if the input data cannot be parsed to form a valid model.

Expand source code

class InstalledApp(BaseModel):
    installedAppId: Optional[str]
    locationId:     Optional[str]
    config:         smartthings.ConfigMap
    permissions:    Optional[Permissions]
    settings:       Optional[Settings]

Ancestors

• pydantic.main.BaseModel
• pydantic.utils.Representation

Subclasses

• pydantic.main.InstalledApp

Class variables

var config : smartapp.api.models.smartthings.ConfigMap

var installedAppId : Optional[str]

var locationId : Optional[str]

var permissions : Optional[List[str]]

var settings : Optional[Settings]

class LifecycleBase (**data: Any)

Create a new model by parsing and validating input data from keyword arguments.

Raises ValidationError if the input data cannot be parsed to form a valid model.

Expand source code

class LifecycleBase(BaseModel):
    lifecycle:    str
    executionId:  Optional[str]
    locale:       Optional[str]
    version:      Optional[str]
    settings:     Optional[Dict]

Ancestors

• pydantic.main.BaseModel
• pydantic.utils.Representation

Subclasses

• AllLifecycles
• Configuration
• Confirmation
• Event
• Install
• Update

Class variables

var executionId : Optional[str]

var lifecycle : str

var locale : Optional[str]

var settings : Optional[Dict[~KT, ~VT]]

var version : Optional[str]

class LifecycleEvent (**data: Any)

Create a new model by parsing and validating input data from keyword arguments.

Raises ValidationError if the input data cannot be parsed to form a valid model.

Expand source code

class LifecycleEvent(BaseModel):
    eventType:        smartthings.EventType
    deviceEvent:      Optional[smartthings.DeviceSubscriptionDetail]
    deviceLifecycle:  Optional[smartthings.DeviceLifecycleDetail]

Ancestors

• pydantic.main.BaseModel
• pydantic.utils.Representation

Subclasses

• pydantic.main.LifecycleEvent

Class variables

var deviceEvent : Optional[smartapp.api.models.smartthings.DeviceSubscriptionDetail]

var deviceLifecycle : Optional[smartapp.api.models.smartthings.DeviceLifecycleDetail]

var eventType : smartapp.api.models.smartthings.EventType

class LifecycleResponse (**data: Any)

Create a new model by parsing and validating input data from keyword arguments.

Raises ValidationError if the input data cannot be parsed to form a valid model.

Expand source code

class LifecycleResponse(BaseModel):
   targetUrl:          Optional[str]
   installData:        Optional[InstallData]
   updateData:         Optional[UpdateData]
   eventData:          Optional[EventData]
   oAuthCallbackData:  Optional[OAuthCallbackData]
   uninstallData:      Optional[UninstallData]
   configurationData:  Optional[ConfigurationData]
   confirmationData:   Optional[ConfirmationData]
   pingData:           Optional[PingData]

Ancestors

• pydantic.main.BaseModel
• pydantic.utils.Representation

Subclasses

• pydantic.main.LifecycleResponse

Class variables

var configurationData : Optional[ConfigurationData]

var confirmationData : Optional[ConfirmationData]

var eventData : Optional[EventData]

var installData : Optional[InstallData]

var oAuthCallbackData : Optional[OAuthCallbackData]

var pingData : Optional[PingData]

var targetUrl : Optional[str]

var uninstallData : Optional[UninstallData]

var updateData : Optional[UpdateData]

class LifecycleType (value, names=None, *, module=None, qualname=None, type=None, start=1)

An enumeration.

Expand source code

class LifecycleType(Enum):
    configuration   = 'CONFIGURATION'
    install         = 'INSTALL'
    update          = 'UPDATE'
    event           = 'EVENT'
    oauth_callback  = 'OAUTH_CALLBACK'
    uninstall       = 'UNINSTALL'

Ancestors

• enum.Enum

Class variables

var configuration

var event

var install

var oauth_callback

var uninstall

var update

class OAuthCallbackData (**data: Any)

Create a new model by parsing and validating input data from keyword arguments.

Raises ValidationError if the input data cannot be parsed to form a valid model.

Expand source code

class OAuthCallbackData(BaseModel):
    installedAppId: str
    urlPath:        str

Ancestors

• pydantic.main.BaseModel
• pydantic.utils.Representation

Subclasses

• pydantic.main.OAuthCallbackData

Class variables

var installedAppId : str

var urlPath : str

class Option (**data: Any)

Create a new model by parsing and validating input data from keyword arguments.

Raises ValidationError if the input data cannot be parsed to form a valid model.

Expand source code

class Option(BaseModel):
    id:   str
    name: str

Ancestors

• pydantic.main.BaseModel
• pydantic.utils.Representation

Subclasses

• pydantic.main.Option

Class variables

var id : str

var name : str

class PageData (**data: Any)

Create a new model by parsing and validating input data from keyword arguments.

Raises ValidationError if the input data cannot be parsed to form a valid model.

Expand source code

class PageData(BaseModel):
    pageId:         str
    name:           str
    nextPageId:     Optional[str]
    previousPageId: Optional[str]
    complete:       bool
    sections:       Optional[List[PageSection]]

Ancestors

• pydantic.main.BaseModel
• pydantic.utils.Representation

Subclasses

• pydantic.main.PageData
• Page

Class variables

var complete : bool

var name : str

var nextPageId : Optional[str]

var pageId : str

var previousPageId : Optional[str]

var sections : Optional[List[PageSection]]

class PageSection (**data: Any)

Create a new model by parsing and validating input data from keyword arguments.

Raises ValidationError if the input data cannot be parsed to form a valid model.

Expand source code

class PageSection(BaseModel):
    name: str
    settings: Optional[List[PageSetting]]

Ancestors

• pydantic.main.BaseModel
• pydantic.utils.Representation

Subclasses

• pydantic.main.PageSection
• Section

Class variables

var name : str

var settings : Optional[List[PageSetting]]

class PageSetting (**data: Any)

Create a new model by parsing and validating input data from keyword arguments.

Raises ValidationError if the input data cannot be parsed to form a valid model.

Expand source code

class PageSetting(BaseModel):
    id:           str
    name:         str
    description:  Optional[str]
    type:         SettingType
    required:     bool
    multiple:     bool
    options:      Optional[Options]
    capabilities: Optional[Capabilities]
    permissions:  Optional[Permissions]

Ancestors

• pydantic.main.BaseModel
• pydantic.utils.Representation

Subclasses

• pydantic.main.PageSetting
• Setting

Class variables

var capabilities : Optional[List[str]]

var description : Optional[str]

var id : str

var multiple : bool

var name : str

var options : Optional[List[Option]]

var permissions : Optional[List[str]]

var required : bool

var type : SettingType

class Phase (value, names=None, *, module=None, qualname=None, type=None, start=1)

An enumeration.

Expand source code

class Phase(Enum):
    initialize = 'INITIALIZE'
    page       = 'PAGE'

Ancestors

• enum.Enum

Class variables

var initialize

var page

class PingData (**data: Any)

Create a new model by parsing and validating input data from keyword arguments.

Raises ValidationError if the input data cannot be parsed to form a valid model.

Expand source code

class PingData(BaseModel):
    challenge: str

Ancestors

• pydantic.main.BaseModel
• pydantic.utils.Representation

Subclasses

• pydantic.main.PingData

Class variables

var challenge : str

class SettingType (value, names=None, *, module=None, qualname=None, type=None, start=1)

An enumeration.

Expand source code

class SettingType(Enum):
    STRING     = 'STRING'
    DEVICE     = 'DEVICE'
    PERMISSION = 'PERMISSION'
    MODE       = 'MODE'
    SCENE      = 'SCENE'
    MESSAGE    = 'MESSAGE'
    ENUM       = 'ENUM'

Ancestors

• enum.Enum

Class variables

var DEVICE

var ENUM

var MESSAGE

var MODE

var PERMISSION

var SCENE

var STRING

class Settings (**data: Any)

Create a new model by parsing and validating input data from keyword arguments.

Raises ValidationError if the input data cannot be parsed to form a valid model.

Expand source code

class Settings(BaseModel):
    __root__: Dict[str, str]

Ancestors

• pydantic.main.BaseModel
• pydantic.utils.Representation

Subclasses

• pydantic.main.Settings

class SmartAppEventRequest (**data: Any)

Create a new model by parsing and validating input data from keyword arguments.

Raises ValidationError if the input data cannot be parsed to form a valid model.

Expand source code

class SmartAppEventRequest(smartthings.SmartAppEventRequest):
    pass

Ancestors

• smartapp.api.models.smartthings.SmartAppEventRequest
• pydantic.main.BaseModel
• pydantic.utils.Representation

Class variables

var attributes : Optional[Dict[str, str]]

var name : Optional[str]

class Subscription (**data: Any)

Create a new model by parsing and validating input data from keyword arguments.

Raises ValidationError if the input data cannot be parsed to form a valid model.

Expand source code

class Subscription(smartthings.Subscription):
    pass

Ancestors

• smartapp.api.models.smartthings.Subscription
• pydantic.main.BaseModel
• pydantic.utils.Representation

Class variables

var capability : Optional[smartapp.api.models.smartthings.CapabilitySubscriptionDetail]

var device : Optional[smartapp.api.models.smartthings.DeviceSubscriptionDetail]

var deviceHealth : Optional[smartapp.api.models.smartthings.DeviceHealthDetail]

var deviceLifecycle : Optional[smartapp.api.models.smartthings.DeviceLifecycleDetail]

var hubHealth : Optional[smartapp.api.models.smartthings.HubHealthDetail]

var id : Optional[str]

var installedAppId : Optional[str]

var mode : Optional[smartapp.api.models.smartthings.ModeSubscriptionDetail]

var sceneLifecycle : Optional[smartapp.api.models.smartthings.SceneLifecycleDetail]

var securityArmState : Optional[smartapp.api.models.smartthings.SecurityArmStateDetail]

var sourceType : Optional[smartapp.api.models.smartthings.SubscriptionSource]

class SubscriptionType (value, names=None, *, module=None, qualname=None, type=None, start=1)

An enumeration.

Expand source code

class SubscriptionType(Enum):
    DEVICE             = 'DEVICE'
    CAPABILITY         = 'CAPABILITY'
    MODE               = 'MODE'
    DEVICE_LIFECYCLE   = 'DEVICE_LIFECYCLE'
    DEVICE_HEALTH      = 'DEVICE_HEALTH'
    SECURITY_ARM_STATE = 'SECURITY_ARM_STATE'
    HUB_HEALTH         = 'HUB_HEALTH'
    SCENE_LIFECYCLE    = 'SCENE_LIFECYCLE'

Ancestors

• enum.Enum

Class variables

var CAPABILITY

var DEVICE

var DEVICE_HEALTH

var DEVICE_LIFECYCLE

var HUB_HEALTH

var MODE

var SCENE_LIFECYCLE

var SECURITY_ARM_STATE

class UninstallData (**data: Any)

Create a new model by parsing and validating input data from keyword arguments.

Raises ValidationError if the input data cannot be parsed to form a valid model.

Expand source code

class UninstallData(BaseModel):
    installedApp: Optional[InstalledApp]
    settings:     Optional[Settings]

Ancestors

• pydantic.main.BaseModel
• pydantic.utils.Representation

Subclasses

• pydantic.main.UninstallData

Class variables

var installedApp : Optional[InstalledApp]

var settings : Optional[Settings]

class Update (**data: Any)

Create a new model by parsing and validating input data from keyword arguments.

Raises ValidationError if the input data cannot be parsed to form a valid model.

Expand source code

class Update(LifecycleBase):
    updateData:   UpdateData
    settings:     Optional[Settings]

Ancestors

• LifecycleBase
• pydantic.main.BaseModel
• pydantic.utils.Representation

Class variables

var settings : Optional[Settings]

var updateData : UpdateData

class UpdateData (**data: Any)

Create a new model by parsing and validating input data from keyword arguments.

Raises ValidationError if the input data cannot be parsed to form a valid model.

Expand source code

class UpdateData(BaseModel):
    authToken:           Optional[str]
    refreshToken:        Optional[str]
    installedApp:        Optional[InstalledApp]
    permissions:         Optional[Permissions]
    previousConfig:      Optional[smartthings.ConfigMap]
    previousPermissions: Optional[Permissions]

Ancestors

• pydantic.main.BaseModel
• pydantic.utils.Representation

Subclasses

• pydantic.main.UpdateData

Class variables

var authToken : Optional[str]

var installedApp : Optional[InstalledApp]

var permissions : Optional[List[str]]

var previousConfig : Optional[smartapp.api.models.smartthings.ConfigMap]

var previousPermissions : Optional[List[str]]

var refreshToken : Optional[str]

class UpdateEvent (**data: Any)

Create a new model by parsing and validating input data from keyword arguments.

Raises ValidationError if the input data cannot be parsed to form a valid model.

Expand source code

class UpdateEvent(smartthings.DeviceStateEvent):
    pass

Ancestors

• smartapp.api.models.smartthings.DeviceStateEvent
• pydantic.main.BaseModel
• pydantic.utils.Representation

Class variables

var attribute : Optional[str]

var capability : Optional[str]

var component : Optional[str]

var data : Optional[Dict[str, Dict[str, Any]]]

var unit : Optional[str]

var value : Any