<p>
The list of workflow type information.
</p>

@param typeInfos
The list of workflow type information.
547989
public void setTypeInfos(java.util.Collection<WorkflowTypeInfo> typeInfos) {
        if (typeInfos == null) {
            this.typeInfos = null;
            return;
        }

        this.typeInfos = new java.util.ArrayList<WorkflowTypeInfo>(typeInfos);
    }
281610
public void setActionTypes(java.util.Collection<ActionType> actionTypes) {
        if (actionTypes == null) {
            this.actionTypes = null;
            return;
        }

        this.actionTypes = new java.util.ArrayList<ActionType>(actionTypes);
    }
844322
@Override
    public ResultSet getTypeInfo() throws SQLException
    {
        checkClosed();
        this.sysCatalog.setString(1, "TYPEINFO");
        ResultSet res = this.sysCatalog.executeQuery();
        return res;
    }
1001066
private static void getTypeInfo(UResourceBundle typeInfoRes) {
        Map<String,Set<String>> _deprecatedKeyTypes = new LinkedHashMap<String,Set<String>>();
        for (UResourceBundleIterator keyInfoIt = typeInfoRes.getIterator(); keyInfoIt.hasNext();) {
            UResourceBundle keyInfoEntry = keyInfoIt.next();
            String key = keyInfoEntry.getKey();
            TypeInfoType typeInfo = TypeInfoType.valueOf(key);
            for (UResourceBundleIterator keyInfoIt2 = keyInfoEntry.getIterator(); keyInfoIt2.hasNext();) {
                UResourceBundle keyInfoEntry2 = keyInfoIt2.next();
                String key2 = keyInfoEntry2.getKey();
                Set<String> _deprecatedTypes = new LinkedHashSet<String>();
                for (UResourceBundleIterator keyInfoIt3 = keyInfoEntry2.getIterator(); keyInfoIt3.hasNext();) {
                    UResourceBundle keyInfoEntry3 = keyInfoIt3.next();
                    String key3 = keyInfoEntry3.getKey();
                    switch (typeInfo) { // allow for expansion
                    case deprecated:
                        _deprecatedTypes.add(key3);
                        break;
                    }
                }
                _deprecatedKeyTypes.put(key2, Collections.unmodifiableSet(_deprecatedTypes));
            }
        }
        DEPRECATED_KEY_TYPES = Collections.unmodifiableMap(_deprecatedKeyTypes);
    }
21387
public static TypeInformation<?> createTypeInfo(Type t) {
		ArrayList<Type> typeHierarchy = new ArrayList<Type>();
		typeHierarchy.add(t);
		return createTypeInfoWithTypeHierarchy(typeHierarchy, t, null, null);
	}
412880
public void setFindingTypes(java.util.Collection<String> findingTypes) {
        if (findingTypes == null) {
            this.findingTypes = null;
            return;
        }

        this.findingTypes = new java.util.ArrayList<String>(findingTypes);
    }
1129359
@SuppressWarnings("unchecked")
	private <IN1, IN2, OUT> TypeInformation<OUT> privateCreateTypeInfo(Class<?> baseClass, Class<?> clazz, int returnParamPos,
			TypeInformation<IN1> in1Type, TypeInformation<IN2> in2Type) {
		ArrayList<Type> typeHierarchy = new ArrayList<Type>();
		Type returnType = getParameterType(baseClass, typeHierarchy, clazz, returnParamPos);

		TypeInformation<OUT> typeInfo;

		// return type is a variable -> try to get the type info from the input directly
		if (returnType instanceof TypeVariable<?>) {
			typeInfo = (TypeInformation<OUT>) createTypeInfoFromInputs((TypeVariable<?>) returnType, typeHierarchy, in1Type, in2Type);

			if (typeInfo != null) {
				return typeInfo;
			}
		}

		// get info from hierarchy
		return (TypeInformation<OUT>) createTypeInfoWithTypeHierarchy(typeHierarchy, returnType, in1Type, in2Type);
	}
246616
static <T> TypeInfoImpl<T> typeInfoFor(T source, Class<T> sourceType,
      InheritingConfiguration configuration) {
    if (configuration.valueAccessStore.getFirstSupportedReader(sourceType) != null)
      return new TypeInfoImpl<T>(source, sourceType, configuration);
    return typeInfoFor(sourceType, configuration);
  }
1337056
public void setColumnTypes(com.google.api.ads.admanager.axis.v201805.ColumnType[] columnTypes) {
        this.columnTypes = columnTypes;
    }
194802
public List<TypeInfo> getTypeInfo() throws SQLException {
        final List<TypeInfo> list = new ArrayList<>();
        try (ResultSet results = databaseMetadata.getTypeInfo()) {
            if (results != null) {
                bind(results, TypeInfo.class, list);
            }
        }
        return list;
    }
462380
@SuppressWarnings("deprecation")
    private void addGalleriesForType(Map<String, CmsGalleryTypeInfo> galleryTypeInfos, String typeName)
    throws CmsLoaderException {

        I_CmsResourceType contentType = getResourceManager().getResourceType(typeName);
        for (I_CmsResourceType galleryType : contentType.getGalleryTypes()) {

            if (galleryTypeInfos.containsKey(galleryType.getTypeName())) {
                CmsGalleryTypeInfo typeInfo = galleryTypeInfos.get(galleryType.getTypeName());
                typeInfo.addContentType(contentType);
            } else {
                CmsGalleryTypeInfo typeInfo;

                typeInfo = new CmsGalleryTypeInfo(
                    galleryType,
                    contentType,
                    getGalleriesByType(galleryType.getTypeId()));

                galleryTypeInfos.put(galleryType.getTypeName(), typeInfo);
            }

        }
    }
195496
public void setLifecycleHookTypes(java.util.Collection<String> lifecycleHookTypes) {
        if (lifecycleHookTypes == null) {
            this.lifecycleHookTypes = null;
            return;
        }

        this.lifecycleHookTypes = new com.amazonaws.internal.SdkInternalList<String>(lifecycleHookTypes);
    }
520114
public void setJobTypes(final Map<String, ? extends Class<?>> jobTypes) {
        checkJobTypes(jobTypes);
        this.jobTypes.clear();
        this.jobTypes.putAll(jobTypes);
    }
61217
private static MessageInfo mapMessageInfo(MessageInfoType messageInfoType) {
        MessageInfo messageInfo = new MessageInfo();
        if (messageInfoType != null) {
            messageInfo.setFlowId(messageInfoType.getFlowId());
            messageInfo.setMessageId(messageInfoType.getMessageId());
            messageInfo.setOperationName(messageInfoType.getOperationName());
            messageInfo.setPortType(messageInfoType.getPorttype() == null
                ? "" : messageInfoType.getPorttype().toString());
            messageInfo.setTransportType(messageInfoType.getTransport());
        }
        return messageInfo;
    }
287122
public void setEventTypeCodes(java.util.Collection<String> eventTypeCodes) {
        if (eventTypeCodes == null) {
            this.eventTypeCodes = null;
            return;
        }

        this.eventTypeCodes = new java.util.ArrayList<String>(eventTypeCodes);
    }
1328083
private void processKnownType(FieldType type)
   {
      //System.out.println("Header: " + type);
      //System.out.println(ByteArrayHelper.hexdump(m_data, m_dataOffset, 36, false, 16, ""));

      GraphicalIndicator indicator = m_container.getCustomField(type).getGraphicalIndicator();
      indicator.setFieldType(type);
      int flags = m_data[m_dataOffset];
      indicator.setProjectSummaryInheritsFromSummaryRows((flags & 0x08) != 0);
      indicator.setSummaryRowsInheritFromNonSummaryRows((flags & 0x04) != 0);
      indicator.setDisplayGraphicalIndicators((flags & 0x02) != 0);
      indicator.setShowDataValuesInToolTips((flags & 0x01) != 0);
      m_dataOffset += 20;

      int nonSummaryRowOffset = MPPUtility.getInt(m_data, m_dataOffset) - 36;
      m_dataOffset += 4;

      int summaryRowOffset = MPPUtility.getInt(m_data, m_dataOffset) - 36;
      m_dataOffset += 4;

      int projectSummaryOffset = MPPUtility.getInt(m_data, m_dataOffset) - 36;
      m_dataOffset += 4;

      int dataSize = MPPUtility.getInt(m_data, m_dataOffset) - 36;
      m_dataOffset += 4;

      //System.out.println("Data");
      //System.out.println(ByteArrayHelper.hexdump(m_data, m_dataOffset, dataSize, false, 16, ""));

      int maxNonSummaryRowOffset = m_dataOffset + summaryRowOffset;
      int maxSummaryRowOffset = m_dataOffset + projectSummaryOffset;
      int maxProjectSummaryOffset = m_dataOffset + dataSize;

      m_dataOffset += nonSummaryRowOffset;

      while (m_dataOffset + 2 < maxNonSummaryRowOffset)
      {
         indicator.addNonSummaryRowCriteria(processCriteria(type));
      }

      while (m_dataOffset + 2 < maxSummaryRowOffset)
      {
         indicator.addSummaryRowCriteria(processCriteria(type));
      }

      while (m_dataOffset + 2 < maxProjectSummaryOffset)
      {
         indicator.addProjectSummaryCriteria(processCriteria(type));
      }
   }
38373
public void setJobFlows(java.util.Collection<JobFlowDetail> jobFlows) {
        if (jobFlows == null) {
            this.jobFlows = null;
            return;
        }

        this.jobFlows = new com.amazonaws.internal.SdkInternalList<JobFlowDetail>(jobFlows);
    }