Move python files to root dir

Change-Id: I16a66e1f6bcb65cbb68f2b622618252885ab47fc
Issue-Id: MODELING-20
Signed-off-by: Zhaoxing <meng.zhaoxing1@zte.com.cn>

18 files changed, 2990 insertions, 0 deletions

diff --git a/nfvparser/toscaparser/elements/TOSCA_definition_1_0.yaml b/nfvparser/toscaparser/elements/TOSCA_definition_1_0.yaml
new file mode 100644
index 0000000..9f3369e
--- /dev/null
+++ b/nfvparser/toscaparser/elements/TOSCA_definition_1_0.yaml
@@ -0,0 +1,952 @@
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+##########################################################################
+# The content of this file reflects TOSCA Simple Profile in YAML version
+# 1.0.0. It describes the definition for TOSCA types including Node Type,
+# Relationship Type, Capability Type and Interfaces.
+##########################################################################
+tosca_definitions_version: tosca_simple_yaml_1_0
+
+##########################################################################
+# Node Type.
+# A Node Type is a reusable entity that defines the type of one or more
+# Node Templates.
+##########################################################################
+node_types:
+  tosca.nodes.Root:
+    description: >
+      The TOSCA root node all other TOSCA base node types derive from.
+    attributes:
+      tosca_id:
+        type: string
+      tosca_name:
+        type: string
+      state:
+        type: string
+    capabilities:
+      feature:
+        type: tosca.capabilities.Node
+    requirements:
+      - dependency:
+          capability: tosca.capabilities.Node
+          node: tosca.nodes.Root
+          relationship: tosca.relationships.DependsOn
+          occurrences: [ 0, UNBOUNDED ]
+    interfaces:
+      Standard:
+        type: tosca.interfaces.node.lifecycle.Standard
+
+  tosca.nodes.Compute:
+    derived_from: tosca.nodes.Root
+    attributes:
+      private_address:
+        type: string
+      public_address:
+        type: string
+      networks:
+        type: map
+        entry_schema:
+          type: tosca.datatypes.network.NetworkInfo
+      ports:
+        type: map
+        entry_schema:
+          type: tosca.datatypes.network.PortInfo
+    capabilities:
+        host:
+           type: tosca.capabilities.Container
+        binding:
+           type: tosca.capabilities.network.Bindable
+        os:
+           type: tosca.capabilities.OperatingSystem
+        scalable:
+           type: tosca.capabilities.Scalable
+        endpoint:
+           type: tosca.capabilities.Endpoint.Admin
+    requirements:
+      - local_storage:
+          capability: tosca.capabilities.Attachment
+          node: tosca.nodes.BlockStorage
+          relationship: tosca.relationships.AttachesTo
+          occurrences: [0, UNBOUNDED]
+
+  tosca.nodes.SoftwareComponent:
+    derived_from: tosca.nodes.Root
+    properties:
+      # domain-specific software component version
+      component_version:
+        type: version
+        required: false
+        description: >
+          Software component version.
+      admin_credential:
+        type: tosca.datatypes.Credential
+        required: false
+    requirements:
+      - host:
+          capability: tosca.capabilities.Container
+          node: tosca.nodes.Compute
+          relationship: tosca.relationships.HostedOn
+
+  tosca.nodes.DBMS:
+    derived_from: tosca.nodes.SoftwareComponent
+    properties:
+      port:
+        required: false
+        type: integer
+        description: >
+          The port the DBMS service will listen to for data and requests.
+      root_password:
+        required: false
+        type: string
+        description: >
+          The root password for the DBMS service.
+    capabilities:
+      host:
+        type: tosca.capabilities.Container
+        valid_source_types: [tosca.nodes.Database]
+
+  tosca.nodes.Database:
+    derived_from: tosca.nodes.Root
+    properties:
+      user:
+        required: false
+        type: string
+        description: >
+          User account name for DB administration
+      port:
+        required: false
+        type: integer
+        description:  >
+          The port the database service will use to listen for incoming data and
+          requests.
+      name:
+        required: false
+        type: string
+        description: >
+          The name of the database.
+      password:
+        required: false
+        type: string
+        description: >
+          The password for the DB user account
+    requirements:
+      - host:
+          capability: tosca.capabilities.Container
+          node: tosca.nodes.DBMS
+          relationship: tosca.relationships.HostedOn
+    capabilities:
+      database_endpoint:
+        type: tosca.capabilities.Endpoint.Database
+
+  tosca.nodes.WebServer:
+    derived_from: tosca.nodes.SoftwareComponent
+    capabilities:
+      data_endpoint:
+        type: tosca.capabilities.Endpoint
+      admin_endpoint:
+        type: tosca.capabilities.Endpoint.Admin
+      host:
+        type: tosca.capabilities.Container
+        valid_source_types: [tosca.nodes.WebApplication]
+
+  tosca.nodes.WebApplication:
+    derived_from: tosca.nodes.Root
+    properties:
+      context_root:
+        type: string
+        required: false
+    requirements:
+      - host:
+          capability: tosca.capabilities.Container
+          node: tosca.nodes.WebServer
+          relationship: tosca.relationships.HostedOn
+    capabilities:
+      app_endpoint:
+        type: tosca.capabilities.Endpoint
+
+  tosca.nodes.BlockStorage:
+    derived_from: tosca.nodes.Root
+    properties:
+      size:
+        type: scalar-unit.size
+        constraints:
+          - greater_or_equal: 1 MB
+      volume_id:
+        type: string
+        required: false
+      snapshot_id:
+        type: string
+        required: false
+    attributes:
+      volume_id:
+        type: string
+    capabilities:
+      attachment:
+        type: tosca.capabilities.Attachment
+
+  tosca.nodes.network.Network:
+    derived_from: tosca.nodes.Root
+    description: >
+      The TOSCA Network node represents a simple, logical network service.
+    properties:
+      ip_version:
+        type: integer
+        required: false
+        default: 4
+        constraints:
+          - valid_values: [ 4, 6 ]
+        description: >
+          The IP version of the requested network. Valid values are 4 for ipv4
+          or 6 for ipv6.
+      cidr:
+        type: string
+        required: false
+        description: >
+          The cidr block of the requested network.
+      start_ip:
+        type: string
+        required: false
+        description: >
+           The IP address to be used as the start of a pool of addresses within
+           the full IP range derived from the cidr block.
+      end_ip:
+        type: string
+        required: false
+        description: >
+            The IP address to be used as the end of a pool of addresses within
+            the full IP range derived from the cidr block.
+      gateway_ip:
+        type: string
+        required: false
+        description: >
+           The gateway IP address.
+      network_name:
+        type: string
+        required: false
+        description: >
+           An identifier that represents an existing Network instance in the
+           underlying cloud infrastructure or can be used as the name of the
+           newly created network. If network_name is provided and no other
+           properties are provided (with exception of network_id), then an
+           existing network instance will be used. If network_name is provided
+           alongside with more properties then a new network with this name will
+           be created.
+      network_id:
+        type: string
+        required: false
+        description: >
+           An identifier that represents an existing Network instance in the
+           underlying cloud infrastructure. This property is mutually exclusive
+           with all other properties except network_name. This can be used alone
+           or together with network_name to identify an existing network.
+      segmentation_id:
+        type: string
+        required: false
+        description: >
+           A segmentation identifier in the underlying cloud infrastructure.
+           E.g. VLAN ID, GRE tunnel ID, etc..
+      network_type:
+        type: string
+        required: false
+        description: >
+           It specifies the nature of the physical network in the underlying
+           cloud infrastructure. Examples are flat, vlan, gre or vxlan.
+           For flat and vlan types, physical_network should be provided too.
+      physical_network:
+        type: string
+        required: false
+        description: >
+           It identifies the physical network on top of which the network is
+           implemented, e.g. physnet1. This property is required if network_type
+           is flat or vlan.
+      dhcp_enabled:
+        type: boolean
+        required: false
+        default: true
+        description: >
+          Indicates should DHCP service be enabled on the network or not.
+    capabilities:
+      link:
+        type: tosca.capabilities.network.Linkable
+
+  tosca.nodes.network.Port:
+    derived_from: tosca.nodes.Root
+    description: >
+      The TOSCA Port node represents a logical entity that associates between
+      Compute and Network normative types. The Port node type effectively
+      represents a single virtual NIC on the Compute node instance.
+    properties:
+      ip_address:
+        type: string
+        required: false
+        description: >
+          Allow the user to set a static IP.
+      order:
+        type: integer
+        required: false
+        default: 0
+        constraints:
+          - greater_or_equal: 0
+        description: >
+          The order of the NIC on the compute instance (e.g. eth2).
+      is_default:
+        type: boolean
+        required: false
+        default: false
+        description: >
+          If is_default=true this port will be used for the default gateway
+          route. Only one port that is associated to single compute node can
+          set as is_default=true.
+      ip_range_start:
+        type: string
+        required: false
+        description: >
+          Defines the starting IP of a range to be allocated for the compute
+          instances that are associated with this Port.
+      ip_range_end:
+        type: string
+        required: false
+        description: >
+          Defines the ending IP of a range to be allocated for the compute
+          instances that are associated with this Port.
+    attributes:
+      ip_address:
+        type: string
+    requirements:
+      - binding:
+          description: >
+            Binding requirement expresses the relationship between Port and
+            Compute nodes. Effectively it indicates that the Port will be
+            attached to specific Compute node instance
+          capability: tosca.capabilities.network.Bindable
+          relationship: tosca.relationships.network.BindsTo
+          node: tosca.nodes.Compute
+      - link:
+          description: >
+            Link requirement expresses the relationship between Port and Network
+            nodes. It indicates which network this port will connect to.
+          capability: tosca.capabilities.network.Linkable
+          relationship: tosca.relationships.network.LinksTo
+          node: tosca.nodes.network.Network
+
+  tosca.nodes.ObjectStorage:
+    derived_from: tosca.nodes.Root
+    description: >
+      The TOSCA ObjectStorage node represents storage that provides the ability
+      to store data as objects (or BLOBs of data) without consideration for the
+      underlying filesystem or devices
+    properties:
+      name:
+        type: string
+        required: true
+        description: >
+          The logical name of the object store (or container).
+      size:
+        type: scalar-unit.size
+        required: false
+        constraints:
+          - greater_or_equal: 0 GB
+        description: >
+          The requested initial storage size.
+      maxsize:
+        type: scalar-unit.size
+        required: false
+        constraints:
+          - greater_or_equal: 0 GB
+        description: >
+          The requested maximum storage size.
+    capabilities:
+      storage_endpoint:
+        type: tosca.capabilities.Endpoint
+
+  tosca.nodes.LoadBalancer:
+    derived_from: tosca.nodes.Root
+    properties:
+      algorithm:
+        type: string
+        required: false
+        status: experimental
+    capabilities:
+      client:
+        type: tosca.capabilities.Endpoint.Public
+        occurrences: [0, UNBOUNDED]
+        description: the Floating (IP) client’s on the public network can connect to
+    requirements:
+      - application:
+          capability: tosca.capabilities.Endpoint
+          relationship: tosca.relationships.RoutesTo
+          occurrences: [0, UNBOUNDED]
+          description: Connection to one or more load balanced applications
+
+  tosca.nodes.Container.Application:
+    derived_from: tosca.nodes.Root
+    requirements:
+      - host:
+          capability: tosca.capabilities.Container
+          node: tosca.nodes.Container.Runtime
+          relationship: tosca.relationships.HostedOn
+
+  tosca.nodes.Container.Runtime:
+    derived_from: tosca.nodes.SoftwareComponent
+    capabilities:
+      host:
+        type: tosca.capabilities.Container
+      scalable:
+        type: tosca.capabilities.Scalable
+
+  tosca.nodes.Container.Application.Docker:
+    derived_from: tosca.nodes.Container.Application
+    requirements:
+      - host:
+          capability: tosca.capabilities.Container.Docker
+
+##########################################################################
+# Relationship Type.
+# A Relationship Type is a reusable entity that defines the type of one
+# or more relationships between Node Types or Node Templates.
+##########################################################################
+relationship_types:
+  tosca.relationships.Root:
+    description: >
+      The TOSCA root Relationship Type all other TOSCA base Relationship Types
+      derive from.
+    attributes:
+      tosca_id:
+        type: string
+      tosca_name:
+        type: string
+    interfaces:
+      Configure:
+        type: tosca.interfaces.relationship.Configure
+
+  tosca.relationships.DependsOn:
+    derived_from: tosca.relationships.Root
+
+  tosca.relationships.HostedOn:
+    derived_from: tosca.relationships.Root
+    valid_target_types: [ tosca.capabilities.Container ]
+
+  tosca.relationships.ConnectsTo:
+    derived_from: tosca.relationships.Root
+    valid_target_types: [ tosca.capabilities.Endpoint ]
+    credential:
+      type: tosca.datatypes.Credential
+      required: false
+
+  tosca.relationships.AttachesTo:
+    derived_from: tosca.relationships.Root
+    valid_target_types: [ tosca.capabilities.Attachment ]
+    properties:
+      location:
+        required: true
+        type: string
+        constraints:
+          - min_length: 1
+      device:
+        required: false
+        type: string
+
+  tosca.relationships.RoutesTo:
+    derived_from: tosca.relationships.ConnectsTo
+    valid_target_types: [ tosca.capabilities.Endpoint ]
+
+  tosca.relationships.network.LinksTo:
+    derived_from: tosca.relationships.DependsOn
+    valid_target_types: [ tosca.capabilities.network.Linkable ]
+
+  tosca.relationships.network.BindsTo:
+    derived_from: tosca.relationships.DependsOn
+    valid_target_types: [ tosca.capabilities.network.Bindable ]
+
+##########################################################################
+# Capability Type.
+# A Capability Type is a reusable entity that describes a kind of
+# capability that a Node Type can declare to expose.
+##########################################################################
+capability_types:
+  tosca.capabilities.Root:
+    description: >
+      The TOSCA root Capability Type all other TOSCA base Capability Types
+      derive from.
+
+  tosca.capabilities.Node:
+    derived_from: tosca.capabilities.Root
+
+  tosca.capabilities.Container:
+    derived_from: tosca.capabilities.Root
+    properties:
+      num_cpus:
+        required: false
+        type: integer
+        constraints:
+          - greater_or_equal: 1
+      cpu_frequency:
+        required: false
+        type: scalar-unit.frequency
+        constraints:
+          - greater_or_equal: 0.1 GHz
+      disk_size:
+        required: false
+        type: scalar-unit.size
+        constraints:
+          - greater_or_equal: 0 MB
+      mem_size:
+        required: false
+        type: scalar-unit.size
+        constraints:
+          - greater_or_equal: 0 MB
+
+  tosca.capabilities.Endpoint:
+    derived_from: tosca.capabilities.Root
+    properties:
+      protocol:
+        type: string
+        required: true
+        default: tcp
+      port:
+        type: tosca.datatypes.network.PortDef
+        required: false
+      secure:
+        type: boolean
+        required: false
+        default: false
+      url_path:
+        type: string
+        required: false
+      port_name:
+        type: string
+        required: false
+      network_name:
+        type: string
+        required: false
+        default: PRIVATE
+      initiator:
+        type: string
+        required: false
+        default: source
+        constraints:
+          - valid_values: [source, target, peer]
+      ports:
+        type: map
+        required: false
+        constraints:
+          - min_length: 1
+        entry_schema:
+          type: tosca.datatypes.network.PortSpec
+    attributes:
+      ip_address:
+        type: string
+
+  tosca.capabilities.Endpoint.Admin:
+    derived_from: tosca.capabilities.Endpoint
+    properties:
+      secure:
+        type: boolean
+        default: true
+        constraints:
+          - equal: true
+
+  tosca.capabilities.Endpoint.Public:
+    derived_from: tosca.capabilities.Endpoint
+    properties:
+      # Change the default network_name to use the first public network found
+      network_name:
+        type: string
+        default: PUBLIC
+        constraints:
+          - equal: PUBLIC
+      floating:
+        description: >
+          Indicates that the public address should be allocated from a pool of
+          floating IPs that are associated with the network.
+        type: boolean
+        default: false
+        status: experimental
+      dns_name:
+        description: The optional name to register with DNS
+        type: string
+        required: false
+        status: experimental
+
+  tosca.capabilities.Scalable:
+    derived_from: tosca.capabilities.Root
+    properties:
+      min_instances:
+        type: integer
+        required: true
+        default: 1
+        description: >
+          This property is used to indicate the minimum number of instances
+          that should be created for the associated TOSCA Node Template by
+          a TOSCA orchestrator.
+      max_instances:
+        type: integer
+        required: true
+        default: 1
+        description: >
+          This property is used to indicate the maximum number of instances
+          that should be created for the associated TOSCA Node Template by
+          a TOSCA orchestrator.
+      default_instances:
+        type: integer
+        required: false
+        description: >
+          An optional property that indicates the requested default number
+          of instances that should be the starting number of instances a
+          TOSCA orchestrator should attempt to allocate.
+          The value for this property MUST be in the range between the values
+          set for min_instances and max_instances properties.
+
+  tosca.capabilities.Endpoint.Database:
+    derived_from: tosca.capabilities.Endpoint
+
+  tosca.capabilities.Attachment:
+    derived_from: tosca.capabilities.Root
+
+  tosca.capabilities.network.Linkable:
+    derived_from: tosca.capabilities.Root
+    description: >
+      A node type that includes the Linkable capability indicates that it can
+      be pointed by tosca.relationships.network.LinksTo relationship type, which
+      represents an association relationship between Port and Network node types.
+
+  tosca.capabilities.network.Bindable:
+    derived_from: tosca.capabilities.Root
+    description: >
+      A node type that includes the Bindable capability indicates that it can
+      be pointed by tosca.relationships.network.BindsTo relationship type, which
+      represents a network association relationship between Port and Compute node
+      types.
+
+  tosca.capabilities.OperatingSystem:
+    derived_from: tosca.capabilities.Root
+    properties:
+      architecture:
+        required: false
+        type: string
+        description: >
+          The host Operating System (OS) architecture.
+      type:
+        required: false
+        type: string
+        description: >
+          The host Operating System (OS) type.
+      distribution:
+        required: false
+        type: string
+        description: >
+          The host Operating System (OS) distribution. Examples of valid values
+          for an “type” of “Linux” would include:
+          debian, fedora, rhel and ubuntu.
+      version:
+        required: false
+        type: version
+        description: >
+          The host Operating System version.
+
+  tosca.capabilities.Container.Docker:
+    derived_from: tosca.capabilities.Container
+    properties:
+      version:
+        type: list
+        required: false
+        entry_schema:
+          type: version
+        description: >
+          The Docker version capability.
+      publish_all:
+        type: boolean
+        default: false
+        required: false
+        description: >
+          Indicates that all ports (ranges) listed in the dockerfile
+          using the EXPOSE keyword be published.
+      publish_ports:
+        type: list
+        entry_schema:
+          type: tosca.datatypes.network.PortSpec
+        required: false
+        description: >
+          List of ports mappings from source (Docker container)
+          to target (host) ports to publish.
+      expose_ports:
+        type: list
+        entry_schema:
+          type: tosca.datatypes.network.PortSpec
+        required: false
+        description: >
+          List of ports mappings from source (Docker container) to expose
+          to other Docker containers (not accessible outside host).
+      volumes:
+        type: list
+        entry_schema:
+          type: string
+        required: false
+        description: >
+          The dockerfile VOLUME command which is used to enable access
+          from the Docker container to a directory on the host machine.
+      host_id:
+        type: string
+        required: false
+        description: >
+            The optional identifier of an existing host resource
+            that should be used to run this container on.
+      volume_id:
+        type: string
+        required: false
+        description: >
+          The optional identifier of an existing storage volume (resource)
+          that should be used to create the container's mount point(s) on.
+
+##########################################################################
+ # Interfaces Type.
+ # The Interfaces element describes a list of one or more interface
+ # definitions for a modelable entity (e.g., a Node or Relationship Type)
+ # as defined within the TOSCA Simple Profile specification.
+##########################################################################
+interface_types:
+  tosca.interfaces.node.lifecycle.Standard:
+    create:
+      description: Standard lifecycle create operation.
+    configure:
+      description: Standard lifecycle configure operation.
+    start:
+      description: Standard lifecycle start operation.
+    stop:
+      description: Standard lifecycle stop operation.
+    delete:
+      description: Standard lifecycle delete operation.
+
+  tosca.interfaces.relationship.Configure:
+    pre_configure_source:
+      description: Operation to pre-configure the source endpoint.
+    pre_configure_target:
+      description: Operation to pre-configure the target endpoint.
+    post_configure_source:
+      description: Operation to post-configure the source endpoint.
+    post_configure_target:
+      description: Operation to post-configure the target endpoint.
+    add_target:
+      description: Operation to add a target node.
+    remove_target:
+      description: Operation to remove a target node.
+    add_source: >
+      description: Operation to notify the target node of a source node which
+      is now available via a relationship.
+      description:
+    target_changed: >
+      description: Operation to notify source some property or attribute of the
+      target changed
+
+##########################################################################
+ # Data Type.
+ # A Datatype is a complex data type declaration which contains other
+ # complex or simple data types.
+##########################################################################
+data_types:
+  tosca.datatypes.Root:
+    description: >
+      The TOSCA root Data Type all other TOSCA base Data Types derive from
+
+  tosca.datatypes.network.NetworkInfo:
+    derived_from: tosca.datatypes.Root
+    properties:
+      network_name:
+        type: string
+      network_id:
+        type: string
+      addresses:
+        type: list
+        entry_schema:
+          type: string
+
+  tosca.datatypes.network.PortInfo:
+    derived_from: tosca.datatypes.Root
+    properties:
+      port_name:
+        type: string
+      port_id:
+        type: string
+      network_id:
+        type: string
+      mac_address:
+        type: string
+      addresses:
+        type: list
+        entry_schema:
+          type: string
+
+  tosca.datatypes.network.PortDef:
+    derived_from: tosca.datatypes.Root
+    type: integer
+    constraints:
+      - in_range: [ 1, 65535 ]
+
+  tosca.datatypes.network.PortSpec:
+    derived_from: tosca.datatypes.Root
+    properties:
+      protocol:
+        type: string
+        required: true
+        default: tcp
+        constraints:
+          - valid_values: [ udp, tcp, igmp ]
+      target:
+        type: tosca.datatypes.network.PortDef
+        required: false
+      target_range:
+        type: range
+        required: false
+        constraints:
+          - in_range: [ 1, 65535 ]
+      source:
+        type: tosca.datatypes.network.PortDef
+        required: false
+      source_range:
+        type: range
+        required: false
+        constraints:
+          - in_range: [ 1, 65535 ]
+
+  tosca.datatypes.Credential:
+    derived_from: tosca.datatypes.Root
+    properties:
+      protocol:
+        type: string
+        required: false
+      token_type:
+        type: string
+        default: password
+        required: true
+      token:
+        type: string
+        required: true
+      keys:
+        type: map
+        entry_schema:
+          type: string
+        required: false
+      user:
+        type: string
+        required: false
+
+##########################################################################
+ # Artifact Type.
+ # An Artifact Type is a reusable entity that defines the type of one or more
+ # files which Node Types or Node Templates can have dependent relationships
+ # and used during operations such as during installation or deployment.
+##########################################################################
+artifact_types:
+  tosca.artifacts.Root:
+    description: >
+      The TOSCA Artifact Type all other TOSCA Artifact Types derive from
+    properties:
+      version: version
+
+  tosca.artifacts.File:
+    derived_from: tosca.artifacts.Root
+
+  tosca.artifacts.Deployment:
+    derived_from: tosca.artifacts.Root
+    description: TOSCA base type for deployment artifacts
+
+  tosca.artifacts.Deployment.Image:
+    derived_from: tosca.artifacts.Deployment
+
+  tosca.artifacts.Deployment.Image.VM:
+    derived_from: tosca.artifacts.Deployment.Image
+
+  tosca.artifacts.Implementation:
+    derived_from: tosca.artifacts.Root
+    description: TOSCA base type for implementation artifacts
+
+  tosca.artifacts.Implementation.Bash:
+    derived_from: tosca.artifacts.Implementation
+    description: Script artifact for the Unix Bash shell
+    mime_type: application/x-sh
+    file_ext: [ sh ]
+
+  tosca.artifacts.Implementation.Python:
+    derived_from: tosca.artifacts.Implementation
+    description: Artifact for the interpreted Python language
+    mime_type: application/x-python
+    file_ext: [ py ]
+
+  tosca.artifacts.Deployment.Image.Container.Docker:
+    derived_from: tosca.artifacts.Deployment.Image
+    description: Docker container image
+
+  tosca.artifacts.Deployment.Image.VM.ISO:
+    derived_from: tosca.artifacts.Deployment.Image
+    description: Virtual Machine (VM) image in ISO disk format
+    mime_type: application/octet-stream
+    file_ext: [ iso ]
+
+  tosca.artifacts.Deployment.Image.VM.QCOW2:
+    derived_from: tosca.artifacts.Deployment.Image
+    description: Virtual Machine (VM) image in QCOW v2 standard disk format
+    mime_type: application/octet-stream
+    file_ext: [ qcow2 ]
+
+##########################################################################
+ # Policy Type.
+ # TOSCA Policy Types represent logical grouping of TOSCA nodes that have
+ # an implied relationship and need to be orchestrated or managed together
+ # to achieve some result.
+##########################################################################
+policy_types:
+  tosca.policies.Root:
+    description: The TOSCA Policy Type all other TOSCA Policy Types derive from.
+
+  tosca.policies.Placement:
+    derived_from: tosca.policies.Root
+    description: The TOSCA Policy Type definition that is used to govern
+      placement of TOSCA nodes or groups of nodes.
+
+  tosca.policies.Placement.Colocate:
+    derived_from: tosca.policies.Placement
+    description: The TOSCA Policy Type definition that is used to govern
+      colocate placement of TOSCA nodes or groups of nodes.
+
+  tosca.policies.Placement.Antilocate:
+    derived_from: tosca.policies.Placement
+    description: The TOSCA Policy Type definition that is used to govern
+      anti-locate placement of TOSCA nodes or groups of nodes.
+
+  tosca.policies.Scaling:
+    derived_from: tosca.policies.Root
+    description: The TOSCA Policy Type definition that is used to govern
+      scaling of TOSCA nodes or groups of nodes.
+
+  tosca.policies.Update:
+    derived_from: tosca.policies.Root
+    description: The TOSCA Policy Type definition that is used to govern
+      update of TOSCA nodes or groups of nodes.
+
+  tosca.policies.Performance:
+    derived_from: tosca.policies.Root
+    description: The TOSCA Policy Type definition that is used to declare
+      performance requirements for TOSCA nodes or groups of nodes.
+
+##########################################################################
+ # Group Type.
+ # Group Type represents logical grouping of TOSCA nodes that have an
+ # implied membership relationship and may need to be orchestrated or
+ # managed together to achieve some result.
+##########################################################################
+group_types:
+  tosca.groups.Root:
+    description: The TOSCA Group Type all other TOSCA Group Types derive from
+    interfaces:
+      Standard:
+        type: tosca.interfaces.node.lifecycle.Standard
diff --git a/nfvparser/toscaparser/elements/__init__.py b/nfvparser/toscaparser/elements/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/nfvparser/toscaparser/elements/__init__.py
diff --git a/nfvparser/toscaparser/elements/artifacttype.py b/nfvparser/toscaparser/elements/artifacttype.py
new file mode 100644
index 0000000..bf379fc
--- /dev/null
+++ b/nfvparser/toscaparser/elements/artifacttype.py
@@ -0,0 +1,50 @@
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+from toscaparser.elements.statefulentitytype import StatefulEntityType
+
+
+class ArtifactTypeDef(StatefulEntityType):
+    '''TOSCA built-in artifacts type.'''
+
+    def __init__(self, atype, custom_def=None):
+        super(ArtifactTypeDef, self).__init__(atype, self.ARTIFACT_PREFIX,
+                                              custom_def)
+        self.type = atype
+        self.custom_def = custom_def
+        self.properties = None
+        if self.PROPERTIES in self.defs:
+            self.properties = self.defs[self.PROPERTIES]
+        self.parent_artifacts = self._get_parent_artifacts()
+
+    def _get_parent_artifacts(self):
+        artifacts = {}
+        parent_artif = self.parent_type.type if self.parent_type else None
+        if parent_artif:
+            while parent_artif != 'tosca.artifacts.Root':
+                artifacts[parent_artif] = self.TOSCA_DEF[parent_artif]
+                parent_artif = artifacts[parent_artif]['derived_from']
+        return artifacts
+
+    @property
+    def parent_type(self):
+        '''Return a artifact entity from which this entity is derived.'''
+        if not hasattr(self, 'defs'):
+            return None
+        partifact_entity = self.derived_from(self.defs)
+        if partifact_entity:
+            return ArtifactTypeDef(partifact_entity, self.custom_def)
+
+    def get_artifact(self, name):
+        '''Return the definition of an artifact field by name.'''
+        if name in self.defs:
+            return self.defs[name]
diff --git a/nfvparser/toscaparser/elements/attribute_definition.py b/nfvparser/toscaparser/elements/attribute_definition.py
new file mode 100644
index 0000000..35ba27f
--- /dev/null
+++ b/nfvparser/toscaparser/elements/attribute_definition.py
@@ -0,0 +1,20 @@
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+
+class AttributeDef(object):
+    '''TOSCA built-in Attribute type.'''
+
+    def __init__(self, name, value=None, schema=None):
+        self.name = name
+        self.value = value
+        self.schema = schema
diff --git a/nfvparser/toscaparser/elements/capabilitytype.py b/nfvparser/toscaparser/elements/capabilitytype.py
new file mode 100644
index 0000000..5fa9661
--- /dev/null
+++ b/nfvparser/toscaparser/elements/capabilitytype.py
@@ -0,0 +1,96 @@
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+from toscaparser.elements.property_definition import PropertyDef
+from toscaparser.elements.statefulentitytype import StatefulEntityType
+
+
+class CapabilityTypeDef(StatefulEntityType):
+    '''TOSCA built-in capabilities type.'''
+    TOSCA_TYPEURI_CAPABILITY_ROOT = 'tosca.capabilities.Root'
+
+    def __init__(self, name, ctype, ntype, custom_def=None):
+        self.name = name
+        super(CapabilityTypeDef, self).__init__(ctype, self.CAPABILITY_PREFIX,
+                                                custom_def)
+        self.nodetype = ntype
+        self.properties = None
+        self.custom_def = custom_def
+        if self.PROPERTIES in self.defs:
+            self.properties = self.defs[self.PROPERTIES]
+        self.parent_capabilities = self._get_parent_capabilities(custom_def)
+
+    def get_properties_def_objects(self):
+        '''Return a list of property definition objects.'''
+        properties = []
+        parent_properties = {}
+        if self.parent_capabilities:
+            for type, value in self.parent_capabilities.items():
+                parent_properties[type] = value.get('properties')
+        if self.properties:
+            for prop, schema in self.properties.items():
+                properties.append(PropertyDef(prop, None, schema))
+        if parent_properties:
+            for parent, props in parent_properties.items():
+                for prop, schema in props.items():
+                    # add parent property if not overridden by children type
+                    if not self.properties or \
+                            prop not in self.properties.keys():
+                        properties.append(PropertyDef(prop, None, schema))
+        return properties
+
+    def get_properties_def(self):
+        '''Return a dictionary of property definition name-object pairs.'''
+        return {prop.name: prop
+                for prop in self.get_properties_def_objects()}
+
+    def get_property_def_value(self, name):
+        '''Return the definition of a given property name.'''
+        props_def = self.get_properties_def()
+        if props_def and name in props_def:
+            return props_def[name].value
+
+    def _get_parent_capabilities(self, custom_def=None):
+        capabilities = {}
+        parent_cap = self.parent_type
+        if parent_cap:
+            parent_cap = parent_cap.type
+            while parent_cap != self.TOSCA_TYPEURI_CAPABILITY_ROOT:
+                if parent_cap in self.TOSCA_DEF.keys():
+                    capabilities[parent_cap] = self.TOSCA_DEF[parent_cap]
+                elif custom_def and parent_cap in custom_def.keys():
+                    capabilities[parent_cap] = custom_def[parent_cap]
+                parent_cap = capabilities[parent_cap]['derived_from']
+        return capabilities
+
+    @property
+    def parent_type(self):
+        '''Return a capability this capability is derived from.'''
+        if not hasattr(self, 'defs'):
+            return None
+        pnode = self.derived_from(self.defs)
+        if pnode:
+            return CapabilityTypeDef(self.name, pnode,
+                                     self.nodetype, self.custom_def)
+
+    def inherits_from(self, type_names):
+        '''Check this capability is in type_names
+
+           Check if this capability or some of its parent types
+           are in the list of types: type_names
+        '''
+        if self.type in type_names:
+            return True
+        elif self.parent_type:
+            return self.parent_type.inherits_from(type_names)
+        else:
+            return False
diff --git a/nfvparser/toscaparser/elements/constraints.py b/nfvparser/toscaparser/elements/constraints.py
new file mode 100644
index 0000000..70863bc
--- /dev/null
+++ b/nfvparser/toscaparser/elements/constraints.py
@@ -0,0 +1,615 @@
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+import collections
+import datetime
+import re
+
+import toscaparser
+from toscaparser.common.exception import ExceptionCollector
+from toscaparser.common.exception import InvalidSchemaError
+from toscaparser.common.exception import ValidationError
+from toscaparser.elements.portspectype import PortSpec
+from toscaparser.elements import scalarunit
+from toscaparser.utils.gettextutils import _
+
+
+class Schema(collections.Mapping):
+
+    KEYS = (
+        TYPE, REQUIRED, DESCRIPTION,
+        DEFAULT, CONSTRAINTS, ENTRYSCHEMA, STATUS
+    ) = (
+        'type', 'required', 'description',
+        'default', 'constraints', 'entry_schema', 'status'
+    )
+
+    PROPERTY_TYPES = (
+        INTEGER, STRING, BOOLEAN, FLOAT, RANGE,
+        NUMBER, TIMESTAMP, LIST, MAP,
+        SCALAR_UNIT_SIZE, SCALAR_UNIT_FREQUENCY, SCALAR_UNIT_TIME,
+        VERSION, PORTDEF, PORTSPEC
+    ) = (
+        'integer', 'string', 'boolean', 'float', 'range',
+        'number', 'timestamp', 'list', 'map',
+        'scalar-unit.size', 'scalar-unit.frequency', 'scalar-unit.time',
+        'version', 'PortDef', PortSpec.SHORTNAME
+    )
+
+    SCALAR_UNIT_SIZE_DEFAULT = 'B'
+    SCALAR_UNIT_SIZE_DICT = {'B': 1, 'KB': 1000, 'KIB': 1024, 'MB': 1000000,
+                             'MIB': 1048576, 'GB': 1000000000,
+                             'GIB': 1073741824, 'TB': 1000000000000,
+                             'TIB': 1099511627776}
+
+    def __init__(self, name, schema_dict):
+        self.name = name
+        if not isinstance(schema_dict, collections.Mapping):
+            msg = (_('Schema definition of "%(pname)s" must be a dict.')
+                   % dict(pname=name))
+            ExceptionCollector.appendException(InvalidSchemaError(message=msg))
+
+        try:
+            schema_dict['type']
+        except KeyError:
+            msg = (_('Schema definition of "%(pname)s" must have a "type" '
+                     'attribute.') % dict(pname=name))
+            ExceptionCollector.appendException(InvalidSchemaError(message=msg))
+
+        self.schema = schema_dict
+        self._len = None
+        self.constraints_list = []
+
+    @property
+    def type(self):
+        return self.schema[self.TYPE]
+
+    @property
+    def required(self):
+        return self.schema.get(self.REQUIRED, True)
+
+    @property
+    def description(self):
+        return self.schema.get(self.DESCRIPTION, '')
+
+    @property
+    def default(self):
+        return self.schema.get(self.DEFAULT)
+
+    @property
+    def status(self):
+        return self.schema.get(self.STATUS, '')
+
+    @property
+    def constraints(self):
+        if not self.constraints_list:
+            constraint_schemata = self.schema.get(self.CONSTRAINTS)
+            if constraint_schemata:
+                self.constraints_list = [Constraint(self.name,
+                                                    self.type,
+                                                    cschema)
+                                         for cschema in constraint_schemata]
+        return self.constraints_list
+
+    @property
+    def entry_schema(self):
+        return self.schema.get(self.ENTRYSCHEMA)
+
+    def __getitem__(self, key):
+        return self.schema[key]
+
+    def __iter__(self):
+        for k in self.KEYS:
+            try:
+                self.schema[k]
+            except KeyError:
+                pass
+            else:
+                yield k
+
+    def __len__(self):
+        if self._len is None:
+            self._len = len(list(iter(self)))
+        return self._len
+
+
+class Constraint(object):
+    '''Parent class for constraints for a Property or Input.'''
+
+    CONSTRAINTS = (EQUAL, GREATER_THAN,
+                   GREATER_OR_EQUAL, LESS_THAN, LESS_OR_EQUAL, IN_RANGE,
+                   VALID_VALUES, LENGTH, MIN_LENGTH, MAX_LENGTH, PATTERN) = \
+                  ('equal', 'greater_than', 'greater_or_equal', 'less_than',
+                   'less_or_equal', 'in_range', 'valid_values', 'length',
+                   'min_length', 'max_length', 'pattern')
+
+    def __new__(cls, property_name, property_type, constraint):
+        if cls is not Constraint:
+            return super(Constraint, cls).__new__(cls)
+
+        if(not isinstance(constraint, collections.Mapping) or
+           len(constraint) != 1):
+            ExceptionCollector.appendException(
+                InvalidSchemaError(message=_('Invalid constraint schema.')))
+
+        for type in constraint.keys():
+            ConstraintClass = get_constraint_class(type)
+            if not ConstraintClass:
+                msg = _('Invalid property "%s".') % type
+                ExceptionCollector.appendException(
+                    InvalidSchemaError(message=msg))
+
+        return ConstraintClass(property_name, property_type, constraint)
+
+    def __init__(self, property_name, property_type, constraint):
+        self.property_name = property_name
+        self.property_type = property_type
+        self.constraint_value = constraint[self.constraint_key]
+        self.constraint_value_msg = self.constraint_value
+        if self.property_type in scalarunit.ScalarUnit.SCALAR_UNIT_TYPES:
+            self.constraint_value = self._get_scalarunit_constraint_value()
+        # check if constraint is valid for property type
+        if property_type not in self.valid_prop_types:
+            msg = _('Property "%(ctype)s" is not valid for data type '
+                    '"%(dtype)s".') % dict(
+                        ctype=self.constraint_key,
+                        dtype=property_type)
+            ExceptionCollector.appendException(InvalidSchemaError(message=msg))
+
+    def _get_scalarunit_constraint_value(self):
+        if self.property_type in scalarunit.ScalarUnit.SCALAR_UNIT_TYPES:
+            ScalarUnit_Class = (scalarunit.
+                                get_scalarunit_class(self.property_type))
+        if isinstance(self.constraint_value, list):
+            return [ScalarUnit_Class(v).get_num_from_scalar_unit()
+                    for v in self.constraint_value]
+        else:
+            return (ScalarUnit_Class(self.constraint_value).
+                    get_num_from_scalar_unit())
+
+    def _err_msg(self, value):
+        return _('Property "%s" could not be validated.') % self.property_name
+
+    def validate(self, value):
+        self.value_msg = value
+        if self.property_type in scalarunit.ScalarUnit.SCALAR_UNIT_TYPES:
+            value = scalarunit.get_scalarunit_value(self.property_type, value)
+        if not self._is_valid(value):
+            err_msg = self._err_msg(value)
+            ExceptionCollector.appendException(
+                ValidationError(message=err_msg))
+
+
+class Equal(Constraint):
+    """Constraint class for "equal"
+
+    Constrains a property or parameter to a value equal to ('=')
+    the value declared.
+    """
+
+    constraint_key = Constraint.EQUAL
+
+    valid_prop_types = Schema.PROPERTY_TYPES
+
+    def _is_valid(self, value):
+        if value == self.constraint_value:
+            return True
+
+        return False
+
+    def _err_msg(self, value):
+        return (_('The value "%(pvalue)s" of property "%(pname)s" is not '
+                  'equal to "%(cvalue)s".') %
+                dict(pname=self.property_name,
+                     pvalue=self.value_msg,
+                     cvalue=self.constraint_value_msg))
+
+
+class GreaterThan(Constraint):
+    """Constraint class for "greater_than"
+
+    Constrains a property or parameter to a value greater than ('>')
+    the value declared.
+    """
+
+    constraint_key = Constraint.GREATER_THAN
+
+    valid_types = (int, float, datetime.date,
+                   datetime.time, datetime.datetime)
+
+    valid_prop_types = (Schema.INTEGER, Schema.FLOAT, Schema.TIMESTAMP,
+                        Schema.SCALAR_UNIT_SIZE, Schema.SCALAR_UNIT_FREQUENCY,
+                        Schema.SCALAR_UNIT_TIME)
+
+    def __init__(self, property_name, property_type, constraint):
+        super(GreaterThan, self).__init__(property_name, property_type,
+                                          constraint)
+        if not isinstance(constraint[self.GREATER_THAN], self.valid_types):
+            ExceptionCollector.appendException(
+                InvalidSchemaError(message=_('The property "greater_than" '
+                                             'expects comparable values.')))
+
+    def _is_valid(self, value):
+        if value > self.constraint_value:
+            return True
+
+        return False
+
+    def _err_msg(self, value):
+        return (_('The value "%(pvalue)s" of property "%(pname)s" must be '
+                  'greater than "%(cvalue)s".') %
+                dict(pname=self.property_name,
+                     pvalue=self.value_msg,
+                     cvalue=self.constraint_value_msg))
+
+
+class GreaterOrEqual(Constraint):
+    """Constraint class for "greater_or_equal"
+
+    Constrains a property or parameter to a value greater than or equal
+    to ('>=') the value declared.
+    """
+
+    constraint_key = Constraint.GREATER_OR_EQUAL
+
+    valid_types = (int, float, datetime.date,
+                   datetime.time, datetime.datetime)
+
+    valid_prop_types = (Schema.INTEGER, Schema.FLOAT, Schema.TIMESTAMP,
+                        Schema.SCALAR_UNIT_SIZE, Schema.SCALAR_UNIT_FREQUENCY,
+                        Schema.SCALAR_UNIT_TIME)
+
+    def __init__(self, property_name, property_type, constraint):
+        super(GreaterOrEqual, self).__init__(property_name, property_type,
+                                             constraint)
+        if not isinstance(self.constraint_value, self.valid_types):
+            ExceptionCollector.appendException(
+                InvalidSchemaError(message=_('The property '
+                                             '"greater_or_equal" expects '
+                                             'comparable values.')))
+
+    def _is_valid(self, value):
+        if toscaparser.functions.is_function(value) or \
+           value >= self.constraint_value:
+            return True
+        return False
+
+    def _err_msg(self, value):
+        return (_('The value "%(pvalue)s" of property "%(pname)s" must be '
+                  'greater than or equal to "%(cvalue)s".') %
+                dict(pname=self.property_name,
+                     pvalue=self.value_msg,
+                     cvalue=self.constraint_value_msg))
+
+
+class LessThan(Constraint):
+    """Constraint class for "less_than"
+
+    Constrains a property or parameter to a value less than ('<')
+    the value declared.
+    """
+
+    constraint_key = Constraint.LESS_THAN
+
+    valid_types = (int, float, datetime.date,
+                   datetime.time, datetime.datetime)
+
+    valid_prop_types = (Schema.INTEGER, Schema.FLOAT, Schema.TIMESTAMP,
+                        Schema.SCALAR_UNIT_SIZE, Schema.SCALAR_UNIT_FREQUENCY,
+                        Schema.SCALAR_UNIT_TIME)
+
+    def __init__(self, property_name, property_type, constraint):
+        super(LessThan, self).__init__(property_name, property_type,
+                                       constraint)
+        if not isinstance(self.constraint_value, self.valid_types):
+            ExceptionCollector.appendException(
+                InvalidSchemaError(message=_('The property "less_than" '
+                                             'expects comparable values.')))
+
+    def _is_valid(self, value):
+        if value < self.constraint_value:
+            return True
+
+        return False
+
+    def _err_msg(self, value):
+        return (_('The value "%(pvalue)s" of property "%(pname)s" must be '
+                  'less than "%(cvalue)s".') %
+                dict(pname=self.property_name,
+                     pvalue=self.value_msg,
+                     cvalue=self.constraint_value_msg))
+
+
+class LessOrEqual(Constraint):
+    """Constraint class for "less_or_equal"
+
+    Constrains a property or parameter to a value less than or equal
+    to ('<=') the value declared.
+    """
+
+    constraint_key = Constraint.LESS_OR_EQUAL
+
+    valid_types = (int, float, datetime.date,
+                   datetime.time, datetime.datetime)
+
+    valid_prop_types = (Schema.INTEGER, Schema.FLOAT, Schema.TIMESTAMP,
+                        Schema.SCALAR_UNIT_SIZE, Schema.SCALAR_UNIT_FREQUENCY,
+                        Schema.SCALAR_UNIT_TIME)
+
+    def __init__(self, property_name, property_type, constraint):
+        super(LessOrEqual, self).__init__(property_name, property_type,
+                                          constraint)
+        if not isinstance(self.constraint_value, self.valid_types):
+            ExceptionCollector.appendException(
+                InvalidSchemaError(message=_('The property "less_or_equal" '
+                                             'expects comparable values.')))
+
+    def _is_valid(self, value):
+        if value <= self.constraint_value:
+            return True
+
+        return False
+
+    def _err_msg(self, value):
+        return (_('The value "%(pvalue)s" of property "%(pname)s" must be '
+                  'less than or equal to "%(cvalue)s".') %
+                dict(pname=self.property_name,
+                     pvalue=self.value_msg,
+                     cvalue=self.constraint_value_msg))
+
+
+class InRange(Constraint):
+    """Constraint class for "in_range"
+
+    Constrains a property or parameter to a value in range of (inclusive)
+    the two values declared.
+    """
+    UNBOUNDED = 'UNBOUNDED'
+
+    constraint_key = Constraint.IN_RANGE
+
+    valid_types = (int, float, datetime.date,
+                   datetime.time, datetime.datetime, str)
+
+    valid_prop_types = (Schema.INTEGER, Schema.FLOAT, Schema.TIMESTAMP,
+                        Schema.SCALAR_UNIT_SIZE, Schema.SCALAR_UNIT_FREQUENCY,
+                        Schema.SCALAR_UNIT_TIME, Schema.RANGE)
+
+    def __init__(self, property_name, property_type, constraint):
+        super(InRange, self).__init__(property_name, property_type, constraint)
+        if(not isinstance(self.constraint_value, collections.Sequence) or
+           (len(constraint[self.IN_RANGE]) != 2)):
+            ExceptionCollector.appendException(
+                InvalidSchemaError(message=_('The property "in_range" '
+                                             'expects a list.')))
+
+        msg = _('The property "in_range" expects comparable values.')
+        for value in self.constraint_value:
+            if not isinstance(value, self.valid_types):
+                ExceptionCollector.appendException(
+                    InvalidSchemaError(message=msg))
+            # The only string we allow for range is the special value
+            # 'UNBOUNDED'
+            if(isinstance(value, str) and value != self.UNBOUNDED):
+                ExceptionCollector.appendException(
+                    InvalidSchemaError(message=msg))
+
+        self.min = self.constraint_value[0]
+        self.max = self.constraint_value[1]
+
+    def _is_valid(self, value):
+        if not isinstance(self.min, str):
+            if value < self.min:
+                return False
+        elif self.min != self.UNBOUNDED:
+            return False
+        if not isinstance(self.max, str):
+            if value > self.max:
+                return False
+        elif self.max != self.UNBOUNDED:
+            return False
+        return True
+
+    def _err_msg(self, value):
+        return (_('The value "%(pvalue)s" of property "%(pname)s" is out of '
+                  'range "(min:%(vmin)s, max:%(vmax)s)".') %
+                dict(pname=self.property_name,
+                     pvalue=self.value_msg,
+                     vmin=self.constraint_value_msg[0],
+                     vmax=self.constraint_value_msg[1]))
+
+
+class ValidValues(Constraint):
+    """Constraint class for "valid_values"
+
+    Constrains a property or parameter to a value that is in the list of
+    declared values.
+    """
+    constraint_key = Constraint.VALID_VALUES
+
+    valid_prop_types = Schema.PROPERTY_TYPES
+
+    def __init__(self, property_name, property_type, constraint):
+        super(ValidValues, self).__init__(property_name, property_type,
+                                          constraint)
+        if not isinstance(self.constraint_value, collections.Sequence):
+            ExceptionCollector.appendException(
+                InvalidSchemaError(message=_('The property "valid_values" '
+                                             'expects a list.')))
+
+    def _is_valid(self, value):
+        if isinstance(value, list):
+            return all(v in self.constraint_value for v in value)
+        return value in self.constraint_value
+
+    def _err_msg(self, value):
+        allowed = '[%s]' % ', '.join(str(a) for a in self.constraint_value)
+        return (_('The value "%(pvalue)s" of property "%(pname)s" is not '
+                  'valid. Expected a value from "%(cvalue)s".') %
+                dict(pname=self.property_name,
+                     pvalue=value,
+                     cvalue=allowed))
+
+
+class Length(Constraint):
+    """Constraint class for "length"
+
+    Constrains the property or parameter to a value of a given length.
+    """
+
+    constraint_key = Constraint.LENGTH
+
+    valid_types = (int, )
+
+    valid_prop_types = (Schema.STRING, )
+
+    def __init__(self, property_name, property_type, constraint):
+        super(Length, self).__init__(property_name, property_type, constraint)
+        if not isinstance(self.constraint_value, self.valid_types):
+            ExceptionCollector.appendException(
+                InvalidSchemaError(message=_('The property "length" expects '
+                                             'an integer.')))
+
+    def _is_valid(self, value):
+        if isinstance(value, str) and len(value) == self.constraint_value:
+            return True
+
+        return False
+
+    def _err_msg(self, value):
+        return (_('Length of value "%(pvalue)s" of property "%(pname)s" '
+                  'must be equal to "%(cvalue)s".') %
+                dict(pname=self.property_name,
+                     pvalue=value,
+                     cvalue=self.constraint_value))
+
+
+class MinLength(Constraint):
+    """Constraint class for "min_length"
+
+    Constrains the property or parameter to a value to a minimum length.
+    """
+
+    constraint_key = Constraint.MIN_LENGTH
+
+    valid_types = (int, )
+
+    valid_prop_types = (Schema.STRING, Schema.MAP)
+
+    def __init__(self, property_name, property_type, constraint):
+        super(MinLength, self).__init__(property_name, property_type,
+                                        constraint)
+        if not isinstance(self.constraint_value, self.valid_types):
+            ExceptionCollector.appendException(
+                InvalidSchemaError(message=_('The property "min_length" '
+                                             'expects an integer.')))
+
+    def _is_valid(self, value):
+        if ((isinstance(value, str) or isinstance(value, dict)) and
+           len(value) >= self.constraint_value):
+            return True
+
+        return False
+
+    def _err_msg(self, value):
+        return (_('Length of value "%(pvalue)s" of property "%(pname)s" '
+                  'must be at least "%(cvalue)s".') %
+                dict(pname=self.property_name,
+                     pvalue=value,
+                     cvalue=self.constraint_value))
+
+
+class MaxLength(Constraint):
+    """Constraint class for "max_length"
+
+    Constrains the property or parameter to a value to a maximum length.
+    """
+
+    constraint_key = Constraint.MAX_LENGTH
+
+    valid_types = (int, )
+
+    valid_prop_types = (Schema.STRING, Schema.MAP)
+
+    def __init__(self, property_name, property_type, constraint):
+        super(MaxLength, self).__init__(property_name, property_type,
+                                        constraint)
+        if not isinstance(self.constraint_value, self.valid_types):
+            ExceptionCollector.appendException(
+                InvalidSchemaError(message=_('The property "max_length" '
+                                             'expects an integer.')))
+
+    def _is_valid(self, value):
+        if ((isinstance(value, str) or isinstance(value, dict)) and
+           len(value) <= self.constraint_value):
+            return True
+
+        return False
+
+    def _err_msg(self, value):
+        return (_('Length of value "%(pvalue)s" of property "%(pname)s" '
+                  'must be no greater than "%(cvalue)s".') %
+                dict(pname=self.property_name,
+                     pvalue=value,
+                     cvalue=self.constraint_value))
+
+
+class Pattern(Constraint):
+    """Constraint class for "pattern"
+
+    Constrains the property or parameter to a value that is allowed by
+    the provided regular expression.
+    """
+
+    constraint_key = Constraint.PATTERN
+
+    valid_types = (str, )
+
+    valid_prop_types = (Schema.STRING, )
+
+    def __init__(self, property_name, property_type, constraint):
+        super(Pattern, self).__init__(property_name, property_type, constraint)
+        if not isinstance(self.constraint_value, self.valid_types):
+            ExceptionCollector.appendException(
+                InvalidSchemaError(message=_('The property "pattern" '
+                                             'expects a string.')))
+        self.match = re.compile(self.constraint_value).match
+
+    def _is_valid(self, value):
+        match = self.match(value)
+        return match is not None and match.end() == len(value)
+
+    def _err_msg(self, value):
+        return (_('The value "%(pvalue)s" of property "%(pname)s" does not '
+                  'match pattern "%(cvalue)s".') %
+                dict(pname=self.property_name,
+                     pvalue=value,
+                     cvalue=self.constraint_value))
+
+
+constraint_mapping = {
+    Constraint.EQUAL: Equal,
+    Constraint.GREATER_THAN: GreaterThan,
+    Constraint.GREATER_OR_EQUAL: GreaterOrEqual,
+    Constraint.LESS_THAN: LessThan,
+    Constraint.LESS_OR_EQUAL: LessOrEqual,
+    Constraint.IN_RANGE: InRange,
+    Constraint.VALID_VALUES: ValidValues,
+    Constraint.LENGTH: Length,
+    Constraint.MIN_LENGTH: MinLength,
+    Constraint.MAX_LENGTH: MaxLength,
+    Constraint.PATTERN: Pattern
+    }
+
+
+def get_constraint_class(type):
+    return constraint_mapping.get(type)
diff --git a/nfvparser/toscaparser/elements/datatype.py b/nfvparser/toscaparser/elements/datatype.py
new file mode 100644
index 0000000..93d1b3a
--- /dev/null
+++ b/nfvparser/toscaparser/elements/datatype.py
@@ -0,0 +1,57 @@
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+
+from toscaparser.elements.statefulentitytype import StatefulEntityType
+
+
+class DataType(StatefulEntityType):
+    '''TOSCA built-in and user defined complex data type.'''
+
+    def __init__(self, datatypename, custom_def=None):
+        super(DataType, self).__init__(datatypename,
+                                       self.DATATYPE_NETWORK_PREFIX,
+                                       custom_def)
+        self.custom_def = custom_def
+
+    @property
+    def parent_type(self):
+        '''Return a datatype this datatype is derived from.'''
+        ptype = self.derived_from(self.defs)
+        if ptype:
+            return DataType(ptype, self.custom_def)
+        return None
+
+    @property
+    def value_type(self):
+        '''Return 'type' section in the datatype schema.'''
+        return self.entity_value(self.defs, 'type')
+
+    def get_all_properties_objects(self):
+        '''Return all properties objects defined in type and parent type.'''
+        props_def = self.get_properties_def_objects()
+        ptype = self.parent_type
+        while ptype:
+            props_def.extend(ptype.get_properties_def_objects())
+            ptype = ptype.parent_type
+        return props_def
+
+    def get_all_properties(self):
+        '''Return a dictionary of all property definition name-object pairs.'''
+        return {prop.name: prop
+                for prop in self.get_all_properties_objects()}
+
+    def get_all_property_value(self, name):
+        '''Return the value of a given property name.'''
+        props_def = self.get_all_properties()
+        if props_def and name in props_def.key():
+            return props_def[name].value
diff --git a/nfvparser/toscaparser/elements/entity_type.py b/nfvparser/toscaparser/elements/entity_type.py
new file mode 100644
index 0000000..9fd6c4d
--- /dev/null
+++ b/nfvparser/toscaparser/elements/entity_type.py
@@ -0,0 +1,170 @@
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+import copy
+import logging
+import os
+from toscaparser.common.exception import ExceptionCollector
+from toscaparser.common.exception import ValidationError
+from toscaparser.extensions.exttools import ExtTools
+import toscaparser.utils.yamlparser
+
+log = logging.getLogger('tosca')
+
+
+class EntityType(object):
+    '''Base class for TOSCA elements.'''
+
+    SECTIONS = (DERIVED_FROM, PROPERTIES, ATTRIBUTES, REQUIREMENTS,
+                INTERFACES, CAPABILITIES, TYPE, ARTIFACTS) = \
+               ('derived_from', 'properties', 'attributes', 'requirements',
+                'interfaces', 'capabilities', 'type', 'artifacts')
+
+    TOSCA_DEF_SECTIONS = ['node_types', 'data_types', 'artifact_types',
+                          'group_types', 'relationship_types',
+                          'capability_types', 'interface_types',
+                          'policy_types']
+
+    '''TOSCA definition file.'''
+    TOSCA_DEF_FILE = os.path.join(
+        os.path.dirname(os.path.abspath(__file__)),
+        "TOSCA_definition_1_0.yaml")
+
+    loader = toscaparser.utils.yamlparser.load_yaml
+
+    TOSCA_DEF_LOAD_AS_IS = loader(TOSCA_DEF_FILE)
+
+    # Map of definition with pre-loaded values of TOSCA_DEF_FILE_SECTIONS
+    TOSCA_DEF = {}
+    for section in TOSCA_DEF_SECTIONS:
+        if section in TOSCA_DEF_LOAD_AS_IS.keys():
+            value = TOSCA_DEF_LOAD_AS_IS[section]
+            for key in value.keys():
+                TOSCA_DEF[key] = value[key]
+
+    RELATIONSHIP_TYPE = (DEPENDSON, HOSTEDON, CONNECTSTO, ATTACHESTO,
+                         LINKSTO, BINDSTO) = \
+                        ('tosca.relationships.DependsOn',
+                         'tosca.relationships.HostedOn',
+                         'tosca.relationships.ConnectsTo',
+                         'tosca.relationships.AttachesTo',
+                         'tosca.relationships.network.LinksTo',
+                         'tosca.relationships.network.BindsTo')
+
+    NODE_PREFIX = 'tosca.nodes.'
+    RELATIONSHIP_PREFIX = 'tosca.relationships.'
+    CAPABILITY_PREFIX = 'tosca.capabilities.'
+    INTERFACE_PREFIX = 'tosca.interfaces.'
+    ARTIFACT_PREFIX = 'tosca.artifacts.'
+    POLICY_PREFIX = 'tosca.policies.'
+    GROUP_PREFIX = 'tosca.groups.'
+    # currently the data types are defined only for network
+    # but may have changes in the future.
+    DATATYPE_PREFIX = 'tosca.datatypes.'
+    DATATYPE_NETWORK_PREFIX = DATATYPE_PREFIX + 'network.'
+    TOSCA = 'tosca'
+
+    def derived_from(self, defs):
+        '''Return a type this type is derived from.'''
+        return self.entity_value(defs, 'derived_from')
+
+    def is_derived_from(self, type_str):
+        '''Check if object inherits from the given type.
+
+        Returns true if this object is derived from 'type_str'.
+        False otherwise.
+        '''
+        if not self.type:
+            return False
+        elif self.type == type_str:
+            return True
+        elif self.parent_type:
+            return self.parent_type.is_derived_from(type_str)
+        else:
+            return False
+
+    def entity_value(self, defs, key):
+        if defs and key in defs:
+            return defs[key]
+
+    def get_value(self, ndtype, defs=None, parent=None):
+        value = None
+        if defs is None:
+            if not hasattr(self, 'defs'):
+                return None
+            defs = self.defs
+        if defs and ndtype in defs:
+            # copy the value to avoid that next operations add items in the
+            # item definitions
+            value = copy.copy(defs[ndtype])
+        if parent:
+            p = self
+            if p:
+                while p:
+                    if p.defs and ndtype in p.defs:
+                        # get the parent value
+                        parent_value = p.defs[ndtype]
+                        if value:
+                            if isinstance(value, dict):
+                                for k, v in parent_value.items():
+                                    if k not in value.keys():
+                                        value[k] = v
+                            if isinstance(value, list):
+                                for p_value in parent_value:
+                                    if isinstance(p_value, dict):
+                                        if list(p_value.keys())[0] not in [
+                                            list(item.keys())[0] for item in
+                                            value]:
+                                            value.append(p_value)
+                                    else:
+                                        if p_value not in value:
+                                            value.append(p_value)
+                        else:
+                            value = copy.copy(parent_value)
+                    p = p.parent_type
+        return value
+
+    def get_definition(self, ndtype):
+        value = None
+        if not hasattr(self, 'defs'):
+            defs = None
+            ExceptionCollector.appendException(
+                ValidationError(message="defs is " + str(defs)))
+        else:
+            defs = self.defs
+        if defs is not None and ndtype in defs:
+            value = defs[ndtype]
+        p = self.parent_type
+        if p:
+            inherited = p.get_definition(ndtype)
+            if inherited:
+                inherited = dict(inherited)
+                if not value:
+                    value = inherited
+                else:
+                    inherited.update(value)
+                    value.update(inherited)
+        return value
+
+
+def update_definitions(version):
+    exttools = ExtTools()
+    extension_defs_file = exttools.get_defs_file(version)
+    loader = toscaparser.utils.yamlparser.load_yaml
+    nfv_def_file = loader(extension_defs_file)
+    nfv_def = {}
+    for section in EntityType.TOSCA_DEF_SECTIONS:
+        if section in nfv_def_file.keys():
+            value = nfv_def_file[section]
+            for key in value.keys():
+                nfv_def[key] = value[key]
+    EntityType.TOSCA_DEF.update(nfv_def)
diff --git a/nfvparser/toscaparser/elements/grouptype.py b/nfvparser/toscaparser/elements/grouptype.py
new file mode 100644
index 0000000..4e58d64
--- /dev/null
+++ b/nfvparser/toscaparser/elements/grouptype.py
@@ -0,0 +1,95 @@
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+
+from toscaparser.common.exception import ExceptionCollector
+from toscaparser.common.exception import InvalidTypeError
+from toscaparser.common.exception import UnknownFieldError
+from toscaparser.elements.statefulentitytype import StatefulEntityType
+
+
+class GroupType(StatefulEntityType):
+    '''TOSCA built-in group type.'''
+
+    SECTIONS = (DERIVED_FROM, VERSION, METADATA, DESCRIPTION, PROPERTIES,
+                MEMBERS, INTERFACES) = \
+               ("derived_from", "version", "metadata", "description",
+                "properties", "members", "interfaces")
+
+    def __init__(self, grouptype, custom_def=None):
+        super(GroupType, self).__init__(grouptype, self.GROUP_PREFIX,
+                                        custom_def)
+        self.custom_def = custom_def
+        self.grouptype = grouptype
+        self._validate_fields()
+        self.group_description = None
+        if self.DESCRIPTION in self.defs:
+            self.group_description = self.defs[self.DESCRIPTION]
+
+        self.group_version = None
+        if self.VERSION in self.defs:
+            self.group_version = self.defs[self.VERSION]
+
+        self.group_properties = None
+        if self.PROPERTIES in self.defs:
+            self.group_properties = self.defs[self.PROPERTIES]
+
+        self.group_members = None
+        if self.MEMBERS in self.defs:
+            self.group_members = self.defs[self.MEMBERS]
+
+        if self.METADATA in self.defs:
+            self.meta_data = self.defs[self.METADATA]
+            self._validate_metadata(self.meta_data)
+
+    @property
+    def parent_type(self):
+        '''Return a group statefulentity of this entity is derived from.'''
+        if not hasattr(self, 'defs'):
+            return None
+        pgroup_entity = self.derived_from(self.defs)
+        if pgroup_entity:
+            return GroupType(pgroup_entity, self.custom_def)
+
+    @property
+    def description(self):
+        return self.group_description
+
+    @property
+    def version(self):
+        return self.group_version
+
+    @property
+    def interfaces(self):
+        return self.get_value(self.INTERFACES)
+
+    def _validate_fields(self):
+        if self.defs:
+            for name in self.defs.keys():
+                if name not in self.SECTIONS:
+                    ExceptionCollector.appendException(
+                        UnknownFieldError(what='Group Type %s'
+                                          % self.grouptype, field=name))
+
+    def _validate_metadata(self, meta_data):
+        if not meta_data.get('type') in ['map', 'tosca:map']:
+            ExceptionCollector.appendException(
+                InvalidTypeError(what='"%s" defined in group for '
+                                 'metadata' % (meta_data.get('type'))))
+        for entry_schema, entry_schema_type in meta_data.items():
+            if isinstance(entry_schema_type, dict) and not \
+                    entry_schema_type.get('type') == 'string':
+                ExceptionCollector.appendException(
+                    InvalidTypeError(what='"%s" defined in group for '
+                                     'metadata "%s"'
+                                     % (entry_schema_type.get('type'),
+                                        entry_schema)))
diff --git a/nfvparser/toscaparser/elements/interfaces.py b/nfvparser/toscaparser/elements/interfaces.py
new file mode 100644
index 0000000..47ec90a
--- /dev/null
+++ b/nfvparser/toscaparser/elements/interfaces.py
@@ -0,0 +1,87 @@
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+from toscaparser.common.exception import ExceptionCollector
+from toscaparser.common.exception import UnknownFieldError
+from toscaparser.elements.statefulentitytype import StatefulEntityType
+
+SECTIONS = (LIFECYCLE, CONFIGURE, LIFECYCLE_SHORTNAME,
+            CONFIGURE_SHORTNAME) = \
+           ('tosca.interfaces.node.lifecycle.Standard',
+            'tosca.interfaces.relationship.Configure',
+            'Standard', 'Configure')
+
+INTERFACEVALUE = (IMPLEMENTATION, INPUTS) = ('implementation', 'inputs')
+
+INTERFACE_DEF_RESERVED_WORDS = ['type', 'inputs', 'derived_from', 'version',
+                                'description']
+
+
+class InterfacesDef(StatefulEntityType):
+    '''TOSCA built-in interfaces type.'''
+
+    def __init__(self, node_type, interfacetype,
+                 node_template=None, name=None, value=None):
+        self.ntype = node_type
+        self.node_template = node_template
+        self.type = interfacetype
+        self.name = name
+        self.value = value
+        self.implementation = None
+        self.inputs = None
+        self.defs = {}
+        if interfacetype == LIFECYCLE_SHORTNAME:
+            interfacetype = LIFECYCLE
+        if interfacetype == CONFIGURE_SHORTNAME:
+            interfacetype = CONFIGURE
+        if hasattr(self.ntype, 'interfaces') \
+           and self.ntype.interfaces \
+           and interfacetype in self.ntype.interfaces:
+            interfacetype = self.ntype.interfaces[interfacetype]['type']
+        if node_type:
+            if self.node_template and self.node_template.custom_def \
+               and interfacetype in self.node_template.custom_def:
+                self.defs = self.node_template.custom_def[interfacetype]
+            else:
+                self.defs = self.TOSCA_DEF[interfacetype]
+        if value:
+            if isinstance(self.value, dict):
+                for i, j in self.value.items():
+                    if i == IMPLEMENTATION:
+                        self.implementation = j
+                    elif i == INPUTS:
+                        self.inputs = j
+                    else:
+                        what = ('"interfaces" of template "%s"' %
+                                self.node_template.name)
+                        ExceptionCollector.appendException(
+                            UnknownFieldError(what=what, field=i))
+            else:
+                self.implementation = value
+
+    @property
+    def lifecycle_ops(self):
+        if self.defs:
+            if self.type == LIFECYCLE:
+                return self._ops()
+
+    @property
+    def configure_ops(self):
+        if self.defs:
+            if self.type == CONFIGURE:
+                return self._ops()
+
+    def _ops(self):
+        ops = []
+        for name in list(self.defs.keys()):
+            ops.append(name)
+        return ops
diff --git a/nfvparser/toscaparser/elements/nodetype.py b/nfvparser/toscaparser/elements/nodetype.py
new file mode 100644
index 0000000..7f3da2d
--- /dev/null
+++ b/nfvparser/toscaparser/elements/nodetype.py
@@ -0,0 +1,213 @@
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+from toscaparser.common.exception import ExceptionCollector
+from toscaparser.common.exception import UnknownFieldError
+from toscaparser.elements.capabilitytype import CapabilityTypeDef
+import toscaparser.elements.interfaces as ifaces
+from toscaparser.elements.interfaces import InterfacesDef
+from toscaparser.elements.relationshiptype import RelationshipType
+from toscaparser.elements.statefulentitytype import StatefulEntityType
+
+
+class NodeType(StatefulEntityType):
+    '''TOSCA built-in node type.'''
+    SECTIONS = (DERIVED_FROM, METADATA, PROPERTIES, VERSION, DESCRIPTION, ATTRIBUTES, REQUIREMENTS, CAPABILITIES, INTERFACES, ARTIFACTS) = \
+               ('derived_from', 'metadata', 'properties', 'version',
+                'description', 'attributes', 'requirements', 'capabilities',
+                'interfaces', 'artifacts')
+
+    def __init__(self, ntype, custom_def=None):
+        super(NodeType, self).__init__(ntype, self.NODE_PREFIX, custom_def)
+        self.ntype = ntype
+        self.custom_def = custom_def
+        self._validate_keys()
+
+    @property
+    def parent_type(self):
+        '''Return a node this node is derived from.'''
+        if not hasattr(self, 'defs'):
+            return None
+        pnode = self.derived_from(self.defs)
+        if pnode:
+            return NodeType(pnode, self.custom_def)
+
+    @property
+    def relationship(self):
+        '''Return a dictionary of relationships to other node types.
+
+        This method returns a dictionary of named relationships that nodes
+        of the current node type (self) can have to other nodes (of specific
+        types) in a TOSCA template.
+
+        '''
+        relationship = {}
+        requires = self.get_all_requirements()
+        if requires:
+            # NOTE(sdmonov): Check if requires is a dict.
+            # If it is a dict convert it to a list of dicts.
+            # This is needed because currently the code below supports only
+            # lists as requirements definition. The following check will
+            # make sure if a map (dict) was provided it will be converted to
+            # a list before proceeding to the parsing.
+            if isinstance(requires, dict):
+                requires = [{key: value} for key, value in requires.items()]
+
+            keyword = None
+            node_type = None
+            for require in requires:
+                for key, req in require.items():
+                    if 'relationship' in req:
+                        relation = req.get('relationship')
+                        if 'type' in relation:
+                            relation = relation.get('type')
+                        node_type = req.get('node')
+                        value = req
+                        if node_type:
+                            keyword = 'node'
+                        else:
+                            # If value is a dict and has a type key
+                            # we need to lookup the node type using
+                            # the capability type
+                            value = req
+                            if isinstance(value, dict):
+                                captype = value['capability']
+                                value = (self.
+                                         _get_node_type_by_cap(captype))
+                            #            _get_node_type_by_cap(key, captype))
+                            # relation = self._get_relation(key, value)
+                            keyword = key
+                            node_type = value
+                rtype = RelationshipType(relation, keyword, self.custom_def)
+                relatednode = NodeType(node_type, self.custom_def)
+                relationship[rtype] = relatednode
+        return relationship
+
+    def _get_node_type_by_cap(self, cap):
+        '''Find the node type that has the provided capability
+
+        This method will lookup all node types if they have the
+        provided capability.
+        '''
+
+        # Filter the node types
+        node_types = [node_type for node_type in self.TOSCA_DEF.keys()
+                      if node_type.startswith(self.NODE_PREFIX) and
+                      node_type != 'tosca.nodes.Root']
+        custom_node_types = [node_type for node_type in self.custom_def.keys()
+                             if node_type.startswith(self.NODE_PREFIX) and
+                             node_type != 'tosca.nodes.Root']
+
+        for node_type in node_types + custom_node_types:
+            if node_type in self.TOSCA_DEF:
+                node_def = self.TOSCA_DEF[node_type]
+            else:
+                node_def = self.custom_def[node_type]
+            if isinstance(node_def, dict) and 'capabilities' in node_def:
+                node_caps = node_def['capabilities']
+                for value in node_caps.values():
+                    if isinstance(value, dict) and \
+                            'type' in value and value['type'] == cap:
+                        return node_type
+
+    def _get_relation(self, key, ndtype):
+        relation = None
+        ntype = NodeType(ndtype, self.custom_def)
+        caps = ntype.get_capabilities()
+        if caps and key in caps.keys():
+            c = caps[key]
+            for r in self.RELATIONSHIP_TYPE:
+                rtypedef = ntype.TOSCA_DEF[r]
+                for properties in rtypedef.values():
+                    if c.type in properties:
+                        relation = r
+                        break
+                if relation:
+                    break
+                else:
+                    for properties in rtypedef.values():
+                        if c.parent_type in properties:
+                            relation = r
+                            break
+        return relation
+
+    def get_capabilities_objects(self):
+        '''Return a list of capability objects.'''
+        typecapabilities = []
+        caps = self.get_value(self.CAPABILITIES, None, True)
+        if caps:
+            # 'name' is symbolic name of the capability
+            # 'value' is a dict { 'type': <capability type name> }
+            for name, value in caps.items():
+                ctype = value.get('type')
+                cap = CapabilityTypeDef(name, ctype, self.type,
+                                        self.custom_def)
+                typecapabilities.append(cap)
+        return typecapabilities
+
+    def get_capabilities(self):
+        '''Return a dictionary of capability name-objects pairs.'''
+        return {cap.name: cap
+                for cap in self.get_capabilities_objects()}
+
+    @property
+    def requirements(self):
+        return self.get_value(self.REQUIREMENTS, None, True)
+
+    def get_all_requirements(self):
+        return self.requirements
+
+    @property
+    def interfaces(self):
+        return self.get_value(self.INTERFACES)
+
+    @property
+    def lifecycle_inputs(self):
+        '''Return inputs to life cycle operations if found.'''
+        inputs = []
+        interfaces = self.interfaces
+        if interfaces:
+            for name, value in interfaces.items():
+                if name == ifaces.LIFECYCLE:
+                    for x, y in value.items():
+                        if x == 'inputs':
+                            for i in y.iterkeys():
+                                inputs.append(i)
+        return inputs
+
+    @property
+    def lifecycle_operations(self):
+        '''Return available life cycle operations if found.'''
+        ops = None
+        interfaces = self.interfaces
+        if interfaces:
+            i = InterfacesDef(self.type, ifaces.LIFECYCLE)
+            ops = i.lifecycle_ops
+        return ops
+
+    def get_capability(self, name):
+        caps = self.get_capabilities()
+        if caps and name in caps.keys():
+            return caps[name].value
+
+    def get_capability_type(self, name):
+        captype = self.get_capability(name)
+        if captype and name in captype.keys():
+            return captype[name].value
+
+    def _validate_keys(self):
+        if self.defs:
+            for key in self.defs.keys():
+                if key not in self.SECTIONS:
+                    ExceptionCollector.appendException(
+                        UnknownFieldError(what='Nodetype"%s"' % self.ntype,
+                                          field=key))
diff --git a/nfvparser/toscaparser/elements/policytype.py b/nfvparser/toscaparser/elements/policytype.py
new file mode 100644
index 0000000..a922d26
--- /dev/null
+++ b/nfvparser/toscaparser/elements/policytype.py
@@ -0,0 +1,121 @@
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+from toscaparser.common.exception import ExceptionCollector
+from toscaparser.common.exception import InvalidTypeError
+from toscaparser.common.exception import UnknownFieldError
+from toscaparser.elements.statefulentitytype import StatefulEntityType
+from toscaparser.utils.validateutils import TOSCAVersionProperty
+
+
+class PolicyType(StatefulEntityType):
+
+    '''TOSCA built-in policies type.'''
+    SECTIONS = (DERIVED_FROM, METADATA, PROPERTIES, VERSION, DESCRIPTION,
+                TARGETS, TRIGGERS, TYPE) = \
+               ('derived_from', 'metadata', 'properties', 'version',
+                'description', 'targets', 'triggers', 'type')
+
+    def __init__(self, ptype, custom_def=None):
+        super(PolicyType, self).__init__(ptype, self.POLICY_PREFIX,
+                                         custom_def)
+        self.type = ptype
+        self.custom_def = custom_def
+        self._validate_keys()
+
+        self.meta_data = None
+        if self.METADATA in self.defs:
+            self.meta_data = self.defs[self.METADATA]
+            self._validate_metadata(self.meta_data)
+
+        self.properties = None
+        if self.PROPERTIES in self.defs:
+            self.properties = self.defs[self.PROPERTIES]
+        self.parent_policies = self._get_parent_policies()
+
+        self.policy_version = None
+        if self.VERSION in self.defs:
+            self.policy_version = TOSCAVersionProperty(
+                self.defs[self.VERSION]).get_version()
+
+        self.policy_description = self.defs[self.DESCRIPTION] \
+            if self.DESCRIPTION in self.defs else None
+
+        self.targets_list = None
+        if self.TARGETS in self.defs:
+            self.targets_list = self.defs[self.TARGETS]
+            self._validate_targets(self.targets_list, custom_def)
+
+    def _get_parent_policies(self):
+        policies = {}
+        parent_policy = self.parent_type.type if self.parent_type else None
+        if parent_policy:
+            while parent_policy != 'tosca.policies.Root':
+                policies[parent_policy] = self.TOSCA_DEF[parent_policy]
+                parent_policy = policies[parent_policy]['derived_from']
+        return policies
+
+    @property
+    def parent_type(self):
+        '''Return a policy statefulentity of this node is derived from.'''
+        if not hasattr(self, 'defs'):
+            return None
+        ppolicy_entity = self.derived_from(self.defs)
+        if ppolicy_entity:
+            return PolicyType(ppolicy_entity, self.custom_def)
+
+    def get_policy(self, name):
+        '''Return the definition of a policy field by name.'''
+        if name in self.defs:
+            return self.defs[name]
+
+    @property
+    def targets(self):
+        '''Return targets.'''
+        return self.targets_list
+
+    @property
+    def description(self):
+        return self.policy_description
+
+    @property
+    def version(self):
+        return self.policy_version
+
+    def _validate_keys(self):
+        for key in self.defs.keys():
+            if key not in self.SECTIONS:
+                ExceptionCollector.appendException(
+                    UnknownFieldError(what='Policy "%s"' % self.type,
+                                      field=key))
+
+    def _validate_targets(self, targets_list, custom_def):
+        for nodetype in targets_list:
+            if nodetype not in custom_def:
+                ExceptionCollector.appendException(
+                    InvalidTypeError(what='"%s" defined in targets for '
+                                     'policy "%s"' % (nodetype, self.type)))
+
+    def _validate_metadata(self, meta_data):
+        if not meta_data.get('type') in ['map', 'tosca:map']:
+            ExceptionCollector.appendException(
+                InvalidTypeError(what='"%s" defined in policy for '
+                                 'metadata' % (meta_data.get('type'))))
+
+        for entry_schema, entry_schema_type in meta_data.items():
+            if isinstance(entry_schema_type, dict) and not \
+                entry_schema_type.get('type') == 'string':
+                ExceptionCollector.appendException(
+                    InvalidTypeError(what='"%s" defined in policy for '
+                                     'metadata "%s"'
+                                     % (entry_schema_type.get('type'),
+                                        entry_schema)))
diff --git a/nfvparser/toscaparser/elements/portspectype.py b/nfvparser/toscaparser/elements/portspectype.py
new file mode 100644
index 0000000..0218305
--- /dev/null
+++ b/nfvparser/toscaparser/elements/portspectype.py
@@ -0,0 +1,86 @@
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+import logging
+
+from toscaparser.common.exception import ExceptionCollector
+from toscaparser.common.exception import InvalidTypeAdditionalRequirementsError
+from toscaparser.utils.gettextutils import _
+import toscaparser.utils.validateutils as validateutils
+
+log = logging.getLogger('tosca')
+
+
+class PortSpec(object):
+    '''Parent class for tosca.datatypes.network.PortSpec type.'''
+
+    SHORTNAME = 'PortSpec'
+    TYPE_URI = 'tosca.datatypes.network.' + SHORTNAME
+
+    PROPERTY_NAMES = (
+        PROTOCOL, SOURCE, SOURCE_RANGE,
+        TARGET, TARGET_RANGE
+    ) = (
+        'protocol', 'source', 'source_range',
+        'target', 'target_range'
+    )
+
+    # TODO(TBD) May want to make this a subclass of DataType
+    # and change init method to set PortSpec's properties
+    def __init__(self):
+        pass
+
+    # The following additional requirements MUST be tested:
+    # 1) A valid PortSpec MUST have at least one of the following properties:
+    #   target, target_range, source or source_range.
+    # 2) A valid PortSpec MUST have a value for the source property that
+    #    is within the numeric range specified by the property source_range
+    #    when source_range is specified.
+    # 3) A valid PortSpec MUST have a value for the target property that is
+    #    within the numeric range specified by the property target_range
+    #    when target_range is specified.
+    @staticmethod
+    def validate_additional_req(properties, prop_name, custom_def=None, ):
+        try:
+            source = properties.get(PortSpec.SOURCE)
+            source_range = properties.get(PortSpec.SOURCE_RANGE)
+            target = properties.get(PortSpec.TARGET)
+            target_range = properties.get(PortSpec.TARGET_RANGE)
+
+            # verify one of the specified values is set
+            if source is None and source_range is None and \
+                    target is None and target_range is None:
+                ExceptionCollector.appendException(
+                    InvalidTypeAdditionalRequirementsError(
+                        type=PortSpec.TYPE_URI))
+            # Validate source value is in specified range
+            if source and source_range:
+                validateutils.validate_value_in_range(source, source_range,
+                                                      PortSpec.SOURCE)
+            else:
+                from toscaparser.dataentity import DataEntity
+                portdef = DataEntity('PortDef', source, None, PortSpec.SOURCE)
+                portdef.validate()
+            # Validate target value is in specified range
+            if target and target_range:
+                validateutils.validate_value_in_range(target, target_range,
+                                                      PortSpec.TARGET)
+            else:
+                from toscaparser.dataentity import DataEntity
+                portdef = DataEntity('PortDef', source, None, PortSpec.TARGET)
+                portdef.validate()
+        except Exception:
+            msg = _('"%(value)s" do not meet requirements '
+                    'for type "%(type)s".') \
+                % {'value': properties, 'type': PortSpec.SHORTNAME}
+            ExceptionCollector.appendException(
+                ValueError(msg))
diff --git a/nfvparser/toscaparser/elements/property_definition.py b/nfvparser/toscaparser/elements/property_definition.py
new file mode 100644
index 0000000..a242ddf
--- /dev/null
+++ b/nfvparser/toscaparser/elements/property_definition.py
@@ -0,0 +1,100 @@
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+from toscaparser.common.exception import ExceptionCollector
+from toscaparser.common.exception import InvalidSchemaError
+from toscaparser.common.exception import TOSCAException
+from toscaparser.utils.gettextutils import _
+
+
+class PropertyDef(object):
+    '''TOSCA built-in Property type.'''
+
+    VALID_PROPERTY_KEYNAMES = (PROPERTY_KEYNAME_DEFAULT,
+                               PROPERTY_KEYNAME_REQUIRED,
+                               PROPERTY_KEYNAME_STATUS) = \
+        ('default', 'required', 'status')
+
+    PROPERTY_REQUIRED_DEFAULT = True
+
+    VALID_REQUIRED_VALUES = ['true', 'false']
+    VALID_STATUS_VALUES = (PROPERTY_STATUS_SUPPORTED,
+                           PROPERTY_STATUS_EXPERIMENTAL) = \
+        ('supported', 'experimental')
+
+    PROPERTY_STATUS_DEFAULT = PROPERTY_STATUS_SUPPORTED
+
+    def __init__(self, name, value=None, schema=None):
+        self.name = name
+        self.value = value
+        self.schema = schema
+        self._status = self.PROPERTY_STATUS_DEFAULT
+        self._required = self.PROPERTY_REQUIRED_DEFAULT
+
+        # Validate required 'type' property exists
+        try:
+            self.schema['type']
+        except KeyError:
+            msg = (_('Schema definition of "%(pname)s" must have a "type" '
+                     'attribute.') % dict(pname=self.name))
+            ExceptionCollector.appendException(
+                InvalidSchemaError(message=msg))
+
+        if self.schema:
+            self._load_required_attr_from_schema()
+            self._load_status_attr_from_schema()
+
+    @property
+    def default(self):
+        if self.schema:
+            for prop_key, prop_value in self.schema.items():
+                if prop_key == self.PROPERTY_KEYNAME_DEFAULT:
+                    return prop_value
+        return None
+
+    @property
+    def required(self):
+        return self._required
+
+    def _load_required_attr_from_schema(self):
+        # IF 'required' keyname exists verify it's a boolean,
+        # if so override default
+        if self.PROPERTY_KEYNAME_REQUIRED in self.schema:
+            value = self.schema[self.PROPERTY_KEYNAME_REQUIRED]
+            if isinstance(value, bool):
+                self._required = value
+            else:
+                valid_values = ', '.join(self.VALID_REQUIRED_VALUES)
+                attr = self.PROPERTY_KEYNAME_REQUIRED
+                TOSCAException.generate_inv_schema_property_error(self,
+                                                                  attr,
+                                                                  value,
+                                                                  valid_values)
+
+    @property
+    def status(self):
+        return self._status
+
+    def _load_status_attr_from_schema(self):
+        # IF 'status' keyname exists verify it's a valid value,
+        # if so override default
+        if self.PROPERTY_KEYNAME_STATUS in self.schema:
+            value = self.schema[self.PROPERTY_KEYNAME_STATUS]
+            if value in self.VALID_STATUS_VALUES:
+                self._status = value
+            else:
+                valid_values = ', '.join(self.VALID_STATUS_VALUES)
+                attr = self.PROPERTY_KEYNAME_STATUS
+                TOSCAException.generate_inv_schema_property_error(self,
+                                                                  attr,
+                                                                  value,
+                                                                  valid_values)
diff --git a/nfvparser/toscaparser/elements/relationshiptype.py b/nfvparser/toscaparser/elements/relationshiptype.py
new file mode 100644
index 0000000..8eefbea
--- /dev/null
+++ b/nfvparser/toscaparser/elements/relationshiptype.py
@@ -0,0 +1,49 @@
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+from toscaparser.common.exception import ExceptionCollector
+from toscaparser.common.exception import UnknownFieldError
+from toscaparser.elements.statefulentitytype import StatefulEntityType
+
+
+class RelationshipType(StatefulEntityType):
+    '''TOSCA built-in relationship type.'''
+    SECTIONS = (DERIVED_FROM, VALID_TARGET_TYPES, INTERFACES,
+                ATTRIBUTES, PROPERTIES, DESCRIPTION, VERSION,
+                CREDENTIAL) = ('derived_from', 'valid_target_types',
+                               'interfaces', 'attributes', 'properties',
+                               'description', 'version', 'credential')
+
+    def __init__(self, type, capability_name=None, custom_def=None):
+        super(RelationshipType, self).__init__(type, self.RELATIONSHIP_PREFIX,
+                                               custom_def)
+        self.capability_name = capability_name
+        self.custom_def = custom_def
+        self._validate_keys()
+
+    @property
+    def parent_type(self):
+        '''Return a relationship this reletionship is derived from.'''
+        prel = self.derived_from(self.defs)
+        if prel:
+            return RelationshipType(prel, self.custom_def)
+
+    @property
+    def valid_target_types(self):
+        return self.entity_value(self.defs, 'valid_target_types')
+
+    def _validate_keys(self):
+        for key in self.defs.keys():
+            if key not in self.SECTIONS:
+                ExceptionCollector.appendException(
+                    UnknownFieldError(what='Relationshiptype "%s"' % self.type,
+                                      field=key))
diff --git a/nfvparser/toscaparser/elements/scalarunit.py b/nfvparser/toscaparser/elements/scalarunit.py
new file mode 100644
index 0000000..d7f72e6
--- /dev/null
+++ b/nfvparser/toscaparser/elements/scalarunit.py
@@ -0,0 +1,129 @@
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+import logging
+import re
+
+from toscaparser.common.exception import ExceptionCollector
+from toscaparser.utils.gettextutils import _
+from toscaparser.utils import validateutils
+
+log = logging.getLogger('tosca')
+
+
+class ScalarUnit(object):
+    '''Parent class for scalar-unit type.'''
+
+    SCALAR_UNIT_TYPES = (
+        SCALAR_UNIT_SIZE, SCALAR_UNIT_FREQUENCY, SCALAR_UNIT_TIME
+    ) = (
+        'scalar-unit.size', 'scalar-unit.frequency', 'scalar-unit.time'
+    )
+
+    def __init__(self, value):
+        self.value = value
+
+    def _check_unit_in_scalar_standard_units(self, input_unit):
+        """Check whether the input unit is following specified standard
+
+        If unit is not following specified standard, convert it to standard
+        unit after displaying a warning message.
+        """
+        if input_unit in self.SCALAR_UNIT_DICT.keys():
+            return input_unit
+        else:
+            for key in self.SCALAR_UNIT_DICT.keys():
+                if key.upper() == input_unit.upper():
+                    log.warning(_('The unit "%(unit)s" does not follow '
+                                  'scalar unit standards; using "%(key)s" '
+                                  'instead.') % {'unit': input_unit,
+                                                 'key': key})
+                    return key
+            msg = (_('The unit "%(unit)s" is not valid. Valid units are '
+                     '"%(valid_units)s".') %
+                   {'unit': input_unit,
+                    'valid_units': sorted(self.SCALAR_UNIT_DICT.keys())})
+            ExceptionCollector.appendException(ValueError(msg))
+
+    def validate_scalar_unit(self):
+        regex = re.compile('([0-9.]+)\s*(\w+)')
+        try:
+            result = regex.match(str(self.value)).groups()
+            validateutils.str_to_num(result[0])
+            scalar_unit = self._check_unit_in_scalar_standard_units(result[1])
+            self.value = ' '.join([result[0], scalar_unit])
+            return self.value
+
+        except Exception:
+            ExceptionCollector.appendException(
+                ValueError(_('"%s" is not a valid scalar-unit.')
+                           % self.value))
+
+    def get_num_from_scalar_unit(self, unit=None):
+        if unit:
+            unit = self._check_unit_in_scalar_standard_units(unit)
+        else:
+            unit = self.SCALAR_UNIT_DEFAULT
+        self.validate_scalar_unit()
+
+        regex = re.compile('([0-9.]+)\s*(\w+)')
+        result = regex.match(str(self.value)).groups()
+        converted = (float(validateutils.str_to_num(result[0]))
+                     * self.SCALAR_UNIT_DICT[result[1]]
+                     / self.SCALAR_UNIT_DICT[unit])
+        if converted - int(converted) < 0.0000000000001:
+            converted = int(converted)
+        return converted
+
+
+class ScalarUnit_Size(ScalarUnit):
+
+    SCALAR_UNIT_DEFAULT = 'B'
+    SCALAR_UNIT_DICT = {'B': 1, 'kB': 1000, 'KiB': 1024, 'MB': 1000000,
+                        'MiB': 1048576, 'GB': 1000000000,
+                        'GiB': 1073741824, 'TB': 1000000000000,
+                        'TiB': 1099511627776}
+
+
+class ScalarUnit_Time(ScalarUnit):
+
+    SCALAR_UNIT_DEFAULT = 'ms'
+    SCALAR_UNIT_DICT = {'d': 86400, 'h': 3600, 'm': 60, 's': 1,
+                        'ms': 0.001, 'us': 0.000001, 'ns': 0.000000001}
+
+
+class ScalarUnit_Frequency(ScalarUnit):
+
+    SCALAR_UNIT_DEFAULT = 'GHz'
+    SCALAR_UNIT_DICT = {'Hz': 1, 'kHz': 1000,
+                        'MHz': 1000000, 'GHz': 1000000000}
+
+
+scalarunit_mapping = {
+    ScalarUnit.SCALAR_UNIT_FREQUENCY: ScalarUnit_Frequency,
+    ScalarUnit.SCALAR_UNIT_SIZE: ScalarUnit_Size,
+    ScalarUnit.SCALAR_UNIT_TIME: ScalarUnit_Time,
+    }
+
+
+def get_scalarunit_class(type):
+    return scalarunit_mapping.get(type)
+
+
+def get_scalarunit_value(type, value, unit=None):
+    if type in ScalarUnit.SCALAR_UNIT_TYPES:
+        ScalarUnit_Class = get_scalarunit_class(type)
+        return (ScalarUnit_Class(value).
+                get_num_from_scalar_unit(unit))
+    else:
+        ExceptionCollector.appendException(
+            TypeError(_('"%s" is not a valid scalar-unit type.') % type))
diff --git a/nfvparser/toscaparser/elements/statefulentitytype.py b/nfvparser/toscaparser/elements/statefulentitytype.py
new file mode 100644
index 0000000..2f221b3
--- /dev/null
+++ b/nfvparser/toscaparser/elements/statefulentitytype.py
@@ -0,0 +1,91 @@
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+from toscaparser.common.exception import ExceptionCollector
+from toscaparser.common.exception import InvalidTypeError
+from toscaparser.elements.attribute_definition import AttributeDef
+from toscaparser.elements.entity_type import EntityType
+from toscaparser.elements.property_definition import PropertyDef
+from toscaparser.unsupportedtype import UnsupportedType
+
+
+class StatefulEntityType(EntityType):
+    '''Class representing TOSCA states.'''
+
+    interfaces_node_lifecycle_operations = ['create',
+                                            'configure', 'start',
+                                            'stop', 'delete']
+
+    interfaces_relationship_configure_operations = ['post_configure_source',
+                                                    'post_configure_target',
+                                                    'add_target',
+                                                    'remove_target']
+
+    def __init__(self, entitytype, prefix, custom_def=None):
+        entire_entitytype = entitytype
+        if UnsupportedType.validate_type(entire_entitytype):
+            self.defs = None
+        else:
+            if entitytype.startswith(self.TOSCA + ":"):
+                entitytype = entitytype[(len(self.TOSCA) + 1):]
+                entire_entitytype = prefix + entitytype
+            if not entitytype.startswith(self.TOSCA):
+                entire_entitytype = prefix + entitytype
+            if entire_entitytype in list(self.TOSCA_DEF.keys()):
+                self.defs = self.TOSCA_DEF[entire_entitytype]
+                entitytype = entire_entitytype
+            elif custom_def and entitytype in list(custom_def.keys()):
+                self.defs = custom_def[entitytype]
+            else:
+                self.defs = None
+                ExceptionCollector.appendException(
+                    InvalidTypeError(what=entitytype))
+        self.type = entitytype
+
+    def get_properties_def_objects(self):
+        '''Return a list of property definition objects.'''
+        properties = []
+        props = self.get_definition(self.PROPERTIES)
+        if props:
+            for prop, schema in props.items():
+                properties.append(PropertyDef(prop, None, schema))
+        return properties
+
+    def get_properties_def(self):
+        '''Return a dictionary of property definition name-object pairs.'''
+        return {prop.name: prop
+                for prop in self.get_properties_def_objects()}
+
+    def get_property_def_value(self, name):
+        '''Return the property definition associated with a given name.'''
+        props_def = self.get_properties_def()
+        if props_def and name in props_def.keys():
+            return props_def[name].value
+
+    def get_attributes_def_objects(self):
+        '''Return a list of attribute definition objects.'''
+        attrs = self.get_value(self.ATTRIBUTES, parent=True)
+        if attrs:
+            return [AttributeDef(attr, None, schema)
+                    for attr, schema in attrs.items()]
+        return []
+
+    def get_attributes_def(self):
+        '''Return a dictionary of attribute definition name-object pairs.'''
+        return {attr.name: attr
+                for attr in self.get_attributes_def_objects()}
+
+    def get_attribute_def_value(self, name):
+        '''Return the attribute definition associated with a given name.'''
+        attrs_def = self.get_attributes_def()
+        if attrs_def and name in attrs_def.keys():
+            return attrs_def[name].value
diff --git a/nfvparser/toscaparser/elements/tosca_type_validation.py b/nfvparser/toscaparser/elements/tosca_type_validation.py
new file mode 100644
index 0000000..82b0b46
--- /dev/null
+++ b/nfvparser/toscaparser/elements/tosca_type_validation.py
@@ -0,0 +1,59 @@
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+from toscaparser.common.exception import ExceptionCollector
+from toscaparser.common.exception import InvalidTemplateVersion
+from toscaparser.common.exception import UnknownFieldError
+from toscaparser.extensions.exttools import ExtTools
+
+
+class TypeValidation(object):
+
+    ALLOWED_TYPE_SECTIONS = (DEFINITION_VERSION, DESCRIPTION, IMPORTS,
+                             DSL_DEFINITIONS, NODE_TYPES, REPOSITORIES,
+                             DATA_TYPES, ARTIFACT_TYPES, GROUP_TYPES,
+                             RELATIONSHIP_TYPES, CAPABILITY_TYPES,
+                             INTERFACE_TYPES, POLICY_TYPES,
+                             TOPOLOGY_TEMPLATE) = \
+        ('tosca_definitions_version', 'description', 'imports',
+         'dsl_definitions', 'node_types', 'repositories',
+         'data_types', 'artifact_types', 'group_types',
+         'relationship_types', 'capability_types',
+         'interface_types', 'policy_types', 'topology_template')
+    VALID_TEMPLATE_VERSIONS = ['tosca_simple_yaml_1_0']
+    exttools = ExtTools()
+    VALID_TEMPLATE_VERSIONS.extend(exttools.get_versions())
+
+    def __init__(self, custom_types, import_def):
+        self.import_def = import_def
+        self._validate_type_keys(custom_types)
+
+    def _validate_type_keys(self, custom_type):
+        version = custom_type[self.DEFINITION_VERSION] \
+            if self.DEFINITION_VERSION in custom_type \
+            else None
+        if version:
+            self._validate_type_version(version)
+            self.version = version
+
+        for name in custom_type:
+            if name not in self.ALLOWED_TYPE_SECTIONS:
+                ExceptionCollector.appendException(
+                    UnknownFieldError(what='Template ' + (self.import_def),
+                                      field=name))
+
+    def _validate_type_version(self, version):
+        if version not in self.VALID_TEMPLATE_VERSIONS:
+            ExceptionCollector.appendException(
+                InvalidTemplateVersion(
+                    what=version + ' in ' + self.import_def,
+                    valid_versions=', '. join(self.VALID_TEMPLATE_VERSIONS)))