12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237223822392240224122422243224422452246224722482249225022512252225322542255225622572258225922602261226222632264226522662267226822692270227122722273227422752276227722782279228022812282228322842285228622872288228922902291229222932294229522962297229822992300230123022303230423052306230723082309231023112312231323142315231623172318231923202321232223232324232523262327232823292330233123322333233423352336233723382339234023412342234323442345234623472348234923502351235223532354235523562357235823592360236123622363236423652366236723682369237023712372237323742375237623772378237923802381238223832384238523862387238823892390239123922393239423952396239723982399240024012402240324042405240624072408240924102411241224132414241524162417241824192420242124222423242424252426242724282429243024312432243324342435243624372438243924402441244224432444244524462447244824492450245124522453245424552456245724582459246024612462246324642465246624672468246924702471247224732474247524762477247824792480248124822483248424852486248724882489249024912492249324942495249624972498249925002501250225032504250525062507250825092510251125122513251425152516251725182519252025212522252325242525252625272528252925302531253225332534253525362537253825392540254125422543254425452546254725482549255025512552255325542555255625572558255925602561256225632564256525662567256825692570257125722573257425752576257725782579258025812582258325842585258625872588258925902591259225932594259525962597259825992600260126022603260426052606260726082609261026112612261326142615261626172618261926202621262226232624262526262627262826292630263126322633263426352636263726382639264026412642264326442645264626472648264926502651265226532654265526562657265826592660266126622663266426652666266726682669267026712672267326742675267626772678267926802681268226832684268526862687268826892690269126922693269426952696269726982699270027012702270327042705270627072708270927102711271227132714271527162717271827192720272127222723272427252726272727282729273027312732273327342735273627372738273927402741274227432744274527462747274827492750275127522753275427552756275727582759276027612762276327642765276627672768276927702771277227732774277527762777277827792780278127822783278427852786278727882789279027912792279327942795279627972798279928002801280228032804280528062807280828092810281128122813281428152816281728182819282028212822282328242825282628272828282928302831283228332834283528362837283828392840284128422843284428452846284728482849285028512852285328542855285628572858285928602861286228632864286528662867286828692870287128722873287428752876287728782879288028812882288328842885288628872888288928902891289228932894289528962897289828992900290129022903290429052906290729082909291029112912291329142915291629172918291929202921292229232924292529262927292829292930293129322933293429352936293729382939294029412942294329442945294629472948294929502951295229532954295529562957295829592960296129622963296429652966296729682969297029712972297329742975297629772978297929802981298229832984298529862987298829892990299129922993299429952996299729982999300030013002300330043005300630073008300930103011301230133014301530163017301830193020302130223023302430253026302730283029303030313032303330343035303630373038303930403041304230433044304530463047304830493050305130523053305430553056305730583059306030613062306330643065306630673068306930703071307230733074307530763077307830793080308130823083308430853086308730883089309030913092309330943095309630973098309931003101310231033104310531063107310831093110311131123113311431153116311731183119312031213122312331243125312631273128312931303131313231333134313531363137313831393140314131423143314431453146314731483149315031513152315331543155315631573158315931603161316231633164316531663167316831693170317131723173317431753176317731783179318031813182318331843185318631873188318931903191319231933194319531963197319831993200320132023203320432053206320732083209321032113212321332143215321632173218321932203221322232233224322532263227322832293230323132323233323432353236323732383239324032413242324332443245324632473248324932503251325232533254325532563257325832593260326132623263326432653266326732683269327032713272327332743275327632773278327932803281328232833284328532863287328832893290329132923293329432953296329732983299330033013302330333043305330633073308330933103311331233133314331533163317331833193320332133223323332433253326332733283329333033313332333333343335333633373338333933403341334233433344334533463347334833493350335133523353335433553356335733583359336033613362336333643365336633673368336933703371337233733374337533763377337833793380338133823383338433853386338733883389339033913392339333943395339633973398339934003401340234033404340534063407340834093410341134123413341434153416341734183419342034213422342334243425342634273428342934303431343234333434343534363437343834393440344134423443344434453446344734483449345034513452345334543455345634573458345934603461346234633464346534663467346834693470347134723473347434753476347734783479348034813482348334843485348634873488348934903491349234933494349534963497349834993500350135023503350435053506350735083509351035113512351335143515351635173518351935203521352235233524352535263527352835293530353135323533353435353536353735383539354035413542354335443545354635473548354935503551355235533554355535563557355835593560356135623563356435653566356735683569357035713572357335743575357635773578357935803581358235833584358535863587358835893590359135923593359435953596359735983599360036013602360336043605360636073608360936103611361236133614361536163617361836193620362136223623362436253626362736283629363036313632363336343635363636373638363936403641364236433644364536463647364836493650365136523653365436553656365736583659366036613662366336643665366636673668366936703671367236733674367536763677367836793680368136823683368436853686368736883689369036913692369336943695369636973698369937003701370237033704370537063707370837093710371137123713371437153716371737183719372037213722372337243725372637273728372937303731373237333734373537363737373837393740374137423743374437453746374737483749375037513752375337543755375637573758375937603761376237633764376537663767376837693770377137723773377437753776377737783779378037813782378337843785378637873788378937903791379237933794379537963797379837993800380138023803380438053806380738083809381038113812381338143815381638173818381938203821382238233824382538263827382838293830383138323833383438353836383738383839384038413842384338443845384638473848384938503851385238533854385538563857385838593860386138623863386438653866386738683869387038713872387338743875387638773878387938803881388238833884388538863887388838893890389138923893389438953896389738983899390039013902390339043905390639073908390939103911391239133914391539163917391839193920392139223923392439253926392739283929393039313932393339343935393639373938393939403941394239433944394539463947394839493950395139523953395439553956395739583959396039613962396339643965396639673968396939703971397239733974397539763977397839793980398139823983398439853986398739883989399039913992399339943995399639973998399940004001400240034004400540064007400840094010401140124013401440154016401740184019402040214022402340244025402640274028402940304031403240334034403540364037403840394040404140424043404440454046404740484049405040514052405340544055405640574058405940604061406240634064406540664067406840694070407140724073407440754076407740784079408040814082408340844085408640874088408940904091409240934094409540964097409840994100410141024103410441054106410741084109411041114112411341144115411641174118411941204121412241234124412541264127412841294130413141324133413441354136413741384139414041414142414341444145414641474148414941504151415241534154415541564157415841594160416141624163416441654166416741684169417041714172417341744175417641774178417941804181418241834184418541864187418841894190419141924193419441954196419741984199420042014202420342044205420642074208420942104211421242134214421542164217421842194220422142224223422442254226422742284229423042314232423342344235423642374238423942404241424242434244424542464247424842494250425142524253425442554256425742584259426042614262426342644265426642674268426942704271427242734274427542764277427842794280428142824283428442854286428742884289429042914292429342944295429642974298429943004301430243034304430543064307430843094310431143124313431443154316431743184319432043214322432343244325432643274328432943304331433243334334433543364337433843394340434143424343434443454346434743484349435043514352435343544355435643574358435943604361436243634364436543664367436843694370437143724373437443754376437743784379438043814382438343844385438643874388438943904391439243934394439543964397439843994400440144024403440444054406440744084409441044114412441344144415441644174418441944204421442244234424442544264427442844294430443144324433443444354436443744384439444044414442444344444445444644474448444944504451445244534454445544564457445844594460446144624463446444654466446744684469447044714472447344744475447644774478447944804481448244834484448544864487448844894490449144924493449444954496449744984499450045014502450345044505450645074508450945104511451245134514451545164517451845194520452145224523452445254526452745284529453045314532453345344535453645374538453945404541454245434544454545464547454845494550455145524553455445554556455745584559456045614562456345644565456645674568456945704571457245734574457545764577457845794580458145824583458445854586458745884589459045914592459345944595459645974598459946004601460246034604460546064607460846094610461146124613461446154616461746184619462046214622462346244625462646274628462946304631463246334634463546364637463846394640464146424643464446454646464746484649465046514652465346544655465646574658465946604661466246634664466546664667466846694670467146724673467446754676467746784679468046814682468346844685468646874688468946904691469246934694469546964697469846994700470147024703470447054706470747084709471047114712471347144715471647174718471947204721472247234724472547264727472847294730473147324733473447354736473747384739474047414742474347444745474647474748474947504751475247534754475547564757475847594760476147624763476447654766476747684769477047714772477347744775477647774778477947804781478247834784478547864787478847894790479147924793479447954796479747984799480048014802480348044805480648074808480948104811481248134814481548164817481848194820482148224823482448254826482748284829483048314832483348344835483648374838483948404841484248434844484548464847484848494850485148524853485448554856485748584859486048614862486348644865486648674868486948704871487248734874487548764877487848794880488148824883488448854886488748884889489048914892489348944895489648974898489949004901490249034904490549064907490849094910491149124913491449154916491749184919492049214922492349244925492649274928492949304931493249334934493549364937493849394940494149424943494449454946494749484949495049514952495349544955495649574958495949604961496249634964496549664967496849694970497149724973497449754976497749784979498049814982498349844985498649874988498949904991499249934994499549964997499849995000500150025003500450055006500750085009501050115012501350145015501650175018501950205021502250235024502550265027502850295030503150325033503450355036503750385039504050415042504350445045504650475048504950505051505250535054505550565057505850595060506150625063506450655066506750685069507050715072507350745075507650775078507950805081508250835084508550865087508850895090509150925093509450955096509750985099510051015102510351045105510651075108510951105111511251135114511551165117511851195120512151225123512451255126512751285129513051315132513351345135513651375138513951405141514251435144514551465147514851495150515151525153515451555156515751585159516051615162516351645165516651675168516951705171517251735174517551765177517851795180518151825183518451855186518751885189519051915192519351945195519651975198519952005201520252035204520552065207520852095210521152125213521452155216521752185219522052215222522352245225522652275228522952305231523252335234523552365237523852395240524152425243524452455246524752485249525052515252525352545255525652575258525952605261526252635264526552665267526852695270527152725273527452755276527752785279528052815282528352845285528652875288528952905291529252935294529552965297529852995300530153025303530453055306530753085309531053115312531353145315531653175318531953205321532253235324532553265327532853295330533153325333533453355336533753385339534053415342534353445345534653475348534953505351535253535354535553565357535853595360536153625363536453655366536753685369537053715372537353745375537653775378537953805381538253835384538553865387538853895390539153925393539453955396539753985399540054015402540354045405540654075408540954105411541254135414541554165417541854195420542154225423542454255426542754285429543054315432543354345435543654375438543954405441544254435444544554465447544854495450545154525453545454555456545754585459546054615462546354645465546654675468546954705471547254735474547554765477547854795480548154825483548454855486548754885489549054915492549354945495549654975498549955005501550255035504550555065507550855095510551155125513551455155516551755185519552055215522552355245525552655275528552955305531553255335534553555365537553855395540554155425543554455455546554755485549555055515552555355545555555655575558555955605561556255635564556555665567556855695570557155725573557455755576557755785579558055815582558355845585558655875588558955905591559255935594559555965597559855995600560156025603560456055606560756085609561056115612561356145615561656175618561956205621562256235624562556265627562856295630563156325633563456355636563756385639564056415642564356445645564656475648564956505651565256535654565556565657565856595660566156625663566456655666566756685669567056715672567356745675567656775678567956805681568256835684568556865687568856895690569156925693569456955696569756985699570057015702570357045705570657075708570957105711571257135714571557165717571857195720572157225723572457255726572757285729573057315732573357345735573657375738573957405741574257435744574557465747574857495750575157525753575457555756575757585759576057615762576357645765576657675768576957705771577257735774577557765777577857795780578157825783578457855786578757885789579057915792579357945795579657975798579958005801580258035804580558065807580858095810581158125813581458155816581758185819582058215822582358245825582658275828582958305831583258335834583558365837583858395840584158425843584458455846584758485849585058515852585358545855585658575858585958605861586258635864586558665867586858695870587158725873587458755876587758785879588058815882588358845885588658875888588958905891589258935894589558965897589858995900590159025903590459055906590759085909591059115912591359145915591659175918591959205921592259235924592559265927592859295930593159325933593459355936593759385939594059415942594359445945594659475948594959505951595259535954595559565957595859595960596159625963596459655966596759685969597059715972597359745975597659775978597959805981598259835984598559865987598859895990599159925993599459955996599759985999600060016002600360046005600660076008600960106011601260136014601560166017601860196020602160226023602460256026602760286029603060316032603360346035603660376038603960406041604260436044604560466047604860496050605160526053605460556056605760586059606060616062606360646065606660676068606960706071607260736074607560766077607860796080608160826083608460856086608760886089609060916092609360946095609660976098609961006101610261036104610561066107610861096110611161126113611461156116611761186119612061216122612361246125612661276128612961306131613261336134613561366137613861396140614161426143614461456146614761486149615061516152615361546155615661576158615961606161616261636164616561666167616861696170617161726173617461756176617761786179618061816182618361846185618661876188618961906191619261936194619561966197619861996200620162026203620462056206620762086209621062116212621362146215621662176218621962206221622262236224622562266227622862296230623162326233623462356236623762386239624062416242624362446245624662476248624962506251625262536254625562566257625862596260626162626263626462656266626762686269627062716272627362746275627662776278627962806281628262836284628562866287628862896290629162926293629462956296629762986299630063016302630363046305630663076308630963106311631263136314631563166317631863196320632163226323632463256326632763286329633063316332633363346335633663376338633963406341634263436344634563466347634863496350635163526353635463556356635763586359636063616362636363646365636663676368636963706371637263736374637563766377637863796380638163826383638463856386638763886389639063916392639363946395639663976398639964006401640264036404640564066407640864096410641164126413641464156416641764186419642064216422642364246425642664276428642964306431643264336434643564366437643864396440644164426443644464456446644764486449645064516452645364546455645664576458645964606461646264636464646564666467646864696470647164726473647464756476647764786479648064816482648364846485648664876488648964906491649264936494649564966497649864996500650165026503650465056506650765086509651065116512651365146515651665176518651965206521652265236524652565266527652865296530653165326533653465356536653765386539654065416542654365446545654665476548654965506551655265536554655565566557655865596560656165626563656465656566656765686569657065716572657365746575657665776578657965806581658265836584658565866587658865896590659165926593659465956596659765986599660066016602660366046605660666076608660966106611661266136614661566166617661866196620662166226623662466256626662766286629663066316632663366346635663666376638663966406641664266436644664566466647664866496650665166526653665466556656665766586659666066616662666366646665666666676668666966706671667266736674667566766677667866796680668166826683668466856686668766886689669066916692669366946695669666976698669967006701670267036704670567066707670867096710671167126713671467156716671767186719672067216722672367246725672667276728672967306731673267336734673567366737673867396740674167426743674467456746674767486749675067516752675367546755675667576758675967606761676267636764676567666767676867696770677167726773677467756776677767786779678067816782678367846785678667876788678967906791679267936794679567966797679867996800680168026803680468056806680768086809681068116812681368146815681668176818681968206821682268236824682568266827682868296830683168326833683468356836683768386839684068416842684368446845684668476848684968506851685268536854685568566857685868596860686168626863686468656866686768686869687068716872687368746875687668776878687968806881688268836884688568866887688868896890689168926893689468956896689768986899690069016902690369046905690669076908690969106911691269136914691569166917691869196920692169226923692469256926692769286929693069316932693369346935693669376938693969406941694269436944694569466947694869496950695169526953695469556956695769586959696069616962696369646965696669676968696969706971697269736974697569766977697869796980698169826983698469856986698769886989699069916992699369946995699669976998699970007001700270037004700570067007700870097010701170127013701470157016701770187019702070217022702370247025702670277028702970307031703270337034703570367037703870397040704170427043704470457046704770487049705070517052705370547055705670577058705970607061706270637064706570667067706870697070707170727073707470757076707770787079708070817082708370847085708670877088708970907091709270937094709570967097709870997100710171027103710471057106710771087109711071117112711371147115711671177118711971207121712271237124712571267127712871297130713171327133713471357136713771387139714071417142714371447145714671477148714971507151715271537154715571567157715871597160716171627163716471657166716771687169717071717172717371747175717671777178717971807181718271837184718571867187718871897190719171927193719471957196719771987199720072017202720372047205720672077208720972107211721272137214721572167217721872197220722172227223722472257226722772287229723072317232723372347235723672377238723972407241724272437244724572467247724872497250725172527253725472557256725772587259726072617262726372647265726672677268726972707271727272737274727572767277727872797280728172827283728472857286728772887289729072917292729372947295729672977298729973007301730273037304730573067307730873097310731173127313731473157316731773187319732073217322732373247325732673277328732973307331733273337334733573367337733873397340734173427343734473457346734773487349735073517352735373547355735673577358735973607361736273637364736573667367736873697370737173727373737473757376737773787379738073817382738373847385738673877388738973907391739273937394739573967397739873997400740174027403740474057406740774087409741074117412741374147415741674177418741974207421742274237424742574267427742874297430743174327433743474357436743774387439744074417442744374447445744674477448744974507451745274537454745574567457745874597460746174627463746474657466746774687469747074717472747374747475747674777478747974807481748274837484748574867487748874897490749174927493749474957496749774987499750075017502750375047505750675077508750975107511751275137514751575167517751875197520752175227523752475257526752775287529753075317532753375347535753675377538753975407541754275437544754575467547754875497550755175527553755475557556755775587559756075617562756375647565756675677568756975707571757275737574757575767577757875797580758175827583758475857586758775887589759075917592759375947595759675977598759976007601760276037604760576067607760876097610761176127613761476157616761776187619762076217622762376247625762676277628762976307631763276337634763576367637763876397640764176427643764476457646764776487649765076517652765376547655765676577658765976607661766276637664766576667667766876697670767176727673767476757676767776787679768076817682768376847685768676877688768976907691769276937694769576967697769876997700770177027703770477057706770777087709771077117712771377147715771677177718771977207721772277237724772577267727772877297730773177327733773477357736773777387739774077417742774377447745774677477748774977507751775277537754775577567757775877597760776177627763776477657766776777687769777077717772777377747775777677777778777977807781778277837784778577867787778877897790779177927793779477957796779777987799780078017802780378047805780678077808780978107811781278137814781578167817781878197820782178227823782478257826782778287829783078317832783378347835783678377838783978407841784278437844784578467847784878497850785178527853785478557856785778587859786078617862786378647865786678677868786978707871787278737874787578767877787878797880788178827883788478857886788778887889789078917892789378947895789678977898789979007901790279037904790579067907790879097910791179127913791479157916791779187919792079217922792379247925792679277928792979307931793279337934793579367937793879397940794179427943794479457946794779487949795079517952795379547955795679577958795979607961796279637964796579667967796879697970797179727973797479757976797779787979798079817982798379847985798679877988798979907991799279937994799579967997799879998000800180028003800480058006800780088009801080118012801380148015801680178018801980208021802280238024802580268027802880298030803180328033803480358036803780388039804080418042804380448045804680478048804980508051805280538054805580568057805880598060806180628063806480658066806780688069807080718072807380748075807680778078807980808081808280838084808580868087808880898090809180928093809480958096809780988099810081018102810381048105810681078108810981108111811281138114811581168117811881198120812181228123812481258126812781288129813081318132813381348135813681378138813981408141814281438144814581468147814881498150815181528153815481558156815781588159816081618162816381648165816681678168816981708171817281738174817581768177817881798180818181828183818481858186818781888189819081918192819381948195819681978198819982008201820282038204820582068207820882098210821182128213821482158216821782188219822082218222822382248225822682278228822982308231823282338234823582368237823882398240824182428243824482458246824782488249825082518252825382548255825682578258825982608261826282638264826582668267826882698270827182728273827482758276827782788279828082818282828382848285828682878288828982908291829282938294829582968297829882998300830183028303830483058306830783088309831083118312831383148315831683178318831983208321832283238324832583268327832883298330833183328333833483358336833783388339834083418342834383448345834683478348834983508351835283538354835583568357835883598360836183628363836483658366836783688369837083718372837383748375837683778378837983808381838283838384838583868387838883898390839183928393839483958396839783988399840084018402840384048405840684078408840984108411841284138414841584168417841884198420842184228423842484258426842784288429843084318432843384348435843684378438843984408441844284438444844584468447844884498450845184528453845484558456845784588459846084618462846384648465846684678468846984708471847284738474847584768477847884798480848184828483848484858486848784888489849084918492849384948495849684978498849985008501850285038504850585068507850885098510851185128513851485158516851785188519852085218522852385248525852685278528852985308531853285338534853585368537853885398540854185428543854485458546854785488549855085518552855385548555855685578558855985608561856285638564856585668567856885698570857185728573857485758576857785788579858085818582858385848585858685878588858985908591859285938594859585968597859885998600860186028603860486058606860786088609861086118612861386148615861686178618861986208621862286238624862586268627862886298630863186328633863486358636863786388639864086418642864386448645864686478648864986508651865286538654865586568657865886598660866186628663866486658666866786688669867086718672867386748675867686778678867986808681868286838684868586868687868886898690869186928693869486958696869786988699870087018702870387048705870687078708870987108711871287138714871587168717871887198720872187228723872487258726872787288729873087318732873387348735873687378738873987408741874287438744874587468747874887498750875187528753875487558756875787588759876087618762876387648765876687678768876987708771877287738774877587768777877887798780878187828783878487858786878787888789879087918792879387948795879687978798879988008801880288038804880588068807880888098810881188128813881488158816881788188819882088218822882388248825882688278828882988308831883288338834883588368837883888398840884188428843884488458846884788488849885088518852885388548855885688578858885988608861886288638864886588668867886888698870887188728873887488758876887788788879888088818882888388848885888688878888888988908891889288938894889588968897889888998900890189028903890489058906890789088909891089118912891389148915891689178918891989208921892289238924892589268927892889298930893189328933893489358936893789388939894089418942894389448945894689478948894989508951895289538954895589568957895889598960896189628963896489658966896789688969897089718972897389748975897689778978897989808981898289838984898589868987898889898990899189928993899489958996899789988999900090019002900390049005900690079008900990109011901290139014901590169017901890199020902190229023902490259026902790289029903090319032903390349035903690379038903990409041904290439044904590469047904890499050905190529053905490559056905790589059906090619062906390649065906690679068906990709071907290739074907590769077907890799080908190829083908490859086908790889089909090919092909390949095909690979098909991009101910291039104910591069107910891099110911191129113911491159116911791189119912091219122912391249125912691279128912991309131913291339134913591369137913891399140914191429143914491459146914791489149915091519152915391549155915691579158915991609161916291639164916591669167916891699170917191729173917491759176917791789179918091819182918391849185918691879188918991909191919291939194919591969197919891999200920192029203920492059206920792089209921092119212921392149215921692179218921992209221922292239224922592269227922892299230923192329233923492359236923792389239924092419242924392449245924692479248924992509251925292539254925592569257925892599260926192629263926492659266926792689269927092719272927392749275927692779278927992809281928292839284928592869287928892899290929192929293929492959296929792989299930093019302930393049305930693079308930993109311931293139314931593169317931893199320932193229323932493259326932793289329933093319332933393349335933693379338933993409341934293439344934593469347934893499350935193529353935493559356935793589359936093619362936393649365936693679368936993709371937293739374937593769377937893799380938193829383938493859386938793889389939093919392939393949395939693979398939994009401940294039404940594069407940894099410941194129413941494159416941794189419942094219422942394249425942694279428942994309431943294339434943594369437943894399440944194429443944494459446944794489449945094519452945394549455945694579458945994609461946294639464946594669467946894699470947194729473947494759476947794789479948094819482948394849485948694879488948994909491949294939494949594969497949894999500950195029503950495059506950795089509951095119512951395149515951695179518951995209521952295239524952595269527952895299530953195329533953495359536953795389539954095419542954395449545954695479548954995509551955295539554955595569557955895599560956195629563956495659566956795689569957095719572957395749575957695779578957995809581958295839584958595869587958895899590959195929593959495959596959795989599960096019602960396049605960696079608960996109611961296139614961596169617961896199620962196229623962496259626962796289629963096319632963396349635963696379638963996409641964296439644964596469647964896499650965196529653965496559656965796589659966096619662966396649665966696679668966996709671967296739674967596769677967896799680968196829683968496859686968796889689969096919692969396949695969696979698969997009701970297039704970597069707970897099710971197129713971497159716971797189719972097219722972397249725972697279728972997309731973297339734973597369737973897399740974197429743974497459746974797489749975097519752975397549755975697579758975997609761976297639764976597669767976897699770977197729773977497759776977797789779978097819782978397849785978697879788978997909791979297939794979597969797979897999800980198029803980498059806980798089809981098119812981398149815981698179818981998209821982298239824982598269827982898299830983198329833983498359836983798389839984098419842984398449845984698479848984998509851985298539854985598569857985898599860986198629863986498659866986798689869987098719872987398749875987698779878987998809881988298839884988598869887988898899890989198929893989498959896989798989899990099019902990399049905990699079908990999109911991299139914991599169917991899199920992199229923992499259926992799289929993099319932993399349935993699379938993999409941994299439944994599469947994899499950995199529953995499559956995799589959996099619962996399649965996699679968996999709971997299739974997599769977997899799980998199829983998499859986998799889989999099919992999399949995999699979998999910000100011000210003100041000510006100071000810009100101001110012100131001410015100161001710018100191002010021100221002310024100251002610027100281002910030100311003210033100341003510036100371003810039100401004110042100431004410045100461004710048100491005010051100521005310054100551005610057100581005910060100611006210063100641006510066100671006810069100701007110072100731007410075100761007710078100791008010081100821008310084100851008610087100881008910090100911009210093100941009510096100971009810099101001010110102101031010410105101061010710108101091011010111101121011310114101151011610117101181011910120101211012210123101241012510126101271012810129101301013110132101331013410135101361013710138101391014010141101421014310144101451014610147101481014910150101511015210153101541015510156101571015810159101601016110162101631016410165101661016710168101691017010171101721017310174101751017610177101781017910180101811018210183101841018510186101871018810189101901019110192101931019410195101961019710198101991020010201102021020310204102051020610207102081020910210102111021210213102141021510216102171021810219102201022110222102231022410225102261022710228102291023010231102321023310234102351023610237102381023910240102411024210243102441024510246102471024810249102501025110252102531025410255102561025710258102591026010261102621026310264102651026610267102681026910270102711027210273102741027510276102771027810279102801028110282102831028410285102861028710288102891029010291102921029310294102951029610297102981029910300103011030210303103041030510306103071030810309103101031110312103131031410315103161031710318103191032010321103221032310324103251032610327103281032910330103311033210333103341033510336103371033810339103401034110342103431034410345103461034710348103491035010351103521035310354103551035610357103581035910360103611036210363103641036510366103671036810369103701037110372103731037410375103761037710378103791038010381103821038310384103851038610387103881038910390103911039210393103941039510396103971039810399104001040110402104031040410405104061040710408104091041010411104121041310414104151041610417104181041910420104211042210423104241042510426104271042810429104301043110432104331043410435104361043710438104391044010441104421044310444104451044610447104481044910450104511045210453104541045510456104571045810459104601046110462104631046410465104661046710468104691047010471104721047310474104751047610477
// NOTE: This file is generated. Do NOT modify it manually.import type { Denops } from "https://deno.land/x/denops_core@v3.0.1/mod.ts";import { globalOptions, localOptions, options } from "./../variable/mod.ts";
/** * 		{only available when compiled with the |+rightleft| * 		feature} * The ASCII code for the first letter of the Hebrew alphabet.  The * routine that maps the keyboard in Hebrew mode, both in Insert mode * (when hkmap is set) and on the command-line (when hitting CTRL-_) * outputs the Hebrew characters in the range [aleph..aleph+26]. * aleph=128 applies to PC code, and aleph=224 applies to ISO 8859-8. * See |rileft.txt|. */export const aleph = {  async get(denops: Denops): Promise<number> {    return await options.get(denops, "aleph") ?? 0;  },  set(denops: Denops, value: number): Promise<void> {    return options.set(denops, "aleph", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "aleph");  },  async getGlobal(denops: Denops): Promise<number> {    return await globalOptions.get(denops, "aleph") ?? 0;  },  setGlobal(denops: Denops, value: number): Promise<void> {    return globalOptions.set(denops, "aleph", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "aleph");  },};
/** * 		{only available when compiled with the |+rightleft| * 		feature} * Allow CTRL-_ in Insert and Command-line mode.  This is default off, to * avoid that users that accidentally type CTRL-_ instead of SHIFT-_ get * into reverse Insert mode, and don't know how to get out.  See * 'revins'. * NOTE: This option is reset when 'compatible' is set. */export const allowrevins = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "allowrevins") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "allowrevins", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "allowrevins");  },  async getGlobal(denops: Denops): Promise<boolean> {    return await globalOptions.get(denops, "allowrevins") ?? false;  },  setGlobal(denops: Denops, value: boolean): Promise<void> {    return globalOptions.set(denops, "allowrevins", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "allowrevins");  },};
/** * Only effective when 'encoding' is "utf-8" or another Unicode encoding. * Tells Vim what to do with characters with East Asian Width Class * Ambiguous (such as Euro, Registered Sign, Copyright Sign, Greek * letters, Cyrillic letters). */export const ambiwidth = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "ambiwidth") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "ambiwidth", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "ambiwidth");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "ambiwidth") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "ambiwidth", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "ambiwidth");  },};
/** * 		{only available when compiled with it, use * 		exists("+autochdir") to check} * When on, Vim will change the current working directory whenever you * open a file, switch buffers, delete a buffer or open/close a window. * It will change to the directory containing the file which was opened * or selected. * Note: When this option is on some plugins may not work. */export const autochdir = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "autochdir") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "autochdir", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "autochdir");  },  async getGlobal(denops: Denops): Promise<boolean> {    return await globalOptions.get(denops, "autochdir") ?? false;  },  setGlobal(denops: Denops, value: boolean): Promise<void> {    return globalOptions.set(denops, "autochdir", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "autochdir");  },};
/** * 		{only available when compiled with the |+arabic| * 		feature} * This option can be set to start editing Arabic text. * Setting this option will: * - Set the 'rightleft' option, unless 'termbidi' is set. * - Set the 'arabicshape' option, unless 'termbidi' is set. * - Set the 'keymap' option to "arabic"; in Insert mode CTRL-^ toggles *   between typing English and Arabic key mapping. * - Set the 'delcombine' option * Note that 'encoding' must be "utf-8" for working with Arabic text. */export const arabic = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "arabic") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "arabic", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "arabic");  },  async getLocal(denops: Denops): Promise<boolean> {    return await localOptions.get(denops, "arabic") ?? false;  },  setLocal(denops: Denops, value: boolean): Promise<void> {    return localOptions.set(denops, "arabic", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "arabic");  },};
/** * 		{only available when compiled with the |+arabic| * 		feature} * When on and 'termbidi' is off, the required visual character * corrections that need to take place for displaying the Arabic language * take effect.  Shaping, in essence, gets enabled; the term is a broad * one which encompasses: *   a) the changing/morphing of characters based on their location *      within a word (initial, medial, final and stand-alone). *   b) the enabling of the ability to compose characters *   c) the enabling of the required combining of some characters * When disabled the display shows each character's true stand-alone * form. * Arabic is a complex language which requires other settings, for * further details see |arabic.txt|. * NOTE: This option is set when 'compatible' is set. */export const arabicshape = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "arabicshape") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "arabicshape", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "arabicshape");  },  async getGlobal(denops: Denops): Promise<boolean> {    return await globalOptions.get(denops, "arabicshape") ?? false;  },  setGlobal(denops: Denops, value: boolean): Promise<void> {    return globalOptions.set(denops, "arabicshape", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "arabicshape");  },};
/** * Copy indent from current line when starting a new line (typing <CR> * in Insert mode or when using the "o" or "O" command).  If you do not * type anything on the new line except <BS> or CTRL-D and then type * <Esc>, CTRL-O or <CR>, the indent is deleted again.  Moving the cursor * to another line has the same effect, unless the 'I' flag is included * in 'cpoptions'. * When autoindent is on, formatting (with the "gq" command or when you * reach 'textwidth' in Insert mode) uses the indentation of the first * line. * When 'smartindent' or 'cindent' is on the indent is changed in * a different way. * The 'autoindent' option is reset when the 'paste' option is set and * restored when 'paste' is reset. */export const autoindent = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "autoindent") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "autoindent", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "autoindent");  },  async getLocal(denops: Denops): Promise<boolean> {    return await localOptions.get(denops, "autoindent") ?? false;  },  setLocal(denops: Denops, value: boolean): Promise<void> {    return localOptions.set(denops, "autoindent", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "autoindent");  },};
/** * When a file has been detected to have been changed outside of Vim and * it has not been changed inside of Vim, automatically read it again. * When the file has been deleted this is not done, so you have the text * from before it was deleted.  When it appears again then it is read. * |timestamp| * If this option has a local value, use this command to switch back to * using the global value: > * 	:set autoread< * < */export const autoread = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "autoread") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "autoread", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "autoread");  },  async getGlobal(denops: Denops): Promise<boolean> {    return await globalOptions.get(denops, "autoread") ?? false;  },  setGlobal(denops: Denops, value: boolean): Promise<void> {    return globalOptions.set(denops, "autoread", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "autoread");  },  async getLocal(denops: Denops): Promise<boolean> {    return await localOptions.get(denops, "autoread") ?? false;  },  setLocal(denops: Denops, value: boolean): Promise<void> {    return localOptions.set(denops, "autoread", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "autoread");  },};
/** * Write the contents of the file, if it has been modified, on each * :next, :rewind, :last, :first, :previous, :stop, :suspend, :tag, :!, * :make, CTRL-] and CTRL-^ command; and when a :buffer, CTRL-O, CTRL-I, * '{A-Z0-9}, or `{A-Z0-9} command takes one to another file. * Note that for some commands the 'autowrite' option is not used, see * 'autowriteall' for that. * Some buffers will not be written, specifically when 'buftype' is * "nowrite", "nofile", "terminal" or "prompt". */export const autowrite = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "autowrite") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "autowrite", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "autowrite");  },  async getGlobal(denops: Denops): Promise<boolean> {    return await globalOptions.get(denops, "autowrite") ?? false;  },  setGlobal(denops: Denops, value: boolean): Promise<void> {    return globalOptions.set(denops, "autowrite", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "autowrite");  },};
/** * Like 'autowrite', but also used for commands ":edit", ":enew", ":quit", * ":qall", ":exit", ":xit", ":recover" and closing the Vim window. * Setting this option also implies that Vim behaves like 'autowrite' has * been set. */export const autowriteall = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "autowriteall") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "autowriteall", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "autowriteall");  },  async getGlobal(denops: Denops): Promise<boolean> {    return await globalOptions.get(denops, "autowriteall") ?? false;  },  setGlobal(denops: Denops, value: boolean): Promise<void> {    return globalOptions.set(denops, "autowriteall", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "autowriteall");  },};
/** * When set to "dark", Vim will try to use colors that look good on a * dark background.  When set to "light", Vim will try to use colors that * look good on a light background.  Any other value is illegal. * Vim tries to set the default value according to the terminal used. * This will not always be correct. * Setting this option does not change the background color, it tells Vim * what the background color looks like.  For changing the background * color, see |:hi-normal|. */export const background = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "background") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "background", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "background");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "background") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "background", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "background");  },};
/** * Influences the working of <BS>, <Del>, CTRL-W and CTRL-U in Insert * mode.  This is a list of items, separated by commas.  Each item allows * a way to backspace over something: * value	effect	~ * indent	allow backspacing over autoindent * eol	allow backspacing over line breaks (join lines) * start	allow backspacing over the start of insert; CTRL-W and CTRL-U * 	stop once at the start of insert. * nostop	like start, except CTRL-W and CTRL-U do not stop at the start of * 	insert. */export const backspace = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "backspace") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "backspace", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "backspace");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "backspace") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "backspace", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "backspace");  },};
/** * Make a backup before overwriting a file.  Leave it around after the * file has been successfully written.  If you do not want to keep the * backup file, but you do want a backup while the file is being * written, reset this option and set the 'writebackup' option (this is * the default).  If you do not want a backup file at all reset both * options (use this if your file system is almost full).  See the * |backup-table| for more explanations. * When the 'backupskip' pattern matches, a backup is not made anyway. * When 'patchmode' is set, the backup may be renamed to become the * oldest version of a file. * NOTE: This option is reset when 'compatible' is set. */export const backup = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "backup") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "backup", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "backup");  },  async getGlobal(denops: Denops): Promise<boolean> {    return await globalOptions.get(denops, "backup") ?? false;  },  setGlobal(denops: Denops, value: boolean): Promise<void> {    return globalOptions.set(denops, "backup", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "backup");  },};
/** * When writing a file and a backup is made, this option tells how it's * done.  This is a comma separated list of words. */export const backupcopy = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "backupcopy") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "backupcopy", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "backupcopy");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "backupcopy") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "backupcopy", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "backupcopy");  },  async getLocal(denops: Denops): Promise<string> {    return await localOptions.get(denops, "backupcopy") ?? "";  },  setLocal(denops: Denops, value: string): Promise<void> {    return localOptions.set(denops, "backupcopy", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "backupcopy");  },};
/** * List of directories for the backup file, separated with commas. * - The backup file will be created in the first directory in the list *   where this is possible.  The directory must exist, Vim will not *   create it for you. * - Empty means that no backup file will be created ('patchmode' is *   impossible!).  Writing may fail because of this. * - A directory "." means to put the backup file in the same directory *   as the edited file. * - A directory starting with "./" (or ".\" for MS-Windows) means to put *   the backup file relative to where the edited file is.  The leading *   "." is replaced with the path name of the edited file. *   ("." inside a directory name has no special meaning). * - Spaces after the comma are ignored, other spaces are considered part *   of the directory name.  To have a space at the start of a directory *   name, precede it with a backslash. * - To include a comma in a directory name precede it with a backslash. * - A directory name may end in an '/'. * - For Unix and Win32, if a directory ends in two path separators "//", *   the backup file name will be built from the complete path to the *   file with all path separators changed to percent '%' signs. This *   will ensure file name uniqueness in the backup directory. *   On Win32, it is also possible to end with "\\".  However, When a *   separating comma is following, you must use "//", since "\\" will *   include the comma in the file name. Therefore it is recommended to *   use '//', instead of '\\'. * - Environment variables are expanded |:set_env|. * - Careful with '\' characters, type one before a space, type two to *   get one in the option (see |option-backslash|), for example: > *     :set bdir=c:\\tmp,\ dir\\,with\\,commas,\\\ dir\ with\ spaces * <	- For backwards compatibility with Vim version 3.0 a '>' at the start *   of the option is removed. * See also 'backup' and 'writebackup' options. * If you want to hide your backup files on Unix, consider this value: > * 	:set backupdir=./.backup,~/.backup,.,/tmp * <	You must create a ".backup" directory in each directory and in your * home directory for this to work properly. * The use of |:set+=| and |:set-=| is preferred when adding or removing * directories from the list.  This avoids problems when a future version * uses another default. * This option cannot be set from a |modeline| or in the |sandbox|, for * security reasons. */export const backupdir = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "backupdir") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "backupdir", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "backupdir");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "backupdir") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "backupdir", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "backupdir");  },};
/** * String which is appended to a file name to make the name of the * backup file.  The default is quite unusual, because this avoids * accidentally overwriting existing files with a backup file.  You might * prefer using ".bak", but make sure that you don't have files with * ".bak" that you want to keep. * Only normal file name characters can be used, "/\*?[|<>" are illegal. */export const backupext = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "backupext") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "backupext", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "backupext");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "backupext") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "backupext", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "backupext");  },};
/** * 		{not available when compiled without the |+wildignore| * 		feature} * A list of file patterns.  When one of the patterns matches with the * name of the file which is written, no backup file is created.  Both * the specified file name and the full path name of the file are used. * The pattern is used like with |:autocmd|, see |autocmd-patterns|. * Watch out for special characters, see |option-backslash|. * When $TMPDIR, $TMP or $TEMP is not defined, it is not used for the * default value.  "/tmp/*" is only used for Unix. */export const backupskip = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "backupskip") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "backupskip", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "backupskip");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "backupskip") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "backupskip", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "backupskip");  },};
/** * 		{only available when compiled with the |+balloon_eval| * 		feature} * Delay in milliseconds before a balloon may pop up.  See |balloon-eval|. */export const balloondelay = {  async get(denops: Denops): Promise<number> {    return await options.get(denops, "balloondelay") ?? 0;  },  set(denops: Denops, value: number): Promise<void> {    return options.set(denops, "balloondelay", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "balloondelay");  },  async getGlobal(denops: Denops): Promise<number> {    return await globalOptions.get(denops, "balloondelay") ?? 0;  },  setGlobal(denops: Denops, value: number): Promise<void> {    return globalOptions.set(denops, "balloondelay", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "balloondelay");  },};
/** * 		{only available when compiled with the |+balloon_eval| * 		feature} * Switch on the |balloon-eval| functionality for the GUI. */export const ballooneval = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "ballooneval") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "ballooneval", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "ballooneval");  },  async getGlobal(denops: Denops): Promise<boolean> {    return await globalOptions.get(denops, "ballooneval") ?? false;  },  setGlobal(denops: Denops, value: boolean): Promise<void> {    return globalOptions.set(denops, "ballooneval", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "ballooneval");  },};
/** * 		{only available when compiled with the |+balloon_eval| * 		feature} * Expression for text to show in evaluation balloon.  It is only used * when 'ballooneval' or 'balloonevalterm' is on.  These variables can be * used: */export const balloonexpr = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "balloonexpr") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "balloonexpr", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "balloonexpr");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "balloonexpr") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "balloonexpr", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "balloonexpr");  },  async getLocal(denops: Denops): Promise<string> {    return await localOptions.get(denops, "balloonexpr") ?? "";  },  setLocal(denops: Denops, value: string): Promise<void> {    return localOptions.set(denops, "balloonexpr", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "balloonexpr");  },};
/** * Specifies for which events the bell will not be rung. It is a comma * separated list of items. For each item that is present, the bell * will be silenced. This is most useful to specify specific events in * insert mode to be silenced. */export const belloff = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "belloff") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "belloff", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "belloff");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "belloff") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "belloff", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "belloff");  },};
/** * This option should be set before editing a binary file.  You can also * use the |-b| Vim argument.  When this option is switched on a few * options will be changed (also when it already was on): * 	'textwidth'  will be set to 0 * 	'wrapmargin' will be set to 0 * 	'modeline'   will be off * 	'expandtab'  will be off * Also, 'fileformat' and 'fileformats' options will not be used, the * file is read and written like 'fileformat' was "unix" (a single <NL> * separates lines). * The 'fileencoding' and 'fileencodings' options will not be used, the * file is read without conversion. * NOTE: When you start editing a(nother) file while the 'bin' option is * on, settings from autocommands may change the settings again (e.g., * 'textwidth'), causing trouble when editing.  You might want to set * 'bin' again when the file has been loaded. * The previous values of these options are remembered and restored when * 'bin' is switched from on to off.  Each buffer has its own set of * saved option values. * To edit a file with 'binary' set you can use the |++bin| argument. * This avoids you have to do ":set bin", which would have effect for all * files you edit. * When writing a file the <EOL> for the last line is only written if * there was one in the original file (normally Vim appends an <EOL> to * the last line if there is none; this would make the file longer).  See * the 'endofline' option. */export const binary = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "binary") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "binary", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "binary");  },  async getLocal(denops: Denops): Promise<boolean> {    return await localOptions.get(denops, "binary") ?? false;  },  setLocal(denops: Denops, value: boolean): Promise<void> {    return localOptions.set(denops, "binary", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "binary");  },};
/** * 		{not available when compiled without the |+linebreak| * 		feature} * This option lets you choose which characters might cause a line * break if 'linebreak' is on.  Only works for ASCII and also for 8-bit * characters when 'encoding' is an 8-bit encoding. */export const breakat = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "breakat") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "breakat", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "breakat");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "breakat") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "breakat", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "breakat");  },};
/** * 		{not available when compiled without the |+linebreak| * 		feature} * Every wrapped line will continue visually indented (same amount of * space as the beginning of that line), thus preserving horizontal blocks * of text. * NOTE: This option is reset when 'compatible' is set. */export const breakindent = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "breakindent") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "breakindent", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "breakindent");  },  async getLocal(denops: Denops): Promise<boolean> {    return await localOptions.get(denops, "breakindent") ?? false;  },  setLocal(denops: Denops, value: boolean): Promise<void> {    return localOptions.set(denops, "breakindent", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "breakindent");  },};
/** * 		{not available when compiled without the |+linebreak| * 		feature} * Settings for 'breakindent'. It can consist of the following optional * items and must be separated by a comma: * 	min:{n}	    Minimum text width that will be kept after * 		    applying 'breakindent', even if the resulting * 		    text should normally be narrower. This prevents * 		    text indented almost to the right window border * 		    occupying lot of vertical space when broken. * 	shift:{n}   After applying 'breakindent', the wrapped line's * 		    beginning will be shifted by the given number of * 		    characters.  It permits dynamic French paragraph * 		    indentation (negative) or emphasizing the line * 		    continuation (positive). * 	sbr	    Display the 'showbreak' value before applying the * 		    additional indent. * The default value for min is 20 and shift is 0. */export const breakindentopt = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "breakindentopt") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "breakindentopt", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "breakindentopt");  },  async getLocal(denops: Denops): Promise<string> {    return await localOptions.get(denops, "breakindentopt") ?? "";  },  setLocal(denops: Denops, value: string): Promise<void> {    return localOptions.set(denops, "breakindentopt", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "breakindentopt");  },};
/** * 		{only for Motif, Athena, GTK, Mac and Win32 GUI} * Which directory to use for the file browser: *    last		Use same directory as with last file browser, where a * 		file was opened or saved. *    buffer	Use the directory of the related buffer. *    current	Use the current directory. *    {path}	Use the specified directory */export const browsedir = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "browsedir") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "browsedir", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "browsedir");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "browsedir") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "browsedir", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "browsedir");  },};
/** * This option specifies what happens when a buffer is no longer * displayed in a window: *   <empty>	follow the global 'hidden' option *   hide		hide the buffer (don't unload it), also when 'hidden' * 		is not set *   unload	unload the buffer, also when 'hidden' is set or using * 		|:hide| *   delete	delete the buffer from the buffer list, also when * 		'hidden' is set or using |:hide|, like using * 		|:bdelete| *   wipe		wipe out the buffer from the buffer list, also when * 		'hidden' is set or using |:hide|, like using * 		|:bwipeout| */export const bufhidden = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "bufhidden") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "bufhidden", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "bufhidden");  },  async getLocal(denops: Denops): Promise<string> {    return await localOptions.get(denops, "bufhidden") ?? "";  },  setLocal(denops: Denops, value: string): Promise<void> {    return localOptions.set(denops, "bufhidden", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "bufhidden");  },};
/** * When this option is set, the buffer shows up in the buffer list.  If * it is reset it is not used for ":bnext", "ls", the Buffers menu, etc. * This option is reset by Vim for buffers that are only used to remember * a file name or marks.  Vim sets it when starting to edit a buffer. * But not when moving to a buffer with ":buffer". */export const buflisted = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "buflisted") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "buflisted", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "buflisted");  },  async getLocal(denops: Denops): Promise<boolean> {    return await localOptions.get(denops, "buflisted") ?? false;  },  setLocal(denops: Denops, value: boolean): Promise<void> {    return localOptions.set(denops, "buflisted", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "buflisted");  },};
/** * The value of this option specifies the type of a buffer: *   <empty>	normal buffer *   nofile	buffer which is not related to a file and will not be * 		written *   nowrite	buffer which will not be written *   acwrite	buffer which will always be written with BufWriteCmd * 		autocommands. *   quickfix	quickfix buffer, contains list of errors |:cwindow| * 		or list of locations |:lwindow| *   help		help buffer (you are not supposed to set this * 		manually) *   terminal	buffer for a |terminal| (you are not supposed to set * 		this manually) *   prompt	buffer where only the last line can be edited, meant * 		to be used by a plugin, see |prompt-buffer| * 		{only when compiled with the |+channel| feature} *   popup		buffer used in a popup window, see |popup|. * 		{only when compiled with the |+textprop| feature} */export const buftype = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "buftype") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "buftype", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "buftype");  },  async getLocal(denops: Denops): Promise<string> {    return await localOptions.get(denops, "buftype") ?? "";  },  setLocal(denops: Denops, value: string): Promise<void> {    return localOptions.set(denops, "buftype", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "buftype");  },};
/** * Specifies details about changing the case of letters.  It may contain * these words, separated by a comma: * internal	Use internal case mapping functions, the current * 		locale does not change the case mapping.  This only * 		matters when 'encoding' is a Unicode encoding, * 		"latin1" or "iso-8859-15".  When "internal" is * 		omitted, the towupper() and towlower() system library * 		functions are used when available. * keepascii	For the ASCII characters (0x00 to 0x7f) use the US * 		case mapping, the current locale is not effective. * 		This probably only matters for Turkish. */export const casemap = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "casemap") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "casemap", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "casemap");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "casemap") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "casemap", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "casemap");  },};
/** * 		{not available when compiled without the * 		|+file_in_path| feature} * This is a list of directories which will be searched when using the * |:cd|, |:tcd| and |:lcd| commands, provided that the directory being * searched for has a relative path, not an absolute part starting with * "/", "./" or "../", the 'cdpath' option is not used then. * The 'cdpath' option's value has the same form and semantics as * |'path'|.  Also see |file-searching|. * The default value is taken from $CDPATH, with a "," prepended to look * in the current directory first. * If the default value taken from $CDPATH is not what you want, include * a modified version of the following command in your vimrc file to * override it: > *   :let &cdpath = ',' . substitute(substitute($CDPATH, '[, ]', '\\\0', 'g'), ':', ',', 'g') * <	This option cannot be set from a |modeline| or in the |sandbox|, for * security reasons. * (parts of 'cdpath' can be passed to the shell to expand file names). */export const cdpath = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "cdpath") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "cdpath", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "cdpath");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "cdpath") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "cdpath", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "cdpath");  },};
/** * 		{only available when compiled with the |+eval| feature} * An expression that is used for character encoding conversion.  It is * evaluated when a file that is to be read or has been written has a * different encoding from what is desired. * 'charconvert' is not used when the internal iconv() function is * supported and is able to do the conversion.  Using iconv() is * preferred, because it is much faster. * 'charconvert' is not used when reading stdin |--|, because there is no * file to convert from.  You will have to save the text in a file first. * The expression must return zero or an empty string for success, * non-zero for failure. * The possible encoding names encountered are in 'encoding'. * Additionally, names given in 'fileencodings' and 'fileencoding' are * used. * Conversion between "latin1", "unicode", "ucs-2", "ucs-4" and "utf-8" * is done internally by Vim, 'charconvert' is not used for this. * 'charconvert' is also used to convert the viminfo file, if the 'c' * flag is present in 'viminfo'.  Also used for Unicode conversion. * Example: > * 	set charconvert=CharConvert() * 	fun CharConvert() * 	  system("recode " * 		\ . v:charconvert_from . ".." . v:charconvert_to * 		\ . " <" . v:fname_in . " >" v:fname_out) * 	  return v:shell_error * 	endfun * <	The related Vim variables are: * 	v:charconvert_from	name of the current encoding * 	v:charconvert_to	name of the desired encoding * 	v:fname_in		name of the input file * 	v:fname_out		name of the output file * Note that v:fname_in and v:fname_out will never be the same. * Note that v:charconvert_from and v:charconvert_to may be different * from 'encoding'.  Vim internally uses UTF-8 instead of UCS-2 or UCS-4. * Encryption is not done by Vim when using 'charconvert'.  If you want * to encrypt the file after conversion, 'charconvert' should take care * of this. * This option cannot be set from a |modeline| or in the |sandbox|, for * security reasons. */export const charconvert = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "charconvert") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "charconvert", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "charconvert");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "charconvert") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "charconvert", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "charconvert");  },};
/** * 		{not available when compiled without the |+cindent| * 		feature} * Enables automatic C program indenting.  See 'cinkeys' to set the keys * that trigger reindenting in insert mode and 'cinoptions' to set your * preferred indent style. * If 'indentexpr' is not empty, it overrules 'cindent'. * If 'lisp' is not on and both 'indentexpr' and 'equalprg' are empty, * the "=" operator indents using this algorithm rather than calling an * external program. * See |C-indenting|. * When you don't like the way 'cindent' works, try the 'smartindent' * option or 'indentexpr'. * This option is not used when 'paste' is set. * NOTE: This option is reset when 'compatible' is set. */export const cindent = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "cindent") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "cindent", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "cindent");  },  async getLocal(denops: Denops): Promise<boolean> {    return await localOptions.get(denops, "cindent") ?? false;  },  setLocal(denops: Denops, value: boolean): Promise<void> {    return localOptions.set(denops, "cindent", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "cindent");  },};
/** * 		{not available when compiled without the |+cindent| * 		feature} * A list of keys that, when typed in Insert mode, cause reindenting of * the current line.  Only used if 'cindent' is on and 'indentexpr' is * empty. * For the format of this option see |cinkeys-format|. * See |C-indenting|. */export const cinkeys = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "cinkeys") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "cinkeys", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "cinkeys");  },  async getLocal(denops: Denops): Promise<string> {    return await localOptions.get(denops, "cinkeys") ?? "";  },  setLocal(denops: Denops, value: string): Promise<void> {    return localOptions.set(denops, "cinkeys", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "cinkeys");  },};
/** * 		{not available when compiled without the |+cindent| * 		feature} * The 'cinoptions' affect the way 'cindent' reindents lines in a C * program.  See |cinoptions-values| for the values of this option, and * |C-indenting| for info on C indenting in general. */export const cinoptions = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "cinoptions") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "cinoptions", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "cinoptions");  },  async getLocal(denops: Denops): Promise<string> {    return await localOptions.get(denops, "cinoptions") ?? "";  },  setLocal(denops: Denops, value: string): Promise<void> {    return localOptions.set(denops, "cinoptions", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "cinoptions");  },};
/** * 		{not available when compiled without both the * 		|+cindent| and the |+smartindent| features} * These keywords start an extra indent in the next line when * 'smartindent' or 'cindent' is set.  For 'cindent' this is only done at * an appropriate place (inside {}). * Note that 'ignorecase' isn't used for 'cinwords'.  If case doesn't * matter, include the keyword both the uppercase and lowercase: * "if,If,IF". */export const cinwords = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "cinwords") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "cinwords", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "cinwords");  },  async getLocal(denops: Denops): Promise<string> {    return await localOptions.get(denops, "cinwords") ?? "";  },  setLocal(denops: Denops, value: string): Promise<void> {    return localOptions.set(denops, "cinwords", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "cinwords");  },};
/** * 		{only in GUI versions or when the |+xterm_clipboard| * 		feature is included} * This option is a list of comma separated names. * Note: if one of the items is "exclude:", then you can't add an item * after that.  Therefore do append an item with += but use ^= to * prepend, e.g.: > * 	set clipboard^=unnamed * <	These names are recognized: */export const clipboard = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "clipboard") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "clipboard", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "clipboard");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "clipboard") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "clipboard", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "clipboard");  },};
/** * Number of screen lines to use for the command-line.  Helps avoiding * |hit-enter| prompts. * The value of this option is stored with the tab page, so that each tab * page can have a different value. */export const cmdheight = {  async get(denops: Denops): Promise<number> {    return await options.get(denops, "cmdheight") ?? 0;  },  set(denops: Denops, value: number): Promise<void> {    return options.set(denops, "cmdheight", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "cmdheight");  },  async getGlobal(denops: Denops): Promise<number> {    return await globalOptions.get(denops, "cmdheight") ?? 0;  },  setGlobal(denops: Denops, value: number): Promise<void> {    return globalOptions.set(denops, "cmdheight", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "cmdheight");  },};
/** * Number of screen lines to use for the command-line window. |cmdwin| */export const cmdwinheight = {  async get(denops: Denops): Promise<number> {    return await options.get(denops, "cmdwinheight") ?? 0;  },  set(denops: Denops, value: number): Promise<void> {    return options.set(denops, "cmdwinheight", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "cmdwinheight");  },  async getGlobal(denops: Denops): Promise<number> {    return await globalOptions.get(denops, "cmdwinheight") ?? 0;  },  setGlobal(denops: Denops, value: number): Promise<void> {    return globalOptions.set(denops, "cmdwinheight", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "cmdwinheight");  },};
/** * 		{not available when compiled without the |+syntax| * 		feature} * 'colorcolumn' is a comma separated list of screen columns that are * highlighted with ColorColumn |hl-ColorColumn|.  Useful to align * text.  Will make screen redrawing slower. * The screen column can be an absolute number, or a number preceded with * '+' or '-', which is added to or subtracted from 'textwidth'. > */export const colorcolumn = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "colorcolumn") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "colorcolumn", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "colorcolumn");  },  async getLocal(denops: Denops): Promise<string> {    return await localOptions.get(denops, "colorcolumn") ?? "";  },  setLocal(denops: Denops, value: string): Promise<void> {    return localOptions.set(denops, "colorcolumn", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "colorcolumn");  },};
/** * Number of columns of the screen.  Normally this is set by the terminal * initialization and does not have to be set by hand.  Also see * |posix-screen-size|. * When Vim is running in the GUI or in a resizable window, setting this * option will cause the window size to be changed.  When you only want * to use the size for the GUI, put the command in your |gvimrc| file. * When you set this option and Vim is unable to change the physical * number of columns of the display, the display may be messed up.  For * the GUI it is always possible and Vim limits the number of columns to * what fits on the screen.  You can use this command to get the widest * window possible: > * 	:set columns=9999 * <	Minimum value is 12, maximum value is 10000. */export const columns = {  async get(denops: Denops): Promise<number> {    return await options.get(denops, "columns") ?? 0;  },  set(denops: Denops, value: number): Promise<void> {    return options.set(denops, "columns", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "columns");  },  async getGlobal(denops: Denops): Promise<number> {    return await globalOptions.get(denops, "columns") ?? 0;  },  setGlobal(denops: Denops, value: number): Promise<void> {    return globalOptions.set(denops, "columns", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "columns");  },};
/** * A comma separated list of strings that can start a comment line.  See * |format-comments|.  See |option-backslash| about using backslashes to * insert a space. */export const comments = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "comments") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "comments", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "comments");  },  async getLocal(denops: Denops): Promise<string> {    return await localOptions.get(denops, "comments") ?? "";  },  setLocal(denops: Denops, value: string): Promise<void> {    return localOptions.set(denops, "comments", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "comments");  },};
/** * 		{not available when compiled without the |+folding| * 		feature} * A template for a comment.  The "%s" in the value is replaced with the * comment text.  Currently only used to add markers for folding, see * |fold-marker|. */export const commentstring = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "commentstring") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "commentstring", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "commentstring");  },  async getLocal(denops: Denops): Promise<string> {    return await localOptions.get(denops, "commentstring") ?? "";  },  setLocal(denops: Denops, value: string): Promise<void> {    return localOptions.set(denops, "commentstring", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "commentstring");  },};
/** * This option specifies how keyword completion |ins-completion| works * when CTRL-P or CTRL-N are used.  It is also used for whole-line * completion |i_CTRL-X_CTRL-L|.  It indicates the type of completion * and the places to scan.  It is a comma separated list of flags: * .	scan the current buffer ('wrapscan' is ignored) * w	scan buffers from other windows * b	scan other loaded buffers that are in the buffer list * u	scan the unloaded buffers that are in the buffer list * U	scan the buffers that are not in the buffer list * k	scan the files given with the 'dictionary' option * kspell  use the currently active spell checking |spell| * k{dict}	scan the file {dict}.  Several "k" flags can be given, * 	patterns are valid too.  For example: > * 		:set cpt=k/usr/dict/*,k~/spanish * <	s	scan the files given with the 'thesaurus' option * s{tsr}	scan the file {tsr}.  Several "s" flags can be given, patterns * 	are valid too. * i	scan current and included files * d	scan current and included files for defined name or macro * 	|i_CTRL-X_CTRL-D| * ]	tag completion * t	same as "]" */export const complete = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "complete") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "complete", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "complete");  },  async getLocal(denops: Denops): Promise<string> {    return await localOptions.get(denops, "complete") ?? "";  },  setLocal(denops: Denops, value: string): Promise<void> {    return localOptions.set(denops, "complete", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "complete");  },};
/** * 		{not available when compiled without the |+eval| * 		feature} * This option specifies a function to be used for Insert mode completion * with CTRL-X CTRL-U. |i_CTRL-X_CTRL-U| * See |complete-functions| for an explanation of how the function is * invoked and what it should return. * This option cannot be set from a |modeline| or in the |sandbox|, for * security reasons. */export const completefunc = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "completefunc") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "completefunc", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "completefunc");  },  async getLocal(denops: Denops): Promise<string> {    return await localOptions.get(denops, "completefunc") ?? "";  },  setLocal(denops: Denops, value: string): Promise<void> {    return localOptions.set(denops, "completefunc", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "completefunc");  },};
/** * 		{only for MS-Windows} * When this option is set it overrules 'shellslash' for completion: * - When this option is set to "slash", a forward slash is used for path *   completion in insert mode. This is useful when editing HTML tag, or *   Makefile with 'noshellslash' on MS-Windows. * - When this option is set to "backslash", backslash is used. This is *   useful when editing a batch file with 'shellslash' set on MS-Windows. * - When this option is empty, same character is used as for *   'shellslash'. * For Insert mode completion the buffer-local value is used.  For * command line completion the global value is used. */export const completeslash = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "completeslash") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "completeslash", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "completeslash");  },  async getLocal(denops: Denops): Promise<string> {    return await localOptions.get(denops, "completeslash") ?? "";  },  setLocal(denops: Denops, value: string): Promise<void> {    return localOptions.set(denops, "completeslash", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "completeslash");  },};
/** * A comma separated list of options for Insert mode completion * |ins-completion|.  The supported values are: */export const completeopt = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "completeopt") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "completeopt", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "completeopt");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "completeopt") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "completeopt", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "completeopt");  },};
/** * 		{not available when compiled without the |+conceal| * 		feature} * Sets the modes in which text in the cursor line can also be concealed. * When the current mode is listed then concealing happens just like in * other lines. *   n		Normal mode *   v		Visual mode *   i		Insert mode *   c		Command line editing, for 'incsearch' */export const concealcursor = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "concealcursor") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "concealcursor", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "concealcursor");  },  async getLocal(denops: Denops): Promise<string> {    return await localOptions.get(denops, "concealcursor") ?? "";  },  setLocal(denops: Denops, value: string): Promise<void> {    return localOptions.set(denops, "concealcursor", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "concealcursor");  },};
/** * 		{not available when compiled without the |+conceal| * 		feature} * Determine how text with the "conceal" syntax attribute |:syn-conceal| * is shown: */export const conceallevel = {  async get(denops: Denops): Promise<number> {    return await options.get(denops, "conceallevel") ?? 0;  },  set(denops: Denops, value: number): Promise<void> {    return options.set(denops, "conceallevel", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "conceallevel");  },  async getLocal(denops: Denops): Promise<number> {    return await localOptions.get(denops, "conceallevel") ?? 0;  },  setLocal(denops: Denops, value: number): Promise<void> {    return localOptions.set(denops, "conceallevel", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "conceallevel");  },};
/** * When 'confirm' is on, certain operations that would normally * fail because of unsaved changes to a buffer, e.g. ":q" and ":e", * instead raise a |dialog| asking if you wish to save the current * file(s).  You can still use a ! to unconditionally |abandon| a buffer. * If 'confirm' is off you can still activate confirmation for one * command only (this is most useful in mappings) with the |:confirm| * command. * Also see the |confirm()| function and the 'v' flag in 'guioptions'. */export const confirm = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "confirm") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "confirm", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "confirm");  },  async getGlobal(denops: Denops): Promise<boolean> {    return await globalOptions.get(denops, "confirm") ?? false;  },  setGlobal(denops: Denops, value: boolean): Promise<void> {    return globalOptions.set(denops, "confirm", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "confirm");  },};
/** * Copy the structure of the existing lines indent when autoindenting a * new line.  Normally the new indent is reconstructed by a series of * tabs followed by spaces as required (unless |'expandtab'| is enabled, * in which case only spaces are used).  Enabling this option makes the * new line copy whatever characters were used for indenting on the * existing line.  'expandtab' has no effect on these characters, a Tab * remains a Tab.  If the new indent is greater than on the existing * line, the remaining space is filled in the normal manner. * NOTE: This option is reset when 'compatible' is set. * Also see 'preserveindent'. */export const copyindent = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "copyindent") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "copyindent", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "copyindent");  },  async getLocal(denops: Denops): Promise<boolean> {    return await localOptions.get(denops, "copyindent") ?? false;  },  setLocal(denops: Denops, value: boolean): Promise<void> {    return localOptions.set(denops, "copyindent", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "copyindent");  },};
/** * A sequence of single character flags.  When a character is present * this indicates Vi-compatible behavior.  This is used for things where * not being Vi-compatible is mostly or sometimes preferred. * 'cpoptions' stands for "compatible-options". * Commas can be added for readability. * To avoid problems with flags that are added in the future, use the * "+=" and "-=" feature of ":set" |add-option-flags|. * NOTE: This option is set to the Vi default value when 'compatible' is * set and to the Vim default value when 'compatible' is reset. * NOTE: This option is set to the POSIX default value at startup when * the Vi default value would be used and the $VIM_POSIX environment * variable exists |posix|.  This means Vim tries to behave like the * POSIX specification. */export const cpoptions = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "cpoptions") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "cpoptions", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "cpoptions");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "cpoptions") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "cpoptions", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "cpoptions");  },};
/** * 		{not available when compiled without the |+cscope| * 		feature} * Determines how many components of the path to show in a list of tags. * See |cscopepathcomp|. * NOTE: This option is set to 0 when 'compatible' is set. */export const cscopepathcomp = {  async get(denops: Denops): Promise<number> {    return await options.get(denops, "cscopepathcomp") ?? 0;  },  set(denops: Denops, value: number): Promise<void> {    return options.set(denops, "cscopepathcomp", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "cscopepathcomp");  },  async getGlobal(denops: Denops): Promise<number> {    return await globalOptions.get(denops, "cscopepathcomp") ?? 0;  },  setGlobal(denops: Denops, value: number): Promise<void> {    return globalOptions.set(denops, "cscopepathcomp", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "cscopepathcomp");  },};
/** * 		{not available when compiled without the |+cscope| * 		feature} * Specifies the command to execute cscope.  See |cscopeprg|. * This option cannot be set from a |modeline| or in the |sandbox|, for * security reasons. */export const cscopeprg = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "cscopeprg") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "cscopeprg", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "cscopeprg");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "cscopeprg") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "cscopeprg", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "cscopeprg");  },};
/** * 		{not available when compiled without the |+cscope| * 		or |+quickfix| features} * Specifies whether to use quickfix window to show cscope results. * See |cscopequickfix|. */export const cscopequickfix = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "cscopequickfix") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "cscopequickfix", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "cscopequickfix");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "cscopequickfix") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "cscopequickfix", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "cscopequickfix");  },};
/** * 		{not available when compiled without the |+cscope| * 		feature} * In the absence of a prefix (-P) for cscope. setting this option enables * to use the basename of cscope.out path as the prefix. * See |cscoperelative|. * NOTE: This option is reset when 'compatible' is set. */export const cscoperelative = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "cscoperelative") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "cscoperelative", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "cscoperelative");  },  async getGlobal(denops: Denops): Promise<boolean> {    return await globalOptions.get(denops, "cscoperelative") ?? false;  },  setGlobal(denops: Denops, value: boolean): Promise<void> {    return globalOptions.set(denops, "cscoperelative", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "cscoperelative");  },};
/** * 		{not available when compiled without the |+cscope| * 		feature} * Use cscope for tag commands.  See |cscope-options|. * NOTE: This option is reset when 'compatible' is set. */export const cscopetag = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "cscopetag") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "cscopetag", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "cscopetag");  },  async getGlobal(denops: Denops): Promise<boolean> {    return await globalOptions.get(denops, "cscopetag") ?? false;  },  setGlobal(denops: Denops, value: boolean): Promise<void> {    return globalOptions.set(denops, "cscopetag", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "cscopetag");  },};
/** * 		{not available when compiled without the |+cscope| * 		feature} * Determines the order in which ":cstag" performs a search.  See * |cscopetagorder|. * NOTE: This option is set to 0 when 'compatible' is set. */export const cscopetagorder = {  async get(denops: Denops): Promise<number> {    return await options.get(denops, "cscopetagorder") ?? 0;  },  set(denops: Denops, value: number): Promise<void> {    return options.set(denops, "cscopetagorder", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "cscopetagorder");  },  async getGlobal(denops: Denops): Promise<number> {    return await globalOptions.get(denops, "cscopetagorder") ?? 0;  },  setGlobal(denops: Denops, value: number): Promise<void> {    return globalOptions.set(denops, "cscopetagorder", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "cscopetagorder");  },};
/** * When this option is set, as the cursor in the current * window moves other cursorbound windows (windows that also have * this option set) move their cursors to the corresponding line and * column.  This option is useful for viewing the * differences between two versions of a file (see 'diff'); in diff mode, * inserted and deleted lines (though not characters within a line) are * taken into account. */export const cursorbind = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "cursorbind") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "cursorbind", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "cursorbind");  },  async getLocal(denops: Denops): Promise<boolean> {    return await localOptions.get(denops, "cursorbind") ?? false;  },  setLocal(denops: Denops, value: boolean): Promise<void> {    return localOptions.set(denops, "cursorbind", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "cursorbind");  },};
/** * 		{not available when compiled without the |+syntax| * 		feature} * Highlight the screen column of the cursor with CursorColumn * |hl-CursorColumn|.  Useful to align text.  Will make screen redrawing * slower. * If you only want the highlighting in the current window you can use * these autocommands: > * 	au WinLeave * set nocursorline nocursorcolumn * 	au WinEnter * set cursorline cursorcolumn * < */export const cursorcolumn = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "cursorcolumn") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "cursorcolumn", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "cursorcolumn");  },  async getLocal(denops: Denops): Promise<boolean> {    return await localOptions.get(denops, "cursorcolumn") ?? false;  },  setLocal(denops: Denops, value: boolean): Promise<void> {    return localOptions.set(denops, "cursorcolumn", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "cursorcolumn");  },};
/** * 		{not available when compiled without the |+syntax| * 		feature} * Highlight the text line of the cursor with CursorLine |hl-CursorLine|. * Useful to easily spot the cursor.  Will make screen redrawing slower. * When Visual mode is active the highlighting isn't used to make it * easier to see the selected text. */export const cursorline = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "cursorline") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "cursorline", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "cursorline");  },  async getLocal(denops: Denops): Promise<boolean> {    return await localOptions.get(denops, "cursorline") ?? false;  },  setLocal(denops: Denops, value: boolean): Promise<void> {    return localOptions.set(denops, "cursorline", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "cursorline");  },};
/** * Pattern to be used to find a macro definition.  It is a search * pattern, just like for the "/" command.  This option is used for the * commands like "[i" and "[d" |include-search|.  The 'isident' option is * used to recognize the defined name after the match: * 	{match with 'define'}{non-ID chars}{defined name}{non-ID char} * See |option-backslash| about inserting backslashes to include a space * or backslash. * The default value is for C programs.  For C++ this value would be * useful, to include const type declarations: > * 	^\(#\s\s[a-z]*\) * <	You can also use "\ze" just before the name and continue the pattern * to check what is following.  E.g. for Javascript, if a function is * defined with "func_name = function(args)": > * 	^\s=\s*function( * <	If the function is defined with "func_name : function() {...": > *         ^\s[:]\sfunction\s*( * <	When using the ":set" command, you need to double the backslashes! * To avoid that use `:let` with a single quote string: > * 	let &l:define = '^\s=\s*function(' * < */export const define = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "define") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "define", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "define");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "define") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "define", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "define");  },  async getLocal(denops: Denops): Promise<string> {    return await localOptions.get(denops, "define") ?? "";  },  setLocal(denops: Denops, value: string): Promise<void> {    return localOptions.set(denops, "define", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "define");  },};
/** * If editing Unicode and this option is set, backspace and Normal mode * "x" delete each combining character on its own.  When it is off (the * default) the character along with its combining characters are * deleted. * Note: When 'delcombine' is set "xx" may work differently from "2x"! */export const delcombine = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "delcombine") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "delcombine", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "delcombine");  },  async getGlobal(denops: Denops): Promise<boolean> {    return await globalOptions.get(denops, "delcombine") ?? false;  },  setGlobal(denops: Denops, value: boolean): Promise<void> {    return globalOptions.set(denops, "delcombine", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "delcombine");  },};
/** * List of file names, separated by commas, that are used to lookup words * for keyword completion commands |i_CTRL-X_CTRL-K|.  Each file should * contain a list of words.  This can be one word per line, or several * words per line, separated by non-keyword characters (white space is * preferred).  Maximum line length is 510 bytes. */export const dictionary = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "dictionary") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "dictionary", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "dictionary");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "dictionary") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "dictionary", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "dictionary");  },  async getLocal(denops: Denops): Promise<string> {    return await localOptions.get(denops, "dictionary") ?? "";  },  setLocal(denops: Denops, value: string): Promise<void> {    return localOptions.set(denops, "dictionary", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "dictionary");  },};
/** * 		{not available when compiled without the |+diff| * 		feature} * Expression which is evaluated to obtain a diff file (either ed-style * or unified-style) from two versions of a file.  See |diff-diffexpr|. * This option cannot be set from a |modeline| or in the |sandbox|, for * security reasons. */export const diffexpr = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "diffexpr") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "diffexpr", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "diffexpr");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "diffexpr") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "diffexpr", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "diffexpr");  },};
/** * 		{not available when compiled without the |+diff| * 		feature} * Option settings for diff mode.  It can consist of the following items. * All are optional.  Items must be separated by a comma. */export const diffopt = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "diffopt") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "diffopt", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "diffopt");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "diffopt") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "diffopt", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "diffopt");  },};
/** * 		{not available when compiled without the |+digraphs| * 		feature} * Enable the entering of digraphs in Insert mode with {char1} <BS> * {char2}.  See |digraphs|. * NOTE: This option is reset when 'compatible' is set. */export const digraph = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "digraph") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "digraph", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "digraph");  },  async getGlobal(denops: Denops): Promise<boolean> {    return await globalOptions.get(denops, "digraph") ?? false;  },  setGlobal(denops: Denops, value: boolean): Promise<void> {    return globalOptions.set(denops, "digraph", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "digraph");  },};
/** * List of directory names for the swap file, separated with commas. * Recommended value:  ".,~/vimswap//" - this will put the swap file next * to the edited file if possible, and in your personal swap directory * otherwise.  Make sure "~/vimswap//" is only readable for you. */export const directory = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "directory") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "directory", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "directory");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "directory") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "directory", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "directory");  },};
/** * Change the way text is displayed.  This is comma separated list of * flags: * lastline	When included, as much as possible of the last line * 		in a window will be displayed.  "@@@" is put in the * 		last columns of the last screen line to indicate the * 		rest of the line is not displayed. * truncate	Like "lastline", but "@@@" is displayed in the first * 		column of the last screen line.  Overrules "lastline". * uhex		Show unprintable characters hexadecimal as <xx> * 		instead of using ^C and ~C. */export const display = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "display") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "display", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "display");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "display") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "display", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "display");  },};
/** * Tells when the 'equalalways' option applies: * 	ver	vertically, width of windows is not affected * 	hor	horizontally, height of windows is not affected * 	both	width and height of windows is affected */export const eadirection = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "eadirection") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "eadirection", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "eadirection");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "eadirection") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "eadirection", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "eadirection");  },};
/** * When on all Unicode emoji characters are considered to be full width. * This excludes "text emoji" characters, which are normally displayed as * single width.  Unfortunately there is no good specification for this * and it has been determined on trial-and-error basis.  Use the * |setcellwidths()| function to change the behavior. */export const emoji = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "emoji") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "emoji", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "emoji");  },  async getGlobal(denops: Denops): Promise<boolean> {    return await globalOptions.get(denops, "emoji") ?? false;  },  setGlobal(denops: Denops, value: boolean): Promise<void> {    return globalOptions.set(denops, "emoji", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "emoji");  },};
/** * Sets the character encoding used inside Vim.  It applies to text in * the buffers, registers, Strings in expressions, text stored in the * viminfo file, etc.  It sets the kind of characters which Vim can work * with.  See |encoding-names| for the possible values. */export const encoding = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "encoding") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "encoding", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "encoding");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "encoding") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "encoding", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "encoding");  },};
/** * When writing a file and this option is off and the 'binary' option * is on, or 'fixeol' option is off, no <EOL> will be written for the * last line in the file.  This option is automatically set or reset when * starting to edit a new file, depending on whether file has an <EOL> * for the last line in the file.  Normally you don't have to set or * reset this option. * When 'binary' is off and 'fixeol' is on the value is not used when * writing the file.  When 'binary' is on or 'fixeol' is off it is used * to remember the presence of a <EOL> for the last line in the file, so * that when you write the file the situation from the original file can * be kept.  But you can change it if you want to. */export const endofline = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "endofline") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "endofline", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "endofline");  },  async getLocal(denops: Denops): Promise<boolean> {    return await localOptions.get(denops, "endofline") ?? false;  },  setLocal(denops: Denops, value: boolean): Promise<void> {    return localOptions.set(denops, "endofline", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "endofline");  },};
/** * When on, all the windows are automatically made the same size after * splitting or closing a window.  This also happens the moment the * option is switched on.  When off, splitting a window will reduce the * size of the current window and leave the other windows the same.  When * closing a window the extra lines are given to the window next to it * (depending on 'splitbelow' and 'splitright'). * When mixing vertically and horizontally split windows, a minimal size * is computed and some windows may be larger if there is room.  The * 'eadirection' option tells in which direction the size is affected. * Changing the height and width of a window can be avoided by setting * 'winfixheight' and 'winfixwidth', respectively. * If a window size is specified when creating a new window sizes are * currently not equalized (it's complicated, but may be implemented in * the future). */export const equalalways = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "equalalways") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "equalalways", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "equalalways");  },  async getGlobal(denops: Denops): Promise<boolean> {    return await globalOptions.get(denops, "equalalways") ?? false;  },  setGlobal(denops: Denops, value: boolean): Promise<void> {    return globalOptions.set(denops, "equalalways", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "equalalways");  },};
/** * External program to use for "=" command.  When this option is empty * the internal formatting functions are used; either 'lisp', 'cindent' * or 'indentexpr'.  When Vim was compiled without internal formatting, * the "indent" program is used. * Environment variables are expanded |:set_env|.  See |option-backslash| * about including spaces and backslashes. * This option cannot be set from a |modeline| or in the |sandbox|, for * security reasons. */export const equalprg = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "equalprg") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "equalprg", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "equalprg");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "equalprg") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "equalprg", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "equalprg");  },  async getLocal(denops: Denops): Promise<string> {    return await localOptions.get(denops, "equalprg") ?? "";  },  setLocal(denops: Denops, value: string): Promise<void> {    return localOptions.set(denops, "equalprg", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "equalprg");  },};
/** * Ring the bell (beep or screen flash) for error messages.  This only * makes a difference for error messages, the bell will be used always * for a lot of errors without a message (e.g., hitting <Esc> in Normal * mode).  See 'visualbell' on how to make the bell behave like a beep, * screen flash or do nothing. See 'belloff' to finetune when to ring the * bell. */export const errorbells = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "errorbells") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "errorbells", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "errorbells");  },  async getGlobal(denops: Denops): Promise<boolean> {    return await globalOptions.get(denops, "errorbells") ?? false;  },  setGlobal(denops: Denops, value: boolean): Promise<void> {    return globalOptions.set(denops, "errorbells", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "errorbells");  },};
/** * 		{not available when compiled without the |+quickfix| * 		feature} * Name of the errorfile for the QuickFix mode (see |:cf|). * When the "-q" command-line argument is used, 'errorfile' is set to the * following argument.  See |-q|. * NOT used for the ":make" command.  See 'makeef' for that. * Environment variables are expanded |:set_env|. * See |option-backslash| about including spaces and backslashes. * This option cannot be set from a |modeline| or in the |sandbox|, for * security reasons. */export const errorfile = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "errorfile") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "errorfile", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "errorfile");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "errorfile") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "errorfile", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "errorfile");  },};
/** * 		{not available when compiled without the |+quickfix| * 		feature} * Scanf-like description of the format for the lines in the error file * (see |errorformat|). */export const errorformat = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "errorformat") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "errorformat", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "errorformat");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "errorformat") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "errorformat", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "errorformat");  },  async getLocal(denops: Denops): Promise<string> {    return await localOptions.get(denops, "errorformat") ?? "";  },  setLocal(denops: Denops, value: string): Promise<void> {    return localOptions.set(denops, "errorformat", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "errorformat");  },};
/** * A list of autocommand event names, which are to be ignored. * When set to "all" or when "all" is one of the items, all autocommand * events are ignored, autocommands will not be executed. * Otherwise this is a comma separated list of event names.  Example: > *     :set ei=WinEnter,WinLeave * < */export const eventignore = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "eventignore") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "eventignore", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "eventignore");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "eventignore") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "eventignore", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "eventignore");  },};
/** * In Insert mode: Use the appropriate number of spaces to insert a * <Tab>.  Spaces are used in indents with the '>' and '<' commands and * when 'autoindent' is on.  To insert a real tab when 'expandtab' is * on, use CTRL-V<Tab>.  See also |:retab| and |ins-expandtab|. * This option is reset when the 'paste' option is set and restored when * the 'paste' option is reset. * NOTE: This option is reset when 'compatible' is set. */export const expandtab = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "expandtab") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "expandtab", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "expandtab");  },  async getLocal(denops: Denops): Promise<boolean> {    return await localOptions.get(denops, "expandtab") ?? false;  },  setLocal(denops: Denops, value: boolean): Promise<void> {    return localOptions.set(denops, "expandtab", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "expandtab");  },};
/** * Sets the character encoding for the file of this buffer. */export const fileencoding = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "fileencoding") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "fileencoding", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "fileencoding");  },  async getLocal(denops: Denops): Promise<string> {    return await localOptions.get(denops, "fileencoding") ?? "";  },  setLocal(denops: Denops, value: string): Promise<void> {    return localOptions.set(denops, "fileencoding", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "fileencoding");  },};
/** * This is a list of character encodings considered when starting to edit * an existing file.  When a file is read, Vim tries to use the first * mentioned character encoding.  If an error is detected, the next one * in the list is tried.  When an encoding is found that works, * 'fileencoding' is set to it.  If all fail, 'fileencoding' is set to * an empty string, which means the value of 'encoding' is used. * 	WARNING: Conversion can cause loss of information!  When * 	'encoding' is "utf-8" (or one of the other Unicode variants) * 	conversion is most likely done in a way that the reverse * 	conversion results in the same text.  When 'encoding' is not * 	"utf-8" some non-ASCII characters may be lost!  You can use * 	the |++bad| argument to specify what is done with characters * 	that can't be converted. * For an empty file or a file with only ASCII characters most encodings * will work and the first entry of 'fileencodings' will be used (except * "ucs-bom", which requires the BOM to be present).  If you prefer * another encoding use an BufReadPost autocommand event to test if your * preferred encoding is to be used.  Example: > * 	au BufReadPost * if search('\S', 'w') == 0 | * 		\ set fenc=iso-2022-jp | endif * <	This sets 'fileencoding' to "iso-2022-jp" if the file does not contain * non-blank characters. * When the |++enc| argument is used then the value of 'fileencodings' is * not used. * Note that 'fileencodings' is not used for a new file, the global value * of 'fileencoding' is used instead.  You can set it with: > * 	:setglobal fenc=iso-8859-2 * <	This means that a non-existing file may get a different encoding than * an empty file. * The special value "ucs-bom" can be used to check for a Unicode BOM * (Byte Order Mark) at the start of the file.  It must not be preceded * by "utf-8" or another Unicode encoding for this to work properly. * An entry for an 8-bit encoding (e.g., "latin1") should be the last, * because Vim cannot detect an error, thus the encoding is always * accepted. * The special value "default" can be used for the encoding from the * environment.  On MS-Windows this is the system encoding.  Otherwise * this is the default value for 'encoding'.  It is useful when * 'encoding' is set to "utf-8" and your environment uses a non-latin1 * encoding, such as Russian. * When 'encoding' is "utf-8" and a file contains an illegal byte * sequence it won't be recognized as UTF-8.  You can use the |8g8| * command to find the illegal byte sequence. * WRONG VALUES:			WHAT'S WRONG: * 	latin1,utf-8		"latin1" will always be used * 	utf-8,ucs-bom,latin1	BOM won't be recognized in an utf-8 * 				file * 	cp1250,latin1		"cp1250" will always be used * If 'fileencodings' is empty, 'fileencoding' is not modified. * See 'fileencoding' for the possible values. * Setting this option does not have an effect until the next time a file * is read. */export const fileencodings = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "fileencodings") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "fileencodings", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "fileencodings");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "fileencodings") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "fileencodings", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "fileencodings");  },};
/** * This gives the <EOL> of the current buffer, which is used for * reading/writing the buffer from/to a file: *     dos	    <CR><NL> *     unix    <NL> *     mac	    <CR> * When "dos" is used, CTRL-Z at the end of a file is ignored. * See |file-formats| and |file-read|. * For the character encoding of the file see 'fileencoding'. * When 'binary' is set, the value of 'fileformat' is ignored, file I/O * works like it was set to "unix". * This option is set automatically when starting to edit a file and * 'fileformats' is not empty and 'binary' is off. * When this option is set, after starting to edit a file, the 'modified' * option is set, because the file would be different when written. * This option can not be changed when 'modifiable' is off. * For backwards compatibility: When this option is set to "dos", * 'textmode' is set, otherwise 'textmode' is reset. */export const fileformat = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "fileformat") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "fileformat", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "fileformat");  },  async getLocal(denops: Denops): Promise<string> {    return await localOptions.get(denops, "fileformat") ?? "";  },  setLocal(denops: Denops, value: string): Promise<void> {    return localOptions.set(denops, "fileformat", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "fileformat");  },};
/** * This gives the end-of-line (<EOL>) formats that will be tried when * starting to edit a new buffer and when reading a file into an existing * buffer: * - When empty, the format defined with 'fileformat' will be used *   always.  It is not set automatically. * - When set to one name, that format will be used whenever a new buffer *   is opened.  'fileformat' is set accordingly for that buffer.  The *   'fileformats' name will be used when a file is read into an existing *   buffer, no matter what 'fileformat' for that buffer is set to. * - When more than one name is present, separated by commas, automatic *   <EOL> detection will be done when reading a file.  When starting to *   edit a file, a check is done for the <EOL>: *   1. If all lines end in <CR><NL>, and 'fileformats' includes "dos", *      'fileformat' is set to "dos". *   2. If a <NL> is found and 'fileformats' includes "unix", 'fileformat' *      is set to "unix".  Note that when a <NL> is found without a *      preceding <CR>, "unix" is preferred over "dos". *   3. If 'fileformat' has not yet been set, and if a <CR> is found, and *      if 'fileformats' includes "mac", 'fileformat' is set to "mac". *      This means that "mac" is only chosen when: *       "unix" is not present or no <NL> is found in the file, and *       "dos" is not present or no <CR><NL> is found in the file. *      Except: if "unix" was chosen, but there is a <CR> before *      the first <NL>, and there appear to be more <CR>s than <NL>s in *      the first few lines, "mac" is used. *   4. If 'fileformat' is still not set, the first name from *      'fileformats' is used. *   When reading a file into an existing buffer, the same is done, but *   this happens like 'fileformat' has been set appropriately for that *   file only, the option is not changed. * When 'binary' is set, the value of 'fileformats' is not used. */export const fileformats = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "fileformats") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "fileformats", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "fileformats");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "fileformats") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "fileformats", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "fileformats");  },};
/** * When set case is ignored when using file names and directories. * See 'wildignorecase' for only ignoring case when doing completion. */export const fileignorecase = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "fileignorecase") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "fileignorecase", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "fileignorecase");  },  async getGlobal(denops: Denops): Promise<boolean> {    return await globalOptions.get(denops, "fileignorecase") ?? false;  },  setGlobal(denops: Denops, value: boolean): Promise<void> {    return globalOptions.set(denops, "fileignorecase", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "fileignorecase");  },};
/** * When this option is set, the FileType autocommand event is triggered. * All autocommands that match with the value of this option will be * executed.  Thus the value of 'filetype' is used in place of the file * name. * Otherwise this option does not always reflect the current file type. * This option is normally set when the file type is detected.  To enable * this use the ":filetype on" command. |:filetype| * Setting this option to a different value is most useful in a modeline, * for a file for which the file type is not automatically recognized. * Example, for in an IDL file: * 	// ~ * |FileType| |filetypes| * When a dot appears in the value then this separates two filetype * names.  Example: * 	// ~ * This will use the "c" filetype first, then the "doxygen" filetype. * This works both for filetype plugins and for syntax files.  More than * one dot may appear. * This option is not copied to another buffer, independent of the 's' or * 'S' flag in 'cpoptions'. * Only normal file name characters can be used, "/\*?[|<>" are illegal. */export const filetype = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "filetype") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "filetype", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "filetype");  },  async getLocal(denops: Denops): Promise<string> {    return await localOptions.get(denops, "filetype") ?? "";  },  setLocal(denops: Denops, value: string): Promise<void> {    return localOptions.set(denops, "filetype", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "filetype");  },};
/** * 		{not available when compiled without the |+folding| * 		feature} * Characters to fill the statuslines and vertical separators. * It is a comma separated list of items: */export const fillchars = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "fillchars") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "fillchars", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "fillchars");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "fillchars") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "fillchars", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "fillchars");  },};
/** * When writing a file and this option is on, <EOL> at the end of file * will be restored if missing. Turn this option off if you want to * preserve the situation from the original file. * When the 'binary' option is set the value of this option doesn't * matter. * See the 'endofline' option. */export const fixendofline = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "fixendofline") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "fixendofline", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "fixendofline");  },  async getLocal(denops: Denops): Promise<boolean> {    return await localOptions.get(denops, "fixendofline") ?? false;  },  setLocal(denops: Denops, value: boolean): Promise<void> {    return localOptions.set(denops, "fixendofline", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "fixendofline");  },};
/** * 		{not available when compiled without the |+folding| * 		feature} * When set to "all", a fold is closed when the cursor isn't in it and * its level is higher than 'foldlevel'.  Useful if you want folds to * automatically close when moving out of them. */export const foldclose = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "foldclose") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "foldclose", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "foldclose");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "foldclose") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "foldclose", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "foldclose");  },};
/** * 		{not available when compiled without the |+folding| * 		feature} * When non-zero, a column with the specified width is shown at the side * of the window which indicates open and closed folds.  The maximum * value is 12. * See |folding|. */export const foldcolumn = {  async get(denops: Denops): Promise<number> {    return await options.get(denops, "foldcolumn") ?? 0;  },  set(denops: Denops, value: number): Promise<void> {    return options.set(denops, "foldcolumn", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "foldcolumn");  },  async getLocal(denops: Denops): Promise<number> {    return await localOptions.get(denops, "foldcolumn") ?? 0;  },  setLocal(denops: Denops, value: number): Promise<void> {    return localOptions.set(denops, "foldcolumn", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "foldcolumn");  },};
/** * 		{not available when compiled without the |+folding| * 		feature} * When off, all folds are open.  This option can be used to quickly * switch between showing all text unfolded and viewing the text with * folds (including manually opened or closed folds).  It can be toggled * with the |zi| command.  The 'foldcolumn' will remain blank when * 'foldenable' is off. * This option is set by commands that create a new fold or close a fold. * See |folding|. */export const foldenable = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "foldenable") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "foldenable", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "foldenable");  },  async getLocal(denops: Denops): Promise<boolean> {    return await localOptions.get(denops, "foldenable") ?? false;  },  setLocal(denops: Denops, value: boolean): Promise<void> {    return localOptions.set(denops, "foldenable", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "foldenable");  },};
/** * 		{not available when compiled without the |+folding| * 		or |+eval| features} * The expression used for when 'foldmethod' is "expr".  It is evaluated * for each line to obtain its fold level.  See |fold-expr|. */export const foldexpr = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "foldexpr") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "foldexpr", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "foldexpr");  },  async getLocal(denops: Denops): Promise<string> {    return await localOptions.get(denops, "foldexpr") ?? "";  },  setLocal(denops: Denops, value: string): Promise<void> {    return localOptions.set(denops, "foldexpr", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "foldexpr");  },};
/** * 		{not available when compiled without the |+folding| * 		feature} * Used only when 'foldmethod' is "indent".  Lines starting with * characters in 'foldignore' will get their fold level from surrounding * lines.  White space is skipped before checking for this character. * The default "#" works well for C programs.  See |fold-indent|. */export const foldignore = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "foldignore") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "foldignore", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "foldignore");  },  async getLocal(denops: Denops): Promise<string> {    return await localOptions.get(denops, "foldignore") ?? "";  },  setLocal(denops: Denops, value: string): Promise<void> {    return localOptions.set(denops, "foldignore", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "foldignore");  },};
/** * 		{not available when compiled without the |+folding| * 		feature} * Sets the fold level: Folds with a higher level will be closed. * Setting this option to zero will close all folds.  Higher numbers will * close fewer folds. * This option is set by commands like |zm|, |zM| and |zR|. * See |fold-foldlevel|. */export const foldlevel = {  async get(denops: Denops): Promise<number> {    return await options.get(denops, "foldlevel") ?? 0;  },  set(denops: Denops, value: number): Promise<void> {    return options.set(denops, "foldlevel", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "foldlevel");  },  async getLocal(denops: Denops): Promise<number> {    return await localOptions.get(denops, "foldlevel") ?? 0;  },  setLocal(denops: Denops, value: number): Promise<void> {    return localOptions.set(denops, "foldlevel", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "foldlevel");  },};
/** * 		{not available when compiled without the |+folding| * 		feature} * Sets 'foldlevel' when starting to edit another buffer in a window. * Useful to always start editing with all folds closed (value zero), * some folds closed (one) or no folds closed (99). * This is done before reading any modeline, thus a setting in a modeline * overrules this option.  Starting to edit a file for |diff-mode| also * ignores this option and closes all folds. * It is also done before BufReadPre autocommands, to allow an autocmd to * overrule the 'foldlevel' value for specific files. * When the value is negative, it is not used. */export const foldlevelstart = {  async get(denops: Denops): Promise<number> {    return await options.get(denops, "foldlevelstart") ?? 0;  },  set(denops: Denops, value: number): Promise<void> {    return options.set(denops, "foldlevelstart", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "foldlevelstart");  },  async getGlobal(denops: Denops): Promise<number> {    return await globalOptions.get(denops, "foldlevelstart") ?? 0;  },  setGlobal(denops: Denops, value: number): Promise<void> {    return globalOptions.set(denops, "foldlevelstart", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "foldlevelstart");  },};
/** * 		{not available when compiled without the |+folding| * 		feature} * The start and end marker used when 'foldmethod' is "marker".  There * must be one comma, which separates the start and end marker.  The * marker is a literal string (a regular expression would be too slow). * See |fold-marker|. */export const foldmarker = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "foldmarker") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "foldmarker", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "foldmarker");  },  async getLocal(denops: Denops): Promise<string> {    return await localOptions.get(denops, "foldmarker") ?? "";  },  setLocal(denops: Denops, value: string): Promise<void> {    return localOptions.set(denops, "foldmarker", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "foldmarker");  },};
/** * 		{not available when compiled without the |+folding| * 		feature} * The kind of folding used for the current window.  Possible values: * |fold-manual|	manual	    Folds are created manually. * |fold-indent|	indent	    Lines with equal indent form a fold. * |fold-expr|	expr	    'foldexpr' gives the fold level of a line. * |fold-marker|	marker	    Markers are used to specify folds. * |fold-syntax|	syntax	    Syntax highlighting items specify folds. * |fold-diff|	diff	    Fold text that is not changed. */export const foldmethod = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "foldmethod") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "foldmethod", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "foldmethod");  },  async getLocal(denops: Denops): Promise<string> {    return await localOptions.get(denops, "foldmethod") ?? "";  },  setLocal(denops: Denops, value: string): Promise<void> {    return localOptions.set(denops, "foldmethod", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "foldmethod");  },};
/** * 		{not available when compiled without the |+folding| * 		feature} * Sets the number of screen lines above which a fold can be displayed * closed.  Also for manually closed folds.  With the default value of * one a fold can only be closed if it takes up two or more screen lines. * Set to zero to be able to close folds of just one screen line. * Note that this only has an effect on what is displayed.  After using * "zc" to close a fold, which is displayed open because it's smaller * than 'foldminlines', a following "zc" may close a containing fold. */export const foldminlines = {  async get(denops: Denops): Promise<number> {    return await options.get(denops, "foldminlines") ?? 0;  },  set(denops: Denops, value: number): Promise<void> {    return options.set(denops, "foldminlines", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "foldminlines");  },  async getLocal(denops: Denops): Promise<number> {    return await localOptions.get(denops, "foldminlines") ?? 0;  },  setLocal(denops: Denops, value: number): Promise<void> {    return localOptions.set(denops, "foldminlines", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "foldminlines");  },};
/** * 		{not available when compiled without the |+folding| * 		feature} * Sets the maximum nesting of folds for the "indent" and "syntax" * methods.  This avoids that too many folds will be created.  Using more * than 20 doesn't work, because the internal limit is 20. */export const foldnestmax = {  async get(denops: Denops): Promise<number> {    return await options.get(denops, "foldnestmax") ?? 0;  },  set(denops: Denops, value: number): Promise<void> {    return options.set(denops, "foldnestmax", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "foldnestmax");  },  async getLocal(denops: Denops): Promise<number> {    return await localOptions.get(denops, "foldnestmax") ?? 0;  },  setLocal(denops: Denops, value: number): Promise<void> {    return localOptions.set(denops, "foldnestmax", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "foldnestmax");  },};
/** * 		{not available when compiled without the |+folding| * 		feature} * Specifies for which type of commands folds will be opened, if the * command moves the cursor into a closed fold.  It is a comma separated * list of items. * NOTE: When the command is part of a mapping this option is not used. * Add the |zv| command to the mapping to get the same effect. * (rationale: the mapping may want to control opening folds itself) */export const foldopen = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "foldopen") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "foldopen", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "foldopen");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "foldopen") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "foldopen", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "foldopen");  },};
/** * 		{not available when compiled without the |+folding| * 		feature} * An expression which is used to specify the text displayed for a closed * fold.  See |fold-foldtext|. */export const foldtext = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "foldtext") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "foldtext", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "foldtext");  },  async getLocal(denops: Denops): Promise<string> {    return await localOptions.get(denops, "foldtext") ?? "";  },  setLocal(denops: Denops, value: string): Promise<void> {    return localOptions.set(denops, "foldtext", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "foldtext");  },};
/** * 		{not available when compiled without the |+eval| * 		feature} * Expression which is evaluated to format a range of lines for the |gq| * operator or automatic formatting (see 'formatoptions').  When this * option is empty 'formatprg' is used. */export const formatexpr = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "formatexpr") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "formatexpr", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "formatexpr");  },  async getLocal(denops: Denops): Promise<string> {    return await localOptions.get(denops, "formatexpr") ?? "";  },  setLocal(denops: Denops, value: string): Promise<void> {    return localOptions.set(denops, "formatexpr", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "formatexpr");  },};
/** * A pattern that is used to recognize a list header.  This is used for * the "n" flag in 'formatoptions'. * The pattern must match exactly the text that will be the indent for * the line below it.  You can use |/\ze| to mark the end of the match * while still checking more characters.  There must be a character * following the pattern, when it matches the whole line it is handled * like there is no match. * The default recognizes a number, followed by an optional punctuation * character and white space. */export const formatlistpat = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "formatlistpat") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "formatlistpat", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "formatlistpat");  },  async getLocal(denops: Denops): Promise<string> {    return await localOptions.get(denops, "formatlistpat") ?? "";  },  setLocal(denops: Denops, value: string): Promise<void> {    return localOptions.set(denops, "formatlistpat", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "formatlistpat");  },};
/** * This is a sequence of letters which describes how automatic * formatting is to be done.  See |fo-table|.  When the 'paste' option is * on, no formatting is done (like 'formatoptions' is empty).  Commas can * be inserted for readability. * To avoid problems with flags that are added in the future, use the * "+=" and "-=" feature of ":set" |add-option-flags|. * NOTE: This option is set to the Vi default value when 'compatible' is * set and to the Vim default value when 'compatible' is reset. */export const formatoptions = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "formatoptions") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "formatoptions", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "formatoptions");  },  async getLocal(denops: Denops): Promise<string> {    return await localOptions.get(denops, "formatoptions") ?? "";  },  setLocal(denops: Denops, value: string): Promise<void> {    return localOptions.set(denops, "formatoptions", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "formatoptions");  },};
/** * The name of an external program that will be used to format the lines * selected with the |gq| operator.  The program must take the input on * stdin and produce the output on stdout.  The Unix program "fmt" is * such a program. * If the 'formatexpr' option is not empty it will be used instead. * Otherwise, if 'formatprg' option is an empty string, the internal * format function will be used |C-indenting|. * Environment variables are expanded |:set_env|.  See |option-backslash| * about including spaces and backslashes. * This option cannot be set from a |modeline| or in the |sandbox|, for * security reasons. */export const formatprg = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "formatprg") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "formatprg", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "formatprg");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "formatprg") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "formatprg", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "formatprg");  },  async getLocal(denops: Denops): Promise<string> {    return await localOptions.get(denops, "formatprg") ?? "";  },  setLocal(denops: Denops, value: string): Promise<void> {    return localOptions.set(denops, "formatprg", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "formatprg");  },};
/** * When on, the library function fsync() will be called after writing a * file.  This will flush a file to disk, ensuring that it is safely * written even on filesystems which do metadata-only journaling.  This * will force the harddrive to spin up on Linux systems running in laptop * mode, so it may be undesirable in some situations.  Be warned that * turning this off increases the chances of data loss after a crash.  On * systems without an fsync() implementation, this variable is always * off. * Also see 'swapsync' for controlling fsync() on swap files. * 'fsync' also applies to |writefile()|, unless a flag is used to * overrule it. * This option cannot be set from a |modeline| or in the |sandbox|, for * security reasons. */export const fsync = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "fsync") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "fsync", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "fsync");  },  async getGlobal(denops: Denops): Promise<boolean> {    return await globalOptions.get(denops, "fsync") ?? false;  },  setGlobal(denops: Denops, value: boolean): Promise<void> {    return globalOptions.set(denops, "fsync", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "fsync");  },};
/** * When on, the ":substitute" flag 'g' is default on.  This means that * all matches in a line are substituted instead of one.  When a 'g' flag * is given to a ":substitute" command, this will toggle the substitution * of all or one match.  See |complex-change|. */export const gdefault = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "gdefault") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "gdefault", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "gdefault");  },  async getGlobal(denops: Denops): Promise<boolean> {    return await globalOptions.get(denops, "gdefault") ?? false;  },  setGlobal(denops: Denops, value: boolean): Promise<void> {    return globalOptions.set(denops, "gdefault", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "gdefault");  },};
/** * Format to recognize for the ":grep" command output. * This is a scanf-like string that uses the same format as the * 'errorformat' option: see |errorformat|. */export const grepformat = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "grepformat") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "grepformat", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "grepformat");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "grepformat") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "grepformat", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "grepformat");  },};
/** * Program to use for the |:grep| command.  This option may contain '%' * and '#' characters, which are expanded like when used in a command- * line.  The placeholder "$*" is allowed to specify where the arguments * will be included.  Environment variables are expanded |:set_env|.  See * |option-backslash| about including spaces and backslashes. * When your "grep" accepts the "-H" argument, use this to make ":grep" * also work well with a single file: > * 	:set grepprg=grep\ -nH * <	Special value: When 'grepprg' is set to "internal" the |:grep| command * works like |:vimgrep|, |:lgrep| like |:lvimgrep|, |:grepadd| like * |:vimgrepadd| and |:lgrepadd| like |:lvimgrepadd|. * See also the section |:make_makeprg|, since most of the comments there * apply equally to 'grepprg'. * For Win32, the default is "findstr /n" if "findstr.exe" can be found, * otherwise it's "grep -n". * This option cannot be set from a |modeline| or in the |sandbox|, for * security reasons. */export const grepprg = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "grepprg") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "grepprg", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "grepprg");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "grepprg") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "grepprg", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "grepprg");  },  async getLocal(denops: Denops): Promise<string> {    return await localOptions.get(denops, "grepprg") ?? "";  },  setLocal(denops: Denops, value: string): Promise<void> {    return localOptions.set(denops, "grepprg", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "grepprg");  },};
/** * 		{only available when compiled with GUI enabled, and * 		for Win32 console} * This option tells Vim what the cursor should look like in different * modes.  It fully works in the GUI.  In a Win32 console, only the * height of the cursor can be changed.  This can be done by specifying a * block cursor, or a percentage for a vertical or horizontal cursor. * For a console the 't_SI', 't_SR', and 't_EI' escape sequences are * used. */export const guicursor = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "guicursor") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "guicursor", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "guicursor");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "guicursor") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "guicursor", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "guicursor");  },};
/** * 		{only available when compiled with GUI enabled} * This is a list of fonts which will be used for the GUI version of Vim. * In its simplest form the value is just one font name. * See |gui-font| for the details. */export const guifont = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "guifont") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "guifont", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "guifont");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "guifont") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "guifont", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "guifont");  },};
/** * 		{only available when compiled with GUI enabled} * When not empty, specifies a comma-separated list of fonts to be used * for double-width characters.  The first font that can be loaded is * used.  See |gui-fontwide|. */export const guifontwide = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "guifontwide") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "guifontwide", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "guifontwide");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "guifontwide") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "guifontwide", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "guifontwide");  },};
/** * 		{only available when compiled with GUI enabled} * This option only has an effect in the GUI version of Vim.  It is a * sequence of letters which describes what components and options of the * GUI should be used. * To avoid problems with flags that are added in the future, use the * "+=" and "-=" feature of ":set" |add-option-flags|. */export const guioptions = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "guioptions") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "guioptions", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "guioptions");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "guioptions") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "guioptions", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "guioptions");  },};
/** * 		{only available when compiled with GUI enabled} * When nonempty describes the text to use in a label of the GUI tab * pages line.  When empty and when the result is empty Vim will use a * default label.  See |setting-guitablabel| for more info. */export const guitablabel = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "guitablabel") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "guitablabel", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "guitablabel");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "guitablabel") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "guitablabel", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "guitablabel");  },};
/** * 		{only available when compiled with GUI enabled} * When nonempty describes the text to use in a tooltip for the GUI tab * pages line.  When empty Vim will use a default tooltip. * This option is otherwise just like 'guitablabel' above. * You can include a line break.  Simplest method is to use |:let|: > * 	:let &guitabtooltip = "line one\nline two" * < */export const guitabtooltip = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "guitabtooltip") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "guitabtooltip", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "guitabtooltip");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "guitabtooltip") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "guitabtooltip", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "guitabtooltip");  },};
/** * Name of the main help file.  All distributed help files should be * placed together in one directory.  Additionally, all "doc" directories * in 'runtimepath' will be used. * Environment variables are expanded |:set_env|.  For example: * "$VIMRUNTIME/doc/help.txt".  If $VIMRUNTIME is not set, $VIM is also * tried.  Also see |$VIMRUNTIME| and |option-backslash| about including * spaces and backslashes. * This option cannot be set from a |modeline| or in the |sandbox|, for * security reasons. */export const helpfile = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "helpfile") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "helpfile", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "helpfile");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "helpfile") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "helpfile", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "helpfile");  },};
/** * Minimal initial height of the help window when it is opened with the * ":help" command.  The initial height of the help window is half of the * current window, or (when the 'ea' option is on) the same as other * windows.  When the height is less than 'helpheight', the height is * set to 'helpheight'.  Set to zero to disable. */export const helpheight = {  async get(denops: Denops): Promise<number> {    return await options.get(denops, "helpheight") ?? 0;  },  set(denops: Denops, value: number): Promise<void> {    return options.set(denops, "helpheight", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "helpheight");  },  async getGlobal(denops: Denops): Promise<number> {    return await globalOptions.get(denops, "helpheight") ?? 0;  },  setGlobal(denops: Denops, value: number): Promise<void> {    return globalOptions.set(denops, "helpheight", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "helpheight");  },};
/** * 		{only available when compiled with the |+multi_lang| * 		feature} * Comma separated list of languages.  Vim will use the first language * for which the desired help can be found.  The English help will always * be used as a last resort.  You can add "en" to prefer English over * another language, but that will only find tags that exist in that * language and not in the English help. * Example: > * 	:set helplang=de,it * <	This will first search German, then Italian and finally English help * files. * When using |CTRL-]| and ":help!" in a non-English help file Vim will * try to find the tag in the current language before using this option. * See |help-translated|. */export const helplang = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "helplang") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "helplang", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "helplang");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "helplang") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "helplang", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "helplang");  },};
/** * When off a buffer is unloaded when it is |abandon|ed.  When on a * buffer becomes hidden when it is |abandon|ed.  If the buffer is still * displayed in another window, it does not become hidden, of course. * The commands that move through the buffer list sometimes make a buffer * hidden although the 'hidden' option is off: When the buffer is * modified, 'autowrite' is off or writing is not possible, and the '!' * flag was used.  See also |windows.txt|. * To only make one buffer hidden use the 'bufhidden' option. * This option is set for one command with ":hide {command}" |:hide|. * WARNING: It's easy to forget that you have changes in hidden buffers. * Think twice when using ":q!" or ":qa!". */export const hidden = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "hidden") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "hidden", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "hidden");  },  async getGlobal(denops: Denops): Promise<boolean> {    return await globalOptions.get(denops, "hidden") ?? false;  },  setGlobal(denops: Denops, value: boolean): Promise<void> {    return globalOptions.set(denops, "hidden", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "hidden");  },};
/** * A history of ":" commands, and a history of previous search patterns * is remembered.  This option decides how many entries may be stored in * each of these histories (see |cmdline-editing|). * The maximum value is 10000. * NOTE: This option is set to the Vi default value when 'compatible' is * set and to the Vim default value when 'compatible' is reset. */export const history = {  async get(denops: Denops): Promise<number> {    return await options.get(denops, "history") ?? 0;  },  set(denops: Denops, value: number): Promise<void> {    return options.set(denops, "history", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "history");  },  async getGlobal(denops: Denops): Promise<number> {    return await globalOptions.get(denops, "history") ?? 0;  },  setGlobal(denops: Denops, value: number): Promise<void> {    return globalOptions.set(denops, "history", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "history");  },};
/** * 		{only available when compiled with the |+rightleft| * 		feature} * When on, the keyboard is mapped for the Hebrew character set. * Normally you would set 'allowrevins' and use CTRL-_ in insert mode to * toggle this option.  See |rileft.txt|. * NOTE: This option is reset when 'compatible' is set. */export const hkmap = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "hkmap") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "hkmap", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "hkmap");  },  async getGlobal(denops: Denops): Promise<boolean> {    return await globalOptions.get(denops, "hkmap") ?? false;  },  setGlobal(denops: Denops, value: boolean): Promise<void> {    return globalOptions.set(denops, "hkmap", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "hkmap");  },};
/** * 		{only available when compiled with the |+rightleft| * 		feature} * When on, phonetic keyboard mapping is used.  'hkmap' must also be on. * This is useful if you have a non-Hebrew keyboard. * See |rileft.txt|. * NOTE: This option is reset when 'compatible' is set. */export const hkmapp = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "hkmapp") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "hkmapp", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "hkmapp");  },  async getGlobal(denops: Denops): Promise<boolean> {    return await globalOptions.get(denops, "hkmapp") ?? false;  },  setGlobal(denops: Denops, value: boolean): Promise<void> {    return globalOptions.set(denops, "hkmapp", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "hkmapp");  },};
/** * 		{not available when compiled without the * 		|+extra_search| feature} * When there is a previous search pattern, highlight all its matches. * The type of highlighting used can be set with the 'l' occasion in the * 'highlight' option.  This uses the "Search" highlight group by * default.  Note that only the matching text is highlighted, any offsets * are not applied. * See also: 'incsearch' and |:match|. * When you get bored looking at the highlighted matches, you can turn it * off with |:nohlsearch|.  This does not change the option value, as * soon as you use a search command, the highlighting comes back. * 'redrawtime' specifies the maximum time spent on finding matches. * When the search pattern can match an end-of-line, Vim will try to * highlight all of the matched text.  However, this depends on where the * search starts.  This will be the first line in the window or the first * line below a closed fold.  A match in a previous line which is not * drawn may not continue in a newly drawn line. * You can specify whether the highlight status is restored on startup * with the 'h' flag in 'viminfo' |viminfo-h|. * NOTE: This option is reset when 'compatible' is set. */export const hlsearch = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "hlsearch") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "hlsearch", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "hlsearch");  },  async getGlobal(denops: Denops): Promise<boolean> {    return await globalOptions.get(denops, "hlsearch") ?? false;  },  setGlobal(denops: Denops, value: boolean): Promise<void> {    return globalOptions.set(denops, "hlsearch", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "hlsearch");  },};
/** * Ignore case in search patterns.  Also used when searching in the tags * file. * Also see 'smartcase' and 'tagcase'. * Can be overruled by using "\c" or "\C" in the pattern, see * |/ignorecase|. */export const ignorecase = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "ignorecase") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "ignorecase", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "ignorecase");  },  async getGlobal(denops: Denops): Promise<boolean> {    return await globalOptions.get(denops, "ignorecase") ?? false;  },  setGlobal(denops: Denops, value: boolean): Promise<void> {    return globalOptions.set(denops, "ignorecase", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "ignorecase");  },};
/** * When set the Input Method is always on when starting to edit a command * line, unless entering a search pattern (see 'imsearch' for that). * Setting this option is useful when your input method allows entering * English characters directly, e.g., when it's used to type accented * characters with dead keys. */export const imcmdline = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "imcmdline") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "imcmdline", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "imcmdline");  },  async getGlobal(denops: Denops): Promise<boolean> {    return await globalOptions.get(denops, "imcmdline") ?? false;  },  setGlobal(denops: Denops, value: boolean): Promise<void> {    return globalOptions.set(denops, "imcmdline", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "imcmdline");  },};
/** * When set the Input Method is never used.  This is useful to disable * the IM when it doesn't work properly. * Currently this option is on by default for SGI/IRIX machines.  This * may change in later releases. */export const imdisable = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "imdisable") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "imdisable", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "imdisable");  },  async getGlobal(denops: Denops): Promise<boolean> {    return await globalOptions.get(denops, "imdisable") ?? false;  },  setGlobal(denops: Denops, value: boolean): Promise<void> {    return globalOptions.set(denops, "imdisable", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "imdisable");  },};
/** * Specifies whether :lmap or an Input Method (IM) is to be used in * Insert mode.  Valid values: * 	0	:lmap is off and IM is off * 	1	:lmap is ON and IM is off * 	2	:lmap is off and IM is ON * To always reset the option to zero when leaving Insert mode with <Esc> * this can be used: > * 	:inoremap <ESC> <ESC>:set iminsert=0<CR> * <	This makes :lmap and IM turn off automatically when leaving Insert * mode. * Note that this option changes when using CTRL-^ in Insert mode * |i_CTRL-^|. * The value is set to 1 when setting 'keymap' to a valid keymap name. * It is also used for the argument of commands like "r" and "f". * The value 0 may not work correctly with Athena and Motif with some XIM * methods.  Use 'imdisable' to disable XIM then. */export const iminsert = {  async get(denops: Denops): Promise<number> {    return await options.get(denops, "iminsert") ?? 0;  },  set(denops: Denops, value: number): Promise<void> {    return options.set(denops, "iminsert", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "iminsert");  },  async getLocal(denops: Denops): Promise<number> {    return await localOptions.get(denops, "iminsert") ?? 0;  },  setLocal(denops: Denops, value: number): Promise<void> {    return localOptions.set(denops, "iminsert", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "iminsert");  },};
/** * Specifies whether :lmap or an Input Method (IM) is to be used when * entering a search pattern.  Valid values: * 	-1	the value of 'iminsert' is used, makes it look like * 		'iminsert' is also used when typing a search pattern * 	0	:lmap is off and IM is off * 	1	:lmap is ON and IM is off * 	2	:lmap is off and IM is ON * Note that this option changes when using CTRL-^ in Command-line mode * |c_CTRL-^|. * The value is set to 1 when it is not -1 and setting the 'keymap' * option to a valid keymap name. * The value 0 may not work correctly with Athena and Motif with some XIM * methods.  Use 'imdisable' to disable XIM then. */export const imsearch = {  async get(denops: Denops): Promise<number> {    return await options.get(denops, "imsearch") ?? 0;  },  set(denops: Denops, value: number): Promise<void> {    return options.set(denops, "imsearch", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "imsearch");  },  async getLocal(denops: Denops): Promise<number> {    return await localOptions.get(denops, "imsearch") ?? 0;  },  setLocal(denops: Denops, value: number): Promise<void> {    return localOptions.set(denops, "imsearch", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "imsearch");  },};
/** * 		{not available when compiled without the * 		|+find_in_path| feature} * Pattern to be used to find an include command.  It is a search * pattern, just like for the "/" command (See |pattern|).  The default * value is for C programs.  This option is used for the commands "[i", * "]I", "[d", etc. * Normally the 'isfname' option is used to recognize the file name that * comes after the matched pattern.  But if "\zs" appears in the pattern * then the text matched from "\zs" to the end, or until "\ze" if it * appears, is used as the file name.  Use this to include characters * that are not in 'isfname', such as a space.  You can then use * 'includeexpr' to process the matched text. * See |option-backslash| about including spaces and backslashes. */export const include = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "include") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "include", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "include");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "include") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "include", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "include");  },  async getLocal(denops: Denops): Promise<string> {    return await localOptions.get(denops, "include") ?? "";  },  setLocal(denops: Denops, value: string): Promise<void> {    return localOptions.set(denops, "include", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "include");  },};
/** * 		{not available when compiled without the * 		|+find_in_path| or |+eval| features} * Expression to be used to transform the string found with the 'include' * option to a file name.  Mostly useful to change "." to "/" for Java: > * 	:set includeexpr=substitute(v:fname,'\\.','/','g') * <	The "v:fname" variable will be set to the file name that was detected. */export const includeexpr = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "includeexpr") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "includeexpr", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "includeexpr");  },  async getLocal(denops: Denops): Promise<string> {    return await localOptions.get(denops, "includeexpr") ?? "";  },  setLocal(denops: Denops, value: string): Promise<void> {    return localOptions.set(denops, "includeexpr", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "includeexpr");  },};
/** * 		{not available when compiled without the * 		|+extra_search| features} * While typing a search command, show where the pattern, as it was typed * so far, matches.  The matched string is highlighted.  If the pattern * is invalid or not found, nothing is shown.  The screen will be updated * often, this is only useful on fast terminals. * Also applies to the pattern in commands: > * 	:global * 	:lvimgrep * 	:lvimgrepadd * 	:smagic * 	:snomagic * 	:sort * 	:substitute * 	:vglobal * 	:vimgrep * 	:vimgrepadd * <	Note that the match will be shown, but the cursor will return to its * original position when no match is found and when pressing <Esc>.  You * still need to finish the search command with <Enter> to move the * cursor to the match. * You can use the CTRL-G and CTRL-T keys to move to the next and * previous match. |c_CTRL-G| |c_CTRL-T| * When compiled with the |+reltime| feature Vim only searches for about * half a second.  With a complicated pattern and/or a lot of text the * match may not be found.  This is to avoid that Vim hangs while you * are typing the pattern. * The highlighting can be set with the 'i' flag in 'highlight'. * When 'hlsearch' is on, all matched strings are highlighted too while * typing a search command. See also: 'hlsearch'. * If you don't want to turn 'hlsearch' on, but want to highlight all * matches while searching, you can turn on and off 'hlsearch' with * autocmd.  Example: > * 	augroup vimrc-incsearch-highlight * 	  autocmd! * 	  autocmd CmdlineEnter /,\? :set hlsearch * 	  autocmd CmdlineLeave /,\? :set nohlsearch * 	augroup END * < * CTRL-L can be used to add one character from after the current match * to the command line.  If 'ignorecase' and 'smartcase' are set and the * command line has no uppercase characters, the added character is * converted to lowercase. * CTRL-R CTRL-W can be used to add the word at the end of the current * match, excluding the characters that were already typed. * NOTE: This option is reset when 'compatible' is set. */export const incsearch = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "incsearch") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "incsearch", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "incsearch");  },  async getGlobal(denops: Denops): Promise<boolean> {    return await globalOptions.get(denops, "incsearch") ?? false;  },  setGlobal(denops: Denops, value: boolean): Promise<void> {    return globalOptions.set(denops, "incsearch", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "incsearch");  },};
/** * 		{not available when compiled without the |+cindent| * 		or |+eval| features} * Expression which is evaluated to obtain the proper indent for a line. * It is used when a new line is created, for the |=| operator and * in Insert mode as specified with the 'indentkeys' option. * When this option is not empty, it overrules the 'cindent' and * 'smartindent' indenting.  When 'lisp' is set, this option is * overridden by the Lisp indentation algorithm. * When 'paste' is set this option is not used for indenting. * The expression is evaluated with |v:lnum| set to the line number for * which the indent is to be computed.  The cursor is also in this line * when the expression is evaluated (but it may be moved around). * The expression must return the number of spaces worth of indent.  It * can return "-1" to keep the current indent (this means 'autoindent' is * used for the indent). * Functions useful for computing the indent are |indent()|, |cindent()| * and |lispindent()|. * The evaluation of the expression must not have side effects!  It must * not change the text, jump to another window, etc.  Afterwards the * cursor position is always restored, thus the cursor may be moved. * Normally this option would be set to call a function: > * 	:set indentexpr=GetMyIndent() * <	Error messages will be suppressed, unless the 'debug' option contains * "msg". * See |indent-expression|. * NOTE: This option is set to "" when 'compatible' is set. */export const indentexpr = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "indentexpr") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "indentexpr", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "indentexpr");  },  async getLocal(denops: Denops): Promise<string> {    return await localOptions.get(denops, "indentexpr") ?? "";  },  setLocal(denops: Denops, value: string): Promise<void> {    return localOptions.set(denops, "indentexpr", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "indentexpr");  },};
/** * 		{not available when compiled without the |+cindent| * 		feature} * A list of keys that, when typed in Insert mode, cause reindenting of * the current line.  Only happens if 'indentexpr' isn't empty. * The format is identical to 'cinkeys', see |indentkeys-format|. * See |C-indenting| and |indent-expression|. */export const indentkeys = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "indentkeys") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "indentkeys", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "indentkeys");  },  async getLocal(denops: Denops): Promise<string> {    return await localOptions.get(denops, "indentkeys") ?? "";  },  setLocal(denops: Denops, value: string): Promise<void> {    return localOptions.set(denops, "indentkeys", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "indentkeys");  },};
/** * When doing keyword completion in insert mode |ins-completion|, and * 'ignorecase' is also on, the case of the match is adjusted depending * on the typed text.  If the typed text contains a lowercase letter * where the match has an upper case letter, the completed part is made * lowercase.  If the typed text has no lowercase letters and the match * has a lowercase letter where the typed text has an uppercase letter, * and there is a letter before it, the completed part is made uppercase. * With 'noinfercase' the match is used as-is. */export const infercase = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "infercase") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "infercase", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "infercase");  },  async getLocal(denops: Denops): Promise<boolean> {    return await localOptions.get(denops, "infercase") ?? false;  },  setLocal(denops: Denops, value: boolean): Promise<void> {    return localOptions.set(denops, "infercase", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "infercase");  },};
/** * Makes Vim work in a way that Insert mode is the default mode.  Useful * if you want to use Vim as a modeless editor.  Used for |evim|. * These Insert mode commands will be useful: * - Use the cursor keys to move around. * - Use CTRL-O to execute one Normal mode command |i_CTRL-O|.  When *   this is a mapping, it is executed as if 'insertmode' was off. *   Normal mode remains active until the mapping is finished. * - Use CTRL-L to execute a number of Normal mode commands, then use *   <Esc> to get back to Insert mode.  Note that CTRL-L moves the cursor *   left, like <Esc> does when 'insertmode' isn't set.  |i_CTRL-L| */export const insertmode = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "insertmode") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "insertmode", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "insertmode");  },  async getGlobal(denops: Denops): Promise<boolean> {    return await globalOptions.get(denops, "insertmode") ?? false;  },  setGlobal(denops: Denops, value: boolean): Promise<void> {    return globalOptions.set(denops, "insertmode", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "insertmode");  },};
/** * The characters specified by this option are included in file names and * path names.  Filenames are used for commands like "gf", "[i" and in * the tags file.  It is also used for "\f" in a |pattern|. * Multi-byte characters 256 and above are always included, only the * characters up to 255 are specified with this option. * For UTF-8 the characters 0xa0 to 0xff are included as well. * Think twice before adding white space to this option.  Although a * space may appear inside a file name, the effect will be that Vim * doesn't know where a file name starts or ends when doing completion. * It most likely works better without a space in 'isfname'. */export const isfname = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "isfname") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "isfname", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "isfname");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "isfname") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "isfname", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "isfname");  },};
/** * The characters given by this option are included in identifiers. * Identifiers are used in recognizing environment variables and after a * match of the 'define' option.  It is also used for "\i" in a * |pattern|.  See 'isfname' for a description of the format of this * option.  For '@' only characters up to 255 are used. * Careful: If you change this option, it might break expanding * environment variables.  E.g., when '/' is included and Vim tries to * expand "$HOME/.viminfo".  Maybe you should change 'iskeyword' instead. */export const isident = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "isident") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "isident", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "isident");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "isident") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "isident", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "isident");  },};
/** * Keywords are used in searching and recognizing with many commands: * "w", "*", "[i", etc.  It is also used for "\k" in a |pattern|.  See * 'isfname' for a description of the format of this option.  For '@' * characters above 255 check the "word" character class (any character * that is not white space or punctuation). * For C programs you could use "a-z,A-Z,48-57,_,.,-,>". * For a help file it is set to all non-blank printable characters except * '*', '"' and '|' (so that CTRL-] on a command finds the help for that * command). * When the 'lisp' option is on the '-' character is always included. * This option also influences syntax highlighting, unless the syntax * uses |:syn-iskeyword|. * NOTE: This option is set to the Vi default value when 'compatible' is * set and to the Vim default value when 'compatible' is reset. */export const iskeyword = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "iskeyword") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "iskeyword", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "iskeyword");  },  async getLocal(denops: Denops): Promise<string> {    return await localOptions.get(denops, "iskeyword") ?? "";  },  setLocal(denops: Denops, value: string): Promise<void> {    return localOptions.set(denops, "iskeyword", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "iskeyword");  },};
/** * The characters given by this option are displayed directly on the * screen.  It is also used for "\p" in a |pattern|.  The characters from * space (ASCII 32) to '~' (ASCII 126) are always displayed directly, * even when they are not included in 'isprint' or excluded.  See * 'isfname' for a description of the format of this option. */export const isprint = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "isprint") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "isprint", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "isprint");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "isprint") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "isprint", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "isprint");  },};
/** * Insert two spaces after a '.', '?' and '!' with a join command. * When 'cpoptions' includes the 'j' flag, only do this after a '.'. * Otherwise only one space is inserted. * NOTE: This option is set when 'compatible' is set. */export const joinspaces = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "joinspaces") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "joinspaces", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "joinspaces");  },  async getGlobal(denops: Denops): Promise<boolean> {    return await globalOptions.get(denops, "joinspaces") ?? false;  },  setGlobal(denops: Denops, value: boolean): Promise<void> {    return globalOptions.set(denops, "joinspaces", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "joinspaces");  },};
/** * 		{only available when compiled with the |+keymap| * 		feature} * Name of a keyboard mapping.  See |mbyte-keymap|. * Setting this option to a valid keymap name has the side effect of * setting 'iminsert' to one, so that the keymap becomes effective. * 'imsearch' is also set to one, unless it was -1 * Only normal file name characters can be used, "/\*?[|<>" are illegal. */export const keymap = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "keymap") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "keymap", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "keymap");  },  async getLocal(denops: Denops): Promise<string> {    return await localOptions.get(denops, "keymap") ?? "";  },  setLocal(denops: Denops, value: string): Promise<void> {    return localOptions.set(denops, "keymap", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "keymap");  },};
/** * List of comma separated words, which enable special things that keys * can do.  These values can be used: *    startsel	Using a shifted special key starts selection (either * 		Select mode or Visual mode, depending on "key" being * 		present in 'selectmode'). *    stopsel	Using a not-shifted special key stops selection. * Special keys in this context are the cursor keys, <End>, <Home>, * <PageUp> and <PageDown>. * The 'keymodel' option is set by the |:behave| command. */export const keymodel = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "keymodel") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "keymodel", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "keymodel");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "keymodel") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "keymodel", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "keymodel");  },};
/** * Program to use for the |K| command.  Environment variables are * expanded |:set_env|.  ":help" may be used to access the Vim internal * help.  (Note that previously setting the global option to the empty * value did this, which is now deprecated.) * When the first character is ":", the command is invoked as a Vim * Ex command prefixed with [count]. * When "man", "man -s" or an Ex command is used, Vim will automatically * translate a count for the "K" command and pass it as the first * argument.  For "man -s" the "-s" is removed when there is no count. * See |option-backslash| about including spaces and backslashes. * Example: > * 	:set keywordprg=man\ -s * <	This option cannot be set from a |modeline| or in the |sandbox|, for * security reasons. */export const keywordprg = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "keywordprg") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "keywordprg", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "keywordprg");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "keywordprg") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "keywordprg", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "keywordprg");  },  async getLocal(denops: Denops): Promise<string> {    return await localOptions.get(denops, "keywordprg") ?? "";  },  setLocal(denops: Denops, value: string): Promise<void> {    return localOptions.set(denops, "keywordprg", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "keywordprg");  },};
/** * 		{only available when compiled with the |+langmap| * 		feature} * This option allows switching your keyboard into a special language * mode.  When you are typing text in Insert mode the characters are * inserted directly.  When in Normal mode the 'langmap' option takes * care of translating these special characters to the original meaning * of the key.  This means you don't have to change the keyboard mode to * be able to execute Normal mode commands. * This is the opposite of the 'keymap' option, where characters are * mapped in Insert mode. * Also consider setting 'langremap' to off, to prevent 'langmap' from * applying to characters resulting from a mapping. * This option cannot be set from a |modeline| or in the |sandbox|, for * security reasons. */export const langmap = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "langmap") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "langmap", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "langmap");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "langmap") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "langmap", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "langmap");  },};
/** * 		{only available when compiled with the |+menu| and * 		|+multi_lang| features} * Language to use for menu translation.  Tells which file is loaded * from the "lang" directory in 'runtimepath': > * 	"lang/menu_" . &langmenu . ".vim" * <	(without the spaces).  For example, to always use the Dutch menus, no * matter what $LANG is set to: > * 	:set langmenu=nl_NL.ISO_8859-1 * <	When 'langmenu' is empty, |v:lang| is used. * Only normal file name characters can be used, "/\*?[|<>" are illegal. * If your $LANG is set to a non-English language but you do want to use * the English menus: > * 	:set langmenu=none * <	This option must be set before loading menus, switching on filetype * detection or syntax highlighting.  Once the menus are defined setting * this option has no effect.  But you could do this: > * 	:source $VIMRUNTIME/delmenu.vim * 	:set langmenu=de_DE.ISO_8859-1 * 	:source $VIMRUNTIME/menu.vim * <	Warning: This deletes all menus that you defined yourself! */export const langmenu = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "langmenu") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "langmenu", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "langmenu");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "langmenu") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "langmenu", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "langmenu");  },};
/** * 		{only available when compiled with the |+langmap| * 		feature} * When off, setting 'langmap' does not apply to characters resulting from * a mapping.  This basically means, if you noticed that setting * 'langmap' disables some of your mappings, try resetting this option. * This option defaults to on for backwards compatibility.  Set it off if * that works for you to avoid mappings to break. */export const langremap = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "langremap") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "langremap", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "langremap");  },  async getGlobal(denops: Denops): Promise<boolean> {    return await globalOptions.get(denops, "langremap") ?? false;  },  setGlobal(denops: Denops, value: boolean): Promise<void> {    return globalOptions.set(denops, "langremap", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "langremap");  },};
/** * The value of this option influences when the last window will have a * status line: * 	0: never * 	1: only if there are at least two windows * 	2: always * The screen looks nicer with a status line if you have several * windows, but it takes another screen line. |status-line| */export const laststatus = {  async get(denops: Denops): Promise<number> {    return await options.get(denops, "laststatus") ?? 0;  },  set(denops: Denops, value: number): Promise<void> {    return options.set(denops, "laststatus", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "laststatus");  },  async getGlobal(denops: Denops): Promise<number> {    return await globalOptions.get(denops, "laststatus") ?? 0;  },  setGlobal(denops: Denops, value: number): Promise<void> {    return globalOptions.set(denops, "laststatus", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "laststatus");  },};
/** * When this option is set, the screen will not be redrawn while * executing macros, registers and other commands that have not been * typed.  Also, updating the window title is postponed.  To force an * update use |:redraw|. */export const lazyredraw = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "lazyredraw") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "lazyredraw", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "lazyredraw");  },  async getGlobal(denops: Denops): Promise<boolean> {    return await globalOptions.get(denops, "lazyredraw") ?? false;  },  setGlobal(denops: Denops, value: boolean): Promise<void> {    return globalOptions.set(denops, "lazyredraw", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "lazyredraw");  },};
/** * 		{not available when compiled without the |+linebreak| * 		feature} * If on, Vim will wrap long lines at a character in 'breakat' rather * than at the last character that fits on the screen.  Unlike * 'wrapmargin' and 'textwidth', this does not insert <EOL>s in the file, * it only affects the way the file is displayed, not its contents. * If 'breakindent' is set, line is visually indented. Then, the value * of 'showbreak' is used to put in front of wrapped lines. This option * is not used when the 'wrap' option is off. * Note that <Tab> characters after an <EOL> are mostly not displayed * with the right amount of white space. */export const linebreak = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "linebreak") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "linebreak", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "linebreak");  },  async getLocal(denops: Denops): Promise<boolean> {    return await localOptions.get(denops, "linebreak") ?? false;  },  setLocal(denops: Denops, value: boolean): Promise<void> {    return localOptions.set(denops, "linebreak", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "linebreak");  },};
/** * 		{only in the GUI} * Number of pixel lines inserted between characters.  Useful if the font * uses the full character cell height, making lines touch each other. * When non-zero there is room for underlining. * With some fonts there can be too much room between lines (to have * space for ascents and descents).  Then it makes sense to set * 'linespace' to a negative value.  This may cause display problems * though! */export const linespace = {  async get(denops: Denops): Promise<number> {    return await options.get(denops, "linespace") ?? 0;  },  set(denops: Denops, value: number): Promise<void> {    return options.set(denops, "linespace", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "linespace");  },  async getGlobal(denops: Denops): Promise<number> {    return await globalOptions.get(denops, "linespace") ?? 0;  },  setGlobal(denops: Denops, value: number): Promise<void> {    return globalOptions.set(denops, "linespace", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "linespace");  },};
/** * 		{not available when compiled without the |+lispindent| * 		feature} * Comma separated list of words that influence the Lisp indenting. * |'lisp'| */export const lispwords = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "lispwords") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "lispwords", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "lispwords");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "lispwords") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "lispwords", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "lispwords");  },  async getLocal(denops: Denops): Promise<string> {    return await localOptions.get(denops, "lispwords") ?? "";  },  setLocal(denops: Denops, value: string): Promise<void> {    return localOptions.set(denops, "lispwords", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "lispwords");  },};
/** * Strings to use in 'list' mode and for the |:list| command.  It is a * comma separated list of string settings. *   eol:c		Character to show at the end of each line.  When * 		omitted, there is no extra character at the end of the * 		line. *   tab:xy[z]	Two or three characters to be used to show a tab. * 		The third character is optional. */export const listchars = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "listchars") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "listchars", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "listchars");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "listchars") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "listchars", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "listchars");  },  async getLocal(denops: Denops): Promise<string> {    return await localOptions.get(denops, "listchars") ?? "";  },  setLocal(denops: Denops, value: string): Promise<void> {    return localOptions.set(denops, "listchars", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "listchars");  },};
/** * When on the plugin scripts are loaded when starting up |load-plugins|. * This option can be reset in your |vimrc| file to disable the loading * of plugins. * Note that using the "-u NONE", "-u DEFAULTS" and "--noplugin" command * line arguments reset this option.  See |-u| and |--noplugin|. */export const loadplugins = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "loadplugins") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "loadplugins", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "loadplugins");  },  async getGlobal(denops: Denops): Promise<boolean> {    return await globalOptions.get(denops, "loadplugins") ?? false;  },  setGlobal(denops: Denops, value: boolean): Promise<void> {    return globalOptions.set(denops, "loadplugins", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "loadplugins");  },};
/** * 		{not available when compiled without the |+quickfix| * 		feature} * Name of the errorfile for the |:make| command (see |:make_makeprg|) * and the |:grep| command. * When it is empty, an internally generated temp file will be used. * When "##" is included, it is replaced by a number to make the name * unique.  This makes sure that the ":make" command doesn't overwrite an * existing file. * NOT used for the ":cf" command.  See 'errorfile' for that. * Environment variables are expanded |:set_env|. * See |option-backslash| about including spaces and backslashes. * This option cannot be set from a |modeline| or in the |sandbox|, for * security reasons. */export const makeef = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "makeef") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "makeef", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "makeef");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "makeef") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "makeef", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "makeef");  },};
/** * Encoding used for reading the output of external commands.  When empty, * encoding is not converted. * This is used for `:make`, `:lmake`, `:grep`, `:lgrep`, `:grepadd`, * `:lgrepadd`, `:cfile`, `:cgetfile`, `:caddfile`, `:lfile`, `:lgetfile`, * and `:laddfile`. */export const makeencoding = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "makeencoding") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "makeencoding", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "makeencoding");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "makeencoding") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "makeencoding", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "makeencoding");  },  async getLocal(denops: Denops): Promise<string> {    return await localOptions.get(denops, "makeencoding") ?? "";  },  setLocal(denops: Denops, value: string): Promise<void> {    return localOptions.set(denops, "makeencoding", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "makeencoding");  },};
/** * Program to use for the ":make" command.  See |:make_makeprg|. * This option may contain '%' and '#' characters (see  |:_%| and |:_#|), * which are expanded to the current and alternate file name.  Use |::S| * to escape file names in case they contain special characters. * Environment variables are expanded |:set_env|.  See |option-backslash| * about including spaces and backslashes. * Note that a '|' must be escaped twice: once for ":set" and once for * the interpretation of a command.  When you use a filter called * "myfilter" do it like this: > *     :set makeprg=gmake\ \\\|\ myfilter * <	The placeholder "$*" can be given (even multiple times) to specify * where the arguments will be included, for example: > *     :set makeprg=latex\ \\\\nonstopmode\ \\\\input\\{$*} * <	This option cannot be set from a |modeline| or in the |sandbox|, for * security reasons. */export const makeprg = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "makeprg") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "makeprg", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "makeprg");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "makeprg") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "makeprg", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "makeprg");  },  async getLocal(denops: Denops): Promise<string> {    return await localOptions.get(denops, "makeprg") ?? "";  },  setLocal(denops: Denops, value: string): Promise<void> {    return localOptions.set(denops, "makeprg", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "makeprg");  },};
/** * Characters that form pairs.  The |%| command jumps from one to the * other. * Only character pairs are allowed that are different, thus you cannot * jump between two double quotes. * The characters must be separated by a colon. * The pairs must be separated by a comma.  Example for including '<' and * '>' (for HTML): > * 	:set mps+=<:> */export const matchpairs = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "matchpairs") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "matchpairs", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "matchpairs");  },  async getLocal(denops: Denops): Promise<string> {    return await localOptions.get(denops, "matchpairs") ?? "";  },  setLocal(denops: Denops, value: string): Promise<void> {    return localOptions.set(denops, "matchpairs", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "matchpairs");  },};
/** * Tenths of a second to show the matching paren, when 'showmatch' is * set.  Note that this is not in milliseconds, like other options that * set a time.  This is to be compatible with Nvi. */export const matchtime = {  async get(denops: Denops): Promise<number> {    return await options.get(denops, "matchtime") ?? 0;  },  set(denops: Denops, value: number): Promise<void> {    return options.set(denops, "matchtime", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "matchtime");  },  async getGlobal(denops: Denops): Promise<number> {    return await globalOptions.get(denops, "matchtime") ?? 0;  },  setGlobal(denops: Denops, value: number): Promise<void> {    return globalOptions.set(denops, "matchtime", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "matchtime");  },};
/** * The maximum number of combining characters supported for displaying. * Only used when 'encoding' is "utf-8". * The default is OK for most languages.  Hebrew may require 4. * Maximum value is 6. * Even when this option is set to 2 you can still edit text with more * combining characters, you just can't see them.  Use |g8| or |ga|. * See |mbyte-combining|. */export const maxcombine = {  async get(denops: Denops): Promise<number> {    return await options.get(denops, "maxcombine") ?? 0;  },  set(denops: Denops, value: number): Promise<void> {    return options.set(denops, "maxcombine", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "maxcombine");  },  async getGlobal(denops: Denops): Promise<number> {    return await globalOptions.get(denops, "maxcombine") ?? 0;  },  setGlobal(denops: Denops, value: number): Promise<void> {    return globalOptions.set(denops, "maxcombine", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "maxcombine");  },};
/** * 		{not available when compiled without the |+eval| * 		feature} * Maximum depth of function calls for user functions.  This normally * catches endless recursion.  When using a recursive function with * more depth, set 'maxfuncdepth' to a bigger number.  But this will use * more memory, there is the danger of failing when memory is exhausted. * Increasing this limit above 200 also changes the maximum for Ex * command recursion, see |E169|. * See also |:function|. */export const maxfuncdepth = {  async get(denops: Denops): Promise<number> {    return await options.get(denops, "maxfuncdepth") ?? 0;  },  set(denops: Denops, value: number): Promise<void> {    return options.set(denops, "maxfuncdepth", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "maxfuncdepth");  },  async getGlobal(denops: Denops): Promise<number> {    return await globalOptions.get(denops, "maxfuncdepth") ?? 0;  },  setGlobal(denops: Denops, value: number): Promise<void> {    return globalOptions.set(denops, "maxfuncdepth", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "maxfuncdepth");  },};
/** * Maximum number of times a mapping is done without resulting in a * character to be used.  This normally catches endless mappings, like * ":map x y" with ":map y x".  It still does not catch ":map g wg", * because the 'w' is used before the next mapping is done.  See also * |key-mapping|. */export const maxmapdepth = {  async get(denops: Denops): Promise<number> {    return await options.get(denops, "maxmapdepth") ?? 0;  },  set(denops: Denops, value: number): Promise<void> {    return options.set(denops, "maxmapdepth", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "maxmapdepth");  },  async getGlobal(denops: Denops): Promise<number> {    return await globalOptions.get(denops, "maxmapdepth") ?? 0;  },  setGlobal(denops: Denops, value: number): Promise<void> {    return globalOptions.set(denops, "maxmapdepth", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "maxmapdepth");  },};
/** * Maximum amount of memory (in Kbyte) to use for pattern matching. * The maximum value is about 2000000.  Use this to work without a limit. * When Vim runs into the limit it gives an error message and mostly * behaves like CTRL-C was typed. * Running into the limit often means that the pattern is very * inefficient or too complex.  This may already happen with the pattern * "\(.\)" works much better. * Might also happen on redraw, when syntax rules try to match a complex * text structure. * Vim may run out of memory before hitting the 'maxmempattern' limit, in * which case you get an "Out of memory" error instead. */export const maxmempattern = {  async get(denops: Denops): Promise<number> {    return await options.get(denops, "maxmempattern") ?? 0;  },  set(denops: Denops, value: number): Promise<void> {    return options.set(denops, "maxmempattern", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "maxmempattern");  },  async getGlobal(denops: Denops): Promise<number> {    return await globalOptions.get(denops, "maxmempattern") ?? 0;  },  setGlobal(denops: Denops, value: number): Promise<void> {    return globalOptions.set(denops, "maxmempattern", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "maxmempattern");  },};
/** * 		{not available when compiled without the |+menu| * 		feature} * Maximum number of items to use in a menu.  Used for menus that are * generated from a list of items, e.g., the Buffers menu.  Changing this * option has no direct effect, the menu must be refreshed first. */export const menuitems = {  async get(denops: Denops): Promise<number> {    return await options.get(denops, "menuitems") ?? 0;  },  set(denops: Denops, value: number): Promise<void> {    return options.set(denops, "menuitems", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "menuitems");  },  async getGlobal(denops: Denops): Promise<number> {    return await globalOptions.get(denops, "menuitems") ?? 0;  },  setGlobal(denops: Denops, value: number): Promise<void> {    return globalOptions.set(denops, "menuitems", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "menuitems");  },};
/** * 		{not available when compiled without the |+syntax| * 		feature} * Parameters for |:mkspell|.  This tunes when to start compressing the * word tree.  Compression can be slow when there are many words, but * it's needed to avoid running out of memory.  The amount of memory used * per word depends very much on how similar the words are, that's why * this tuning is complicated. */export const mkspellmem = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "mkspellmem") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "mkspellmem", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "mkspellmem");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "mkspellmem") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "mkspellmem", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "mkspellmem");  },};
/** * If 'modeline' is on 'modelines' gives the number of lines that is * checked for set commands.  If 'modeline' is off or 'modelines' is zero * no lines are checked.  See |modeline|. */export const modeline = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "modeline") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "modeline", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "modeline");  },  async getLocal(denops: Denops): Promise<boolean> {    return await localOptions.get(denops, "modeline") ?? false;  },  setLocal(denops: Denops, value: boolean): Promise<void> {    return localOptions.set(denops, "modeline", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "modeline");  },};
/** * When on allow some options that are an expression to be set in the * modeline.  Check the option for whether it is affected by * 'modelineexpr'.  Also see |modeline|. * This option cannot be set from a |modeline| or in the |sandbox|, for * security reasons. */export const modelineexpr = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "modelineexpr") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "modelineexpr", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "modelineexpr");  },  async getGlobal(denops: Denops): Promise<boolean> {    return await globalOptions.get(denops, "modelineexpr") ?? false;  },  setGlobal(denops: Denops, value: boolean): Promise<void> {    return globalOptions.set(denops, "modelineexpr", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "modelineexpr");  },};
/** * If 'modeline' is on 'modelines' gives the number of lines that is * checked for set commands.  If 'modeline' is off or 'modelines' is zero * no lines are checked.  See |modeline|. * NOTE: 'modeline' is set to the Vi default value when 'compatible' is * set and to the Vim default value when 'compatible' is reset. */export const modelines = {  async get(denops: Denops): Promise<number> {    return await options.get(denops, "modelines") ?? 0;  },  set(denops: Denops, value: number): Promise<void> {    return options.set(denops, "modelines", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "modelines");  },  async getGlobal(denops: Denops): Promise<number> {    return await globalOptions.get(denops, "modelines") ?? 0;  },  setGlobal(denops: Denops, value: number): Promise<void> {    return globalOptions.set(denops, "modelines", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "modelines");  },};
/** * When off the buffer contents cannot be changed.  The 'fileformat' and * 'fileencoding' options also can't be changed. * Can be reset on startup with the |-M| command line argument. */export const modifiable = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "modifiable") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "modifiable", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "modifiable");  },  async getLocal(denops: Denops): Promise<boolean> {    return await localOptions.get(denops, "modifiable") ?? false;  },  setLocal(denops: Denops, value: boolean): Promise<void> {    return localOptions.set(denops, "modifiable", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "modifiable");  },};
/** * When on, the buffer is considered to be modified.  This option is set * when: * 1. A change was made to the text since it was last written.  Using the *    |undo| command to go back to the original text will reset the *    option.  But undoing changes that were made before writing the *    buffer will set the option again, since the text is different from *    when it was written. * 2. 'fileformat' or 'fileencoding' is different from its original *    value.  The original value is set when the buffer is read or *    written.  A ":set nomodified" command also resets the original *    values to the current values and the 'modified' option will be *    reset. *    Similarly for 'eol' and 'bomb'. * This option is not set when a change is made to the buffer as the * result of a BufNewFile, BufRead/BufReadPost, BufWritePost, * FileAppendPost or VimLeave autocommand event.  See |gzip-example| for * an explanation. * When 'buftype' is "nowrite" or "nofile" this option may be set, but * will be ignored. * Note that the text may actually be the same, e.g. 'modified' is set * when using "rA" on an "A". */export const modified = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "modified") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "modified", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "modified");  },  async getLocal(denops: Denops): Promise<boolean> {    return await localOptions.get(denops, "modified") ?? false;  },  setLocal(denops: Denops, value: boolean): Promise<void> {    return localOptions.set(denops, "modified", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "modified");  },};
/** * 		{only works in the GUI} * The window that the mouse pointer is on is automatically activated. * When changing the window layout or window focus in another way, the * mouse pointer is moved to the window with keyboard focus.  Off is the * default because it makes using the pull down menus a little goofy, as * a pointer transit may activate a window unintentionally. * MS-Windows: Also see 'scrollfocus' for what window is scrolled when * using the mouse scroll wheel. */export const mousefocus = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "mousefocus") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "mousefocus", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "mousefocus");  },  async getGlobal(denops: Denops): Promise<boolean> {    return await globalOptions.get(denops, "mousefocus") ?? false;  },  setGlobal(denops: Denops, value: boolean): Promise<void> {    return globalOptions.set(denops, "mousefocus", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "mousefocus");  },};
/** * 		{only works in the GUI} * When on, the mouse pointer is hidden when characters are typed. * The mouse pointer is restored when the mouse is moved. */export const mousehide = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "mousehide") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "mousehide", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "mousehide");  },  async getGlobal(denops: Denops): Promise<boolean> {    return await globalOptions.get(denops, "mousehide") ?? false;  },  setGlobal(denops: Denops, value: boolean): Promise<void> {    return globalOptions.set(denops, "mousehide", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "mousehide");  },};
/** * Sets the model to use for the mouse.  The name mostly specifies what * the right mouse button is used for: *    extend	Right mouse button extends a selection.  This works * 		like in an xterm. *    popup	Right mouse button pops up a menu.  The shifted left * 		mouse button extends a selection.  This works like * 		with Microsoft Windows. *    popup_setpos Like "popup", but the cursor will be moved to the * 		position where the mouse was clicked, and thus the * 		selected operation will act upon the clicked object. * 		If clicking inside a selection, that selection will * 		be acted upon, i.e. no cursor move.  This implies of * 		course, that right clicking outside a selection will * 		end Visual mode. * Overview of what button does what for each model: * mouse		    extend		popup(_setpos) ~ * left click	    place cursor	place cursor * left drag	    start selection	start selection * shift-left	    search word		extend selection * right click	    extend selection	popup menu (place cursor) * right drag	    extend selection	- * middle click	    paste		paste */export const mousemodel = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "mousemodel") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "mousemodel", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "mousemodel");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "mousemodel") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "mousemodel", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "mousemodel");  },};
/** * 		{only available when compiled with the |+mouseshape| * 		feature} * This option tells Vim what the mouse pointer should look like in * different modes.  The option is a comma separated list of parts, much * like used for 'guicursor'.  Each part consist of a mode/location-list * and an argument-list: * 	mode-list:shape,mode-list:shape,.. * The mode-list is a dash separated list of these modes/locations: * 		In a normal window: ~ * 	n	Normal mode * 	v	Visual mode * 	ve	Visual mode with 'selection' "exclusive" (same as 'v', * 		if not specified) * 	o	Operator-pending mode * 	i	Insert mode * 	r	Replace mode */export const mouseshape = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "mouseshape") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "mouseshape", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "mouseshape");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "mouseshape") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "mouseshape", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "mouseshape");  },};
/** * Only for GUI, Win32 and Unix with xterm.  Defines the maximum * time in msec between two mouse clicks for the second click to be * recognized as a multi click. */export const mousetime = {  async get(denops: Denops): Promise<number> {    return await options.get(denops, "mousetime") ?? 0;  },  set(denops: Denops, value: number): Promise<void> {    return options.set(denops, "mousetime", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "mousetime");  },  async getGlobal(denops: Denops): Promise<number> {    return await globalOptions.get(denops, "mousetime") ?? 0;  },  setGlobal(denops: Denops, value: number): Promise<void> {    return globalOptions.set(denops, "mousetime", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "mousetime");  },};
/** * This defines what bases Vim will consider for numbers when using the * CTRL-A and CTRL-X commands for adding to and subtracting from a number * respectively; see |CTRL-A| for more info on these commands. * alpha	If included, single alphabetical characters will be * 	incremented or decremented.  This is useful for a list with a * 	letter index a), b), etc. * octal	If included, numbers that start with a zero will be considered * 	to be octal.  Example: Using CTRL-A on "007" results in "010". * hex	If included, numbers starting with "0x" or "0X" will be * 	considered to be hexadecimal.  Example: Using CTRL-X on * 	"0x100" results in "0x0ff". * bin	If included, numbers starting with "0b" or "0B" will be * 	considered to be binary.  Example: Using CTRL-X on * 	"0b1000" subtracts one, resulting in "0b0111". * unsigned    If included, numbers are recognized as unsigned. Thus a * 	leading dash or negative sign won't be considered as part of * 	the number.  Examples: * 	    Using CTRL-X on "2020" in "9-2020" results in "9-2019" * 	    (without "unsigned" it would become "9-2021"). * 	    Using CTRL-A on "2020" in "9-2020" results in "9-2021" * 	    (without "unsigned" it would become "9-2019"). * 	    Using CTRL-X on "0" or CTRL-A on "18446744073709551615" * 	    (2^64 - 1) has no effect, overflow is prevented. * Numbers which simply begin with a digit in the range 1-9 are always * considered decimal.  This also happens for numbers that are not * recognized as octal or hex. */export const nrformats = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "nrformats") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "nrformats", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "nrformats");  },  async getLocal(denops: Denops): Promise<string> {    return await localOptions.get(denops, "nrformats") ?? "";  },  setLocal(denops: Denops, value: string): Promise<void> {    return localOptions.set(denops, "nrformats", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "nrformats");  },};
/** * Print the line number in front of each line.  When the 'n' option is * excluded from 'cpoptions' a wrapped line will not use the column of * line numbers (this is the default when 'compatible' isn't set). * The 'numberwidth' option can be used to set the room used for the line * number. * When a long, wrapped line doesn't start with the first character, '-' * characters are put before the number. * See |hl-LineNr|  and |hl-CursorLineNr| for the highlighting used for * the number. * The 'relativenumber' option changes the displayed number to be * relative to the cursor.  Together with 'number' there are these * four combinations (cursor in line 3): */export const number = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "number") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "number", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "number");  },  async getLocal(denops: Denops): Promise<boolean> {    return await localOptions.get(denops, "number") ?? false;  },  setLocal(denops: Denops, value: boolean): Promise<void> {    return localOptions.set(denops, "number", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "number");  },};
/** * 		{only available when compiled with the |+linebreak| * 		feature} * Minimal number of columns to use for the line number.  Only relevant * when the 'number' or 'relativenumber' option is set or printing lines * with a line number. Since one space is always between the number and * the text, there is one less character for the number itself. * The value is the minimum width.  A bigger width is used when needed to * fit the highest line number in the buffer respectively the number of * rows in the window, depending on whether 'number' or 'relativenumber' * is set. Thus with the Vim default of 4 there is room for a line number * up to 999. When the buffer has 1000 lines five columns will be used. * The minimum value is 1, the maximum value is 20. * NOTE: This option is set to the Vi default value when 'compatible' is * set and to the Vim default value when 'compatible' is reset. */export const numberwidth = {  async get(denops: Denops): Promise<number> {    return await options.get(denops, "numberwidth") ?? 0;  },  set(denops: Denops, value: number): Promise<void> {    return options.set(denops, "numberwidth", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "numberwidth");  },  async getLocal(denops: Denops): Promise<number> {    return await localOptions.get(denops, "numberwidth") ?? 0;  },  setLocal(denops: Denops, value: number): Promise<void> {    return localOptions.set(denops, "numberwidth", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "numberwidth");  },};
/** * 		{not available when compiled without the |+eval| * 		feature} * This option specifies a function to be used for Insert mode omni * completion with CTRL-X CTRL-O. |i_CTRL-X_CTRL-O| * See |complete-functions| for an explanation of how the function is * invoked and what it should return. * This option is usually set by a filetype plugin: * |:filetype-plugin-on| * This option cannot be set from a |modeline| or in the |sandbox|, for * security reasons. */export const omnifunc = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "omnifunc") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "omnifunc", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "omnifunc");  },  async getLocal(denops: Denops): Promise<string> {    return await localOptions.get(denops, "omnifunc") ?? "";  },  setLocal(denops: Denops, value: string): Promise<void> {    return localOptions.set(denops, "omnifunc", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "omnifunc");  },};
/** * 		{only for MS-Windows} * Enable reading and writing from devices.  This may get Vim stuck on a * device that can be opened but doesn't actually do the I/O.  Therefore * it is off by default. * Note that on MS-Windows editing "aux.h", "lpt1.txt" and the like also * result in editing a device. */export const opendevice = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "opendevice") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "opendevice", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "opendevice");  },  async getGlobal(denops: Denops): Promise<boolean> {    return await globalOptions.get(denops, "opendevice") ?? false;  },  setGlobal(denops: Denops, value: boolean): Promise<void> {    return globalOptions.set(denops, "opendevice", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "opendevice");  },};
/** * This option specifies a function to be called by the |g@| operator. * See |:map-operator| for more info and an example. */export const operatorfunc = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "operatorfunc") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "operatorfunc", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "operatorfunc");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "operatorfunc") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "operatorfunc", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "operatorfunc");  },};
/** * Directories used to find packages.  See |packages|. */export const packpath = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "packpath") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "packpath", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "packpath");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "packpath") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "packpath", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "packpath");  },};
/** * Specifies the nroff macros that separate paragraphs.  These are pairs * of two letters (see |object-motions|). */export const paragraphs = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "paragraphs") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "paragraphs", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "paragraphs");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "paragraphs") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "paragraphs", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "paragraphs");  },};
/** * When non-empty, specifies the key sequence that toggles the 'paste' * option.  This is like specifying a mapping: > *     :map {keys} :set invpaste<CR> * <	Where {keys} is the value of 'pastetoggle'. * The difference is that it will work even when 'paste' is set. * 'pastetoggle' works in Insert mode and Normal mode, but not in * Command-line mode. * Mappings are checked first, thus overrule 'pastetoggle'.  However, * when 'paste' is on mappings are ignored in Insert mode, thus you can do * this: > *     :map <F10> :set paste<CR> *     :map <F11> :set nopaste<CR> *     :imap <F10> <C-O>:set paste<CR> *     :imap <F11> <nop> *     :set pastetoggle=<F11> * <	This will make <F10> start paste mode and <F11> stop paste mode. * Note that typing <F10> in paste mode inserts "<F10>", since in paste * mode everything is inserted literally, except the 'pastetoggle' key * sequence. * When the value has several bytes 'ttimeoutlen' applies. */export const pastetoggle = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "pastetoggle") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "pastetoggle", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "pastetoggle");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "pastetoggle") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "pastetoggle", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "pastetoggle");  },};
/** * 		{not available when compiled without the |+diff| * 		feature} * Expression which is evaluated to apply a patch to a file and generate * the resulting new version of the file.  See |diff-patchexpr|. */export const patchexpr = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "patchexpr") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "patchexpr", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "patchexpr");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "patchexpr") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "patchexpr", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "patchexpr");  },};
/** * When non-empty the oldest version of a file is kept.  This can be used * to keep the original version of a file if you are changing files in a * source distribution.  Only the first time that a file is written a * copy of the original file will be kept.  The name of the copy is the * name of the original file with the string in the 'patchmode' option * appended.  This option should start with a dot.  Use a string like * ".orig" or ".org".  'backupdir' must not be empty for this to work * (Detail: The backup file is renamed to the patchmode file after the * new file has been successfully written, that's why it must be possible * to write a backup file).  If there was no file to be backed up, an * empty file is created. * When the 'backupskip' pattern matches, a patchmode file is not made. * Using 'patchmode' for compressed files appends the extension at the * end (e.g., "file.gz.orig"), thus the resulting name isn't always * recognized as a compressed file. * Only normal file name characters can be used, "/\*?[|<>" are illegal. */export const patchmode = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "patchmode") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "patchmode", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "patchmode");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "patchmode") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "patchmode", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "patchmode");  },};
/** * This is a list of directories which will be searched when using the * |gf|, [f, ]f, ^Wf, |:find|, |:sfind|, |:tabfind| and other commands, * provided that the file being searched for has a relative path (not * starting with "/", "./" or "../").  The directories in the 'path' * option may be relative or absolute. * - Use commas to separate directory names: > * 	:set path=.,/usr/local/include,/usr/include * <	- Spaces can also be used to separate directory names (for backwards *   compatibility with version 3.0).  To have a space in a directory *   name, precede it with an extra backslash, and escape the space: > * 	:set path=.,/dir/with\\\ space * <	- To include a comma in a directory name precede it with an extra *   backslash: > * 	:set path=.,/dir/with\\,comma * <	- To search relative to the directory of the current file, use: > * 	:set path=. * <	- To search in the current directory use an empty string between two *   commas: > * 	:set path=,, * <	- A directory name may end in a ':' or '/'. * - Environment variables are expanded |:set_env|. * - When using |netrw.vim| URLs can be used.  For example, adding *   "http://www.vim.org" will make ":find index.html" work. * - Search upwards and downwards in a directory tree using "*" and *   ";".  See |file-searching| for info and syntax. *   {not available when compiled without the |+path_extra| feature} * - Careful with '\' characters, type two to get one in the option: > * 	:set path=.,c:\\include * <	  Or just use '/' instead: > * 	:set path=.,c:/include * <	Don't forget "." or files won't even be found in the same directory as * the file! * The maximum length is limited.  How much depends on the system, mostly * it is something like 256 or 1024 characters. * You can check if all the include files are found, using the value of * 'path', see |:checkpath|. * The use of |:set+=| and |:set-=| is preferred when adding or removing * directories from the list.  This avoids problems when a future version * uses another default.  To remove the current directory use: > * 	:set path-= * <	To add the current directory use: > * 	:set path+= * <	To use an environment variable, you probably need to replace the * separator.  Here is an example to append $INCL, in which directory * names are separated with a semi-colon: > * 	:let &path = &path . "," . substitute($INCL, ';', ',', 'g') * <	Replace the ';' with a ':' or whatever separator is used.  Note that * this doesn't work when $INCL contains a comma or white space. */export const path = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "path") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "path", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "path");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "path") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "path", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "path");  },  async getLocal(denops: Denops): Promise<string> {    return await localOptions.get(denops, "path") ?? "";  },  setLocal(denops: Denops, value: string): Promise<void> {    return localOptions.set(denops, "path", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "path");  },};
/** * When changing the indent of the current line, preserve as much of the * indent structure as possible.  Normally the indent is replaced by a * series of tabs followed by spaces as required (unless |'expandtab'| is * enabled, in which case only spaces are used).  Enabling this option * means the indent will preserve as many existing characters as possible * for indenting, and only add additional tabs or spaces as required. * 'expandtab' does not apply to the preserved white space, a Tab remains * a Tab. * NOTE: When using ">>" multiple times the resulting indent is a mix of * tabs and spaces.  You might not like this. * NOTE: This option is reset when 'compatible' is set. * Also see 'copyindent'. * Use |:retab| to clean up white space. */export const preserveindent = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "preserveindent") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "preserveindent", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "preserveindent");  },  async getLocal(denops: Denops): Promise<boolean> {    return await localOptions.get(denops, "preserveindent") ?? false;  },  setLocal(denops: Denops, value: boolean): Promise<void> {    return localOptions.set(denops, "preserveindent", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "preserveindent");  },};
/** * 		{not available when compiled without the |+quickfix| * 		feature} * Default height for a preview window.  Used for |:ptag| and associated * commands.  Used for |CTRL-W_}| when no count is given.  Not used when * 'previewpopup' is set. */export const previewheight = {  async get(denops: Denops): Promise<number> {    return await options.get(denops, "previewheight") ?? 0;  },  set(denops: Denops, value: number): Promise<void> {    return options.set(denops, "previewheight", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "previewheight");  },  async getGlobal(denops: Denops): Promise<number> {    return await globalOptions.get(denops, "previewheight") ?? 0;  },  setGlobal(denops: Denops, value: number): Promise<void> {    return globalOptions.set(denops, "previewheight", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "previewheight");  },};
/** * 		{not available when compiled without the |+quickfix| * 		feature} * Identifies the preview window.  Only one window can have this option * set.  It's normally not set directly, but by using one of the commands * |:ptag|, |:pedit|, etc. */export const previewwindow = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "previewwindow") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "previewwindow", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "previewwindow");  },  async getLocal(denops: Denops): Promise<boolean> {    return await localOptions.get(denops, "previewwindow") ?? false;  },  setLocal(denops: Denops, value: boolean): Promise<void> {    return localOptions.set(denops, "previewwindow", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "previewwindow");  },};
/** * 		{only available when compiled with the |+printer| * 		feature} * The name of the printer to be used for |:hardcopy|. * See |pdev-option|. * This option cannot be set from a |modeline| or in the |sandbox|, for * security reasons. */export const printdevice = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "printdevice") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "printdevice", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "printdevice");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "printdevice") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "printdevice", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "printdevice");  },};
/** * 		{only available when compiled with the |+printer| * 		and |+postscript| features} * Sets the character encoding used when printing. * See |penc-option|. */export const printencoding = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "printencoding") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "printencoding", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "printencoding");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "printencoding") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "printencoding", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "printencoding");  },};
/** * 		{only available when compiled with the |+printer| * 		and |+postscript| features} * Expression used to print the PostScript produced with |:hardcopy|. * See |pexpr-option|. * This option cannot be set from a |modeline| or in the |sandbox|, for * security reasons. */export const printexpr = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "printexpr") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "printexpr", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "printexpr");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "printexpr") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "printexpr", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "printexpr");  },};
/** * 		{only available when compiled with the |+printer| * 		feature} * The name of the font that will be used for |:hardcopy|. * See |pfn-option|. */export const printfont = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "printfont") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "printfont", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "printfont");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "printfont") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "printfont", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "printfont");  },};
/** * 		{only available when compiled with the |+printer| * 		feature} * The format of the header produced in |:hardcopy| output. * See |pheader-option|. */export const printheader = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "printheader") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "printheader", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "printheader");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "printheader") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "printheader", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "printheader");  },};
/** * 		{only available when compiled with the |+printer| * 		and |+postscript| features} * The CJK character set to be used for CJK output from |:hardcopy|. * See |pmbcs-option|. */export const printmbcharset = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "printmbcharset") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "printmbcharset", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "printmbcharset");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "printmbcharset") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "printmbcharset", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "printmbcharset");  },};
/** * 		{only available when compiled with the |+printer| * 		and |+postscript| features} * List of font names to be used for CJK output from |:hardcopy|. * See |pmbfn-option|. */export const printmbfont = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "printmbfont") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "printmbfont", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "printmbfont");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "printmbfont") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "printmbfont", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "printmbfont");  },};
/** * 		{only available when compiled with |+printer| feature} * List of items that control the format of the output of |:hardcopy|. * See |popt-option|. */export const printoptions = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "printoptions") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "printoptions", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "printoptions");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "printoptions") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "printoptions", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "printoptions");  },};
/** * Determines the maximum number of items to show in the popup menu for * Insert mode completion.  When zero as much space as available is used. * |ins-completion-menu|. */export const pumheight = {  async get(denops: Denops): Promise<number> {    return await options.get(denops, "pumheight") ?? 0;  },  set(denops: Denops, value: number): Promise<void> {    return options.set(denops, "pumheight", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "pumheight");  },  async getGlobal(denops: Denops): Promise<number> {    return await globalOptions.get(denops, "pumheight") ?? 0;  },  setGlobal(denops: Denops, value: number): Promise<void> {    return globalOptions.set(denops, "pumheight", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "pumheight");  },};
/** * Determines the minimum width to use for the popup menu for Insert mode * completion.  |ins-completion-menu|. */export const pumwidth = {  async get(denops: Denops): Promise<number> {    return await options.get(denops, "pumwidth") ?? 0;  },  set(denops: Denops, value: number): Promise<void> {    return options.set(denops, "pumwidth", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "pumwidth");  },  async getGlobal(denops: Denops): Promise<number> {    return await globalOptions.get(denops, "pumwidth") ?? 0;  },  setGlobal(denops: Denops, value: number): Promise<void> {    return globalOptions.set(denops, "pumwidth", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "pumwidth");  },};
/** * 		{only available when compiled with the |+python| or * 		the |+python3| feature} * Specifies the python version used for pyx* functions and commands * |python_x|.  The default value is as follows: */export const pyxversion = {  async get(denops: Denops): Promise<number> {    return await options.get(denops, "pyxversion") ?? 0;  },  set(denops: Denops, value: number): Promise<void> {    return options.set(denops, "pyxversion", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "pyxversion");  },  async getGlobal(denops: Denops): Promise<number> {    return await globalOptions.get(denops, "pyxversion") ?? 0;  },  setGlobal(denops: Denops, value: number): Promise<void> {    return globalOptions.set(denops, "pyxversion", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "pyxversion");  },};
/** * 		{only available when compiled with the |+quickfix| * 		feature} * This option specifies a function to be used to get the text to display * in the quickfix and location list windows.  This can be used to * customize the information displayed in the quickfix or location window * for each entry in the corresponding quickfix or location list.  See * |quickfix-window-function| for an explanation of how to write the * function and an example. The value can be the name of a function or a * lambda. */export const quickfixtextfunc = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "quickfixtextfunc") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "quickfixtextfunc", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "quickfixtextfunc");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "quickfixtextfunc") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "quickfixtextfunc", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "quickfixtextfunc");  },};
/** * The characters that are used to escape quotes in a string.  Used for * objects like a', a" and a` |a'|. * When one of the characters in this option is found inside a string, * the following character will be skipped.  The default value makes the * text "foo\"bar\\" considered to be one string. */export const quoteescape = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "quoteescape") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "quoteescape", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "quoteescape");  },  async getLocal(denops: Denops): Promise<string> {    return await localOptions.get(denops, "quoteescape") ?? "";  },  setLocal(denops: Denops, value: string): Promise<void> {    return localOptions.set(denops, "quoteescape", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "quoteescape");  },};
/** * If on, writes fail unless you use a '!'.  Protects you from * accidentally overwriting a file.  Default on when Vim is started * in read-only mode ("vim -R") or when the executable is called "view". * When using ":w!" the 'readonly' option is reset for the current * buffer, unless the 'Z' flag is in 'cpoptions'. * When using the ":view" command the 'readonly' option is set for the * newly edited buffer. * See 'modifiable' for disallowing changes to the buffer. */export const readonly = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "readonly") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "readonly", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "readonly");  },  async getLocal(denops: Denops): Promise<boolean> {    return await localOptions.get(denops, "readonly") ?? false;  },  setLocal(denops: Denops, value: boolean): Promise<void> {    return localOptions.set(denops, "readonly", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "readonly");  },};
/** * 		{only available when compiled with the |+reltime| * 		feature} * The time in milliseconds for redrawing the display.  This applies to * searching for patterns for 'hlsearch', |:match| highlighting and syntax * highlighting. * When redrawing takes more than this many milliseconds no further * matches will be highlighted. * For syntax highlighting the time applies per window.  When over the * limit syntax highlighting is disabled until |CTRL-L| is used. * This is used to avoid that Vim hangs when using a very complicated * pattern. */export const redrawtime = {  async get(denops: Denops): Promise<number> {    return await options.get(denops, "redrawtime") ?? 0;  },  set(denops: Denops, value: number): Promise<void> {    return options.set(denops, "redrawtime", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "redrawtime");  },  async getGlobal(denops: Denops): Promise<number> {    return await globalOptions.get(denops, "redrawtime") ?? 0;  },  setGlobal(denops: Denops, value: number): Promise<void> {    return globalOptions.set(denops, "redrawtime", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "redrawtime");  },};
/** * This selects the default regexp engine. |two-engines| * The possible values are: * 	0	automatic selection * 	1	old engine * 	2	NFA engine * Note that when using the NFA engine and the pattern contains something * that is not supported the pattern will not match.  This is only useful * for debugging the regexp engine. * Using automatic selection enables Vim to switch the engine, if the * default engine becomes too costly.  E.g., when the NFA engine uses too * many states.  This should prevent Vim from hanging on a combination of * a complex pattern with long text. */export const regexpengine = {  async get(denops: Denops): Promise<number> {    return await options.get(denops, "regexpengine") ?? 0;  },  set(denops: Denops, value: number): Promise<void> {    return options.set(denops, "regexpengine", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "regexpengine");  },  async getGlobal(denops: Denops): Promise<number> {    return await globalOptions.get(denops, "regexpengine") ?? 0;  },  setGlobal(denops: Denops, value: number): Promise<void> {    return globalOptions.set(denops, "regexpengine", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "regexpengine");  },};
/** * Show the line number relative to the line with the cursor in front of * each line. Relative line numbers help you use the |count| you can * precede some vertical motion commands (e.g. j k + -) with, without * having to calculate it yourself. Especially useful in combination with * other commands (e.g. y d c < > gq gw =). * When the 'n' option is excluded from 'cpoptions' a wrapped * line will not use the column of line numbers (this is the default when * 'compatible' isn't set). * The 'numberwidth' option can be used to set the room used for the line * number. * When a long, wrapped line doesn't start with the first character, '-' * characters are put before the number. * See |hl-LineNr|  and |hl-CursorLineNr| for the highlighting used for * the number. */export const relativenumber = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "relativenumber") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "relativenumber", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "relativenumber");  },  async getLocal(denops: Denops): Promise<boolean> {    return await localOptions.get(denops, "relativenumber") ?? false;  },  setLocal(denops: Denops, value: boolean): Promise<void> {    return localOptions.set(denops, "relativenumber", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "relativenumber");  },};
/** * 		{only available when compiled with the |+rightleft| * 		feature} * Inserting characters in Insert mode will work backwards.  See "typing * backwards" |ins-reverse|.  This option can be toggled with the CTRL-_ * command in Insert mode, when 'allowrevins' is set. * NOTE: This option is reset when 'compatible' is set. * This option is reset when 'paste' is set and restored when 'paste' is * reset. */export const revins = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "revins") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "revins", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "revins");  },  async getGlobal(denops: Denops): Promise<boolean> {    return await globalOptions.get(denops, "revins") ?? false;  },  setGlobal(denops: Denops, value: boolean): Promise<void> {    return globalOptions.set(denops, "revins", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "revins");  },};
/** * 		{only available when compiled with the |+rightleft| * 		feature} * When on, display orientation becomes right-to-left, i.e., characters * that are stored in the file appear from the right to the left. * Using this option, it is possible to edit files for languages that * are written from the right to the left such as Hebrew and Arabic. * This option is per window, so it is possible to edit mixed files * simultaneously, or to view the same file in both ways (this is * useful whenever you have a mixed text file with both right-to-left * and left-to-right strings so that both sets are displayed properly * in different windows).  Also see |rileft.txt|. */export const rightleft = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "rightleft") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "rightleft", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "rightleft");  },  async getLocal(denops: Denops): Promise<boolean> {    return await localOptions.get(denops, "rightleft") ?? false;  },  setLocal(denops: Denops, value: boolean): Promise<void> {    return localOptions.set(denops, "rightleft", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "rightleft");  },};
/** * 		{only available when compiled with the |+rightleft| * 		feature} * Each word in this option enables the command line editing to work in * right-to-left mode for a group of commands: */export const rightleftcmd = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "rightleftcmd") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "rightleftcmd", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "rightleftcmd");  },  async getLocal(denops: Denops): Promise<string> {    return await localOptions.get(denops, "rightleftcmd") ?? "";  },  setLocal(denops: Denops, value: string): Promise<void> {    return localOptions.set(denops, "rightleftcmd", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "rightleftcmd");  },};
/** * 		{not available when compiled without the * 		|+cmdline_info| feature} * Show the line and column number of the cursor position, separated by a * comma.  When there is room, the relative position of the displayed * text in the file is shown on the far right: * 	Top	first line is visible * 	Bot	last line is visible * 	All	first and last line are visible * 	45%	relative position in the file * If 'rulerformat' is set, it will determine the contents of the ruler. * Each window has its own ruler.  If a window has a status line, the * ruler is shown there.  Otherwise it is shown in the last line of the * screen.  If the statusline is given by 'statusline' (i.e. not empty), * this option takes precedence over 'ruler' and 'rulerformat' * If the number of characters displayed is different from the number of * bytes in the text (e.g., for a TAB or a multibyte character), both * the text column (byte number) and the screen column are shown, * separated with a dash. * For an empty line "0-1" is shown. * For an empty buffer the line number will also be zero: "0,0-1". * This option is reset when 'paste' is set and restored when 'paste' is * reset. * If you don't want to see the ruler all the time but want to know where * you are, use "g CTRL-G" |g_CTRL-G|. * NOTE: This option is reset when 'compatible' is set. */export const ruler = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "ruler") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "ruler", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "ruler");  },  async getGlobal(denops: Denops): Promise<boolean> {    return await globalOptions.get(denops, "ruler") ?? false;  },  setGlobal(denops: Denops, value: boolean): Promise<void> {    return globalOptions.set(denops, "ruler", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "ruler");  },};
/** * 		{not available when compiled without the |+statusline| * 		feature} * When this option is not empty, it determines the content of the ruler * string, as displayed for the 'ruler' option. * The format of this option is like that of 'statusline'. * This option cannot be set in a modeline when 'modelineexpr' is off. */export const rulerformat = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "rulerformat") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "rulerformat", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "rulerformat");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "rulerformat") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "rulerformat", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "rulerformat");  },};
/** * This is a list of directories which will be searched for runtime * files: *   filetype.vim	filetypes by file name |new-filetype| *   scripts.vim	filetypes by file contents |new-filetype-scripts| *   autoload/	automatically loaded scripts |autoload-functions| *   colors/	color scheme files |:colorscheme| *   compiler/	compiler files |:compiler| *   doc/		documentation |write-local-help| *   ftplugin/	filetype plugins |write-filetype-plugin| *   import/	files that are found by `:import` *   indent/	indent scripts |indent-expression| *   keymap/	key mapping files |mbyte-keymap| *   lang/		menu translations |:menutrans| *   menu.vim	GUI menus |menu.vim| *   pack/		packages |:packadd| *   plugin/	plugin scripts |write-plugin| *   print/	files for printing |postscript-print-encoding| *   spell/	spell checking files |spell| *   syntax/	syntax files |mysyntaxfile| *   tutor/	files for vimtutor |tutor| */export const runtimepath = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "runtimepath") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "runtimepath", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "runtimepath");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "runtimepath") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "runtimepath", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "runtimepath");  },};
/** * Number of lines to scroll with CTRL-U and CTRL-D commands.  Will be * set to half the number of lines in the window when the window size * changes.  This may happen when enabling the |status-line| or * 'tabline' option after setting the 'scroll' option. * If you give a count to the CTRL-U or CTRL-D command it will * be used as the new value for 'scroll'.  Reset to half the window * height with ":set scroll=0". */export const scroll = {  async get(denops: Denops): Promise<number> {    return await options.get(denops, "scroll") ?? 0;  },  set(denops: Denops, value: number): Promise<void> {    return options.set(denops, "scroll", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "scroll");  },  async getLocal(denops: Denops): Promise<number> {    return await localOptions.get(denops, "scroll") ?? 0;  },  setLocal(denops: Denops, value: number): Promise<void> {    return localOptions.set(denops, "scroll", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "scroll");  },};
/** * See also |scroll-binding|.  When this option is set, the current * window scrolls as other scrollbind windows (windows that also have * this option set) scroll.  This option is useful for viewing the * differences between two versions of a file, see 'diff'. * See |'scrollopt'| for options that determine how this option should be * interpreted. * This option is mostly reset when splitting a window to edit another * file.  This means that ":split | edit file" results in two windows * with scroll-binding, but ":split file" does not. */export const scrollbind = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "scrollbind") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "scrollbind", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "scrollbind");  },  async getLocal(denops: Denops): Promise<boolean> {    return await localOptions.get(denops, "scrollbind") ?? false;  },  setLocal(denops: Denops, value: boolean): Promise<void> {    return localOptions.set(denops, "scrollbind", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "scrollbind");  },};
/** * Minimal number of lines to scroll when the cursor gets off the * screen (e.g., with "j").  Not used for scroll commands (e.g., CTRL-E, * CTRL-D).  Useful if your terminal scrolls very slowly. * When set to a negative number from -1 to -100 this is used as the * percentage of the window height.  Thus -50 scrolls half the window * height. * NOTE: This option is set to 1 when 'compatible' is set. */export const scrolljump = {  async get(denops: Denops): Promise<number> {    return await options.get(denops, "scrolljump") ?? 0;  },  set(denops: Denops, value: number): Promise<void> {    return options.set(denops, "scrolljump", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "scrolljump");  },  async getGlobal(denops: Denops): Promise<number> {    return await globalOptions.get(denops, "scrolljump") ?? 0;  },  setGlobal(denops: Denops, value: number): Promise<void> {    return globalOptions.set(denops, "scrolljump", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "scrolljump");  },};
/** * Minimal number of screen lines to keep above and below the cursor. * This will make some context visible around where you are working.  If * you set it to a very large value (999) the cursor line will always be * in the middle of the window (except at the start or end of the file or * when long lines wrap). * After using the local value, go back the global value with one of * these two: > * 	setlocal scrolloff< * 	setlocal scrolloff=-1 * <	For scrolling horizontally see 'sidescrolloff'. * NOTE: This option is set to 0 when 'compatible' is set. */export const scrolloff = {  async get(denops: Denops): Promise<number> {    return await options.get(denops, "scrolloff") ?? 0;  },  set(denops: Denops, value: number): Promise<void> {    return options.set(denops, "scrolloff", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "scrolloff");  },  async getGlobal(denops: Denops): Promise<number> {    return await globalOptions.get(denops, "scrolloff") ?? 0;  },  setGlobal(denops: Denops, value: number): Promise<void> {    return globalOptions.set(denops, "scrolloff", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "scrolloff");  },  async getLocal(denops: Denops): Promise<number> {    return await localOptions.get(denops, "scrolloff") ?? 0;  },  setLocal(denops: Denops, value: number): Promise<void> {    return localOptions.set(denops, "scrolloff", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "scrolloff");  },};
/** * This is a comma-separated list of words that specifies how * 'scrollbind' windows should behave.  'sbo' stands for ScrollBind * Options. * The following words are available: *     ver		Bind vertical scrolling for 'scrollbind' windows *     hor		Bind horizontal scrolling for 'scrollbind' windows *     jump	Applies to the offset between two windows for vertical * 		scrolling.  This offset is the difference in the first * 		displayed line of the bound windows.  When moving * 		around in a window, another 'scrollbind' window may * 		reach a position before the start or after the end of * 		the buffer.  The offset is not changed though, when * 		moving back the 'scrollbind' window will try to scroll * 		to the desired position when possible. * 		When now making that window the current one, two * 		things can be done with the relative offset: * 		1. When "jump" is not included, the relative offset is * 		   adjusted for the scroll position in the new current * 		   window.  When going back to the other window, the * 		   new relative offset will be used. * 		2. When "jump" is included, the other windows are * 		   scrolled to keep the same relative offset.  When * 		   going back to the other window, it still uses the * 		   same relative offset. * Also see |scroll-binding|. * When 'diff' mode is active there always is vertical scroll binding, * even when "ver" isn't there. */export const scrollopt = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "scrollopt") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "scrollopt", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "scrollopt");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "scrollopt") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "scrollopt", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "scrollopt");  },};
/** * Specifies the nroff macros that separate sections.  These are pairs of * two letters (See |object-motions|).  The default makes a section start * at the nroff macros ".SH", ".NH", ".H", ".HU", ".nh" and ".sh". */export const sections = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "sections") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "sections", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "sections");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "sections") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "sections", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "sections");  },};
/** * This option defines the behavior of the selection.  It is only used * in Visual and Select mode. * Possible values: *    value	past line     inclusive ~ *    old		   no		yes *    inclusive	   yes		yes *    exclusive	   yes		no * "past line" means that the cursor is allowed to be positioned one * character past the line. * "inclusive" means that the last character of the selection is included * in an operation.  For example, when "x" is used to delete the * selection. * When "old" is used and 'virtualedit' allows the cursor to move past * the end of line the line break still isn't included. * Note that when "exclusive" is used and selecting from the end * backwards, you cannot include the last character of a line, when * starting in Normal mode and 'virtualedit' empty. */export const selection = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "selection") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "selection", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "selection");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "selection") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "selection", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "selection");  },};
/** * This is a comma separated list of words, which specifies when to start * Select mode instead of Visual mode, when a selection is started. * Possible values: *    mouse	when using the mouse *    key		when using shifted special keys *    cmd		when using "v", "V" or CTRL-V * See |Select-mode|. * The 'selectmode' option is set by the |:behave| command. */export const selectmode = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "selectmode") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "selectmode", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "selectmode");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "selectmode") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "selectmode", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "selectmode");  },};
/** * 		{not available when compiled without the |+mksession| * 		feature} * Changes the effect of the |:mksession| command.  It is a comma * separated list of words.  Each word enables saving and restoring * something: *    word		save and restore ~ *    blank	empty windows *    buffers	hidden and unloaded buffers, not just those in windows *    curdir	the current directory *    folds	manually created folds, opened/closed folds and local * 		fold options *    globals	global variables that start with an uppercase letter * 		and contain at least one lowercase letter.  Only * 		String and Number types are stored. *    help		the help window *    localoptions	options and mappings local to a window or buffer (not * 		global values for local options) *    options	all options and mappings (also global values for local * 		options) *    skiprtp	exclude 'runtimepath' and 'packpath' from the options *    resize	size of the Vim window: 'lines' and 'columns' *    sesdir	the directory in which the session file is located * 		will become the current directory (useful with * 		projects accessed over a network from different * 		systems) *    slash	backslashes in file names replaced with forward * 		slashes *    tabpages	all tab pages; without this only the current tab page * 		is restored, so that you can make a session for each * 		tab page separately *    terminal	include terminal windows where the command can be * 		restored *    unix		with Unix end-of-line format (single <NL>), even when * 		on Windows or DOS *    winpos	position of the whole Vim window *    winsize	window sizes */export const sessionoptions = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "sessionoptions") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "sessionoptions", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "sessionoptions");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "sessionoptions") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "sessionoptions", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "sessionoptions");  },};
/** * Name of the shell to use for ! and :! commands.  When changing the * value also check these options: 'shelltype', 'shellpipe', 'shellslash' * 'shellredir', 'shellquote', 'shellxquote' and 'shellcmdflag'. * It is allowed to give an argument to the command, e.g.  "csh -f". * See |option-backslash| about including spaces and backslashes. * Environment variables are expanded |:set_env|. */export const shell = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "shell") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "shell", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "shell");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "shell") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "shell", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "shell");  },};
/** * Flag passed to the shell to execute "!" and ":!" commands; e.g., * "bash.exe -c ls", "powershell.exe -Command dir", or "cmd.exe /c dir". * For MS-Windows, the default is set according to the value of 'shell', * to reduce the need to set this option by the user. * On Unix it can have more than one flag.  Each white space separated * part is passed as an argument to the shell command. * See |option-backslash| about including spaces and backslashes. * Also see |dos-shell| and |dos-powershell| for MS-Windows. * This option cannot be set from a |modeline| or in the |sandbox|, for * security reasons. */export const shellcmdflag = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "shellcmdflag") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "shellcmdflag", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "shellcmdflag");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "shellcmdflag") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "shellcmdflag", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "shellcmdflag");  },};
/** * 		{not available when compiled without the |+quickfix| * 		feature} * String to be used to put the output of the ":make" command in the * error file.  See also |:make_makeprg|.  See |option-backslash| about * including spaces and backslashes. * The name of the temporary file can be represented by "%s" if necessary * (the file name is appended automatically if no %s appears in the value * of this option). * For the Amiga the default is ">".  For MS-Windows using powershell the * default is "2>&1 | Out-File -Encoding default", otherwise the default * is ">%s 2>&1".  The output is directly saved in a file and not echoed * to the screen. * For Unix the default is "| tee".  The stdout of the compiler is saved * in a file and echoed to the screen.  If the 'shell' option is "csh" or * "tcsh" after initializations, the default becomes "|& tee".  If the * 'shell' option is "sh", "ksh", "mksh", "pdksh", "zsh", "zsh-beta", * "bash", "fish", "ash" or "dash" the default becomes "2>&1| tee".  This * means that stderr is also included.  Before using the 'shell' option a * path is removed, thus "/bin/sh" uses "sh". * For Unix and MS-Windows, when the 'shell' option is "pwsh" the default * becomes ">%s 2>&1" and the output is not echoed to the screen. * The initialization of this option is done after reading the ".vimrc" * and the other initializations, so that when the 'shell' option is set * there, the 'shellpipe' option changes automatically, unless it was * explicitly set before. * When 'shellpipe' is set to an empty string, no redirection of the * ":make" output will be done.  This is useful if you use a 'makeprg' * that writes to 'makeef' by itself.  If you want no piping, but do * want to include the 'makeef', set 'shellpipe' to a single space. * Don't forget to precede the space with a backslash: ":set sp=\ ". * In the future pipes may be used for filtering and this option will * become obsolete (at least for Unix). * This option cannot be set from a |modeline| or in the |sandbox|, for * security reasons. */export const shellpipe = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "shellpipe") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "shellpipe", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "shellpipe");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "shellpipe") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "shellpipe", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "shellpipe");  },};
/** * Quoting character(s), put around the command passed to the shell, for * the "!" and ":!" commands.  The redirection is kept outside of the * quoting.  See 'shellxquote' to include the redirection.  It's * probably not useful to set both options. * This is an empty string by default.  Only known to be useful for * third-party shells on MS-Windows-like systems, such as the MKS Korn * Shell or bash, where it should be "\"".  See |dos-shell|. * This option cannot be set from a |modeline| or in the |sandbox|, for * security reasons. */export const shellquote = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "shellquote") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "shellquote", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "shellquote");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "shellquote") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "shellquote", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "shellquote");  },};
/** * String to be used to put the output of a filter command in a temporary * file.  See also |:!|.  See |option-backslash| about including spaces * and backslashes. * The name of the temporary file can be represented by "%s" if necessary * (the file name is appended automatically if no %s appears in the value * of this option). * The default is ">".  For Unix, if the 'shell' option is "csh" or * "tcsh" during initializations, the default becomes ">&".  If the * 'shell' option is "sh", "ksh", "mksh", "pdksh", "zsh", "zsh-beta", * "bash", "fish", or "pwsh", the default becomes ">%s 2>&1".  This means * that stderr is also included.  For Win32, the Unix checks are done and * additionally "cmd" is checked for, which makes the default ">%s 2>&1", * and "powershell" is checked for which makes the default * "2>&1 | Out-File -Encoding default" (see |dos-powershell|).  Also, the * same names with ".exe" appended are checked for. * The initialization of this option is done after reading the ".vimrc" * and the other initializations, so that when the 'shell' option is set * there, the 'shellredir' option changes automatically unless it was * explicitly set before. * In the future pipes may be used for filtering and this option will * become obsolete (at least for Unix). * This option cannot be set from a |modeline| or in the |sandbox|, for * security reasons. */export const shellredir = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "shellredir") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "shellredir", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "shellredir");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "shellredir") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "shellredir", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "shellredir");  },};
/** * 		{only for MS-Windows} * When set, a forward slash is used when expanding file names.  This is * useful when a Unix-like shell is used instead of cmd.exe, pwsh.exe, or * powershell.exe.  Backward slashes can still be typed, but they are * changed to forward slashes by Vim. * Note that setting or resetting this option has no effect for some * existing file names, thus this option needs to be set before opening * any file for best results.  This might change in the future. * 'shellslash' only works when a backslash can be used as a path * separator.  To test if this is so use: > * 	if exists('+shellslash') * <	Also see 'completeslash'. */export const shellslash = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "shellslash") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "shellslash", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "shellslash");  },  async getGlobal(denops: Denops): Promise<boolean> {    return await globalOptions.get(denops, "shellslash") ?? false;  },  setGlobal(denops: Denops, value: boolean): Promise<void> {    return globalOptions.set(denops, "shellslash", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "shellslash");  },};
/** * When on, use temp files for shell commands.  When off use a pipe. * When using a pipe is not possible temp files are used anyway. * Currently a pipe is only supported on Unix and MS-Windows 2K and * later.  You can check it with: > * 	:if has("filterpipe") * <	The advantage of using a pipe is that nobody can read the temp file * and the 'shell' command does not need to support redirection. * The advantage of using a temp file is that the file type and encoding * can be detected. * The |FilterReadPre|, |FilterReadPost| and |FilterWritePre|, * |FilterWritePost| autocommands event are not triggered when * 'shelltemp' is off. * The `system()` function does not respect this option and always uses * temp files. * NOTE: This option is set to the Vim default value when 'compatible' * is reset. */export const shelltemp = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "shelltemp") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "shelltemp", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "shelltemp");  },  async getGlobal(denops: Denops): Promise<boolean> {    return await globalOptions.get(denops, "shelltemp") ?? false;  },  setGlobal(denops: Denops, value: boolean): Promise<void> {    return globalOptions.set(denops, "shelltemp", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "shelltemp");  },};
/** * When 'shellxquote' is set to "(" then the characters listed in this * option will be escaped with a '^' character.  This makes it possible * to execute most external commands with cmd.exe. */export const shellxescape = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "shellxescape") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "shellxescape", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "shellxescape");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "shellxescape") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "shellxescape", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "shellxescape");  },};
/** * Quoting character(s), put around the command passed to the shell, for * the "!" and ":!" commands.  Includes the redirection.  See * 'shellquote' to exclude the redirection.  It's probably not useful * to set both options. * When the value is '(' then ')' is appended. When the value is '"(' * then ')"' is appended. * When the value is '(' then also see 'shellxescape'. * This is an empty string by default on most systems, but is known to be * useful for on Win32 version, either for cmd.exe, powershell.exe, or * pwsh.exe which automatically strips off the first and last quote on a * command, or 3rd-party shells such as the MKS Korn Shell or bash, where * it should be "\"".  The default is adjusted according the value of * 'shell', to reduce the need to set this option by the user.  See * |dos-shell|. * This option cannot be set from a |modeline| or in the |sandbox|, for * security reasons. */export const shellxquote = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "shellxquote") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "shellxquote", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "shellxquote");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "shellxquote") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "shellxquote", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "shellxquote");  },};
/** * Round indent to multiple of 'shiftwidth'.  Applies to > and < * commands.  CTRL-T and CTRL-D in Insert mode always round the indent to * a multiple of 'shiftwidth' (this is Vi compatible). * NOTE: This option is reset when 'compatible' is set. */export const shiftround = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "shiftround") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "shiftround", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "shiftround");  },  async getGlobal(denops: Denops): Promise<boolean> {    return await globalOptions.get(denops, "shiftround") ?? false;  },  setGlobal(denops: Denops, value: boolean): Promise<void> {    return globalOptions.set(denops, "shiftround", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "shiftround");  },};
/** * Number of spaces to use for each step of (auto)indent.  Used for * |'cindent'|, |>>|, |<<|, etc. * When zero the 'ts' value will be used.  Use the |shiftwidth()| * function to get the effective shiftwidth value. */export const shiftwidth = {  async get(denops: Denops): Promise<number> {    return await options.get(denops, "shiftwidth") ?? 0;  },  set(denops: Denops, value: number): Promise<void> {    return options.set(denops, "shiftwidth", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "shiftwidth");  },  async getLocal(denops: Denops): Promise<number> {    return await localOptions.get(denops, "shiftwidth") ?? 0;  },  setLocal(denops: Denops, value: number): Promise<void> {    return localOptions.set(denops, "shiftwidth", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "shiftwidth");  },};
/** * This option helps to avoid all the |hit-enter| prompts caused by file * messages, for example  with CTRL-G, and to avoid some other messages. * It is a list of flags: *  flag	meaning when present	~ *   f	use "(3 of 5)" instead of "(file 3 of 5)" *   i	use "[noeol]" instead of "[Incomplete last line]" *   l	use "999L, 888B" instead of "999 lines, 888 bytes" *   m	use "[+]" instead of "[Modified]" *   n	use "[New]" instead of "[New File]" *   r	use "[RO]" instead of "[readonly]" *   w	use "[w]" instead of "written" for file write message * 	and "[a]" instead of "appended" for ':w >> file' command *   x	use "[dos]" instead of "[dos format]", "[unix]" instead of * 	"[unix format]" and "[mac]" instead of "[mac format]". *   a	all of the above abbreviations */export const shortmess = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "shortmess") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "shortmess", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "shortmess");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "shortmess") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "shortmess", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "shortmess");  },};
/** * 		{not available when compiled without the |+linebreak| * 		feature} * String to put at the start of lines that have been wrapped.  Useful * values are "> " or "+++ ": > * 	:set showbreak=>\ * <	Note the backslash to escape the trailing space.  It's easier like * this: > * 	:let &showbreak = '+++ ' * <	Only printable single-cell characters are allowed, excluding <Tab> and * comma (in a future version the comma might be used to separate the * part that is shown at the end and at the start of a line). * The characters are highlighted according to the '@' flag in * 'highlight'. * Note that tabs after the showbreak will be displayed differently. * If you want the 'showbreak' to appear in between line numbers, add the * "n" flag to 'cpoptions'. * A window-local value overrules a global value.  If the global value is * set and you want no value in the current window use NONE: > * 	:setlocal showbreak=NONE * < */export const showbreak = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "showbreak") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "showbreak", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "showbreak");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "showbreak") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "showbreak", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "showbreak");  },  async getLocal(denops: Denops): Promise<string> {    return await localOptions.get(denops, "showbreak") ?? "";  },  setLocal(denops: Denops, value: string): Promise<void> {    return localOptions.set(denops, "showbreak", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "showbreak");  },};
/** * 		{not available when compiled without the * 		|+cmdline_info| feature} * Show (partial) command in the last line of the screen.  Set this * option off if your terminal is slow. * In Visual mode the size of the selected area is shown: * - When selecting characters within a line, the number of characters. *   If the number of bytes is different it is also displayed: "2-6" *   means two characters and six bytes. * - When selecting more than one line, the number of lines. * - When selecting a block, the size in screen characters: *   {lines}x{columns}. * NOTE: This option is set to the Vi default value when 'compatible' is * set and to the Vim default value when 'compatible' is reset. */export const showcmd = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "showcmd") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "showcmd", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "showcmd");  },  async getGlobal(denops: Denops): Promise<boolean> {    return await globalOptions.get(denops, "showcmd") ?? false;  },  setGlobal(denops: Denops, value: boolean): Promise<void> {    return globalOptions.set(denops, "showcmd", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "showcmd");  },};
/** * When completing a word in insert mode (see |ins-completion|) from the * tags file, show both the tag name and a tidied-up form of the search * pattern (if there is one) as possible matches.  Thus, if you have * matched a C function, you can see a template for what arguments are * required (coding style permitting). * Note that this doesn't work well together with having "longest" in * 'completeopt', because the completion from the search pattern may not * match the typed text. */export const showfulltag = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "showfulltag") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "showfulltag", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "showfulltag");  },  async getGlobal(denops: Denops): Promise<boolean> {    return await globalOptions.get(denops, "showfulltag") ?? false;  },  setGlobal(denops: Denops, value: boolean): Promise<void> {    return globalOptions.set(denops, "showfulltag", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "showfulltag");  },};
/** * When a bracket is inserted, briefly jump to the matching one.  The * jump is only done if the match can be seen on the screen.  The time to * show the match can be set with 'matchtime'. * A Beep is given if there is no match (no matter if the match can be * seen or not). * This option is reset when 'paste' is set and restored when 'paste' is * reset. * When the 'm' flag is not included in 'cpoptions', typing a character * will immediately move the cursor back to where it belongs. * See the "sm" field in 'guicursor' for setting the cursor shape and * blinking when showing the match. * The 'matchpairs' option can be used to specify the characters to show * matches for.  'rightleft' and 'revins' are used to look for opposite * matches. * Also see the matchparen plugin for highlighting the match when moving * around |pi_paren.txt|. * Note: Use of the short form is rated PG. */export const showmatch = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "showmatch") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "showmatch", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "showmatch");  },  async getGlobal(denops: Denops): Promise<boolean> {    return await globalOptions.get(denops, "showmatch") ?? false;  },  setGlobal(denops: Denops, value: boolean): Promise<void> {    return globalOptions.set(denops, "showmatch", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "showmatch");  },};
/** * If in Insert, Replace or Visual mode put a message on the last line. * Use the 'M' flag in 'highlight' to set the type of highlighting for * this message. * When |XIM| may be used the message will include "XIM".  But this * doesn't mean XIM is really active, especially when 'imactivatekey' is * not set. * NOTE: This option is set to the Vi default value when 'compatible' is * set and to the Vim default value when 'compatible' is reset. */export const showmode = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "showmode") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "showmode", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "showmode");  },  async getGlobal(denops: Denops): Promise<boolean> {    return await globalOptions.get(denops, "showmode") ?? false;  },  setGlobal(denops: Denops, value: boolean): Promise<void> {    return globalOptions.set(denops, "showmode", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "showmode");  },};
/** * The value of this option specifies when the line with tab page labels * will be displayed: * 	0: never * 	1: only if there are at least two tab pages * 	2: always * This is both for the GUI and non-GUI implementation of the tab pages * line. * See |tab-page| for more information about tab pages. */export const showtabline = {  async get(denops: Denops): Promise<number> {    return await options.get(denops, "showtabline") ?? 0;  },  set(denops: Denops, value: number): Promise<void> {    return options.set(denops, "showtabline", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "showtabline");  },  async getGlobal(denops: Denops): Promise<number> {    return await globalOptions.get(denops, "showtabline") ?? 0;  },  setGlobal(denops: Denops, value: number): Promise<void> {    return globalOptions.set(denops, "showtabline", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "showtabline");  },};
/** * The minimal number of columns to scroll horizontally.  Used only when * the 'wrap' option is off and the cursor is moved off of the screen. * When it is zero the cursor will be put in the middle of the screen. * When using a slow terminal set it to a large number or 0.  When using * a fast terminal use a small number or 1.  Not used for "zh" and "zl" * commands. */export const sidescroll = {  async get(denops: Denops): Promise<number> {    return await options.get(denops, "sidescroll") ?? 0;  },  set(denops: Denops, value: number): Promise<void> {    return options.set(denops, "sidescroll", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "sidescroll");  },  async getGlobal(denops: Denops): Promise<number> {    return await globalOptions.get(denops, "sidescroll") ?? 0;  },  setGlobal(denops: Denops, value: number): Promise<void> {    return globalOptions.set(denops, "sidescroll", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "sidescroll");  },};
/** * The minimal number of screen columns to keep to the left and to the * right of the cursor if 'nowrap' is set.  Setting this option to a * value greater than 0 while having |'sidescroll'| also at a non-zero * value makes some context visible in the line you are scrolling in * horizontally (except at beginning of the line).  Setting this option * to a large value (like 999) has the effect of keeping the cursor * horizontally centered in the window, as long as one does not come too * close to the beginning of the line. * After using the local value, go back the global value with one of * these two: > * 	setlocal sidescrolloff< * 	setlocal sidescrolloff=-1 * <	NOTE: This option is set to 0 when 'compatible' is set. */export const sidescrolloff = {  async get(denops: Denops): Promise<number> {    return await options.get(denops, "sidescrolloff") ?? 0;  },  set(denops: Denops, value: number): Promise<void> {    return options.set(denops, "sidescrolloff", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "sidescrolloff");  },  async getGlobal(denops: Denops): Promise<number> {    return await globalOptions.get(denops, "sidescrolloff") ?? 0;  },  setGlobal(denops: Denops, value: number): Promise<void> {    return globalOptions.set(denops, "sidescrolloff", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "sidescrolloff");  },  async getLocal(denops: Denops): Promise<number> {    return await localOptions.get(denops, "sidescrolloff") ?? 0;  },  setLocal(denops: Denops, value: number): Promise<void> {    return localOptions.set(denops, "sidescrolloff", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "sidescrolloff");  },};
/** * 		{not available when compiled without the |+signs| * 		feature} * Whether or not to draw the signcolumn. Valid values are: *    "auto"   	only when there is a sign to display *    "no"	    	never *    "yes"    	always *    "number"	display signs in the 'number' column. If the number * 		column is not present, then behaves like "auto". */export const signcolumn = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "signcolumn") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "signcolumn", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "signcolumn");  },  async getLocal(denops: Denops): Promise<string> {    return await localOptions.get(denops, "signcolumn") ?? "";  },  setLocal(denops: Denops, value: string): Promise<void> {    return localOptions.set(denops, "signcolumn", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "signcolumn");  },};
/** * Override the 'ignorecase' option if the search pattern contains upper * case characters.  Only used when the search pattern is typed and * 'ignorecase' option is on.  Used for the commands "/", "?", "n", "N", * ":g" and ":s".  Not used for "*", "#", "gd", tag search, etc.  After * "*" and "#" you can make 'smartcase' used by doing a "/" command, * recalling the search pattern from history and hitting <Enter>. * NOTE: This option is reset when 'compatible' is set. */export const smartcase = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "smartcase") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "smartcase", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "smartcase");  },  async getGlobal(denops: Denops): Promise<boolean> {    return await globalOptions.get(denops, "smartcase") ?? false;  },  setGlobal(denops: Denops, value: boolean): Promise<void> {    return globalOptions.set(denops, "smartcase", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "smartcase");  },};
/** * 		{not available when compiled without the * 		|+smartindent| feature} * Do smart autoindenting when starting a new line.  Works for C-like * programs, but can also be used for other languages.  'cindent' does * something like this, works better in most cases, but is more strict, * see |C-indenting|.  When 'cindent' is on or 'indentexpr' is set, * setting 'si' has no effect.  'indentexpr' is a more advanced * alternative. * Normally 'autoindent' should also be on when using 'smartindent'. * An indent is automatically inserted: * - After a line ending in '{'. * - After a line starting with a keyword from 'cinwords'. * - Before a line starting with '}' (only with the "O" command). * When typing '}' as the first character in a new line, that line is * given the same indent as the matching '{'. * When typing '#' as the first character in a new line, the indent for * that line is removed, the '#' is put in the first column.  The indent * is restored for the next line.  If you don't want this, use this * mapping: ":inoremap # X^H#", where ^H is entered with CTRL-V CTRL-H. * When using the ">>" command, lines starting with '#' are not shifted * right. * NOTE: This option is reset when 'compatible' is set. * This option is reset when 'paste' is set and restored when 'paste' is * reset. */export const smartindent = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "smartindent") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "smartindent", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "smartindent");  },  async getLocal(denops: Denops): Promise<boolean> {    return await localOptions.get(denops, "smartindent") ?? false;  },  setLocal(denops: Denops, value: boolean): Promise<void> {    return localOptions.set(denops, "smartindent", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "smartindent");  },};
/** * When on, a <Tab> in front of a line inserts blanks according to * 'shiftwidth'.  'tabstop' or 'softtabstop' is used in other places.  A * <BS> will delete a 'shiftwidth' worth of space at the start of the * line. * When off, a <Tab> always inserts blanks according to 'tabstop' or * 'softtabstop'.  'shiftwidth' is only used for shifting text left or * right |shift-left-right|. * What gets inserted (a <Tab> or spaces) depends on the 'expandtab' * option.  Also see |ins-expandtab|.  When 'expandtab' is not set, the * number of spaces is minimized by using <Tab>s. * This option is reset when 'paste' is set and restored when 'paste' is * reset. * NOTE: This option is reset when 'compatible' is set. */export const smarttab = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "smarttab") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "smarttab", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "smarttab");  },  async getGlobal(denops: Denops): Promise<boolean> {    return await globalOptions.get(denops, "smarttab") ?? false;  },  setGlobal(denops: Denops, value: boolean): Promise<void> {    return globalOptions.set(denops, "smarttab", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "smarttab");  },};
/** * Number of spaces that a <Tab> counts for while performing editing * operations, like inserting a <Tab> or using <BS>.  It "feels" like * <Tab>s are being inserted, while in fact a mix of spaces and <Tab>s is * used.  This is useful to keep the 'ts' setting at its standard value * of 8, while being able to edit like it is set to 'sts'.  However, * commands like "x" still work on the actual characters. * When 'sts' is zero, this feature is off. * When 'sts' is negative, the value of 'shiftwidth' is used. * 'softtabstop' is set to 0 when the 'paste' option is set and restored * when 'paste' is reset. * See also |ins-expandtab|.  When 'expandtab' is not set, the number of * spaces is minimized by using <Tab>s. * The 'L' flag in 'cpoptions' changes how tabs are used when 'list' is * set. * NOTE: This option is set to 0 when 'compatible' is set. */export const softtabstop = {  async get(denops: Denops): Promise<number> {    return await options.get(denops, "softtabstop") ?? 0;  },  set(denops: Denops, value: number): Promise<void> {    return options.set(denops, "softtabstop", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "softtabstop");  },  async getLocal(denops: Denops): Promise<number> {    return await localOptions.get(denops, "softtabstop") ?? 0;  },  setLocal(denops: Denops, value: number): Promise<void> {    return localOptions.set(denops, "softtabstop", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "softtabstop");  },};
/** * 		{not available when compiled without the |+syntax| * 		feature} * Pattern to locate the end of a sentence.  The following word will be * checked to start with a capital letter.  If not then it is highlighted * with SpellCap |hl-SpellCap| (unless the word is also badly spelled). * When this check is not wanted make this option empty. * Only used when 'spell' is set. * Be careful with special characters, see |option-backslash| about * including spaces and backslashes. * To set this option automatically depending on the language, see * |set-spc-auto|. */export const spellcapcheck = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "spellcapcheck") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "spellcapcheck", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "spellcapcheck");  },  async getLocal(denops: Denops): Promise<string> {    return await localOptions.get(denops, "spellcapcheck") ?? "";  },  setLocal(denops: Denops, value: string): Promise<void> {    return localOptions.set(denops, "spellcapcheck", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "spellcapcheck");  },};
/** * 		{not available when compiled without the |+syntax| * 		feature} * Name of the word list file where words are added for the |zg| and |zw| * commands.  It must end in ".{encoding}.add".  You need to include the * path, otherwise the file is placed in the current directory. * It may also be a comma separated list of names.  A count before the * |zg| and |zw| commands can be used to access each.  This allows using * a personal word list file and a project word list file. * When a word is added while this option is empty Vim will set it for * you: Using the first directory in 'runtimepath' that is writable.  If * there is no "spell" directory yet it will be created.  For the file * name the first language name that appears in 'spelllang' is used, * ignoring the region. * The resulting ".spl" file will be used for spell checking, it does not * have to appear in 'spelllang'. * Normally one file is used for all regions, but you can add the region * name if you want to.  However, it will then only be used when * 'spellfile' is set to it, for entries in 'spelllang' only files * without region name will be found. * This option cannot be set from a |modeline| or in the |sandbox|, for * security reasons. */export const spellfile = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "spellfile") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "spellfile", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "spellfile");  },  async getLocal(denops: Denops): Promise<string> {    return await localOptions.get(denops, "spellfile") ?? "";  },  setLocal(denops: Denops, value: string): Promise<void> {    return localOptions.set(denops, "spellfile", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "spellfile");  },};
/** * 		{not available when compiled without the |+syntax| * 		feature} * A comma separated list of word list names.  When the 'spell' option is * on spellchecking will be done for these languages.  Example: > * 	set spelllang=en_us,nl,medical * <	This means US English, Dutch and medical words are recognized.  Words * that are not recognized will be highlighted. * The word list name must consist of alphanumeric characters, a dash or * an underscore.  It should not include a comma or dot.  Using a dash is * recommended to separate the two letter language name from a * specification.  Thus "en-rare" is used for rare English words. * A region name must come last and have the form "_xx", where "xx" is * the two-letter, lower case region name.  You can use more than one * region by listing them: "en_us,en_ca" supports both US and Canadian * English, but not words specific for Australia, New Zealand or Great * Britain. (Note: currently en_au and en_nz dictionaries are older than * en_ca, en_gb and en_us). * If the name "cjk" is included East Asian characters are excluded from * spell checking.  This is useful when editing text that also has Asian * words. * As a special case the name of a .spl file can be given as-is.  The * first "_xx" in the name is removed and used as the region name * (_xx is an underscore, two letters and followed by a non-letter). * This is mainly for testing purposes.  You must make sure the correct * encoding is used, Vim doesn't check it. * When 'encoding' is set the word lists are reloaded.  Thus it's a good * idea to set 'spelllang' after setting 'encoding' to avoid loading the * files twice. * How the related spell files are found is explained here: |spell-load|. */export const spelllang = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "spelllang") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "spelllang", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "spelllang");  },  async getLocal(denops: Denops): Promise<string> {    return await localOptions.get(denops, "spelllang") ?? "";  },  setLocal(denops: Denops, value: string): Promise<void> {    return localOptions.set(denops, "spelllang", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "spelllang");  },};
/** * 		{not available when compiled without the |+syntax| * 		feature} * A comma separated list of options for spell checking: *    camel	When a word is CamelCased, assume "Cased" is a * 		separate word: every upper-case character in a word * 		that comes after a lower case character indicates the * 		start of a new word. */export const spelloptions = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "spelloptions") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "spelloptions", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "spelloptions");  },  async getLocal(denops: Denops): Promise<string> {    return await localOptions.get(denops, "spelloptions") ?? "";  },  setLocal(denops: Denops, value: string): Promise<void> {    return localOptions.set(denops, "spelloptions", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "spelloptions");  },};
/** * 		{not available when compiled without the |+syntax| * 		feature} * Methods used for spelling suggestions.  Both for the |z=| command and * the |spellsuggest()| function.  This is a comma-separated list of * items: */export const spellsuggest = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "spellsuggest") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "spellsuggest", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "spellsuggest");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "spellsuggest") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "spellsuggest", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "spellsuggest");  },};
/** * When on, splitting a window will put the new window below the current * one. |:split| */export const splitbelow = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "splitbelow") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "splitbelow", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "splitbelow");  },  async getGlobal(denops: Denops): Promise<boolean> {    return await globalOptions.get(denops, "splitbelow") ?? false;  },  setGlobal(denops: Denops, value: boolean): Promise<void> {    return globalOptions.set(denops, "splitbelow", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "splitbelow");  },};
/** * When on, splitting a window will put the new window right of the * current one. |:vsplit| */export const splitright = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "splitright") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "splitright", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "splitright");  },  async getGlobal(denops: Denops): Promise<boolean> {    return await globalOptions.get(denops, "splitright") ?? false;  },  setGlobal(denops: Denops, value: boolean): Promise<void> {    return globalOptions.set(denops, "splitright", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "splitright");  },};
/** * When "on" the commands listed below move the cursor to the first * non-blank of the line.  When off the cursor is kept in the same column * (if possible).  This applies to the commands: CTRL-D, CTRL-U, CTRL-B, * CTRL-F, "G", "H", "M", "L", gg, and to the commands "d", "<<" and ">>" * with a linewise operator, with "%" with a count and to buffer changing * commands (CTRL-^, :bnext, :bNext, etc.).  Also for an Ex command that * only has a line number, e.g., ":25" or ":+". * In case of buffer changing commands the cursor is placed at the column * where it was the last time the buffer was edited. * NOTE: This option is set when 'compatible' is set. */export const startofline = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "startofline") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "startofline", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "startofline");  },  async getGlobal(denops: Denops): Promise<boolean> {    return await globalOptions.get(denops, "startofline") ?? false;  },  setGlobal(denops: Denops, value: boolean): Promise<void> {    return globalOptions.set(denops, "startofline", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "startofline");  },};
/** * 		{not available when compiled without the |+statusline| * 		feature} * When nonempty, this option determines the content of the status line. * Also see |status-line|. */export const statusline = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "statusline") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "statusline", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "statusline");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "statusline") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "statusline", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "statusline");  },  async getLocal(denops: Denops): Promise<string> {    return await localOptions.get(denops, "statusline") ?? "";  },  setLocal(denops: Denops, value: string): Promise<void> {    return localOptions.set(denops, "statusline", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "statusline");  },};
/** * Files with these suffixes get a lower priority when multiple files * match a wildcard.  See |suffixes|.  Commas can be used to separate the * suffixes.  Spaces after the comma are ignored.  A dot is also seen as * the start of a suffix.  To avoid a dot or comma being recognized as a * separator, precede it with a backslash (see |option-backslash| about * including spaces and backslashes). * See 'wildignore' for completely ignoring files. * The use of |:set+=| and |:set-=| is preferred when adding or removing * suffixes from the list.  This avoids problems when a future version * uses another default. */export const suffixes = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "suffixes") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "suffixes", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "suffixes");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "suffixes") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "suffixes", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "suffixes");  },};
/** * 		{not available when compiled without the * 		|+file_in_path| feature} * Comma separated list of suffixes, which are used when searching for a * file for the "gf", "[I", etc. commands.  Example: > * 	:set suffixesadd=.java * < */export const suffixesadd = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "suffixesadd") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "suffixesadd", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "suffixesadd");  },  async getLocal(denops: Denops): Promise<string> {    return await localOptions.get(denops, "suffixesadd") ?? "";  },  setLocal(denops: Denops, value: string): Promise<void> {    return localOptions.set(denops, "suffixesadd", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "suffixesadd");  },};
/** * Use a swapfile for the buffer.  This option can be reset when a * swapfile is not wanted for a specific buffer.  For example, with * confidential information that even root must not be able to access. * Careful: All text will be in memory: * 	- Don't use this for big files. * 	- Recovery will be impossible! * A swapfile will only be present when |'updatecount'| is non-zero and * 'swapfile' is set. * When 'swapfile' is reset, the swap file for the current buffer is * immediately deleted.  When 'swapfile' is set, and 'updatecount' is * non-zero, a swap file is immediately created. * Also see |swap-file| and |'swapsync'|. * If you want to open a new buffer without creating a swap file for it, * use the |:noswapfile| modifier. * See 'directory' for where the swap file is created. */export const swapfile = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "swapfile") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "swapfile", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "swapfile");  },  async getLocal(denops: Denops): Promise<boolean> {    return await localOptions.get(denops, "swapfile") ?? false;  },  setLocal(denops: Denops, value: boolean): Promise<void> {    return localOptions.set(denops, "swapfile", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "swapfile");  },};
/** * This option controls the behavior when switching between buffers. * Mostly for |quickfix| commands some values are also used for other * commands, as mentioned below. * Possible values (comma separated list): *    useopen	If included, jump to the first open window that * 		contains the specified buffer (if there is one). * 		Otherwise: Do not examine other windows. * 		This setting is checked with |quickfix| commands, when * 		jumping to errors (":cc", ":cn", "cp", etc.).  It is * 		also used in all buffer related split commands, for * 		example ":sbuffer", ":sbnext", or ":sbrewind". *    usetab	Like "useopen", but also consider windows in other tab * 		pages. *    split	If included, split the current window before loading * 		a buffer for a |quickfix| command that display errors. * 		Otherwise: do not split, use current window (when used * 		in the quickfix window: the previously used window or * 		split if there is no other window). *    vsplit	Just like "split" but split vertically. *    newtab	Like "split", but open a new tab page.  Overrules * 		"split" when both are present. *    uselast	If included, jump to the previously used window when * 		jumping to errors with |quickfix| commands. */export const switchbuf = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "switchbuf") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "switchbuf", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "switchbuf");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "switchbuf") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "switchbuf", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "switchbuf");  },};
/** * 		{not available when compiled without the |+syntax| * 		feature} * Maximum column in which to search for syntax items.  In long lines the * text after this column is not highlighted and following lines may not * be highlighted correctly, because the syntax state is cleared. * This helps to avoid very slow redrawing for an XML file that is one * long line. * Set to zero to remove the limit. */export const synmaxcol = {  async get(denops: Denops): Promise<number> {    return await options.get(denops, "synmaxcol") ?? 0;  },  set(denops: Denops, value: number): Promise<void> {    return options.set(denops, "synmaxcol", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "synmaxcol");  },  async getLocal(denops: Denops): Promise<number> {    return await localOptions.get(denops, "synmaxcol") ?? 0;  },  setLocal(denops: Denops, value: number): Promise<void> {    return localOptions.set(denops, "synmaxcol", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "synmaxcol");  },};
/** * 		{not available when compiled without the |+syntax| * 		feature} * When this option is set, the syntax with this name is loaded, unless * syntax highlighting has been switched off with ":syntax off". * Otherwise this option does not always reflect the current syntax (the * b:current_syntax variable does). * This option is most useful in a modeline, for a file which syntax is * not automatically recognized.  Example, in an IDL file: * 	// ~ * When a dot appears in the value then this separates two filetype * names.  Example: * 	// ~ * This will use the "c" syntax first, then the "doxygen" syntax. * Note that the second one must be prepared to be loaded as an addition, * otherwise it will be skipped.  More than one dot may appear. * To switch off syntax highlighting for the current file, use: > * 	:set syntax=OFF * <	To switch syntax highlighting on according to the current value of the * 'filetype' option: > * 	:set syntax=ON * <	What actually happens when setting the 'syntax' option is that the * Syntax autocommand event is triggered with the value as argument. * This option is not copied to another buffer, independent of the 's' or * 'S' flag in 'cpoptions'. * Only normal file name characters can be used, "/\*?[|<>" are illegal. */export const syntax = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "syntax") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "syntax", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "syntax");  },  async getLocal(denops: Denops): Promise<string> {    return await localOptions.get(denops, "syntax") ?? "";  },  setLocal(denops: Denops, value: string): Promise<void> {    return localOptions.set(denops, "syntax", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "syntax");  },};
/** * When nonempty, this option determines the content of the tab pages * line at the top of the Vim window.  When empty Vim will use a default * tab pages line.  See |setting-tabline| for more info. */export const tabline = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "tabline") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "tabline", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "tabline");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "tabline") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "tabline", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "tabline");  },};
/** * Maximum number of tab pages to be opened by the |-p| command line * argument or the ":tab all" command. |tabpage| */export const tabpagemax = {  async get(denops: Denops): Promise<number> {    return await options.get(denops, "tabpagemax") ?? 0;  },  set(denops: Denops, value: number): Promise<void> {    return options.set(denops, "tabpagemax", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "tabpagemax");  },  async getGlobal(denops: Denops): Promise<number> {    return await globalOptions.get(denops, "tabpagemax") ?? 0;  },  setGlobal(denops: Denops, value: number): Promise<void> {    return globalOptions.set(denops, "tabpagemax", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "tabpagemax");  },};
/** * Number of spaces that a <Tab> in the file counts for.  Also see * |:retab| command, and 'softtabstop' option. */export const tabstop = {  async get(denops: Denops): Promise<number> {    return await options.get(denops, "tabstop") ?? 0;  },  set(denops: Denops, value: number): Promise<void> {    return options.set(denops, "tabstop", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "tabstop");  },  async getLocal(denops: Denops): Promise<number> {    return await localOptions.get(denops, "tabstop") ?? 0;  },  setLocal(denops: Denops, value: number): Promise<void> {    return localOptions.set(denops, "tabstop", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "tabstop");  },};
/** * When searching for a tag (e.g., for the |:ta| command), Vim can either * use a binary search or a linear search in a tags file.  Binary * searching makes searching for a tag a LOT faster, but a linear search * will find more tags if the tags file wasn't properly sorted. * Vim normally assumes that your tags files are sorted, or indicate that * they are not sorted.  Only when this is not the case does the * 'tagbsearch' option need to be switched off. */export const tagbsearch = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "tagbsearch") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "tagbsearch", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "tagbsearch");  },  async getGlobal(denops: Denops): Promise<boolean> {    return await globalOptions.get(denops, "tagbsearch") ?? false;  },  setGlobal(denops: Denops, value: boolean): Promise<void> {    return globalOptions.set(denops, "tagbsearch", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "tagbsearch");  },};
/** * This option specifies how case is handled when searching the tags * file: *    followic	Follow the 'ignorecase' option *    followscs    Follow the 'smartcase' and 'ignorecase' options *    ignore	Ignore case *    match	Match case *    smart	Ignore case unless an upper case letter is used * NOTE: This option is set to the Vi default value when 'compatible' is * set and to the Vim default value when 'compatible' is reset. */export const tagcase = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "tagcase") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "tagcase", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "tagcase");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "tagcase") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "tagcase", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "tagcase");  },  async getLocal(denops: Denops): Promise<string> {    return await localOptions.get(denops, "tagcase") ?? "";  },  setLocal(denops: Denops, value: string): Promise<void> {    return localOptions.set(denops, "tagcase", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "tagcase");  },};
/** * 		{not available when compiled without the |+eval| * 		feature} * This option specifies a function to be used to perform tag searches. * The function gets the tag pattern and should return a List of matching * tags.  See |tag-function| for an explanation of how to write the * function and an example. */export const tagfunc = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "tagfunc") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "tagfunc", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "tagfunc");  },  async getLocal(denops: Denops): Promise<string> {    return await localOptions.get(denops, "tagfunc") ?? "";  },  setLocal(denops: Denops, value: string): Promise<void> {    return localOptions.set(denops, "tagfunc", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "tagfunc");  },};
/** * If non-zero, tags are significant up to this number of characters. */export const taglength = {  async get(denops: Denops): Promise<number> {    return await options.get(denops, "taglength") ?? 0;  },  set(denops: Denops, value: number): Promise<void> {    return options.set(denops, "taglength", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "taglength");  },  async getGlobal(denops: Denops): Promise<number> {    return await globalOptions.get(denops, "taglength") ?? 0;  },  setGlobal(denops: Denops, value: number): Promise<void> {    return globalOptions.set(denops, "taglength", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "taglength");  },};
/** * If on and using a tags file in another directory, file names in that * tags file are relative to the directory where the tags file is. * NOTE: This option is set to the Vi default value when 'compatible' is * set and to the Vim default value when 'compatible' is reset. */export const tagrelative = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "tagrelative") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "tagrelative", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "tagrelative");  },  async getGlobal(denops: Denops): Promise<boolean> {    return await globalOptions.get(denops, "tagrelative") ?? false;  },  setGlobal(denops: Denops, value: boolean): Promise<void> {    return globalOptions.set(denops, "tagrelative", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "tagrelative");  },};
/** * Filenames for the tag command, separated by spaces or commas.  To * include a space or comma in a file name, precede it with a backslash * (see |option-backslash| about including spaces and backslashes). * When a file name starts with "./", the '.' is replaced with the path * of the current file.  But only when the 'd' flag is not included in * 'cpoptions'.  Environment variables are expanded |:set_env|.  Also see * |tags-option|. * "*" and other wildcards can be used to search for tags files in * a directory tree.  See |file-searching|.  E.g., "/lib/** /tags" will * find all files named "tags" below "/lib".  The filename itself cannot * contain wildcards, it is used as-is.  E.g., "/lib/** /tags?" will find * files called "tags?".  {not available when compiled without the * |+path_extra| feature} * The |tagfiles()| function can be used to get a list of the file names * actually used. * If Vim was compiled with the |+emacs_tags| feature, Emacs-style tag * files are also supported.  They are automatically recognized.  The * default value becomes "./tags,./TAGS,tags,TAGS", unless case * differences are ignored (MS-Windows).  |emacs-tags| * The use of |:set+=| and |:set-=| is preferred when adding or removing * file names from the list.  This avoids problems when a future version * uses another default. */export const tags = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "tags") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "tags", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "tags");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "tags") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "tags", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "tags");  },  async getLocal(denops: Denops): Promise<string> {    return await localOptions.get(denops, "tags") ?? "";  },  setLocal(denops: Denops, value: string): Promise<void> {    return localOptions.set(denops, "tags", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "tags");  },};
/** * When on, the |tagstack| is used normally.  When off, a ":tag" or * ":tselect" command with an argument will not push the tag onto the * tagstack.  A following ":tag" without an argument, a ":pop" command or * any other command that uses the tagstack will use the unmodified * tagstack, but does change the pointer to the active entry. * Resetting this option is useful when using a ":tag" command in a * mapping which should not change the tagstack. */export const tagstack = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "tagstack") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "tagstack", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "tagstack");  },  async getGlobal(denops: Denops): Promise<boolean> {    return await globalOptions.get(denops, "tagstack") ?? false;  },  setGlobal(denops: Denops, value: boolean): Promise<void> {    return globalOptions.set(denops, "tagstack", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "tagstack");  },};
/** * 		{only available when compiled with the |+arabic| * 		feature} * The terminal is in charge of Bi-directionality of text (as specified * by Unicode).  The terminal is also expected to do the required shaping * that some languages (such as Arabic) require. * Setting this option implies that 'rightleft' will not be set when * 'arabic' is set and the value of 'arabicshape' will be ignored. * Note that setting 'termbidi' has the immediate effect that * 'arabicshape' is ignored, but 'rightleft' isn't changed automatically. * This option is reset when the GUI is started. * For further details see |arabic.txt|. */export const termbidi = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "termbidi") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "termbidi", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "termbidi");  },  async getGlobal(denops: Denops): Promise<boolean> {    return await globalOptions.get(denops, "termbidi") ?? false;  },  setGlobal(denops: Denops, value: boolean): Promise<void> {    return globalOptions.set(denops, "termbidi", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "termbidi");  },};
/** * 		{not available when compiled without the * 		|+termguicolors| feature} * When on, uses |highlight-guifg| and |highlight-guibg| attributes in * the terminal (thus using 24-bit color). */export const termguicolors = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "termguicolors") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "termguicolors", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "termguicolors");  },  async getGlobal(denops: Denops): Promise<boolean> {    return await globalOptions.get(denops, "termguicolors") ?? false;  },  setGlobal(denops: Denops, value: boolean): Promise<void> {    return globalOptions.set(denops, "termguicolors", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "termguicolors");  },};
/** * Maximum width of text that is being inserted.  A longer line will be * broken after white space to get this width.  A zero value disables * this. * 'textwidth' is set to 0 when the 'paste' option is set and restored * when 'paste' is reset. * When 'textwidth' is zero, 'wrapmargin' may be used.  See also * 'formatoptions' and |ins-textwidth|. * When 'formatexpr' is set it will be used to break the line. * NOTE: This option is set to 0 when 'compatible' is set. */export const textwidth = {  async get(denops: Denops): Promise<number> {    return await options.get(denops, "textwidth") ?? 0;  },  set(denops: Denops, value: number): Promise<void> {    return options.set(denops, "textwidth", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "textwidth");  },  async getLocal(denops: Denops): Promise<number> {    return await localOptions.get(denops, "textwidth") ?? 0;  },  setLocal(denops: Denops, value: number): Promise<void> {    return localOptions.set(denops, "textwidth", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "textwidth");  },};
/** * List of file names, separated by commas, that are used to lookup words * for thesaurus completion commands |i_CTRL-X_CTRL-T|. */export const thesaurus = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "thesaurus") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "thesaurus", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "thesaurus");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "thesaurus") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "thesaurus", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "thesaurus");  },  async getLocal(denops: Denops): Promise<string> {    return await localOptions.get(denops, "thesaurus") ?? "";  },  setLocal(denops: Denops, value: string): Promise<void> {    return localOptions.set(denops, "thesaurus", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "thesaurus");  },};
/** * When on: The tilde command "~" behaves like an operator. * NOTE: This option is reset when 'compatible' is set. */export const tildeop = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "tildeop") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "tildeop", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "tildeop");  },  async getGlobal(denops: Denops): Promise<boolean> {    return await globalOptions.get(denops, "tildeop") ?? false;  },  setGlobal(denops: Denops, value: boolean): Promise<void> {    return globalOptions.set(denops, "tildeop", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "tildeop");  },};
/** * 		global */export const timeout = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "timeout") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "timeout", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "timeout");  },  async getGlobal(denops: Denops): Promise<boolean> {    return await globalOptions.get(denops, "timeout") ?? false;  },  setGlobal(denops: Denops, value: boolean): Promise<void> {    return globalOptions.set(denops, "timeout", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "timeout");  },};
/** * 		global */export const timeoutlen = {  async get(denops: Denops): Promise<number> {    return await options.get(denops, "timeoutlen") ?? 0;  },  set(denops: Denops, value: number): Promise<void> {    return options.set(denops, "timeoutlen", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "timeoutlen");  },  async getGlobal(denops: Denops): Promise<number> {    return await globalOptions.get(denops, "timeoutlen") ?? 0;  },  setGlobal(denops: Denops, value: number): Promise<void> {    return globalOptions.set(denops, "timeoutlen", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "timeoutlen");  },};
/** * The time in milliseconds that is waited for a key code or mapped key * sequence to complete.  Also used for CTRL-\ CTRL-N and CTRL-\ CTRL-G * when part of a command has been typed. * Normally only 'timeoutlen' is used and 'ttimeoutlen' is -1.  When a * different timeout value for key codes is desired set 'ttimeoutlen' to * a non-negative number. */export const ttimeoutlen = {  async get(denops: Denops): Promise<number> {    return await options.get(denops, "ttimeoutlen") ?? 0;  },  set(denops: Denops, value: number): Promise<void> {    return options.set(denops, "ttimeoutlen", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "ttimeoutlen");  },  async getGlobal(denops: Denops): Promise<number> {    return await globalOptions.get(denops, "ttimeoutlen") ?? 0;  },  setGlobal(denops: Denops, value: number): Promise<void> {    return globalOptions.set(denops, "ttimeoutlen", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "ttimeoutlen");  },};
/** * Indicates a fast terminal connection.  More characters will be sent to * the screen for redrawing, instead of using insert/delete line * commands.  Improves smoothness of redrawing when there are multiple * windows and the terminal does not support a scrolling region. * Also enables the extra writing of characters at the end of each screen * line for lines that wrap.  This helps when using copy/paste with the * mouse in an xterm and other terminals. */export const ttyfast = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "ttyfast") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "ttyfast", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "ttyfast");  },  async getGlobal(denops: Denops): Promise<boolean> {    return await globalOptions.get(denops, "ttyfast") ?? false;  },  setGlobal(denops: Denops, value: boolean): Promise<void> {    return globalOptions.set(denops, "ttyfast", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "ttyfast");  },};
/** * 		{only when compiled with the |+persistent_undo| feature} * List of directory names for undo files, separated with commas. * See |'backupdir'| for details of the format. * "." means using the directory of the file.  The undo file name for * "file.txt" is ".file.txt.un~". * For other directories the file name is the full path of the edited * file, with path separators replaced with "%". * When writing: The first directory that exists is used. "." always * works, no directories after "." will be used for writing. * When reading all entries are tried to find an undo file.  The first * undo file that exists is used.  When it cannot be read an error is * given, no further entry is used. * See |undo-persistence|. * This option cannot be set from a |modeline| or in the |sandbox|, for * security reasons. */export const undodir = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "undodir") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "undodir", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "undodir");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "undodir") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "undodir", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "undodir");  },};
/** * 		{only when compiled with the |+persistent_undo| feature} * When on, Vim automatically saves undo history to an undo file when * writing a buffer to a file, and restores undo history from the same * file on buffer read. * The directory where the undo file is stored is specified by 'undodir'. * For more information about this feature see |undo-persistence|. * The undo file is not read when 'undoreload' causes the buffer from * before a reload to be saved for undo. * When 'undofile' is turned off the undo file is NOT deleted. * NOTE: This option is reset when 'compatible' is set. */export const undofile = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "undofile") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "undofile", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "undofile");  },  async getLocal(denops: Denops): Promise<boolean> {    return await localOptions.get(denops, "undofile") ?? false;  },  setLocal(denops: Denops, value: boolean): Promise<void> {    return localOptions.set(denops, "undofile", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "undofile");  },};
/** * Maximum number of changes that can be undone.  Since undo information * is kept in memory, higher numbers will cause more memory to be used. * Nevertheless, a single change can already use a large amount of memory. * Set to 0 for Vi compatibility: One level of undo and "u" undoes * itself: > * 	set ul=0 * <	But you can also get Vi compatibility by including the 'u' flag in * 'cpoptions', and still be able to use CTRL-R to repeat undo. * Also see |undo-two-ways|. * Set to -1 for no undo at all.  You might want to do this only for the * current buffer: > * 	setlocal ul=-1 * <	This helps when you run out of memory for a single change. */export const undolevels = {  async get(denops: Denops): Promise<number> {    return await options.get(denops, "undolevels") ?? 0;  },  set(denops: Denops, value: number): Promise<void> {    return options.set(denops, "undolevels", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "undolevels");  },  async getGlobal(denops: Denops): Promise<number> {    return await globalOptions.get(denops, "undolevels") ?? 0;  },  setGlobal(denops: Denops, value: number): Promise<void> {    return globalOptions.set(denops, "undolevels", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "undolevels");  },  async getLocal(denops: Denops): Promise<number> {    return await localOptions.get(denops, "undolevels") ?? 0;  },  setLocal(denops: Denops, value: number): Promise<void> {    return localOptions.set(denops, "undolevels", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "undolevels");  },};
/** * Save the whole buffer for undo when reloading it.  This applies to the * ":e!" command and reloading for when the buffer changed outside of * Vim. |FileChangedShell| * The save only happens when this option is negative or when the number * of lines is smaller than the value of this option. * Set this option to zero to disable undo for a reload. */export const undoreload = {  async get(denops: Denops): Promise<number> {    return await options.get(denops, "undoreload") ?? 0;  },  set(denops: Denops, value: number): Promise<void> {    return options.set(denops, "undoreload", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "undoreload");  },  async getGlobal(denops: Denops): Promise<number> {    return await globalOptions.get(denops, "undoreload") ?? 0;  },  setGlobal(denops: Denops, value: number): Promise<void> {    return globalOptions.set(denops, "undoreload", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "undoreload");  },};
/** * After typing this many characters the swap file will be written to * disk.  When zero, no swap file will be created at all (see chapter on * recovery |crash-recovery|).  'updatecount' is set to zero by starting * Vim with the "-n" option, see |startup|.  When editing in readonly * mode this option will be initialized to 10000. * The swapfile can be disabled per buffer with |'swapfile'|. * When 'updatecount' is set from zero to non-zero, swap files are * created for all buffers that have 'swapfile' set.  When 'updatecount' * is set to zero, existing swap files are not deleted. * Also see |'swapsync'|. * This option has no meaning in buffers where |'buftype'| is "nofile" * or "nowrite". */export const updatecount = {  async get(denops: Denops): Promise<number> {    return await options.get(denops, "updatecount") ?? 0;  },  set(denops: Denops, value: number): Promise<void> {    return options.set(denops, "updatecount", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "updatecount");  },  async getGlobal(denops: Denops): Promise<number> {    return await globalOptions.get(denops, "updatecount") ?? 0;  },  setGlobal(denops: Denops, value: number): Promise<void> {    return globalOptions.set(denops, "updatecount", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "updatecount");  },};
/** * If this many milliseconds nothing is typed the swap file will be * written to disk (see |crash-recovery|).  Also used for the * |CursorHold| autocommand event. */export const updatetime = {  async get(denops: Denops): Promise<number> {    return await options.get(denops, "updatetime") ?? 0;  },  set(denops: Denops, value: number): Promise<void> {    return options.set(denops, "updatetime", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "updatetime");  },  async getGlobal(denops: Denops): Promise<number> {    return await globalOptions.get(denops, "updatetime") ?? 0;  },  setGlobal(denops: Denops, value: number): Promise<void> {    return globalOptions.set(denops, "updatetime", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "updatetime");  },};
/** * 		{only available when compiled with the |+vartabs| * 		feature} * A list of the number of spaces that a <Tab> counts for while editing, * such as inserting a <Tab> or using <BS>.  It "feels" like variable- * width <Tab>s are being inserted, while in fact a mixture of spaces * and <Tab>s is used.  Tab widths are separated with commas, with the * final value applying to all subsequent tabs. */export const varsofttabstop = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "varsofttabstop") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "varsofttabstop", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "varsofttabstop");  },  async getLocal(denops: Denops): Promise<string> {    return await localOptions.get(denops, "varsofttabstop") ?? "";  },  setLocal(denops: Denops, value: string): Promise<void> {    return localOptions.set(denops, "varsofttabstop", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "varsofttabstop");  },};
/** * 		{only available when compiled with the |+vartabs| * 		feature} * A list of the number of spaces that a <Tab> in the file counts for, * separated by commas.  Each value corresponds to one tab, with the * final value applying to all subsequent tabs. For example: > * 	:set vartabstop=4,20,10,8 * <	This will make the first tab 4 spaces wide, the second 20 spaces, * the third 10 spaces, and all following tabs 8 spaces. */export const vartabstop = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "vartabstop") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "vartabstop", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "vartabstop");  },  async getLocal(denops: Denops): Promise<string> {    return await localOptions.get(denops, "vartabstop") ?? "";  },  setLocal(denops: Denops, value: string): Promise<void> {    return localOptions.set(denops, "vartabstop", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "vartabstop");  },};
/** * When bigger than zero, Vim will give messages about what it is doing. * Currently, these messages are given: * >= 1	When the viminfo file is read or written. * >= 2	When a file is ":source"'ed. * >= 4	Shell commands. * >= 5	Every searched tags file and include file. * >= 8	Files for which a group of autocommands is executed. * >= 9	Every executed autocommand. * >= 11	Finding items in a path * >= 12	Every executed function. * >= 13	When an exception is thrown, caught, finished, or discarded. * >= 14	Anything pending in a ":finally" clause. * >= 15	Every executed Ex command from a script (truncated at 200 * 	characters). * >= 16	Every executed Ex command. */export const verbose = {  async get(denops: Denops): Promise<number> {    return await options.get(denops, "verbose") ?? 0;  },  set(denops: Denops, value: number): Promise<void> {    return options.set(denops, "verbose", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "verbose");  },  async getGlobal(denops: Denops): Promise<number> {    return await globalOptions.get(denops, "verbose") ?? 0;  },  setGlobal(denops: Denops, value: number): Promise<void> {    return globalOptions.set(denops, "verbose", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "verbose");  },};
/** * When not empty all messages are written in a file with this name. * When the file exists messages are appended. * Writing to the file ends when Vim exits or when 'verbosefile' is made * empty.  Writes are buffered, thus may not show up for some time. * Setting 'verbosefile' to a new value is like making it empty first. * The difference with |:redir| is that verbose messages are not * displayed when 'verbosefile' is set. */export const verbosefile = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "verbosefile") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "verbosefile", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "verbosefile");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "verbosefile") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "verbosefile", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "verbosefile");  },};
/** * 		{not available when compiled without the |+mksession| * 		feature} * Name of the directory where to store files for |:mkview|. * This option cannot be set from a |modeline| or in the |sandbox|, for * security reasons. */export const viewdir = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "viewdir") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "viewdir", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "viewdir");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "viewdir") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "viewdir", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "viewdir");  },};
/** * 		{not available when compiled without the |+mksession| * 		feature} * Changes the effect of the |:mkview| command.  It is a comma separated * list of words.  Each word enables saving and restoring something: *    word		save and restore ~ *    cursor	cursor position in file and in window *    folds	manually created folds, opened/closed folds and local * 		fold options *    options	options and mappings local to a window or buffer (not * 		global values for local options) *    localoptions same as "options" *    slash	backslashes in file names replaced with forward * 		slashes *    unix		with Unix end-of-line format (single <NL>), even when * 		on MS-Windows *    curdir	the window-local directory, if set with `:lcd` */export const viewoptions = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "viewoptions") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "viewoptions", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "viewoptions");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "viewoptions") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "viewoptions", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "viewoptions");  },};
/** * A comma separated list of these words: *     block	Allow virtual editing in Visual block mode. *     insert	Allow virtual editing in Insert mode. *     all		Allow virtual editing in all modes. *     onemore	Allow the cursor to move just past the end of the line */export const virtualedit = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "virtualedit") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "virtualedit", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "virtualedit");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "virtualedit") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "virtualedit", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "virtualedit");  },};
/** * Use a visual bell instead of beeping.  The terminal code to display the * visual bell is given with 't_vb'.  When no beep or flash is wanted, * use: > * 	:set vb t_vb= * <	If you want a short flash, you can use this on many terminals: > * 	:set vb t_vb=[?5h$<100>[?5l * <	Here $<100> specifies the time, you can use a smaller or bigger value * to get a shorter or longer flash. */export const visualbell = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "visualbell") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "visualbell", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "visualbell");  },  async getGlobal(denops: Denops): Promise<boolean> {    return await globalOptions.get(denops, "visualbell") ?? false;  },  setGlobal(denops: Denops, value: boolean): Promise<void> {    return globalOptions.set(denops, "visualbell", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "visualbell");  },};
/** * Allow specified keys that move the cursor left/right to move to the * previous/next line when the cursor is on the first/last character in * the line.  Concatenate characters to allow this for these keys: * 	char   key	  mode	~ * 	 b    <BS>	 Normal and Visual * 	 s    <Space>	 Normal and Visual * 	 h    "h"	 Normal and Visual (not recommended) * 	 l    "l"	 Normal and Visual (not recommended) * 	 <    <Left>	 Normal and Visual * 	 >    <Right>	 Normal and Visual * 	 ~    "~"	 Normal * 	 [    <Left>	 Insert and Replace * 	 ]    <Right>	 Insert and Replace * For example: > * 	:set ww=<,>,[,] * <	allows wrap only when cursor keys are used. * When the movement keys are used in combination with a delete or change * operator, the <EOL> also counts for a character.  This makes "3h" * different from "3dh" when the cursor crosses the end of a line.  This * is also true for "x" and "X", because they do the same as "dl" and * "dh".  If you use this, you may also want to use the mapping * ":map <BS> X" to make backspace delete the character in front of the * cursor. * When 'l' is included and it is used after an operator at the end of a * line (not an empty line) then it will not move to the next line.  This * makes "dl", "cl", "yl" etc. work normally. * NOTE: This option is set to the Vi default value when 'compatible' is * set and to the Vim default value when 'compatible' is reset. */export const whichwrap = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "whichwrap") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "whichwrap", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "whichwrap");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "whichwrap") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "whichwrap", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "whichwrap");  },};
/** * Character you have to type to start wildcard expansion in the * command-line, as specified with 'wildmode'. * More info here: |cmdline-completion|. * The character is not recognized when used inside a macro.  See * 'wildcharm' for that. * Although 'wc' is a number option, you can set it to a special key: > * 	:set wc=<Esc> * <	NOTE: This option is set to the Vi default value when 'compatible' is * set and to the Vim default value when 'compatible' is reset. */export const wildchar = {  async get(denops: Denops): Promise<number> {    return await options.get(denops, "wildchar") ?? 0;  },  set(denops: Denops, value: number): Promise<void> {    return options.set(denops, "wildchar", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "wildchar");  },  async getGlobal(denops: Denops): Promise<number> {    return await globalOptions.get(denops, "wildchar") ?? 0;  },  setGlobal(denops: Denops, value: number): Promise<void> {    return globalOptions.set(denops, "wildchar", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "wildchar");  },};
/** * 'wildcharm' works exactly like 'wildchar', except that it is * recognized when used inside a macro.  You can find "spare" command-line * keys suitable for this option by looking at |ex-edit-index|.  Normally * you'll never actually type 'wildcharm', just use it in mappings that * automatically invoke completion mode, e.g.: > * 	:set wcm=<C-Z> * 	:cnoremap ss so $vim/sessions/*.vim<C-Z> * <	Then after typing :ss you can use CTRL-P & CTRL-N. */export const wildcharm = {  async get(denops: Denops): Promise<number> {    return await options.get(denops, "wildcharm") ?? 0;  },  set(denops: Denops, value: number): Promise<void> {    return options.set(denops, "wildcharm", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "wildcharm");  },  async getGlobal(denops: Denops): Promise<number> {    return await globalOptions.get(denops, "wildcharm") ?? 0;  },  setGlobal(denops: Denops, value: number): Promise<void> {    return globalOptions.set(denops, "wildcharm", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "wildcharm");  },};
/** * 		{not available when compiled without the |+wildignore| * 		feature} * A list of file patterns.  A file that matches with one of these * patterns is ignored when expanding |wildcards|, completing file or * directory names, and influences the result of |expand()|, |glob()| and * |globpath()| unless a flag is passed to disable this. * The pattern is used like with |:autocmd|, see |autocmd-patterns|. * Also see 'suffixes'. * Example: > * 	:set wildignore=.obj * <	The use of |:set+=| and |:set-=| is preferred when adding or removing * a pattern from the list.  This avoids problems when a future version * uses another default. */export const wildignore = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "wildignore") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "wildignore", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "wildignore");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "wildignore") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "wildignore", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "wildignore");  },};
/** * When set case is ignored when completing file names and directories. * Has no effect when 'fileignorecase' is set. * Does not apply when the shell is used to expand wildcards, which * happens when there are special characters. */export const wildignorecase = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "wildignorecase") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "wildignorecase", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "wildignorecase");  },  async getGlobal(denops: Denops): Promise<boolean> {    return await globalOptions.get(denops, "wildignorecase") ?? false;  },  setGlobal(denops: Denops, value: boolean): Promise<void> {    return globalOptions.set(denops, "wildignorecase", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "wildignorecase");  },};
/** * 		{not available if compiled without the |+wildmenu| * 		feature} * When 'wildmenu' is on, command-line completion operates in an enhanced * mode.  On pressing 'wildchar' (usually <Tab>) to invoke completion, * the possible matches are shown just above the command line, with the * first match highlighted (overwriting the status line, if there is * one).  Keys that show the previous/next match, such as <Tab> or * CTRL-P/CTRL-N, cause the highlight to move to the appropriate match. * When 'wildmode' is used, "wildmenu" mode is used where "full" is * specified.  "longest" and "list" do not start "wildmenu" mode. * You can check the current mode with |wildmenumode()|. * If there are more matches than can fit in the line, a ">" is shown on * the right and/or a "<" is shown on the left.  The status line scrolls * as needed. * The "wildmenu" mode is abandoned when a key is hit that is not used * for selecting a completion. * While the "wildmenu" is active the following keys have special * meanings: */export const wildmenu = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "wildmenu") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "wildmenu", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "wildmenu");  },  async getGlobal(denops: Denops): Promise<boolean> {    return await globalOptions.get(denops, "wildmenu") ?? false;  },  setGlobal(denops: Denops, value: boolean): Promise<void> {    return globalOptions.set(denops, "wildmenu", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "wildmenu");  },};
/** * Completion mode that is used for the character specified with * 'wildchar'.  It is a comma separated list of up to four parts.  Each * part specifies what to do for each consecutive use of 'wildchar'.  The * first part specifies the behavior for the first use of 'wildchar', * The second part for the second use, etc. */export const wildmode = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "wildmode") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "wildmode", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "wildmode");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "wildmode") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "wildmode", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "wildmode");  },};
/** * 		{not available when compiled without the |+wildignore| * 		feature} * A list of words that change how command line completion is done. * Currently only one word is allowed: *   tagfile	When using CTRL-D to list matching tags, the kind of * 		tag and the file of the tag is listed.	Only one match * 		is displayed per line.  Often used tag kinds are: * 			d	#define * 			f	function * Also see |cmdline-completion|. */export const wildoptions = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "wildoptions") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "wildoptions", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "wildoptions");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "wildoptions") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "wildoptions", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "wildoptions");  },};
/** * 		{only used in Win32, Motif, GTK and Photon GUI} * Some GUI versions allow the access to menu entries by using the ALT * key in combination with a character that appears underlined in the * menu.  This conflicts with the use of the ALT key for mappings and * entering special characters.  This option tells what to do: *   no	Don't use ALT keys for menus.  ALT key combinations can be * 	mapped, but there is no automatic handling.  This can then be * 	done with the |:simalt| command. *   yes	ALT key handling is done by the windowing system.  ALT key * 	combinations cannot be mapped. *   menu	Using ALT in combination with a character that is a menu * 	shortcut key, will be handled by the windowing system.  Other * 	keys can be mapped. * If the menu is disabled by excluding 'm' from 'guioptions', the ALT * key is never used for the menu. * This option is not used for <F10>; on Win32 and with GTK <F10> will * select the menu, unless it has been mapped. */export const winaltkeys = {  async get(denops: Denops): Promise<string> {    return await options.get(denops, "winaltkeys") ?? "";  },  set(denops: Denops, value: string): Promise<void> {    return options.set(denops, "winaltkeys", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "winaltkeys");  },  async getGlobal(denops: Denops): Promise<string> {    return await globalOptions.get(denops, "winaltkeys") ?? "";  },  setGlobal(denops: Denops, value: string): Promise<void> {    return globalOptions.set(denops, "winaltkeys", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "winaltkeys");  },};
/** * Window height used for |CTRL-F| and |CTRL-B| when there is only one * window and the value is smaller than 'lines' minus one.  The screen * will scroll 'window' minus two lines, with a minimum of one. * When 'window' is equal to 'lines' minus one CTRL-F and CTRL-B scroll * in a much smarter way, taking care of wrapping lines. * When resizing the Vim window, the value is smaller than 1 or more than * or equal to 'lines' it will be set to 'lines' minus 1. * Note: Do not confuse this with the height of the Vim window, use * 'lines' for that. */export const window = {  async get(denops: Denops): Promise<number> {    return await options.get(denops, "window") ?? 0;  },  set(denops: Denops, value: number): Promise<void> {    return options.set(denops, "window", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "window");  },  async getGlobal(denops: Denops): Promise<number> {    return await globalOptions.get(denops, "window") ?? 0;  },  setGlobal(denops: Denops, value: number): Promise<void> {    return globalOptions.set(denops, "window", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "window");  },};
/** * Minimal number of lines for the current window.  This is not a hard * minimum, Vim will use fewer lines if there is not enough room.  If the * focus goes to a window that is smaller, its size is increased, at the * cost of the height of other windows. * Set 'winheight' to a small number for normal editing. * Set it to 999 to make the current window fill most of the screen. * Other windows will be only 'winminheight' high.  This has the drawback * that ":all" will create only two windows.  To avoid "vim -o 1 2 3 4" * to create only two windows, set the option after startup is done, * using the |VimEnter| event: > * 	au VimEnter * set winheight=999 * <	Minimum value is 1. * The height is not adjusted after one of the commands that change the * height of the current window. * 'winheight' applies to the current window.  Use 'winminheight' to set * the minimal height for other windows. */export const winheight = {  async get(denops: Denops): Promise<number> {    return await options.get(denops, "winheight") ?? 0;  },  set(denops: Denops, value: number): Promise<void> {    return options.set(denops, "winheight", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "winheight");  },  async getGlobal(denops: Denops): Promise<number> {    return await globalOptions.get(denops, "winheight") ?? 0;  },  setGlobal(denops: Denops, value: number): Promise<void> {    return globalOptions.set(denops, "winheight", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "winheight");  },};
/** * Keep the window height when windows are opened or closed and * 'equalalways' is set.  Also for |CTRL-W_=|.  Set by default for the * |preview-window| and |quickfix-window|. * The height may be changed anyway when running out of room. */export const winfixheight = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "winfixheight") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "winfixheight", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "winfixheight");  },  async getLocal(denops: Denops): Promise<boolean> {    return await localOptions.get(denops, "winfixheight") ?? false;  },  setLocal(denops: Denops, value: boolean): Promise<void> {    return localOptions.set(denops, "winfixheight", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "winfixheight");  },};
/** * Keep the window width when windows are opened or closed and * 'equalalways' is set.  Also for |CTRL-W_=|. * The width may be changed anyway when running out of room. */export const winfixwidth = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "winfixwidth") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "winfixwidth", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "winfixwidth");  },  async getLocal(denops: Denops): Promise<boolean> {    return await localOptions.get(denops, "winfixwidth") ?? false;  },  setLocal(denops: Denops, value: boolean): Promise<void> {    return localOptions.set(denops, "winfixwidth", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "winfixwidth");  },};
/** * The minimal height of a window, when it's not the current window. * This is a hard minimum, windows will never become smaller. * When set to zero, windows may be "squashed" to zero lines (i.e. just a * status bar) if necessary.  They will return to at least one line when * they become active (since the cursor has to have somewhere to go.) * Use 'winheight' to set the minimal height of the current window. * This option is only checked when making a window smaller.  Don't use a * large number, it will cause errors when opening more than a few * windows.  A value of 0 to 3 is reasonable. */export const winminheight = {  async get(denops: Denops): Promise<number> {    return await options.get(denops, "winminheight") ?? 0;  },  set(denops: Denops, value: number): Promise<void> {    return options.set(denops, "winminheight", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "winminheight");  },  async getGlobal(denops: Denops): Promise<number> {    return await globalOptions.get(denops, "winminheight") ?? 0;  },  setGlobal(denops: Denops, value: number): Promise<void> {    return globalOptions.set(denops, "winminheight", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "winminheight");  },};
/** * The minimal width of a window, when it's not the current window. * This is a hard minimum, windows will never become smaller. * When set to zero, windows may be "squashed" to zero columns (i.e. just * a vertical separator) if necessary.  They will return to at least one * line when they become active (since the cursor has to have somewhere * to go.) * Use 'winwidth' to set the minimal width of the current window. * This option is only checked when making a window smaller.  Don't use a * large number, it will cause errors when opening more than a few * windows.  A value of 0 to 12 is reasonable. */export const winminwidth = {  async get(denops: Denops): Promise<number> {    return await options.get(denops, "winminwidth") ?? 0;  },  set(denops: Denops, value: number): Promise<void> {    return options.set(denops, "winminwidth", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "winminwidth");  },  async getGlobal(denops: Denops): Promise<number> {    return await globalOptions.get(denops, "winminwidth") ?? 0;  },  setGlobal(denops: Denops, value: number): Promise<void> {    return globalOptions.set(denops, "winminwidth", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "winminwidth");  },};
/** * Minimal number of columns for the current window.  This is not a hard * minimum, Vim will use fewer columns if there is not enough room.  If * the current window is smaller, its size is increased, at the cost of * the width of other windows.  Set it to 999 to make the current window * always fill the screen.  Set it to a small number for normal editing. * The width is not adjusted after one of the commands to change the * width of the current window. * 'winwidth' applies to the current window.  Use 'winminwidth' to set * the minimal width for other windows. */export const winwidth = {  async get(denops: Denops): Promise<number> {    return await options.get(denops, "winwidth") ?? 0;  },  set(denops: Denops, value: number): Promise<void> {    return options.set(denops, "winwidth", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "winwidth");  },  async getGlobal(denops: Denops): Promise<number> {    return await globalOptions.get(denops, "winwidth") ?? 0;  },  setGlobal(denops: Denops, value: number): Promise<void> {    return globalOptions.set(denops, "winwidth", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "winwidth");  },};
/** * Number of characters from the right window border where wrapping * starts.  When typing text beyond this limit, an <EOL> will be inserted * and inserting continues on the next line. * Options that add a margin, such as 'number' and 'foldcolumn', cause * the text width to be further reduced.  This is Vi compatible. * When 'textwidth' is non-zero, this option is not used. * This option is set to 0 when 'paste' is set and restored when 'paste' * is reset. * See also 'formatoptions' and |ins-textwidth|. */export const wrapmargin = {  async get(denops: Denops): Promise<number> {    return await options.get(denops, "wrapmargin") ?? 0;  },  set(denops: Denops, value: number): Promise<void> {    return options.set(denops, "wrapmargin", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "wrapmargin");  },  async getLocal(denops: Denops): Promise<number> {    return await localOptions.get(denops, "wrapmargin") ?? 0;  },  setLocal(denops: Denops, value: number): Promise<void> {    return localOptions.set(denops, "wrapmargin", value);  },  resetLocal(denops: Denops): Promise<void> {    return localOptions.remove(denops, "wrapmargin");  },};
/** * Searches wrap around the end of the file.  Also applies to |]s| and * |[s|, searching for spelling mistakes. */export const wrapscan = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "wrapscan") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "wrapscan", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "wrapscan");  },  async getGlobal(denops: Denops): Promise<boolean> {    return await globalOptions.get(denops, "wrapscan") ?? false;  },  setGlobal(denops: Denops, value: boolean): Promise<void> {    return globalOptions.set(denops, "wrapscan", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "wrapscan");  },};
/** * Allows writing to any file with no need for "!" override. */export const writeany = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "writeany") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "writeany", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "writeany");  },  async getGlobal(denops: Denops): Promise<boolean> {    return await globalOptions.get(denops, "writeany") ?? false;  },  setGlobal(denops: Denops, value: boolean): Promise<void> {    return globalOptions.set(denops, "writeany", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "writeany");  },};
/** * Make a backup before overwriting a file.  The backup is removed after * the file was successfully written, unless the 'backup' option is * also on. * WARNING: Switching this option off means that when Vim fails to write * your buffer correctly and then, for whatever reason, Vim exits, you * lose both the original file and what you were writing.  Only reset * this option if your file system is almost full and it makes the write * fail (and make sure not to exit Vim until the write was successful). * See |backup-table| for another explanation. * When the 'backupskip' pattern matches, a backup is not made anyway. * Depending on 'backupcopy' the backup is a new file or the original * file renamed (and a new file is written). * NOTE: This option is set to the default value when 'compatible' is * set. */export const writebackup = {  async get(denops: Denops): Promise<boolean> {    return await options.get(denops, "writebackup") ?? false;  },  set(denops: Denops, value: boolean): Promise<void> {    return options.set(denops, "writebackup", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "writebackup");  },  async getGlobal(denops: Denops): Promise<boolean> {    return await globalOptions.get(denops, "writebackup") ?? false;  },  setGlobal(denops: Denops, value: boolean): Promise<void> {    return globalOptions.set(denops, "writebackup", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "writebackup");  },};
/** * The number of milliseconds to wait for each character sent to the * screen.  When non-zero, characters are sent to the terminal one by * one.  For debugging purposes. */export const writedelay = {  async get(denops: Denops): Promise<number> {    return await options.get(denops, "writedelay") ?? 0;  },  set(denops: Denops, value: number): Promise<void> {    return options.set(denops, "writedelay", value);  },  reset(denops: Denops): Promise<void> {    return options.remove(denops, "writedelay");  },  async getGlobal(denops: Denops): Promise<number> {    return await globalOptions.get(denops, "writedelay") ?? 0;  },  setGlobal(denops: Denops, value: number): Promise<void> {    return globalOptions.set(denops, "writedelay", value);  },  resetGlobal(denops: Denops): Promise<void> {    return globalOptions.remove(denops, "writedelay");  },};