Get the model elastic type.

@return string
978422
public function getDocumentType()
    {
        // if the type is defined use it else return the table name
        if (isset($this->documentType) and !empty($this->documentType)) {
            return $this->documentType;
        }

        return $this->getTable();
    }
839140
protected function getType()
  {
    if($this->currObj instanceof TeamSpeak3_Node_Server)
    {
      return "server";
    }
    elseif($this->currObj instanceof TeamSpeak3_Node_Channel)
    {
      return "channel";
    }
    elseif($this->currObj instanceof TeamSpeak3_Node_Client)
    {
      return "client";
    }
    elseif($this->currObj instanceof TeamSpeak3_Node_Servergroup || $this->currObj instanceof TeamSpeak3_Node_Channelgroup)
    {
      return "group";
    }

    return "host";
  }
220981
public function getTypeSerializer()
    {
        if (isset(self::$serializerTypeMap[$this->getType()])) {
            return self::$serializerTypeMap[$this->getType()];
        }

        // our fallback default
        return self::$serializerTypeMap[self::TYPE_STRING];
    }
910529
public function getType(): string
    {
        if (null === $this->type) {
            $success = true;

            $type = $this->getItem('browscap.type', false, $success);

            if (null !== $type && $success) {
                $this->type = $type;
            }
        }

        return $this->type;
    }
633246
def determine_types(self):
        
        from nefertari.elasticsearch import ES
        collections = self.get_collections()
        resources = self.get_resources(collections)
        models = set([res.view.Model for res in resources])
        es_models = [mdl for mdl in models if mdl
                     and getattr(mdl, '_index_enabled', False)]
        types = [ES.src2type(mdl.__name__) for mdl in es_models]
        return types
60295
public function getType()
    {
        $userType = get_user_meta($this->ID, self::KEY_TYPE, true);
        return ($userType) ? $userType : self::TYPE_DEFAULT;
    }
270530
protected function _getType() {
        $className = strtolower(get_class($this));
        $classNameParts = explode('_', $className);
        $type = array_pop($classNameParts);
        if (array_key_exists($type, self::$_mapping)) {
            return self::$_mapping[$type];
        }
        return self::DEFAULT_TYPE;
    }
249076
protected static function getModelTypes()
    {
        $class = get_called_class();

        if($class::$useType === false) {
            return array();
        }

        $class_name = $class::getClassName(false);
        $parent = get_parent_class($class);
        if ($parent) {
            $names_parent = $parent::getModelTypes();
            $names = array_merge($names_parent, array($class_name));
        } else {
            $names = array();
        }

        return $names;

    }
981212
public function getValueType()
	{
		if ( $this->_value instanceof IXmlSchemaType )
		{
			return Type::FromValue( $this->_value );
		}
		else
		{
			$qn = $this->_xmlType->QualifiedName;
			$xmlType = $qn->prefix ? "{$qn->prefix}:{$qn->localName}" : "{$qn->localName}";
			return Type::XmlTypeToType( $xmlType );
		}

		return Type::FromValue( $this->_value );
	}
420085
public function type()
	{
		$file = new Filesystem();
        $path    = realpath(__DIR__.'/../Libraries/Fields');
        $fields = $file->glob($path.'/*.php');
		$data = [];
        if($fields) {
        	foreach ($fields as $key => $value) {
				$name = substr(basename($value), 0, -4);
				if($name != 'FieldAbs') {
					$obj = $this->get($name);
					$data[] = array('id' => $name, 'name' => $obj->name);
				}
        	}
        }
		return $data;
	}
808443
protected function elasticToModel()
    {
        $items = array();

        foreach ($this->response['hits']['hits'] as $hit) {
            $items[] = $this->instance->newFromElasticResults($hit);
        }

        return $items;
    }
281719
public function getType()
    {
        if($this->_type == null) {
            $this->_type = parse_url($this->_path, PHP_URL_HOST);
        }

        return $this->_type;
    }
112273
public function getTypes()
    {
        return array_reduce(
            $this->_models,
            function ($result, $item) {
                $result[$item['type']] = $item['type'];
                return $result;
            },
            []
        );
    }
130946
public function getType()
    {
        if (null === $this->type) {
            $this->type = $this->getCallableType($this->handler);
        }

        return $this->type;
    }
345161
public function getJsConfig()
    {
        $config = [
            'dateFormat' => $this->getDateFormat(),
            'from'       => ['id' => $this->getJsId('date-range-picker', 'from')],
            'to'         => ['id' => $this->getJsId('date-range-picker', 'to')],
        ];

        $dateBounds = $this->indexManager->getIndicesDateBounds(
            \Smile\ElasticsuiteTracker\Api\EventIndexInterface::INDEX_IDENTIFIER,
            $this->reportContext->getStoreId()
        );
        if (!empty($dateBounds)) {
            list($minDate, $maxDate) = $dateBounds;
            $config['minDate'] = $this->formatDate($minDate, \IntlDateFormatter::SHORT, false, 'UTC');
            $config['maxDate'] = $this->formatDate($maxDate, \IntlDateFormatter::SHORT, false, 'UTC');
        }

        return $this->jsonSerializer->serialize($config);
    }
950180
public function getType()
    {
        $map = [
            'input' => self::TYPE_FIELD_TEXT,
            'textarea' => self::TYPE_FIELD_TEXT_AREA,
            'select' => self::TYPE_FIELD_SELECT,
        ];
        $tagName = strtolower($this->tagName());
        $typeField = isset($map[$tagName]) ? $map[$tagName] : self::TYPE_NODE;
        if (($typeField == self::TYPE_FIELD_TEXT) && (strtolower($this->attribute('type')) == 'file')) {
            $typeField = self::TYPE_FIELD_FILE;
        }
        return $typeField;
    }
1224252
public static function getEngineType()
    {
        $container = self::getContainer();
        $builder = CollectionBuilder::create($container, new EngineTasks());

        return $container->get('projectXEngine')
            ->setBuilder($builder);
    }