docs: public void createPackageContents() {
  		if (isCreated) return;
  		isCreated = true;
  
  		// Create classes and their features
  		grammarEClass = createEClass(GRAMMAR);
  		createEAttribute(grammarEClass, GRAMMAR__NAME);
  		createEReference(grammarEClass, GRAMMAR__USED_GRAMMARS);
  		createEAttribute(grammarEClass, GRAMMAR__DEFINES_HIDDEN_TOKENS);
  		createEReference(grammarEClass, GRAMMAR__HIDDEN_TOKENS);
  		createEReference(grammarEClass, GRAMMAR__METAMODEL_DECLARATIONS);
  		createEReference(grammarEClass, GRAMMAR__RULES);
  
  		abstractRuleEClass = createEClass(ABSTRACT_RULE);
  		createEAttribute(abstractRuleEClass, ABSTRACT_RULE__NAME);
  		createEReference(abstractRuleEClass, ABSTRACT_RULE__TYPE);
  		createEReference(abstractRuleEClass, ABSTRACT_RULE__ALTERNATIVES);
  		createEReference(abstractRuleEClass, ABSTRACT_RULE__ANNOTATIONS);
  
  		abstractMetamodelDeclarationEClass = createEClass(ABSTRACT_METAMODEL_DECLARATION);
  		createEReference(abstractMetamodelDeclarationEClass, ABSTRACT_METAMODEL_DECLARATION__EPACKAGE);
  		createEAttribute(abstractMetamodelDeclarationEClass, ABSTRACT_METAMODEL_DECLARATION__ALIAS);
  
  		generatedMetamodelEClass = createEClass(GENERATED_METAMODEL);
  		createEAttribute(generatedMetamodelEClass, GENERATED_METAMODEL__NAME);
  
  		referencedMetamodelEClass = createEClass(REFERENCED_METAMODEL);
  
  		parserRuleEClass = createEClass(PARSER_RULE);
  		createEAttribute(parserRuleEClass, PARSER_RULE__DEFINES_HIDDEN_TOKENS);
  		createEReference(parserRuleEClass, PARSER_RULE__HIDDEN_TOKENS);
  		createEReference(parserRuleEClass, PARSER_RULE__PARAMETERS);
  		createEAttribute(parserRuleEClass, PARSER_RULE__FRAGMENT);
  		createEAttribute(parserRuleEClass, PARSER_RULE__WILDCARD);
  
  		typeRefEClass = createEClass(TYPE_REF);
  		createEReference(typeRefEClass, TYPE_REF__METAMODEL);
  		createEReference(typeRefEClass, TYPE_REF__CLASSIFIER);
  
  		abstractElementEClass = createEClass(ABSTRACT_ELEMENT);
  		createEAttribute(abstractElementEClass, ABSTRACT_ELEMENT__CARDINALITY);
  		createEAttribute(abstractElementEClass, ABSTRACT_ELEMENT__PREDICATED);
  		createEAttribute(abstractElementEClass, ABSTRACT_ELEMENT__FIRST_SET_PREDICATED);
  
  		actionEClass = createEClass(ACTION);
  		createEReference(actionEClass, ACTION__TYPE);
  		createEAttribute(actionEClass, ACTION__FEATURE);
  		createEAttribute(actionEClass, ACTION__OPERATOR);
  
  		keywordEClass = createEClass(KEYWORD);
  		createEAttribute(keywordEClass, KEYWORD__VALUE);
  
  		ruleCallEClass = createEClass(RULE_CALL);
  		createEReference(ruleCallEClass, RULE_CALL__RULE);
  		createEReference(ruleCallEClass, RULE_CALL__ARGUMENTS);
  		createEAttribute(ruleCallEClass, RULE_CALL__EXPLICITLY_CALLED);
  
  		assignmentEClass = createEClass(ASSIGNMENT);
  		createEAttribute(assignmentEClass, ASSIGNMENT__FEATURE);
  		createEAttribute(assignmentEClass, ASSIGNMENT__OPERATOR);
  		createEReference(assignmentEClass, ASSIGNMENT__TERMINAL);
  
  		crossReferenceEClass = createEClass(CROSS_REFERENCE);
  		createEReference(crossReferenceEClass, CROSS_REFERENCE__TYPE);
  		createEReference(crossReferenceEClass, CROSS_REFERENCE__TERMINAL);
  
  		terminalRuleEClass = createEClass(TERMINAL_RULE);
  		createEAttribute(terminalRuleEClass, TERMINAL_RULE__FRAGMENT);
  
  		abstractNegatedTokenEClass = createEClass(ABSTRACT_NEGATED_TOKEN);
  		createEReference(abstractNegatedTokenEClass, ABSTRACT_NEGATED_TOKEN__TERMINAL);
  
  		negatedTokenEClass = createEClass(NEGATED_TOKEN);
  
  		untilTokenEClass = createEClass(UNTIL_TOKEN);
  
  		wildcardEClass = createEClass(WILDCARD);
  
  		enumRuleEClass = createEClass(ENUM_RULE);
  
  		enumLiteralDeclarationEClass = createEClass(ENUM_LITERAL_DECLARATION);
  		createEReference(enumLiteralDeclarationEClass, ENUM_LITERAL_DECLARATION__ENUM_LITERAL);
  		createEReference(enumLiteralDeclarationEClass, ENUM_LITERAL_DECLARATION__LITERAL);
  
  		alternativesEClass = createEClass(ALTERNATIVES);
  
  		unorderedGroupEClass = createEClass(UNORDERED_GROUP);
  
  		groupEClass = createEClass(GROUP);
  		createEReference(groupEClass, GROUP__GUARD_CONDITION);
  
  		characterRangeEClass = createEClass(CHARACTER_RANGE);
  		createEReference(characterRangeEClass, CHARACTER_RANGE__LEFT);
  		createEReference(characterRangeEClass, CHARACTER_RANGE__RIGHT);
  
  		compoundElementEClass = createEClass(COMPOUND_ELEMENT);
  		createEReference(compoundElementEClass, COMPOUND_ELEMENT__ELEMENTS);
  
  		eofEClass = createEClass(EOF);
  
  		parameterEClass = createEClass(PARAMETER);
  		createEAttribute(parameterEClass, PARAMETER__NAME);
  
  		namedArgumentEClass = createEClass(NAMED_ARGUMENT);
  		createEReference(namedArgumentEClass, NAMED_ARGUMENT__PARAMETER);
  		createEReference(namedArgumentEClass, NAMED_ARGUMENT__VALUE);
  		createEAttribute(namedArgumentEClass, NAMED_ARGUMENT__CALLED_BY_NAME);
  
  		conditionEClass = createEClass(CONDITION);
  
  		conjunctionEClass = createEClass(CONJUNCTION);
  
  		negationEClass = createEClass(NEGATION);
  		createEReference(negationEClass, NEGATION__VALUE);
  
  		disjunctionEClass = createEClass(DISJUNCTION);
  
  		compositeConditionEClass = createEClass(COMPOSITE_CONDITION);
  		createEReference(compositeConditionEClass, COMPOSITE_CONDITION__LEFT);
  		createEReference(compositeConditionEClass, COMPOSITE_CONDITION__RIGHT);
  
  		parameterReferenceEClass = createEClass(PARAMETER_REFERENCE);
  		createEReference(parameterReferenceEClass, PARAMETER_REFERENCE__PARAMETER);
  
  		literalConditionEClass = createEClass(LITERAL_CONDITION);
  		createEAttribute(literalConditionEClass, LITERAL_CONDITION__TRUE);
  
  		annotationEClass = createEClass(ANNOTATION);
  		createEAttribute(annotationEClass, ANNOTATION__NAME);
  	}