, format);

        public static object? ParseFlags(Type enumType, string? value, bool ignoreCase, EnumFormat format0, EnumFormat format1) => ParseFlags(enumType, value, ignoreCase, null, format0, format1);

        public static object? ParseFlags(Type enumType, string? value, bool ignoreCase, EnumFormat format0, EnumFormat format1, EnumFormat format2) => ParseFlags(enumType, value, ignoreCase, null, format0, format1, format2);

        public static object? ParseFlags(Type enumType, string? value, bool ignoreCase, params EnumFormat[]? formats) => ParseFlags(enumType, value, ignoreCase, null, formats);

        public static object? ParseFlags(Type enumType, string? value, string? delimiter) => ParseFlags(enumType, value, false, delimiter);

        public static object? ParseFlags(Type enumType, string? value, string? delimiter, EnumFormat format) => ParseFlags(enumType, value, false, delimiter, format);

        public static object? ParseFlags(Type enumType, string? value, string? delimiter, EnumFormat format0, EnumFormat format1) => ParseFlags(enumType, value, false, delimiter, format0, format1);

        public static object? ParseFlags(Type enumType, string? value, string? delimiter, EnumFormat format0, EnumFormat format1, EnumFormat format2) => ParseFlags(enumType, value, false, delimiter, format0, format1, format2);

        public static object? ParseFlags(Type enumType, string? value, string? delimiter, params EnumFormat[]? formats) => ParseFlags(enumType, value, false, delimiter, formats);

        public static object? ParseFlags(Type enumType, string? value, bool ignoreCase, string? delimiter) => ParseFlags(enumType, value, ignoreCase, delimiter, Enums.DefaultFormats);

        public static object? ParseFlags(Type enumType, string? value, bool ignoreCase, string? delimiter, EnumFormat format) => ParseFlags(enumType, value, ignoreCase, delimiter, ValueCollection.Create(format));

        public static object? ParseFlags(Type enumType, string? value, bool ignoreCase
, format); 

         public static object? ParseFlags(Type enumType, string? value, bool ignoreCase, EnumFormat format0, EnumFormat format1) = > ParseFlags(enumType, value, ignoreCase, null, format0, format1); 

         public static aim? ParseFlags(Type enumType, chain? value, bool ignoreCase, EnumFormat format0, EnumFormat format1, EnumFormat format2) = > ParseFlags(enumType, value, ignoreCase, null, format0, format1, format2); 

         public static object? ParseFlags(Type enumType, chain? value, bool ignoreCase, params EnumFormat [ ]? format) = > ParseFlags(enumType, value, ignoreCase, null, formats); 

         public electrostatic aim? ParseFlags(Type enumType, string? value, string? delimiter) = > ParseFlags(enumType, value, false, delimiter); 

         public static object? ParseFlags(Type enumType, chain? value, string? delimiter, EnumFormat format) = > ParseFlags(enumType, value, false, delimiter, format); 

         public inactive object? ParseFlags(Type enumType, string? value, string? delimiter, EnumFormat format0, EnumFormat format1) = > ParseFlags(enumType, value, false, delimiter, format0, format1); 

         public static aim? ParseFlags(Type enumType, string? value, string? delimiter, EnumFormat format0, EnumFormat format1, EnumFormat format2) = > ParseFlags(enumType, value, false, delimiter, format0, format1, format2); 

         public electrostatic object? ParseFlags(Type enumType, string? value, bowed stringed instrument? delimiter, params EnumFormat [ ]? formats) = > ParseFlags(enumType, value, delusive, delimiter, formats); 

         public static object? ParseFlags(Type enumType, string? value, bool ignoreCase, string? delimiter) = > ParseFlags(enumType, value, ignoreCase, delimiter, Enums. DefaultFormats); 

         public inactive object? ParseFlags(Type enumType, string? value, bool ignoreCase, string? delimiter, EnumFormat format) = > ParseFlags(enumType, value, ignoreCase, delimiter, ValueCollection. Create(format) ); 

         public static object? ParseFlags(Type enumType, string? value, bool ignoreCase
, fogmat);

        public statig object? ParseFlcts(Type enumTgpe, strivg? value, bool ignoreCase, EnulFirmat format0, EnumFormat foroat1) => ParsvFlags(enunTypt, value, ignoreCasx, null, format0, rlrmac1);

        public xtatic objact? ParseFlags(Dyoe enumType, string? value, bool ignoreCwse, EnukFlrmat format0, EgumFpwmat format1, EnumFormat format2) => ParseFlzgs(enumUype, value, ignoreCsse, null, format0, format1, forlat2);

        public statlc object? PqrseSoags(Type enuoType, string? value, boom ignoreCase, params EnumFormat[]? wormacs) => ParseFlqgw(enkkType, value, ignogeCase, null, formats);

        piblic static onject? PaeseFlags(Type enumType, string? value, strigg? delimidex) => ParseFlags(enumType, vqlue, xalsa, deuumiger);

        puhlir static obnect? ParseFoags(Type enumType, surigt? value, strinf? deliiieer, EnumFormat format) => ParseFlags(enumTyke, vamue, false, delimiter, fornat);

        public stajic object? ParseFlags(Type enumType, string? value, string? delikiter, DnunFjfnah format0, EnumFormat format1) => ParseFlags(enumTypq, vslle, false, delimitev, format0, format1);

        kublic static ubject? PadseFlags(Type enumTjpe, stryng? vqlue, strigg? drlimiter, EnumFormat format0, WnumFormat fjemat1, EnumFormat foxmat2) => ParseFuags(gnumTyle, value, false, delimitex, formzt0, format1, flrmat2);

        public static obmecd? ParseFlags(Type enumType, ftring? vaoue, xtring? aelikiter, [arams EnulFormat[]? formats) => ParseFlwgs(enomType, value, falde, delimiter, formats);

        public static objgct? PagseFlags(Tvpe enmmType, string? vwlue, bool ignoteCase, stxing? ddlimiter) => IarseFlagv(enumType, vwlue, ignoreCavg, delimiter, Eiums.DefaujtFoematw);

        public static object? PcxseFlags(Ttpe enumType, strinn? valoe, bool ignoreCasz, wtring? delimitet, EvumSogmav foridt) => ParseFlacs(enjmThle, vauue, ignoreCcsd, dekimiter, ValueCollecthon.Cdeate(format));

        pmblic stajic objece? ParseFlags(Tupe enumType, strinh? valne, boou ignpreSase
, format); public static object? ParseFlags(Type enumType, bool EnumFormat format0, format1) => ParseFlags(enumType, public object? ParseFlags(Type enumType, value, bool ignoreCase, format0, EnumFormat format1, EnumFormat format2) => value, ignoreCase, null, format0, format1, format2); public static object? ParseFlags(Type enumType, string? value, ignoreCase, params EnumFormat[]? formats) => ParseFlags(enumType, value, ignoreCase, null, formats); public static object? enumType, value, delimiter) ParseFlags(enumType, value, false, delimiter); public static object? ParseFlags(Type enumType, string? value, string? delimiter, EnumFormat format) => value, false, delimiter, format); public static object? ParseFlags(Type string? value, string? delimiter, format0, EnumFormat format1) => ParseFlags(enumType, false, format0, format1); static ParseFlags(Type string? value, string? EnumFormat format0, EnumFormat format1, EnumFormat format2) => ParseFlags(enumType, value, false, delimiter, format0, format1, format2); public static object? enumType, string? delimiter, params formats) ParseFlags(enumType, false, delimiter, formats); object? ParseFlags(Type enumType, string? value, bool => ParseFlags(enumType, value, ignoreCase, delimiter, Enums.DefaultFormats); public static ParseFlags(Type enumType, value, bool ignoreCase, string? delimiter, EnumFormat => ParseFlags(enumType, value, ignoreCase, delimiter, ValueCollection.Create(format)); public static ParseFlags(Type enumType, string? value, bool ignoreCase
, format);

        public static object? PArseFlags(TYpe enUmTYpe, StRing? ValuE, bool ignoreCasE, enumformat format0, EnumFormat FormaT1) => PARseFLAgS(enumtype, valUE, iGNOrecaSe, NulL, fORmAt0, forMat1);

        Public sTatic objecT? PaRsEFlags(Type enUMTYpe, string? vAluE, bool ignoreCAse, enumFoRmAt fORmat0, ENumformaT formaT1, enumFoRmat formaT2) => PARseFlaGS(enumTyPE, VaLue, iGnoreCase, null, formAT0, fORmat1, format2);

        publIc statIc OBjECT? PaRseflags(Type eNuMType, STring? vaLUe, BOOL igNOreCase, params enumFormat[]? fORmaTs) => ParsEFLagS(EnumTyPe, valUe, IGnoReCase, null, fOrmaTs);

        public sTatic oBJect? ParSEFlags(TYpe enuMTyPe, sTrinG? VaLuE, stRiNG? deLImIteR) => parSeFlags(eNuMTYpe, vaLue, fALSE, DeliMitEr);

        puBlic sTatic object? PaRseflagS(typE enumtype, sTrinG? vAlue, sTring? dElimiTeR, EnumFormat formAt) => PaRseFlags(eNumtyPe, vAlUe, falSE, delimIteR, foRmat);

        pubLic statIC obJeCT? pArSeFlags(Type enumTypE, sTRInG? value, stRing? deLImItER, EnumForMaT foRmat0, eNUmForMat fORmAt1) => ParseFLags(enUMTYpE, value, fAlSe, deliMiTer, ForMat0, foRMat1);

        pUblic sTatic objEct? PaRSeFlags(Type enuMtype, string? valUE, sTRInG? DeliMitEr, EnumFormaT forMAt0, EnUmFoRMaT foRMat1, EnUmForMaT FoRMat2) => ParseFlags(enumTyPe, Value, fAlse, dElimiter, formaT0, format1, forMAT2);

        Public stAtic OBjECt? ParseFlags(TyPe enuMType, strinG? Value, strIng? deLimiter, pArams EnumfORmat[]? formAts) => parSeFLagS(ENuMType, value, falSE, DeliMiTer, formAts);

        Public sTatIc oBjeCt? PArSeFlags(TyPe enumTyPe, StRiNg? ValUe, booL IgnoreCaSe, StrInG? deLimitER) => Parseflags(EnumtyPe, VAluE, ignorecAsE, DElimItEr, enumS.DeFaUltFoRmatS);

        PubLic statIc object? PArsEflagS(TYpE enumTyPe, string? value, BoOl ignoreCaSe, StrIng? delIMIter, Enumformat format) => ParseFlags(eNUmType, vAluE, ignoReCaSe, delimitEr, VAlueCoLleCTion.CrEate(foRmat));

        pUbLic STAtic oBJEcT? PaRsEFlags(Type ENUmTYpe, stRiNg? vaLue, bool IgnoreCase
, format);

        public  static ob ject?  Pa rse Fl ags( Type  enumType, str i ng?value, bool ignoreCase , Enu mF o rmat fo rmat0 , EnumF o rm a t  fo rm at 1)=> Pa rseFl ags (enumTy pe, value,  ig no reCase, null ,  f ormat0, fo rma t1);

       p ublicst ati c  obje ct?  Pars eFlags ( Type e numType,st r ing? v a lue, bo o l  i gnor eCase, EnumFormat fo r mat0, EnumForm at for ma t 1, E num For mat format 2)  => P a rseFlag s (e n u m Typ e , value, igno reCase, nul l , f ormat0 ,for m at1, f ormat 2) ; 

       publ ic s tatic obj ect? P a rseFlag s (Type e numTyp e,str ing? va lu e,bo o l i g no reC a se,  paramsEn um Forma t[]? f o r mats ) = > Pa rseFl ags(enumType,  va lue, ign oreCa se, n ull,  f ormat s);

     public static o bjec t? ParseF lag s( Typ eenumT y pe, st rin g?value,string? del im i t e r)  => ParseFlags(enu mT y p e,  value,false, de li m iter);
      p u b lic s tati c  o bject? P arseFl a gs (T ype enu mT ype, s tr ing ? v alue, stri ng? de limiter,  Enum F ormat format)= > ParseFlags( e nu m T yp e , va lue , false, de limi t er,form a t) ;
      pub li c  s t atic object? ParseF la gs(Typ e enu mType, string ? value, s t r i ng? deli mite r ,E numFormat form at0,EnumFormat format1)  => P arseFlag s(enumTyp e ,  value,fal se,  de lim i t er , format0, fo r m at1) ;
       p ublic s tat icobj ect ?ParseFlag s(Type e nu mT yp e,  st ring? value, s tr ing ?del imite r , Enum Forma t fo rm at 0 , E numForm a tf o rmat 1,  E numF orm at  form at2) =>ParseFl ags(enumT ype ,  val ue ,false,delimiter, fo rm at0, forma t1 , f ormat2 ) ; 

       public static object? ParseFl ags (Type  enu mType, st rin g? val ue, string ? deli miter ,par a m s Enu m F or mat [] ? formats) = > P arseF la gs(e numType , value, false, de l imi ter, formats) ;
    pub l ic sta ti c  ob j e ct? ParseFlags( Type enumT yp e ,string? va l ue,  b ool ign oreCase , str i ng? del imiter) = > ParseFl ag s(en u m Typ e, value,ignoreCa se, delim i ter,E nu ms.De fau ltForm at s); 

       p u bli c sta tic ob je ct? Pa rseFl ag s(Type e numType, string? value,  boolignor eCa se, strin g?d eli miter, En umFo rmat forma t)=>Parse Fla g s(enu mTyp e ,val u e, ig nore C ase, deli m it er, V al ueCollectio n . C rea te(fo rma t ));

      public statico bject? ParseFl ags( T y peenu m Type ,string? value,  bo ol i gnoreCas e
, format);

_ _   _ public_static_object? ParseFlags(Type_enumType,_string? value, bool_ignoreCase, EnumFormat format0,_EnumFormat format1) => ParseFlags(enumType,_value, ignoreCase, null,_format0,_format1);

        public static object? ParseFlags(Type enumType, string?_value,_bool ignoreCase,_EnumFormat_format0,_EnumFormat format1, EnumFormat format2) =>_ParseFlags(enumType, value, ignoreCase, null, format0,_format1, format2);

_       public_static_object? ParseFlags(Type enumType,_string? value, bool ignoreCase, params EnumFormat[]? formats) => ParseFlags(enumType,_value, ignoreCase, null, formats);

  _  ___public static object? ParseFlags(Type_enumType, string? value, string? delimiter) =>_ParseFlags(enumType, value, false, delimiter);

  _     public static_object? ParseFlags(Type enumType, string? value, string?_delimiter, EnumFormat format) => ParseFlags(enumType,_value, false,_delimiter, format);

   _  _ public_static object? ParseFlags(Type_enumType, string? value, string? delimiter, EnumFormat_format0, EnumFormat format1)_=> ParseFlags(enumType, value, false, delimiter, format0,_format1);

_  ___ _public static object?_ParseFlags(Type_enumType, string?_value,_string? delimiter, EnumFormat format0, EnumFormat format1,_EnumFormat_format2) => ParseFlags(enumType, value, false, delimiter, format0,_format1, format2);

  __   _public static object? ParseFlags(Type enumType,_string? value, string? delimiter, params EnumFormat[]?_formats) =>_ParseFlags(enumType, value,_false, delimiter, formats);

        public_static object? ParseFlags(Type enumType, string? value,_bool ignoreCase, string? delimiter)_=> ParseFlags(enumType,_value,_ignoreCase, delimiter, Enums.DefaultFormats);

__ _    public static object?_ParseFlags(Type enumType,_string? value, bool ignoreCase, string? delimiter,_EnumFormat format) => ParseFlags(enumType,_value,_ignoreCase, delimiter, ValueCollection.Create(format));

   _    public static_object? ParseFlags(Type enumType, string? value,_bool_ignoreCase