@param string $fieldType Field type

@return array
17511
private function getDefaultFieldOptions($fieldType)
    {
        $options = isset($this->defaultFieldOptions[$fieldType]) ? $this->defaultFieldOptions[$fieldType] : [];

        $translationJoiner = $this->translationJoiner;

        switch ($fieldType) {
            case EntityType::class:
                $options['query_builder'] = function (EntityRepository $er) use ($translationJoiner) {
                    $qb = $er->createQueryBuilder('o');

                    if ($translationJoiner->isTranslatable($er->getClassName())) {
                        $translationJoiner->joinTranslation($qb, true);
                    }

                    return $qb;
                };
        }

        return $options;
    }
550200
public static function field_types() {

		$field_types = array(
			'text',
			'website',
			// 'link',
			'phone',
			'email',
			'password',
			'paragraph',
			'wysiwyg',
			'code',
			'datetime',
			'date',
			'time',
			'number',
			'currency',
			'file',
			'avatar',
			'oembed',
			'pick',
			'boolean',
			'color',
			'slug',
		);

		$field_types = array_merge( $field_types, array_keys( self::$field_types ) );

		$field_types = array_filter( array_unique( $field_types ) );

		$types = apply_filters( 'pods_api_field_types', $field_types );

		$field_types = pods_transient_get( 'pods_field_types' );

		if ( empty( $field_types ) || count( $types ) != count( $field_types ) ) {
			$field_types = array();

			foreach ( $types as $field_type ) {
				$file = null;

				if ( isset( self::$field_types[ $field_type ] ) ) {
					$file = self::$field_types[ $field_type ]['file'];
				}

				self::field_loader( $field_type, $file );

				if ( ! isset( self::$loaded[ $field_type ] ) || ! is_object( self::$loaded[ $field_type ] ) ) {
					continue;
				}

				$class_vars = get_class_vars( get_class( self::$loaded[ $field_type ] ) );
				// PHP 5.2.x workaround
				$field_types[ $field_type ]         = $class_vars;
				$field_types[ $field_type ]['file'] = $file;
			}

			self::$field_types = $field_types;

			pods_transient_set( 'pods_field_types', self::$field_types );
		} else {
			self::$field_types = array_merge( $field_types, self::$field_types );
		}//end if

		return self::$field_types;
	}
711835
protected function getTypeForString($type)
    {
        switch ($type) {
            case 'string':
                return DataTypes::STRING_TYPE;
            case 'number':
                return DataTypes::NUMBER_TYPE;
            case 'date':
            case 'datetime':
                return DataTypes::DATETIME_TYPE;
            case 'boolean':
                return DataTypes::BOOLEAN_TYPE;
            case 'tags':
                return DataTypes::TAGS_TYPE;
            case 'auto-complete':
                return DataTypes::AUTO_COMPLETE_TYPE;
            default:
                return DataTypes::UNDEFINED_TYPE;
        }
    }
231112
private function initFieldType($type)
    {
        if (isset($this->fieldTypes[$type])) {
            return;
        }

        $typeInstance = false;
        foreach ($this->extensions as $extension) {
            if ($extension->hasFieldType($type)) {
                $typeInstance = $extension->getFieldType($type);
                break;
            }
        }

        if (!$typeInstance) {
            return;
        }

        $this->fieldTypes[$type] = $typeInstance;

        $ext = [];
        foreach ($this->extensions as $extension) {
            if ($extension->hasFieldTypeExtensions($type)) {
                $fieldExtensions = $extension->getFieldTypeExtensions($type);
                foreach ($fieldExtensions as $fieldExtension) {
                    $ext[] = $fieldExtension;
                }
            }
        }

        $this->fieldExtensions[$type] = $ext;
    }
1135753
public function getXMLDBFieldType($type) {

        $result = XMLDB_TYPE_INCORRECT;

        switch (strtolower($type)) {
            case 'int':
                $result = XMLDB_TYPE_INTEGER;
                break;
            case 'number':
                $result = XMLDB_TYPE_NUMBER;
                break;
            case 'float':
                $result = XMLDB_TYPE_FLOAT;
                break;
            case 'char':
                $result = XMLDB_TYPE_CHAR;
                break;
            case 'text':
                $result = XMLDB_TYPE_TEXT;
                break;
            case 'binary':
                $result = XMLDB_TYPE_BINARY;
                break;
            case 'datetime':
                $result = XMLDB_TYPE_DATETIME;
                break;
        }
        // Return the normalized XMLDB_TYPE
        return $result;
    }
1055462
public function getFieldTypeService()
    {
        if (null === $this->fieldTypeService) {
            $this->fieldTypeService = new FieldTypeService($this->fieldTypes);
        }

        return $this->fieldTypeService;
    }
103799
protected function buildCheckableChildren($fieldType)
    {
        $multiple = $this->getOption('multiple') ? '[]' : '';

        foreach ((array)$this->options['choices'] as $key => $choice) {
            $id = str_replace('.', '_', $this->getNameKey()) . '_' . $key;
            $options = $this->formHelper->mergeOptions(
                $this->getOption('choice_options'),
                [
                    'attr'       => ['id' => $id],
                    'label_attr' => ['for' => $id],
                    'label'      => $this->formHelper->formatLabel($choice),
                    'checked'    => in_array($key, (array)$this->options[$this->valueProperty]),
                    'value'      => $key
                ]
            );
            $this->children[] = new $fieldType(
                $this->name . $multiple,
                $this->choiceType,
                $this->parent,
                $options
            );
        }
    }
269775
public function & GetFirstFieldByType ($fieldType = '') {
		$result = NULL;
		foreach ($this->fields as & $field) {
			if ($field->GetType() == $fieldType) {
				$result = & $field;
			}
		}
		return $result;
	}
424224
public static function objectType($fieldId)
    {
        //====================================================================//
        // decode
        $result = self::isIdField($fieldId);
        if (empty($result)) {
            return false;
        }
        //====================================================================//
        // Return Field Identifier
        return   $result['ObjectType'];
    }
302933
public function getNamesByFieldType($fieldType)
    {
        $result = [];
        foreach ($this->dsIdMap as $node) {
            /* @var $node ElementtypeStructureNode */
            if ($fieldType === $node->getType()) {
                $result[] = $node->getName();
            }
        }

        return $result;
    }
396145
public function getNodesOfType(string $type): array
    {
        return isset($this->nodesByType[$type]) ? $this->nodesByType[$type] : [];
    }
411744
protected function parseHelloFields($type)
    {
        $this->server_caps = array();
        $lines = explode("\n", $this->last_reply);
        foreach ($lines as $n => $s) {
            $s = trim(substr($s, 4));
            if (!$s) {
                continue;
            }
            $fields = explode(' ', $s);
            if ($fields) {
                if (!$n) {
                    $name = $type;
                    $fields = $fields[0];
                } else {
                    $name = array_shift($fields);
                    if ($name == 'SIZE') {
                        $fields = ($fields) ? $fields[0] : 0;
                    }
                }
                $this->server_caps[$name] = ($fields ? $fields : true);
            }
        }
    }
386894
protected function loadFieldTypeData() {
    if (!isset($this->fieldTypesData)) {
      $this->fieldTypesData = $this->environment->getStorage()->retrieve('field_types');
    }

    return $this->fieldTypesData;
  }
873569
public static function block_field_types() {

		static $field_types = null;

		if ( null === $field_types ) {
			$field_types = array( 'heading', 'html' );

			/**
			 * Returns the available text field types
			 *
			 * @since unknown
			 *
			 * @param object $field_types Outputs the field types
			 */

			$field_types = apply_filters( 'pods_block_field_types', $field_types );
		}

		return $field_types;
	}
344135
public function listFieldTypesOptions() {
    $field_types_data = $this->loadFieldTypeData();

    $return = [];
    foreach ($field_types_data as $field_type_id => $field_type_info) {
      $return[$field_type_id] = $field_type_info['label'];
    }

    return $return;
  }
380856
protected static function dataTypeToIndexField($type)
    {
        $key = '';
        $currentLang = LanguageHelper::getCurrent();
        switch ($type) {
            case Property::DATA_TYPE_STRING :
                $key = 'str_value_' . $currentLang;
                break;
            case Property::DATA_TYPE_TEXT :
                $key = 'txt_value_' . $currentLang;
                break;
            case Property::DATA_TYPE_BOOLEAN :
            case Property::DATA_TYPE_INTEGER :
                $key = 'value_integer';
                break;
            case Property::DATA_TYPE_FLOAT :
                $key = 'value_float';
                break;
            case Property::DATA_TYPE_INVARIANT_STRING :
            case Property::DATA_TYPE_PACKED_JSON :
                $key = 'utr_text';
                break;
        }
        return $key;
    }
505540
public function deleteFieldTypes($fieldTypes)
    {
        $schema = $this->get();
        $request = [];
        foreach ($fieldTypes as $fieldType) {
            if ($this->hasFieldType($fieldType, $schema)) {
                $request['delete-field-type'][] = ['name' => $fieldType];
            }
        }

        return $this->request($request);
    }