Something went wrong. Try again.
atproto Thingiverse but good
Something went wrong. Try again.
217 kB · 6199 lines
Rust
at epic-86
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380238123822383238423852386238723882389239023912392239323942395239623972398239924002401240224032404240524062407240824092410241124122413241424152416241724182419242024212422242324242425242624272428242924302431243224332434243524362437243824392440244124422443244424452446244724482449245024512452245324542455245624572458245924602461246224632464246524662467246824692470247124722473247424752476247724782479248024812482248324842485248624872488248924902491249224932494249524962497249824992500250125022503250425052506250725082509251025112512251325142515251625172518251925202521252225232524252525262527252825292530253125322533253425352536253725382539254025412542254325442545254625472548254925502551255225532554255525562557255825592560256125622563256425652566256725682569257025712572257325742575257625772578257925802581258225832584258525862587258825892590259125922593259425952596259725982599260026012602260326042605260626072608260926102611261226132614261526162617261826192620262126222623262426252626262726282629263026312632263326342635263626372638263926402641264226432644264526462647264826492650265126522653265426552656265726582659266026612662266326642665266626672668266926702671267226732674267526762677267826792680268126822683268426852686268726882689269026912692269326942695269626972698269927002701270227032704270527062707270827092710271127122713271427152716271727182719272027212722272327242725272627272728272927302731273227332734273527362737273827392740274127422743274427452746274727482749275027512752275327542755275627572758275927602761276227632764276527662767276827692770277127722773277427752776277727782779278027812782278327842785278627872788278927902791279227932794279527962797279827992800280128022803280428052806280728082809281028112812281328142815281628172818281928202821282228232824282528262827282828292830283128322833283428352836283728382839284028412842284328442845284628472848284928502851285228532854285528562857285828592860286128622863286428652866286728682869287028712872287328742875287628772878287928802881288228832884288528862887288828892890289128922893289428952896289728982899290029012902290329042905290629072908290929102911291229132914291529162917291829192920292129222923292429252926292729282929293029312932293329342935293629372938293929402941294229432944294529462947294829492950295129522953295429552956295729582959296029612962296329642965296629672968296929702971297229732974297529762977297829792980298129822983298429852986298729882989299029912992299329942995299629972998299930003001300230033004300530063007300830093010301130123013301430153016301730183019302030213022302330243025302630273028302930303031303230333034303530363037303830393040304130423043304430453046304730483049305030513052305330543055305630573058305930603061306230633064306530663067306830693070307130723073307430753076307730783079308030813082308330843085308630873088308930903091309230933094309530963097309830993100310131023103310431053106310731083109311031113112311331143115311631173118311931203121312231233124312531263127312831293130313131323133313431353136313731383139314031413142314331443145314631473148314931503151315231533154315531563157315831593160316131623163316431653166316731683169317031713172317331743175317631773178317931803181318231833184318531863187318831893190319131923193319431953196319731983199320032013202320332043205320632073208320932103211321232133214321532163217321832193220322132223223322432253226322732283229323032313232323332343235323632373238323932403241324232433244324532463247324832493250325132523253325432553256325732583259326032613262326332643265326632673268326932703271327232733274327532763277327832793280328132823283328432853286328732883289329032913292329332943295329632973298329933003301330233033304330533063307330833093310331133123313331433153316331733183319332033213322332333243325332633273328332933303331333233333334333533363337333833393340334133423343334433453346334733483349335033513352335333543355335633573358335933603361336233633364336533663367336833693370337133723373337433753376337733783379338033813382338333843385338633873388338933903391339233933394339533963397339833993400340134023403340434053406340734083409341034113412341334143415341634173418341934203421342234233424342534263427342834293430343134323433343434353436343734383439344034413442344334443445344634473448344934503451345234533454345534563457345834593460346134623463346434653466346734683469347034713472347334743475347634773478347934803481348234833484348534863487348834893490349134923493349434953496349734983499350035013502350335043505350635073508350935103511351235133514351535163517351835193520352135223523352435253526352735283529353035313532353335343535353635373538353935403541354235433544354535463547354835493550355135523553355435553556355735583559356035613562356335643565356635673568356935703571357235733574357535763577357835793580358135823583358435853586358735883589359035913592359335943595359635973598359936003601360236033604360536063607360836093610361136123613361436153616361736183619362036213622362336243625362636273628362936303631363236333634363536363637363836393640364136423643364436453646364736483649365036513652365336543655365636573658365936603661366236633664366536663667366836693670367136723673367436753676367736783679368036813682368336843685368636873688368936903691369236933694369536963697369836993700370137023703370437053706370737083709371037113712371337143715371637173718371937203721372237233724372537263727372837293730373137323733373437353736373737383739374037413742374337443745374637473748374937503751375237533754375537563757375837593760376137623763376437653766376737683769377037713772377337743775377637773778377937803781378237833784378537863787378837893790379137923793379437953796379737983799380038013802380338043805380638073808380938103811381238133814381538163817381838193820382138223823382438253826382738283829383038313832383338343835383638373838383938403841384238433844384538463847384838493850385138523853385438553856385738583859386038613862386338643865386638673868386938703871387238733874387538763877387838793880388138823883388438853886388738883889389038913892389338943895389638973898389939003901390239033904390539063907390839093910391139123913391439153916391739183919392039213922392339243925392639273928392939303931393239333934393539363937393839393940394139423943394439453946394739483949395039513952395339543955395639573958395939603961396239633964396539663967396839693970397139723973397439753976397739783979398039813982398339843985398639873988398939903991399239933994399539963997399839994000400140024003400440054006400740084009401040114012401340144015401640174018401940204021402240234024402540264027402840294030403140324033403440354036403740384039404040414042404340444045404640474048404940504051405240534054405540564057405840594060406140624063406440654066406740684069407040714072407340744075407640774078407940804081408240834084408540864087408840894090409140924093409440954096409740984099410041014102410341044105410641074108410941104111411241134114411541164117411841194120412141224123412441254126412741284129413041314132413341344135413641374138413941404141414241434144414541464147414841494150415141524153415441554156415741584159416041614162416341644165416641674168416941704171417241734174417541764177417841794180418141824183418441854186418741884189419041914192419341944195419641974198419942004201420242034204420542064207420842094210421142124213421442154216421742184219422042214222422342244225422642274228422942304231423242334234423542364237423842394240424142424243424442454246424742484249425042514252425342544255425642574258425942604261426242634264426542664267426842694270427142724273427442754276427742784279428042814282428342844285428642874288428942904291429242934294429542964297429842994300430143024303430443054306430743084309431043114312431343144315431643174318431943204321432243234324432543264327432843294330433143324333433443354336433743384339434043414342434343444345434643474348434943504351435243534354435543564357435843594360436143624363436443654366436743684369437043714372437343744375437643774378437943804381438243834384438543864387438843894390439143924393439443954396439743984399440044014402440344044405440644074408440944104411441244134414441544164417441844194420442144224423442444254426442744284429443044314432443344344435443644374438443944404441444244434444444544464447444844494450445144524453445444554456445744584459446044614462446344644465446644674468446944704471447244734474447544764477447844794480448144824483448444854486448744884489449044914492449344944495449644974498449945004501450245034504450545064507450845094510451145124513451445154516451745184519452045214522452345244525452645274528452945304531453245334534453545364537453845394540454145424543454445454546454745484549455045514552455345544555455645574558455945604561456245634564456545664567456845694570457145724573457445754576457745784579458045814582458345844585458645874588458945904591459245934594459545964597459845994600460146024603460446054606460746084609461046114612461346144615461646174618461946204621462246234624462546264627462846294630463146324633463446354636463746384639464046414642464346444645464646474648464946504651465246534654465546564657465846594660466146624663466446654666466746684669467046714672467346744675467646774678467946804681468246834684468546864687468846894690469146924693469446954696469746984699470047014702470347044705470647074708470947104711471247134714471547164717471847194720472147224723472447254726472747284729473047314732473347344735473647374738473947404741474247434744474547464747474847494750475147524753475447554756475747584759476047614762476347644765476647674768476947704771477247734774477547764777477847794780478147824783478447854786478747884789479047914792479347944795479647974798479948004801480248034804480548064807480848094810481148124813481448154816481748184819482048214822482348244825482648274828482948304831483248334834483548364837483848394840484148424843484448454846484748484849485048514852485348544855485648574858485948604861486248634864486548664867486848694870487148724873487448754876487748784879488048814882488348844885488648874888488948904891489248934894489548964897489848994900490149024903490449054906490749084909491049114912491349144915491649174918491949204921492249234924492549264927492849294930493149324933493449354936493749384939494049414942494349444945494649474948494949504951495249534954495549564957495849594960496149624963496449654966496749684969497049714972497349744975497649774978497949804981498249834984498549864987498849894990499149924993499449954996499749984999500050015002500350045005500650075008500950105011501250135014501550165017501850195020502150225023502450255026502750285029503050315032503350345035503650375038503950405041504250435044504550465047504850495050505150525053505450555056505750585059506050615062506350645065506650675068506950705071507250735074507550765077507850795080508150825083508450855086508750885089509050915092509350945095509650975098509951005101510251035104510551065107510851095110511151125113511451155116511751185119512051215122512351245125512651275128512951305131513251335134513551365137513851395140514151425143514451455146514751485149515051515152515351545155515651575158515951605161516251635164516551665167516851695170517151725173517451755176517751785179518051815182518351845185518651875188518951905191519251935194519551965197519851995200520152025203520452055206520752085209521052115212521352145215521652175218521952205221522252235224522552265227522852295230523152325233523452355236523752385239524052415242524352445245524652475248524952505251525252535254525552565257525852595260526152625263526452655266526752685269527052715272527352745275527652775278527952805281528252835284528552865287528852895290529152925293529452955296529752985299530053015302530353045305530653075308530953105311531253135314531553165317531853195320532153225323532453255326532753285329533053315332533353345335533653375338533953405341534253435344534553465347534853495350535153525353535453555356535753585359536053615362536353645365536653675368536953705371537253735374537553765377537853795380538153825383538453855386538753885389539053915392539353945395539653975398539954005401540254035404540554065407540854095410541154125413541454155416541754185419542054215422542354245425542654275428542954305431543254335434543554365437543854395440544154425443544454455446544754485449545054515452545354545455545654575458545954605461546254635464546554665467546854695470547154725473547454755476547754785479548054815482548354845485548654875488548954905491549254935494549554965497549854995500550155025503550455055506550755085509551055115512551355145515551655175518551955205521552255235524552555265527552855295530553155325533553455355536553755385539554055415542554355445545554655475548554955505551555255535554555555565557555855595560556155625563556455655566556755685569557055715572557355745575557655775578557955805581558255835584558555865587558855895590559155925593559455955596559755985599560056015602560356045605560656075608560956105611561256135614561556165617561856195620562156225623562456255626562756285629563056315632563356345635563656375638563956405641564256435644564556465647564856495650565156525653565456555656565756585659566056615662566356645665566656675668566956705671567256735674567556765677567856795680568156825683568456855686568756885689569056915692569356945695569656975698569957005701570257035704570557065707570857095710571157125713571457155716571757185719572057215722572357245725572657275728572957305731573257335734573557365737573857395740574157425743574457455746574757485749575057515752575357545755575657575758575957605761576257635764576557665767576857695770577157725773577457755776577757785779578057815782578357845785578657875788578957905791579257935794579557965797579857995800580158025803580458055806580758085809581058115812581358145815581658175818581958205821582258235824582558265827582858295830583158325833583458355836583758385839584058415842584358445845584658475848584958505851585258535854585558565857585858595860586158625863586458655866586758685869587058715872587358745875587658775878587958805881588258835884588558865887588858895890589158925893589458955896589758985899590059015902590359045905590659075908590959105911591259135914591559165917591859195920592159225923592459255926592759285929593059315932593359345935593659375938593959405941594259435944594559465947594859495950595159525953595459555956595759585959596059615962596359645965596659675968596959705971597259735974597559765977597859795980598159825983598459855986598759885989599059915992599359945995599659975998599960006001600260036004600560066007600860096010601160126013601460156016601760186019602060216022602360246025602660276028602960306031603260336034603560366037603860396040604160426043604460456046604760486049605060516052605360546055605660576058605960606061606260636064606560666067606860696070607160726073607460756076607760786079608060816082608360846085608660876088608960906091609260936094609560966097609860996100610161026103610461056106610761086109611061116112611361146115611661176118611961206121612261236124612561266127612861296130613161326133613461356136613761386139614061416142614361446145614661476148614961506151615261536154615561566157615861596160616161626163616461656166616761686169617061716172617361746175617661776178617961806181618261836184618561866187618861896190619161926193619461956196619761986199// @generated by jacquard-lexicon. DO NOT EDIT.//// Lexicon: space.polymodel.library.defs//// This file was automatically generated from Lexicon schemas.// Any manual changes will be overwritten on the next regeneration.
//! Generated bindings for the `space.polymodel.library` Lexicon namespace/module.pub mod delete_thing;pub mod get_author_things;pub mod get_feed;pub mod get_model;pub mod get_model_load_bundle;pub mod get_part_file;pub mod get_thing;pub mod model;pub mod part;pub mod publish_thing;pub mod search_things;pub mod stage_file;pub mod thing;pub mod update_thing;
#[allow(unused_imports)]use alloc::collections::BTreeMap;
#[allow(unused_imports)]use core::marker::PhantomData;use jacquard_common::{CowStr, BosStr, DefaultStr, FromStaticStr};use jacquard_common::deps::bytes::Bytes;
#[allow(unused_imports)]use jacquard_common::deps::codegen::unicode_segmentation::UnicodeSegmentation;use jacquard_common::deps::smol_str::SmolStr;use jacquard_common::types::blob::BlobRef;use jacquard_common::types::string::{Did, Handle, AtUri, Cid, Datetime, UriValue};use jacquard_common::types::value::Data;use jacquard_derive::IntoStatic;use jacquard_lexicon::lexicon::LexiconDoc;use jacquard_lexicon::schema::LexiconSchema;
#[allow(unused_imports)]use jacquard_lexicon::validation::{ConstraintError, ValidationPath};use serde::{Serialize, Deserialize};use crate::com_atproto::repo::strong_ref::StrongRef;use crate::space_polymodel::library;
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]#[serde(rename_all = "camelCase", bound(deserialize = "S: Deserialize<'de> + BosStr"))]pub struct Actor<S: BosStr = DefaultStr> { ///Avatar image URL resolved by the app view (CDN). #[serde(skip_serializing_if = "Option::is_none")] pub avatar: Option<UriValue<S>>, #[serde(skip_serializing_if = "Option::is_none")] pub description: Option<S>, pub did: Did<S>, #[serde(skip_serializing_if = "Option::is_none")] pub display_name: Option<S>, #[serde(skip_serializing_if = "Option::is_none")] pub follower_count: Option<i64>, #[serde(skip_serializing_if = "Option::is_none")] pub following_count: Option<i64>, pub handle: Handle<S>, ///Hydrated profile pronouns for bylines and cards. #[serde(skip_serializing_if = "Option::is_none")] pub pronouns: Option<S>, ///Count of published Polymodel things by this actor. #[serde(skip_serializing_if = "Option::is_none")] pub thing_count: Option<i64>, #[serde(skip_serializing_if = "Option::is_none")] pub viewer: Option<library::ActorViewerState<S>>, #[serde(flatten, default, skip_serializing_if = "Option::is_none")] pub extra_data: Option<BTreeMap<SmolStr, Data<S>>>,}
/// Detailed hydrated actor/profile view for profile surfaces, modeled after app.bsky.actor profile view splits.
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]#[serde(rename_all = "camelCase", bound(deserialize = "S: Deserialize<'de> + BosStr"))]pub struct ActorViewDetailed<S: BosStr = DefaultStr> { ///Avatar image URL resolved by the app view (CDN). #[serde(skip_serializing_if = "Option::is_none")] pub avatar: Option<UriValue<S>>, #[serde(skip_serializing_if = "Option::is_none")] pub default_license: Option<S>, #[serde(skip_serializing_if = "Option::is_none")] pub description: Option<S>, pub did: Did<S>, #[serde(skip_serializing_if = "Option::is_none")] pub display_name: Option<S>, #[serde(skip_serializing_if = "Option::is_none")] pub follower_count: Option<i64>, #[serde(skip_serializing_if = "Option::is_none")] pub following_count: Option<i64>, pub handle: Handle<S>, pub indexed_at: Datetime, #[serde(skip_serializing_if = "Option::is_none")] pub links: Option<Vec<UriValue<S>>>, #[serde(skip_serializing_if = "Option::is_none")] pub printers: Option<Vec<S>>, #[serde(skip_serializing_if = "Option::is_none")] pub pronouns: Option<S>, pub record: Data<S>, ///Count of published Polymodel things by this actor. #[serde(skip_serializing_if = "Option::is_none")] pub thing_count: Option<i64>, pub viewer: library::ActorViewerState<S>, #[serde(flatten, default, skip_serializing_if = "Option::is_none")] pub extra_data: Option<BTreeMap<SmolStr, Data<S>>>,}
/// Viewer-specific relationship state for an actor/profile.
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Default)]#[serde(rename_all = "camelCase", bound(deserialize = "S: Deserialize<'de> + BosStr"))]pub struct ActorViewerState<S: BosStr = DefaultStr> { #[serde(skip_serializing_if = "Option::is_none")] pub blocked_by: Option<bool>, ///Block record URI if the requester blocks this actor. #[serde(skip_serializing_if = "Option::is_none")] pub blocking: Option<AtUri<S>>, ///Follow record URI if this actor follows the requester. #[serde(skip_serializing_if = "Option::is_none")] pub followed_by: Option<AtUri<S>>, ///Follow record URI if the requester follows this actor. #[serde(skip_serializing_if = "Option::is_none")] pub following: Option<AtUri<S>>, #[serde(skip_serializing_if = "Option::is_none")] pub muted: Option<bool>, #[serde(flatten, default, skip_serializing_if = "Option::is_none")] pub extra_data: Option<BTreeMap<SmolStr, Data<S>>>,}
/// Width:height aspect ratio of an image, for layout before the blob loads.
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]#[serde(rename_all = "camelCase", bound(deserialize = "S: Deserialize<'de> + BosStr"))]pub struct AspectRatio<S: BosStr = DefaultStr> { pub height: i64, pub width: i64, #[serde(flatten, default, skip_serializing_if = "Option::is_none")] pub extra_data: Option<BTreeMap<SmolStr, Data<S>>>,}
/// Axis-aligned bounding-box dimensions. ATProto has no float type, so x/y/z are decimal strings (e.g. 12.5) parsed to floats internally.
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Default)]#[serde(rename_all = "camelCase", bound(deserialize = "S: Deserialize<'de> + BosStr"))]pub struct Bbox<S: BosStr = DefaultStr> { #[serde(skip_serializing_if = "Option::is_none")] pub unit: Option<S>, pub x: S, pub y: S, pub z: S, #[serde(flatten, default, skip_serializing_if = "Option::is_none")] pub extra_data: Option<BTreeMap<SmolStr, Data<S>>>,}
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]#[serde(rename_all = "camelCase", bound(deserialize = "S: Deserialize<'de> + BosStr"))]pub struct Chunk<S: BosStr = DefaultStr> { pub blob: BlobRef<S>, pub offset: i64, pub size: i64, #[serde(flatten, default, skip_serializing_if = "Option::is_none")] pub extra_data: Option<BTreeMap<SmolStr, Data<S>>>,}
pub type Cover<S = DefaultStr> = Vec<library::Image<S>>;
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]#[serde(rename_all = "camelCase", bound(deserialize = "S: Deserialize<'de> + BosStr"))]pub struct FeedItem<S: BosStr = DefaultStr> { pub thing: library::ThingViewBasic<S>, #[serde(flatten, default, skip_serializing_if = "Option::is_none")] pub extra_data: Option<BTreeMap<SmolStr, Data<S>>>,}
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]#[serde(rename_all = "camelCase", bound(deserialize = "S: Deserialize<'de> + BosStr"))]pub struct FeedView<S: BosStr = DefaultStr> { #[serde(skip_serializing_if = "Option::is_none")] pub cursor: Option<S>, pub items: Vec<library::FeedItem<S>>, #[serde(flatten, default, skip_serializing_if = "Option::is_none")] pub extra_data: Option<BTreeMap<SmolStr, Data<S>>>,}
/// Chunk-capable geometry manifest. Reassemble by concatenating chunks in offset order. Per-chunk integrity is the blob CID; offset+size make ordering explicit; digest verifies the fully reassembled file.
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]#[serde(rename_all = "camelCase", bound(deserialize = "S: Deserialize<'de> + BosStr"))]pub struct File<S: BosStr = DefaultStr> { pub chunks: Vec<library::Chunk<S>>, ///sha256 digest of the fully reassembled file #[serde(skip_serializing_if = "Option::is_none")] #[serde(default, with = "jacquard_common::opt_serde_bytes_helper")] pub digest: Option<Bytes>, pub mime_type: S, ///size in bytes of the fully reassembled file pub size: i64, #[serde(flatten, default, skip_serializing_if = "Option::is_none")] pub extra_data: Option<BTreeMap<SmolStr, Data<S>>>,}
/// An authored image: a blob plus alt text and aspect ratio. Stored on records; the app view resolves it to #imageView.
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]#[serde(rename_all = "camelCase", bound(deserialize = "S: Deserialize<'de> + BosStr"))]pub struct Image<S: BosStr = DefaultStr> { ///Alt text describing the image, for accessibility. pub alt: S, pub aspect_ratio: library::AspectRatio<S>, pub image: BlobRef<S>, #[serde(flatten, default, skip_serializing_if = "Option::is_none")] pub extra_data: Option<BTreeMap<SmolStr, Data<S>>>,}
/// A resolved image view: CDN URLs for thumbnail and full size plus aspect ratio. Currently resolved via Bluesky's CDN by the app view.
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]#[serde(rename_all = "camelCase", bound(deserialize = "S: Deserialize<'de> + BosStr"))]pub struct ImageView<S: BosStr = DefaultStr> { #[serde(skip_serializing_if = "Option::is_none")] pub alt: Option<S>, #[serde(skip_serializing_if = "Option::is_none")] pub aspect_ratio: Option<library::AspectRatio<S>>, ///Fully-qualified full-size URL (CDN, resolved by the app view). pub fullsize: UriValue<S>, ///Fully-qualified thumbnail URL (CDN, resolved by the app view). pub thumb: UriValue<S>, #[serde(flatten, default, skip_serializing_if = "Option::is_none")] pub extra_data: Option<BTreeMap<SmolStr, Data<S>>>,}
pub type Instructions<S = DefaultStr> = Vec<S>;pub type IntendedToWorkWith<S = DefaultStr> = Vec<StrongRef<S>>;
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]#[serde(rename_all = "camelCase", bound(deserialize = "S: Deserialize<'de> + BosStr"))]pub struct ModelView<S: BosStr = DefaultStr> { pub author: library::Actor<S>, pub cid: Cid<S>, #[serde(skip_serializing_if = "Option::is_none")] pub cover: Option<Vec<library::ImageView<S>>>, pub indexed_at: Datetime, pub name: S, pub part_count: i64, #[serde(skip_serializing_if = "Option::is_none")] pub previews: Option<Vec<library::ImageView<S>>>, pub record: Data<S>, #[serde(skip_serializing_if = "Option::is_none")] pub summary: Option<S>, pub uri: AtUri<S>, pub viewer: library::ViewerState<S>, #[serde(flatten, default, skip_serializing_if = "Option::is_none")] pub extra_data: Option<BTreeMap<SmolStr, Data<S>>>,}
pub type Name<S = DefaultStr> = S;
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]#[serde(rename_all = "camelCase", bound(deserialize = "S: Deserialize<'de> + BosStr"))]pub struct PartView<S: BosStr = DefaultStr> { pub author: library::Actor<S>, pub cid: Cid<S>, pub file: library::File<S>, #[serde(skip_serializing_if = "Option::is_none")] pub format: Option<S>, pub indexed_at: Datetime, pub name: S, #[serde(skip_serializing_if = "Option::is_none")] pub previews: Option<Vec<library::ImageView<S>>>, pub record: Data<S>, pub uri: AtUri<S>, pub viewer: library::ViewerState<S>, #[serde(flatten, default, skip_serializing_if = "Option::is_none")] pub extra_data: Option<BTreeMap<SmolStr, Data<S>>>,}
pub type Previews<S = DefaultStr> = Vec<library::Image<S>>;pub type PrintSettings<S = DefaultStr> = Vec<S>;pub type SearchQuery<S = DefaultStr> = S;pub type ShortText<S = DefaultStr> = S;pub type Tag<S = DefaultStr> = S;pub type Tags<S = DefaultStr> = Vec<library::Tag<S>>;
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]#[serde(rename_all = "camelCase", bound(deserialize = "S: Deserialize<'de> + BosStr"))]pub struct ThingView<S: BosStr = DefaultStr> { pub author: library::Actor<S>, pub cid: Cid<S>, #[serde(skip_serializing_if = "Option::is_none")] pub cover: Option<Vec<library::ImageView<S>>>, #[serde(skip_serializing_if = "Option::is_none")] pub derived_from: Option<StrongRef<S>>, pub indexed_at: Datetime, #[serde(skip_serializing_if = "Option::is_none")] pub intended_to_work_with: Option<Vec<StrongRef<S>>>, pub license: S, pub like_count: i64, pub model_count: i64, pub name: S, ///Thing-level aggregate count of parts across included models, computed by the app view. pub part_count: i64, #[serde(skip_serializing_if = "Option::is_none")] pub previews: Option<Vec<library::ImageView<S>>>, pub record: Data<S>, pub save_count: i64, #[serde(skip_serializing_if = "Option::is_none")] pub summary: Option<S>, ///Hydrated display tags, including appview-aggregated external tag assertions. #[serde(skip_serializing_if = "Option::is_none")] pub tags: Option<Vec<S>>, pub uri: AtUri<S>, pub viewer: library::ViewerState<S>, #[serde(flatten, default, skip_serializing_if = "Option::is_none")] pub extra_data: Option<BTreeMap<SmolStr, Data<S>>>,}
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]#[serde(rename_all = "camelCase", bound(deserialize = "S: Deserialize<'de> + BosStr"))]pub struct ThingViewBasic<S: BosStr = DefaultStr> { pub author: library::Actor<S>, pub cid: Cid<S>, #[serde(skip_serializing_if = "Option::is_none")] pub cover: Option<Vec<library::ImageView<S>>>, pub indexed_at: Datetime, pub like_count: i64, pub model_count: i64, pub name: S, ///Thing-level aggregate count of parts across included models, computed by the app view. pub part_count: i64, #[serde(skip_serializing_if = "Option::is_none")] pub previews: Option<Vec<library::ImageView<S>>>, pub save_count: i64, ///Hydrated display tags for browse/search/profile cards, including appview-aggregated external tag assertions. #[serde(skip_serializing_if = "Option::is_none")] pub tags: Option<Vec<S>>, pub uri: AtUri<S>, pub viewer: library::ViewerState<S>, #[serde(flatten, default, skip_serializing_if = "Option::is_none")] pub extra_data: Option<BTreeMap<SmolStr, Data<S>>>,}
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Default)]#[serde(rename_all = "camelCase", bound(deserialize = "S: Deserialize<'de> + BosStr"))]pub struct ViewerState<S: BosStr = DefaultStr> { #[serde(skip_serializing_if = "Option::is_none")] pub like: Option<AtUri<S>>, #[serde(skip_serializing_if = "Option::is_none")] pub save: Option<AtUri<S>>, #[serde(flatten, default, skip_serializing_if = "Option::is_none")] pub extra_data: Option<BTreeMap<SmolStr, Data<S>>>,}
/// Reference-only shared field set; fields are inlined on thing/model.
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Default)]#[serde(rename_all = "camelCase", bound(deserialize = "S: Deserialize<'de> + BosStr"))]pub struct WorkMeta<S: BosStr = DefaultStr> { #[serde(skip_serializing_if = "Option::is_none")] pub cover: Option<Vec<library::Image<S>>>, #[serde(skip_serializing_if = "Option::is_none")] pub derived_from: Option<StrongRef<S>>, #[serde(skip_serializing_if = "Option::is_none")] pub instructions: Option<Vec<S>>, #[serde(skip_serializing_if = "Option::is_none")] pub intended_to_work_with: Option<Vec<StrongRef<S>>>, #[serde(skip_serializing_if = "Option::is_none")] pub license: Option<S>, #[serde(skip_serializing_if = "Option::is_none")] pub name: Option<S>, #[serde(skip_serializing_if = "Option::is_none")] pub previews: Option<Vec<library::Image<S>>>, #[serde(skip_serializing_if = "Option::is_none")] pub summary: Option<S>, #[serde(skip_serializing_if = "Option::is_none")] pub tags: Option<Vec<S>>, #[serde(flatten, default, skip_serializing_if = "Option::is_none")] pub extra_data: Option<BTreeMap<SmolStr, Data<S>>>,}
impl<S: BosStr> LexiconSchema for Actor<S> { fn nsid() -> &'static str { "space.polymodel.library.defs" } fn def_name() -> &'static str { "actor" } fn lexicon_doc() -> LexiconDoc<'static> { lexicon_doc_space_polymodel_library_defs() } fn validate(&self) -> Result<(), ConstraintError> { Ok(()) }}
impl<S: BosStr> LexiconSchema for ActorViewDetailed<S> { fn nsid() -> &'static str { "space.polymodel.library.defs" } fn def_name() -> &'static str { "actorViewDetailed" } fn lexicon_doc() -> LexiconDoc<'static> { lexicon_doc_space_polymodel_library_defs() } fn validate(&self) -> Result<(), ConstraintError> { Ok(()) }}
impl<S: BosStr> LexiconSchema for ActorViewerState<S> { fn nsid() -> &'static str { "space.polymodel.library.defs" } fn def_name() -> &'static str { "actorViewerState" } fn lexicon_doc() -> LexiconDoc<'static> { lexicon_doc_space_polymodel_library_defs() } fn validate(&self) -> Result<(), ConstraintError> { Ok(()) }}
impl<S: BosStr> LexiconSchema for AspectRatio<S> { fn nsid() -> &'static str { "space.polymodel.library.defs" } fn def_name() -> &'static str { "aspectRatio" } fn lexicon_doc() -> LexiconDoc<'static> { lexicon_doc_space_polymodel_library_defs() } fn validate(&self) -> Result<(), ConstraintError> { Ok(()) }}
impl<S: BosStr> LexiconSchema for Bbox<S> { fn nsid() -> &'static str { "space.polymodel.library.defs" } fn def_name() -> &'static str { "bbox" } fn lexicon_doc() -> LexiconDoc<'static> { lexicon_doc_space_polymodel_library_defs() } fn validate(&self) -> Result<(), ConstraintError> { Ok(()) }}
impl<S: BosStr> LexiconSchema for Chunk<S> { fn nsid() -> &'static str { "space.polymodel.library.defs" } fn def_name() -> &'static str { "chunk" } fn lexicon_doc() -> LexiconDoc<'static> { lexicon_doc_space_polymodel_library_defs() } fn validate(&self) -> Result<(), ConstraintError> { { let value = &self.blob; { let size = value.blob().size; if size > 104857600usize { return Err(ConstraintError::BlobTooLarge { path: ValidationPath::from_field("blob"), max: 104857600usize, actual: size, }); } } } { let value = &self.blob; { let mime = value.blob().mime_type.as_str(); let accepted: &[&str] = &[ "model/stl", "model/3mf", "model/obj", "model/gltf+json", "model/gltf-binary", "application/x-ldraw", "model/ldraw", "application/octet-stream", "model/step", "application/step", ]; let matched = accepted .iter() .any(|pattern| { if *pattern == "*/*" { true } else if pattern.ends_with("/*") { let prefix = &pattern[..pattern.len() - 2]; mime.starts_with(prefix) && mime.as_bytes().get(prefix.len()) == Some(&b'/') } else { mime == *pattern } }); if !matched { return Err(ConstraintError::BlobMimeTypeNotAccepted { path: ValidationPath::from_field("blob"), accepted: vec![ "model/stl".to_string(), "model/3mf".to_string(), "model/obj" .to_string(), "model/gltf+json".to_string(), "model/gltf-binary".to_string(), "application/x-ldraw" .to_string(), "model/ldraw".to_string(), "application/octet-stream".to_string(), "model/step" .to_string(), "application/step".to_string() ], actual: mime.to_string(), }); } } } { let value = &self.offset; if *value < 0i64 { return Err(ConstraintError::Minimum { path: ValidationPath::from_field("offset"), min: 0i64, actual: *value, }); } } { let value = &self.size; if *value < 0i64 { return Err(ConstraintError::Minimum { path: ValidationPath::from_field("size"), min: 0i64, actual: *value, }); } } Ok(()) }}
impl<S: BosStr> LexiconSchema for FeedItem<S> { fn nsid() -> &'static str { "space.polymodel.library.defs" } fn def_name() -> &'static str { "feedItem" } fn lexicon_doc() -> LexiconDoc<'static> { lexicon_doc_space_polymodel_library_defs() } fn validate(&self) -> Result<(), ConstraintError> { Ok(()) }}
impl<S: BosStr> LexiconSchema for FeedView<S> { fn nsid() -> &'static str { "space.polymodel.library.defs" } fn def_name() -> &'static str { "feedView" } fn lexicon_doc() -> LexiconDoc<'static> { lexicon_doc_space_polymodel_library_defs() } fn validate(&self) -> Result<(), ConstraintError> { Ok(()) }}
impl<S: BosStr> LexiconSchema for File<S> { fn nsid() -> &'static str { "space.polymodel.library.defs" } fn def_name() -> &'static str { "file" } fn lexicon_doc() -> LexiconDoc<'static> { lexicon_doc_space_polymodel_library_defs() } fn validate(&self) -> Result<(), ConstraintError> { { let value = &self.chunks; #[allow(unused_comparisons)] if value.len() > 4096usize { return Err(ConstraintError::MaxLength { path: ValidationPath::from_field("chunks"), max: 4096usize, actual: value.len(), }); } } Ok(()) }}
impl<S: BosStr> LexiconSchema for Image<S> { fn nsid() -> &'static str { "space.polymodel.library.defs" } fn def_name() -> &'static str { "image" } fn lexicon_doc() -> LexiconDoc<'static> { lexicon_doc_space_polymodel_library_defs() } fn validate(&self) -> Result<(), ConstraintError> { { let value = &self.alt; #[allow(unused_comparisons)] if <str>::len(value.as_ref()) > 10000usize { return Err(ConstraintError::MaxLength { path: ValidationPath::from_field("alt"), max: 10000usize, actual: <str>::len(value.as_ref()), }); } } { let value = &self.alt; { let count = UnicodeSegmentation::graphemes(value.as_ref(), true).count(); if count > 2000usize { return Err(ConstraintError::MaxGraphemes { path: ValidationPath::from_field("alt"), max: 2000usize, actual: count, }); } } } { let value = &self.image; { let size = value.blob().size; if size > 5242880usize { return Err(ConstraintError::BlobTooLarge { path: ValidationPath::from_field("image"), max: 5242880usize, actual: size, }); } } } { let value = &self.image; { let mime = value.blob().mime_type.as_str(); let accepted: &[&str] = &["image/png", "image/jpeg", "image/webp"]; let matched = accepted .iter() .any(|pattern| { if *pattern == "*/*" { true } else if pattern.ends_with("/*") { let prefix = &pattern[..pattern.len() - 2]; mime.starts_with(prefix) && mime.as_bytes().get(prefix.len()) == Some(&b'/') } else { mime == *pattern } }); if !matched { return Err(ConstraintError::BlobMimeTypeNotAccepted { path: ValidationPath::from_field("image"), accepted: vec![ "image/png".to_string(), "image/jpeg".to_string(), "image/webp".to_string() ], actual: mime.to_string(), }); } } } Ok(()) }}
impl<S: BosStr> LexiconSchema for ImageView<S> { fn nsid() -> &'static str { "space.polymodel.library.defs" } fn def_name() -> &'static str { "imageView" } fn lexicon_doc() -> LexiconDoc<'static> { lexicon_doc_space_polymodel_library_defs() } fn validate(&self) -> Result<(), ConstraintError> { Ok(()) }}
impl<S: BosStr> LexiconSchema for ModelView<S> { fn nsid() -> &'static str { "space.polymodel.library.defs" } fn def_name() -> &'static str { "modelView" } fn lexicon_doc() -> LexiconDoc<'static> { lexicon_doc_space_polymodel_library_defs() } fn validate(&self) -> Result<(), ConstraintError> { Ok(()) }}
impl<S: BosStr> LexiconSchema for PartView<S> { fn nsid() -> &'static str { "space.polymodel.library.defs" } fn def_name() -> &'static str { "partView" } fn lexicon_doc() -> LexiconDoc<'static> { lexicon_doc_space_polymodel_library_defs() } fn validate(&self) -> Result<(), ConstraintError> { Ok(()) }}
impl<S: BosStr> LexiconSchema for ThingView<S> { fn nsid() -> &'static str { "space.polymodel.library.defs" } fn def_name() -> &'static str { "thingView" } fn lexicon_doc() -> LexiconDoc<'static> { lexicon_doc_space_polymodel_library_defs() } fn validate(&self) -> Result<(), ConstraintError> { Ok(()) }}
impl<S: BosStr> LexiconSchema for ThingViewBasic<S> { fn nsid() -> &'static str { "space.polymodel.library.defs" } fn def_name() -> &'static str { "thingViewBasic" } fn lexicon_doc() -> LexiconDoc<'static> { lexicon_doc_space_polymodel_library_defs() } fn validate(&self) -> Result<(), ConstraintError> { Ok(()) }}
impl<S: BosStr> LexiconSchema for ViewerState<S> { fn nsid() -> &'static str { "space.polymodel.library.defs" } fn def_name() -> &'static str { "viewerState" } fn lexicon_doc() -> LexiconDoc<'static> { lexicon_doc_space_polymodel_library_defs() } fn validate(&self) -> Result<(), ConstraintError> { Ok(()) }}
impl<S: BosStr> LexiconSchema for WorkMeta<S> { fn nsid() -> &'static str { "space.polymodel.library.defs" } fn def_name() -> &'static str { "workMeta" } fn lexicon_doc() -> LexiconDoc<'static> { lexicon_doc_space_polymodel_library_defs() } fn validate(&self) -> Result<(), ConstraintError> { Ok(()) }}
pub mod actor_state {
pub use crate::builder_types::{Set, Unset, IsSet, IsUnset}; #[allow(unused)] use ::core::marker::PhantomData; mod sealed { pub trait Sealed {} } /// State trait tracking which required fields have been set pub trait State: sealed::Sealed { type Did; type Handle; } /// Empty state - all required fields are unset pub struct Empty(()); impl sealed::Sealed for Empty {} impl State for Empty { type Did = Unset; type Handle = Unset; } ///State transition - sets the `did` field to Set pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>); impl<St: State> sealed::Sealed for SetDid<St> {} impl<St: State> State for SetDid<St> { type Did = Set<members::did>; type Handle = St::Handle; } ///State transition - sets the `handle` field to Set pub struct SetHandle<St: State = Empty>(PhantomData<fn() -> St>); impl<St: State> sealed::Sealed for SetHandle<St> {} impl<St: State> State for SetHandle<St> { type Did = St::Did; type Handle = Set<members::handle>; } /// Marker types for field names #[allow(non_camel_case_types)] pub mod members { ///Marker type for the `did` field pub struct did(()); ///Marker type for the `handle` field pub struct handle(()); }}
/// Builder for constructing an instance of this type.pub struct ActorBuilder<St: actor_state::State, S: BosStr = DefaultStr> { _state: PhantomData<fn() -> St>, _fields: ( Option<UriValue<S>>, Option<S>, Option<Did<S>>, Option<S>, Option<i64>, Option<i64>, Option<Handle<S>>, Option<S>, Option<i64>, Option<library::ActorViewerState<S>>, ), _type: PhantomData<fn() -> S>,}
impl Actor<DefaultStr> { /// Create a new builder for this type, using the default string type (DefaultStr = SmolStr) if needed pub fn new() -> ActorBuilder<actor_state::Empty, DefaultStr> { ActorBuilder::new() }}
impl<S: BosStr> Actor<S> { /// Create a new builder for this type pub fn builder() -> ActorBuilder<actor_state::Empty, S> { ActorBuilder::builder() }}
impl ActorBuilder<actor_state::Empty, DefaultStr> { /// Create a new builder with all fields unset, using the default string type, if needed pub fn new() -> Self { ActorBuilder { _state: PhantomData, _fields: (None, None, None, None, None, None, None, None, None, None), _type: PhantomData, } }}
impl<S: BosStr> ActorBuilder<actor_state::Empty, S> { /// Create a new builder with all fields unset pub fn builder() -> Self { ActorBuilder { _state: PhantomData, _fields: (None, None, None, None, None, None, None, None, None, None), _type: PhantomData, } }}
impl<St: actor_state::State, S: BosStr> ActorBuilder<St, S> { /// Set the `avatar` field (optional) pub fn avatar(mut self, value: impl Into<Option<UriValue<S>>>) -> Self { self._fields.0 = value.into(); self } /// Set the `avatar` field to an Option value (optional) pub fn maybe_avatar(mut self, value: Option<UriValue<S>>) -> Self { self._fields.0 = value; self }}
impl<St: actor_state::State, S: BosStr> ActorBuilder<St, S> { /// Set the `description` field (optional) pub fn description(mut self, value: impl Into<Option<S>>) -> Self { self._fields.1 = value.into(); self } /// Set the `description` field to an Option value (optional) pub fn maybe_description(mut self, value: Option<S>) -> Self { self._fields.1 = value; self }}
impl<St, S: BosStr> ActorBuilder<St, S>where St: actor_state::State, St::Did: actor_state::IsUnset,{ /// Set the `did` field (required) pub fn did( mut self, value: impl Into<Did<S>>, ) -> ActorBuilder<actor_state::SetDid<St>, S> { self._fields.2 = Option::Some(value.into()); ActorBuilder { _state: PhantomData, _fields: self._fields, _type: PhantomData, } }}
impl<St: actor_state::State, S: BosStr> ActorBuilder<St, S> { /// Set the `displayName` field (optional) pub fn display_name(mut self, value: impl Into<Option<S>>) -> Self { self._fields.3 = value.into(); self } /// Set the `displayName` field to an Option value (optional) pub fn maybe_display_name(mut self, value: Option<S>) -> Self { self._fields.3 = value; self }}
impl<St: actor_state::State, S: BosStr> ActorBuilder<St, S> { /// Set the `followerCount` field (optional) pub fn follower_count(mut self, value: impl Into<Option<i64>>) -> Self { self._fields.4 = value.into(); self } /// Set the `followerCount` field to an Option value (optional) pub fn maybe_follower_count(mut self, value: Option<i64>) -> Self { self._fields.4 = value; self }}
impl<St: actor_state::State, S: BosStr> ActorBuilder<St, S> { /// Set the `followingCount` field (optional) pub fn following_count(mut self, value: impl Into<Option<i64>>) -> Self { self._fields.5 = value.into(); self } /// Set the `followingCount` field to an Option value (optional) pub fn maybe_following_count(mut self, value: Option<i64>) -> Self { self._fields.5 = value; self }}
impl<St, S: BosStr> ActorBuilder<St, S>where St: actor_state::State, St::Handle: actor_state::IsUnset,{ /// Set the `handle` field (required) pub fn handle( mut self, value: impl Into<Handle<S>>, ) -> ActorBuilder<actor_state::SetHandle<St>, S> { self._fields.6 = Option::Some(value.into()); ActorBuilder { _state: PhantomData, _fields: self._fields, _type: PhantomData, } }}
impl<St: actor_state::State, S: BosStr> ActorBuilder<St, S> { /// Set the `pronouns` field (optional) pub fn pronouns(mut self, value: impl Into<Option<S>>) -> Self { self._fields.7 = value.into(); self } /// Set the `pronouns` field to an Option value (optional) pub fn maybe_pronouns(mut self, value: Option<S>) -> Self { self._fields.7 = value; self }}
impl<St: actor_state::State, S: BosStr> ActorBuilder<St, S> { /// Set the `thingCount` field (optional) pub fn thing_count(mut self, value: impl Into<Option<i64>>) -> Self { self._fields.8 = value.into(); self } /// Set the `thingCount` field to an Option value (optional) pub fn maybe_thing_count(mut self, value: Option<i64>) -> Self { self._fields.8 = value; self }}
impl<St: actor_state::State, S: BosStr> ActorBuilder<St, S> { /// Set the `viewer` field (optional) pub fn viewer( mut self, value: impl Into<Option<library::ActorViewerState<S>>>, ) -> Self { self._fields.9 = value.into(); self } /// Set the `viewer` field to an Option value (optional) pub fn maybe_viewer(mut self, value: Option<library::ActorViewerState<S>>) -> Self { self._fields.9 = value; self }}
impl<St, S: BosStr> ActorBuilder<St, S>where St: actor_state::State, St::Did: actor_state::IsSet, St::Handle: actor_state::IsSet,{ /// Build the final struct. pub fn build(self) -> Actor<S> { Actor { avatar: self._fields.0, description: self._fields.1, did: self._fields.2.unwrap(), display_name: self._fields.3, follower_count: self._fields.4, following_count: self._fields.5, handle: self._fields.6.unwrap(), pronouns: self._fields.7, thing_count: self._fields.8, viewer: self._fields.9, extra_data: Default::default(), } } /// Build the final struct with custom extra_data. pub fn build_with_data(self, extra_data: BTreeMap<SmolStr, Data<S>>) -> Actor<S> { Actor { avatar: self._fields.0, description: self._fields.1, did: self._fields.2.unwrap(), display_name: self._fields.3, follower_count: self._fields.4, following_count: self._fields.5, handle: self._fields.6.unwrap(), pronouns: self._fields.7, thing_count: self._fields.8, viewer: self._fields.9, extra_data: Some(extra_data), } }}
fn lexicon_doc_space_polymodel_library_defs() -> LexiconDoc<'static> { #[allow(unused_imports)] use jacquard_common::{CowStr, deps::smol_str::SmolStr, types::blob::MimeType}; use jacquard_lexicon::lexicon::*; use alloc::collections::BTreeMap; LexiconDoc { lexicon: Lexicon::Lexicon1, id: CowStr::new_static("space.polymodel.library.defs"), defs: { let mut map = BTreeMap::new(); map.insert( SmolStr::new_static("actor"), LexUserType::Object(LexObject { required: Some( vec![SmolStr::new_static("did"), SmolStr::new_static("handle")], ), properties: { #[allow(unused_mut)] let mut map = BTreeMap::new(); map.insert( SmolStr::new_static("avatar"), LexObjectProperty::String(LexString { description: Some( CowStr::new_static( "Avatar image URL resolved by the app view (CDN).", ), ), format: Some(LexStringFormat::Uri), ..Default::default() }), ); map.insert( SmolStr::new_static("description"), LexObjectProperty::String(LexString { ..Default::default() }), ); map.insert( SmolStr::new_static("did"), LexObjectProperty::String(LexString { format: Some(LexStringFormat::Did), ..Default::default() }), ); map.insert( SmolStr::new_static("displayName"), LexObjectProperty::String(LexString { ..Default::default() }), ); map.insert( SmolStr::new_static("followerCount"), LexObjectProperty::Integer(LexInteger { ..Default::default() }), ); map.insert( SmolStr::new_static("followingCount"), LexObjectProperty::Integer(LexInteger { ..Default::default() }), ); map.insert( SmolStr::new_static("handle"), LexObjectProperty::String(LexString { format: Some(LexStringFormat::Handle), ..Default::default() }), ); map.insert( SmolStr::new_static("pronouns"), LexObjectProperty::String(LexString { description: Some( CowStr::new_static( "Hydrated profile pronouns for bylines and cards.", ), ), ..Default::default() }), ); map.insert( SmolStr::new_static("thingCount"), LexObjectProperty::Integer(LexInteger { ..Default::default() }), ); map.insert( SmolStr::new_static("viewer"), LexObjectProperty::Ref(LexRef { r#ref: CowStr::new_static("#actorViewerState"), ..Default::default() }), ); map }, ..Default::default() }), ); map.insert( SmolStr::new_static("actorViewDetailed"), LexUserType::Object(LexObject { description: Some( CowStr::new_static( "Detailed hydrated actor/profile view for profile surfaces, modeled after app.bsky.actor profile view splits.", ), ), required: Some( vec![ SmolStr::new_static("did"), SmolStr::new_static("handle"), SmolStr::new_static("record"), SmolStr::new_static("indexedAt"), SmolStr::new_static("viewer") ], ), properties: { #[allow(unused_mut)] let mut map = BTreeMap::new(); map.insert( SmolStr::new_static("avatar"), LexObjectProperty::String(LexString { description: Some( CowStr::new_static( "Avatar image URL resolved by the app view (CDN).", ), ), format: Some(LexStringFormat::Uri), ..Default::default() }), ); map.insert( SmolStr::new_static("defaultLicense"), LexObjectProperty::String(LexString { ..Default::default() }), ); map.insert( SmolStr::new_static("description"), LexObjectProperty::String(LexString { ..Default::default() }), ); map.insert( SmolStr::new_static("did"), LexObjectProperty::String(LexString { format: Some(LexStringFormat::Did), ..Default::default() }), ); map.insert( SmolStr::new_static("displayName"), LexObjectProperty::String(LexString { ..Default::default() }), ); map.insert( SmolStr::new_static("followerCount"), LexObjectProperty::Integer(LexInteger { ..Default::default() }), ); map.insert( SmolStr::new_static("followingCount"), LexObjectProperty::Integer(LexInteger { ..Default::default() }), ); map.insert( SmolStr::new_static("handle"), LexObjectProperty::String(LexString { format: Some(LexStringFormat::Handle), ..Default::default() }), ); map.insert( SmolStr::new_static("indexedAt"), LexObjectProperty::String(LexString { format: Some(LexStringFormat::Datetime), ..Default::default() }), ); map.insert( SmolStr::new_static("links"), LexObjectProperty::Array(LexArray { items: LexArrayItem::String(LexString { format: Some(LexStringFormat::Uri), ..Default::default() }), ..Default::default() }), ); map.insert( SmolStr::new_static("printers"), LexObjectProperty::Array(LexArray { items: LexArrayItem::String(LexString { ..Default::default() }), ..Default::default() }), ); map.insert( SmolStr::new_static("pronouns"), LexObjectProperty::String(LexString { ..Default::default() }), ); map.insert( SmolStr::new_static("record"), LexObjectProperty::Unknown(LexUnknown { ..Default::default() }), ); map.insert( SmolStr::new_static("thingCount"), LexObjectProperty::Integer(LexInteger { ..Default::default() }), ); map.insert( SmolStr::new_static("viewer"), LexObjectProperty::Ref(LexRef { r#ref: CowStr::new_static("#actorViewerState"), ..Default::default() }), ); map }, ..Default::default() }), ); map.insert( SmolStr::new_static("actorViewerState"), LexUserType::Object(LexObject { description: Some( CowStr::new_static( "Viewer-specific relationship state for an actor/profile.", ), ), properties: { #[allow(unused_mut)] let mut map = BTreeMap::new(); map.insert( SmolStr::new_static("blockedBy"), LexObjectProperty::Boolean(LexBoolean { ..Default::default() }), ); map.insert( SmolStr::new_static("blocking"), LexObjectProperty::String(LexString { description: Some( CowStr::new_static( "Block record URI if the requester blocks this actor.", ), ), format: Some(LexStringFormat::AtUri), ..Default::default() }), ); map.insert( SmolStr::new_static("followedBy"), LexObjectProperty::String(LexString { description: Some( CowStr::new_static( "Follow record URI if this actor follows the requester.", ), ), format: Some(LexStringFormat::AtUri), ..Default::default() }), ); map.insert( SmolStr::new_static("following"), LexObjectProperty::String(LexString { description: Some( CowStr::new_static( "Follow record URI if the requester follows this actor.", ), ), format: Some(LexStringFormat::AtUri), ..Default::default() }), ); map.insert( SmolStr::new_static("muted"), LexObjectProperty::Boolean(LexBoolean { ..Default::default() }), ); map }, ..Default::default() }), ); map.insert( SmolStr::new_static("aspectRatio"), LexUserType::Object(LexObject { description: Some( CowStr::new_static( "Width:height aspect ratio of an image, for layout before the blob loads.", ), ), required: Some( vec![SmolStr::new_static("width"), SmolStr::new_static("height")], ), properties: { #[allow(unused_mut)] let mut map = BTreeMap::new(); map.insert( SmolStr::new_static("height"), LexObjectProperty::Integer(LexInteger { ..Default::default() }), ); map.insert( SmolStr::new_static("width"), LexObjectProperty::Integer(LexInteger { ..Default::default() }), ); map }, ..Default::default() }), ); map.insert( SmolStr::new_static("bbox"), LexUserType::Object(LexObject { description: Some( CowStr::new_static( "Axis-aligned bounding-box dimensions. ATProto has no float type, so x/y/z are decimal strings (e.g. 12.5) parsed to floats internally.", ), ), required: Some( vec![ SmolStr::new_static("x"), SmolStr::new_static("y"), SmolStr::new_static("z") ], ), properties: { #[allow(unused_mut)] let mut map = BTreeMap::new(); map.insert( SmolStr::new_static("unit"), LexObjectProperty::String(LexString { ..Default::default() }), ); map.insert( SmolStr::new_static("x"), LexObjectProperty::String(LexString { ..Default::default() }), ); map.insert( SmolStr::new_static("y"), LexObjectProperty::String(LexString { ..Default::default() }), ); map.insert( SmolStr::new_static("z"), LexObjectProperty::String(LexString { ..Default::default() }), ); map }, ..Default::default() }), ); map.insert( SmolStr::new_static("chunk"), LexUserType::Object(LexObject { required: Some( vec![ SmolStr::new_static("blob"), SmolStr::new_static("offset"), SmolStr::new_static("size") ], ), properties: { #[allow(unused_mut)] let mut map = BTreeMap::new(); map.insert( SmolStr::new_static("blob"), LexObjectProperty::Blob(LexBlob { ..Default::default() }), ); map.insert( SmolStr::new_static("offset"), LexObjectProperty::Integer(LexInteger { minimum: Some(0i64), ..Default::default() }), ); map.insert( SmolStr::new_static("size"), LexObjectProperty::Integer(LexInteger { minimum: Some(0i64), ..Default::default() }), ); map }, ..Default::default() }), ); map.insert( SmolStr::new_static("cover"), LexUserType::Array(LexArray { items: LexArrayItem::Ref(LexRef { r#ref: CowStr::new_static("#image"), ..Default::default() }), max_length: Some(8usize), ..Default::default() }), ); map.insert( SmolStr::new_static("feedItem"), LexUserType::Object(LexObject { required: Some(vec![SmolStr::new_static("thing")]), properties: { #[allow(unused_mut)] let mut map = BTreeMap::new(); map.insert( SmolStr::new_static("thing"), LexObjectProperty::Ref(LexRef { r#ref: CowStr::new_static("#thingViewBasic"), ..Default::default() }), ); map }, ..Default::default() }), ); map.insert( SmolStr::new_static("feedView"), LexUserType::Object(LexObject { required: Some(vec![SmolStr::new_static("items")]), properties: { #[allow(unused_mut)] let mut map = BTreeMap::new(); map.insert( SmolStr::new_static("cursor"), LexObjectProperty::String(LexString { ..Default::default() }), ); map.insert( SmolStr::new_static("items"), LexObjectProperty::Array(LexArray { items: LexArrayItem::Ref(LexRef { r#ref: CowStr::new_static("#feedItem"), ..Default::default() }), ..Default::default() }), ); map }, ..Default::default() }), ); map.insert( SmolStr::new_static("file"), LexUserType::Object(LexObject { description: Some( CowStr::new_static( "Chunk-capable geometry manifest. Reassemble by concatenating chunks in offset order. Per-chunk integrity is the blob CID; offset+size make ordering explicit; digest verifies the fully reassembled file.", ), ), required: Some( vec![ SmolStr::new_static("mimeType"), SmolStr::new_static("size"), SmolStr::new_static("chunks") ], ), properties: { #[allow(unused_mut)] let mut map = BTreeMap::new(); map.insert( SmolStr::new_static("chunks"), LexObjectProperty::Array(LexArray { items: LexArrayItem::Ref(LexRef { r#ref: CowStr::new_static("#chunk"), ..Default::default() }), max_length: Some(4096usize), ..Default::default() }), ); map.insert( SmolStr::new_static("digest"), LexObjectProperty::Bytes(LexBytes { ..Default::default() }), ); map.insert( SmolStr::new_static("mimeType"), LexObjectProperty::String(LexString { ..Default::default() }), ); map.insert( SmolStr::new_static("size"), LexObjectProperty::Integer(LexInteger { ..Default::default() }), ); map }, ..Default::default() }), ); map.insert( SmolStr::new_static("image"), LexUserType::Object(LexObject { description: Some( CowStr::new_static( "An authored image: a blob plus alt text and aspect ratio. Stored on records; the app view resolves it to #imageView.", ), ), required: Some( vec![ SmolStr::new_static("image"), SmolStr::new_static("alt"), SmolStr::new_static("aspectRatio") ], ), properties: { #[allow(unused_mut)] let mut map = BTreeMap::new(); map.insert( SmolStr::new_static("alt"), LexObjectProperty::String(LexString { description: Some( CowStr::new_static( "Alt text describing the image, for accessibility.", ), ), max_length: Some(10000usize), max_graphemes: Some(2000usize), ..Default::default() }), ); map.insert( SmolStr::new_static("aspectRatio"), LexObjectProperty::Ref(LexRef { r#ref: CowStr::new_static("#aspectRatio"), ..Default::default() }), ); map.insert( SmolStr::new_static("image"), LexObjectProperty::Blob(LexBlob { ..Default::default() }), ); map }, ..Default::default() }), ); map.insert( SmolStr::new_static("imageView"), LexUserType::Object(LexObject { description: Some( CowStr::new_static( "A resolved image view: CDN URLs for thumbnail and full size plus aspect ratio. Currently resolved via Bluesky's CDN by the app view.", ), ), required: Some( vec![ SmolStr::new_static("thumb"), SmolStr::new_static("fullsize") ], ), properties: { #[allow(unused_mut)] let mut map = BTreeMap::new(); map.insert( SmolStr::new_static("alt"), LexObjectProperty::String(LexString { ..Default::default() }), ); map.insert( SmolStr::new_static("aspectRatio"), LexObjectProperty::Ref(LexRef { r#ref: CowStr::new_static("#aspectRatio"), ..Default::default() }), ); map.insert( SmolStr::new_static("fullsize"), LexObjectProperty::String(LexString { description: Some( CowStr::new_static( "Fully-qualified full-size URL (CDN, resolved by the app view).", ), ), format: Some(LexStringFormat::Uri), ..Default::default() }), ); map.insert( SmolStr::new_static("thumb"), LexObjectProperty::String(LexString { description: Some( CowStr::new_static( "Fully-qualified thumbnail URL (CDN, resolved by the app view).", ), ), format: Some(LexStringFormat::Uri), ..Default::default() }), ); map }, ..Default::default() }), ); map.insert( SmolStr::new_static("instructions"), LexUserType::Array(LexArray { items: LexArrayItem::String(LexString { ..Default::default() }), max_length: Some(100usize), ..Default::default() }), ); map.insert( SmolStr::new_static("intendedToWorkWith"), LexUserType::Array(LexArray { items: LexArrayItem::Ref(LexRef { r#ref: CowStr::new_static("com.atproto.repo.strongRef"), ..Default::default() }), max_length: Some(32usize), ..Default::default() }), ); map.insert( SmolStr::new_static("modelView"), LexUserType::Object(LexObject { required: Some( vec![ SmolStr::new_static("uri"), SmolStr::new_static("cid"), SmolStr::new_static("author"), SmolStr::new_static("record"), SmolStr::new_static("indexedAt"), SmolStr::new_static("name"), SmolStr::new_static("partCount"), SmolStr::new_static("viewer") ], ), properties: { #[allow(unused_mut)] let mut map = BTreeMap::new(); map.insert( SmolStr::new_static("author"), LexObjectProperty::Ref(LexRef { r#ref: CowStr::new_static("#actor"), ..Default::default() }), ); map.insert( SmolStr::new_static("cid"), LexObjectProperty::String(LexString { format: Some(LexStringFormat::Cid), ..Default::default() }), ); map.insert( SmolStr::new_static("cover"), LexObjectProperty::Array(LexArray { items: LexArrayItem::Ref(LexRef { r#ref: CowStr::new_static("#imageView"), ..Default::default() }), ..Default::default() }), ); map.insert( SmolStr::new_static("indexedAt"), LexObjectProperty::String(LexString { format: Some(LexStringFormat::Datetime), ..Default::default() }), ); map.insert( SmolStr::new_static("name"), LexObjectProperty::String(LexString { ..Default::default() }), ); map.insert( SmolStr::new_static("partCount"), LexObjectProperty::Integer(LexInteger { ..Default::default() }), ); map.insert( SmolStr::new_static("previews"), LexObjectProperty::Array(LexArray { items: LexArrayItem::Ref(LexRef { r#ref: CowStr::new_static("#imageView"), ..Default::default() }), ..Default::default() }), ); map.insert( SmolStr::new_static("record"), LexObjectProperty::Unknown(LexUnknown { ..Default::default() }), ); map.insert( SmolStr::new_static("summary"), LexObjectProperty::String(LexString { ..Default::default() }), ); map.insert( SmolStr::new_static("uri"), LexObjectProperty::String(LexString { format: Some(LexStringFormat::AtUri), ..Default::default() }), ); map.insert( SmolStr::new_static("viewer"), LexObjectProperty::Ref(LexRef { r#ref: CowStr::new_static("#viewerState"), ..Default::default() }), ); map }, ..Default::default() }), ); map.insert( SmolStr::new_static("name"), LexUserType::String(LexString { max_length: Some(1024usize), max_graphemes: Some(256usize), ..Default::default() }), ); map.insert( SmolStr::new_static("partView"), LexUserType::Object(LexObject { required: Some( vec![ SmolStr::new_static("uri"), SmolStr::new_static("cid"), SmolStr::new_static("author"), SmolStr::new_static("record"), SmolStr::new_static("indexedAt"), SmolStr::new_static("name"), SmolStr::new_static("file"), SmolStr::new_static("viewer") ], ), properties: { #[allow(unused_mut)] let mut map = BTreeMap::new(); map.insert( SmolStr::new_static("author"), LexObjectProperty::Ref(LexRef { r#ref: CowStr::new_static("#actor"), ..Default::default() }), ); map.insert( SmolStr::new_static("cid"), LexObjectProperty::String(LexString { format: Some(LexStringFormat::Cid), ..Default::default() }), ); map.insert( SmolStr::new_static("file"), LexObjectProperty::Ref(LexRef { r#ref: CowStr::new_static("#file"), ..Default::default() }), ); map.insert( SmolStr::new_static("format"), LexObjectProperty::String(LexString { ..Default::default() }), ); map.insert( SmolStr::new_static("indexedAt"), LexObjectProperty::String(LexString { format: Some(LexStringFormat::Datetime), ..Default::default() }), ); map.insert( SmolStr::new_static("name"), LexObjectProperty::String(LexString { ..Default::default() }), ); map.insert( SmolStr::new_static("previews"), LexObjectProperty::Array(LexArray { items: LexArrayItem::Ref(LexRef { r#ref: CowStr::new_static("#imageView"), ..Default::default() }), ..Default::default() }), ); map.insert( SmolStr::new_static("record"), LexObjectProperty::Unknown(LexUnknown { ..Default::default() }), ); map.insert( SmolStr::new_static("uri"), LexObjectProperty::String(LexString { format: Some(LexStringFormat::AtUri), ..Default::default() }), ); map.insert( SmolStr::new_static("viewer"), LexObjectProperty::Ref(LexRef { r#ref: CowStr::new_static("#viewerState"), ..Default::default() }), ); map }, ..Default::default() }), ); map.insert( SmolStr::new_static("previews"), LexUserType::Array(LexArray { items: LexArrayItem::Ref(LexRef { r#ref: CowStr::new_static("#image"), ..Default::default() }), max_length: Some(12usize), ..Default::default() }), ); map.insert( SmolStr::new_static("printSettings"), LexUserType::Array(LexArray { items: LexArrayItem::String(LexString { ..Default::default() }), max_length: Some(50usize), ..Default::default() }), ); map.insert( SmolStr::new_static("searchQuery"), LexUserType::String(LexString { max_length: Some(256usize), ..Default::default() }), ); map.insert( SmolStr::new_static("shortText"), LexUserType::String(LexString { max_length: Some(2000usize), max_graphemes: Some(300usize), ..Default::default() }), ); map.insert( SmolStr::new_static("tag"), LexUserType::String(LexString { max_length: Some(1024usize), max_graphemes: Some(256usize), ..Default::default() }), ); map.insert( SmolStr::new_static("tags"), LexUserType::Array(LexArray { items: LexArrayItem::Ref(LexRef { r#ref: CowStr::new_static("#tag"), ..Default::default() }), max_length: Some(16usize), ..Default::default() }), ); map.insert( SmolStr::new_static("thingView"), LexUserType::Object(LexObject { required: Some( vec![ SmolStr::new_static("uri"), SmolStr::new_static("cid"), SmolStr::new_static("author"), SmolStr::new_static("record"), SmolStr::new_static("indexedAt"), SmolStr::new_static("name"), SmolStr::new_static("license"), SmolStr::new_static("likeCount"), SmolStr::new_static("saveCount"), SmolStr::new_static("modelCount"), SmolStr::new_static("partCount"), SmolStr::new_static("viewer") ], ), properties: { #[allow(unused_mut)] let mut map = BTreeMap::new(); map.insert( SmolStr::new_static("author"), LexObjectProperty::Ref(LexRef { r#ref: CowStr::new_static("#actor"), ..Default::default() }), ); map.insert( SmolStr::new_static("cid"), LexObjectProperty::String(LexString { format: Some(LexStringFormat::Cid), ..Default::default() }), ); map.insert( SmolStr::new_static("cover"), LexObjectProperty::Array(LexArray { items: LexArrayItem::Ref(LexRef { r#ref: CowStr::new_static("#imageView"), ..Default::default() }), ..Default::default() }), ); map.insert( SmolStr::new_static("derivedFrom"), LexObjectProperty::Ref(LexRef { r#ref: CowStr::new_static("com.atproto.repo.strongRef"), ..Default::default() }), ); map.insert( SmolStr::new_static("indexedAt"), LexObjectProperty::String(LexString { format: Some(LexStringFormat::Datetime), ..Default::default() }), ); map.insert( SmolStr::new_static("intendedToWorkWith"), LexObjectProperty::Array(LexArray { items: LexArrayItem::Ref(LexRef { r#ref: CowStr::new_static("com.atproto.repo.strongRef"), ..Default::default() }), ..Default::default() }), ); map.insert( SmolStr::new_static("license"), LexObjectProperty::String(LexString { ..Default::default() }), ); map.insert( SmolStr::new_static("likeCount"), LexObjectProperty::Integer(LexInteger { ..Default::default() }), ); map.insert( SmolStr::new_static("modelCount"), LexObjectProperty::Integer(LexInteger { ..Default::default() }), ); map.insert( SmolStr::new_static("name"), LexObjectProperty::String(LexString { ..Default::default() }), ); map.insert( SmolStr::new_static("partCount"), LexObjectProperty::Integer(LexInteger { ..Default::default() }), ); map.insert( SmolStr::new_static("previews"), LexObjectProperty::Array(LexArray { items: LexArrayItem::Ref(LexRef { r#ref: CowStr::new_static("#imageView"), ..Default::default() }), ..Default::default() }), ); map.insert( SmolStr::new_static("record"), LexObjectProperty::Unknown(LexUnknown { ..Default::default() }), ); map.insert( SmolStr::new_static("saveCount"), LexObjectProperty::Integer(LexInteger { ..Default::default() }), ); map.insert( SmolStr::new_static("summary"), LexObjectProperty::String(LexString { ..Default::default() }), ); map.insert( SmolStr::new_static("tags"), LexObjectProperty::Array(LexArray { description: Some( CowStr::new_static( "Hydrated display tags, including appview-aggregated external tag assertions.", ), ), items: LexArrayItem::String(LexString { ..Default::default() }), ..Default::default() }), ); map.insert( SmolStr::new_static("uri"), LexObjectProperty::String(LexString { format: Some(LexStringFormat::AtUri), ..Default::default() }), ); map.insert( SmolStr::new_static("viewer"), LexObjectProperty::Ref(LexRef { r#ref: CowStr::new_static("#viewerState"), ..Default::default() }), ); map }, ..Default::default() }), ); map.insert( SmolStr::new_static("thingViewBasic"), LexUserType::Object(LexObject { required: Some( vec![ SmolStr::new_static("uri"), SmolStr::new_static("cid"), SmolStr::new_static("author"), SmolStr::new_static("name"), SmolStr::new_static("likeCount"), SmolStr::new_static("saveCount"), SmolStr::new_static("modelCount"), SmolStr::new_static("partCount"), SmolStr::new_static("indexedAt"), SmolStr::new_static("viewer") ], ), properties: { #[allow(unused_mut)] let mut map = BTreeMap::new(); map.insert( SmolStr::new_static("author"), LexObjectProperty::Ref(LexRef { r#ref: CowStr::new_static("#actor"), ..Default::default() }), ); map.insert( SmolStr::new_static("cid"), LexObjectProperty::String(LexString { format: Some(LexStringFormat::Cid), ..Default::default() }), ); map.insert( SmolStr::new_static("cover"), LexObjectProperty::Array(LexArray { items: LexArrayItem::Ref(LexRef { r#ref: CowStr::new_static("#imageView"), ..Default::default() }), ..Default::default() }), ); map.insert( SmolStr::new_static("indexedAt"), LexObjectProperty::String(LexString { format: Some(LexStringFormat::Datetime), ..Default::default() }), ); map.insert( SmolStr::new_static("likeCount"), LexObjectProperty::Integer(LexInteger { ..Default::default() }), ); map.insert( SmolStr::new_static("modelCount"), LexObjectProperty::Integer(LexInteger { ..Default::default() }), ); map.insert( SmolStr::new_static("name"), LexObjectProperty::String(LexString { ..Default::default() }), ); map.insert( SmolStr::new_static("partCount"), LexObjectProperty::Integer(LexInteger { ..Default::default() }), ); map.insert( SmolStr::new_static("previews"), LexObjectProperty::Array(LexArray { items: LexArrayItem::Ref(LexRef { r#ref: CowStr::new_static("#imageView"), ..Default::default() }), ..Default::default() }), ); map.insert( SmolStr::new_static("saveCount"), LexObjectProperty::Integer(LexInteger { ..Default::default() }), ); map.insert( SmolStr::new_static("tags"), LexObjectProperty::Array(LexArray { description: Some( CowStr::new_static( "Hydrated display tags for browse/search/profile cards, including appview-aggregated external tag assertions.", ), ), items: LexArrayItem::String(LexString { ..Default::default() }), ..Default::default() }), ); map.insert( SmolStr::new_static("uri"), LexObjectProperty::String(LexString { format: Some(LexStringFormat::AtUri), ..Default::default() }), ); map.insert( SmolStr::new_static("viewer"), LexObjectProperty::Ref(LexRef { r#ref: CowStr::new_static("#viewerState"), ..Default::default() }), ); map }, ..Default::default() }), ); map.insert( SmolStr::new_static("viewerState"), LexUserType::Object(LexObject { properties: { #[allow(unused_mut)] let mut map = BTreeMap::new(); map.insert( SmolStr::new_static("like"), LexObjectProperty::String(LexString { format: Some(LexStringFormat::AtUri), ..Default::default() }), ); map.insert( SmolStr::new_static("save"), LexObjectProperty::String(LexString { format: Some(LexStringFormat::AtUri), ..Default::default() }), ); map }, ..Default::default() }), ); map.insert( SmolStr::new_static("workMeta"), LexUserType::Object(LexObject { description: Some( CowStr::new_static( "Reference-only shared field set; fields are inlined on thing/model.", ), ), properties: { #[allow(unused_mut)] let mut map = BTreeMap::new(); map.insert( SmolStr::new_static("cover"), LexObjectProperty::Array(LexArray { items: LexArrayItem::Ref(LexRef { r#ref: CowStr::new_static("#image"), ..Default::default() }), ..Default::default() }), ); map.insert( SmolStr::new_static("derivedFrom"), LexObjectProperty::Ref(LexRef { r#ref: CowStr::new_static("com.atproto.repo.strongRef"), ..Default::default() }), ); map.insert( SmolStr::new_static("instructions"), LexObjectProperty::Array(LexArray { items: LexArrayItem::String(LexString { ..Default::default() }), ..Default::default() }), ); map.insert( SmolStr::new_static("intendedToWorkWith"), LexObjectProperty::Array(LexArray { items: LexArrayItem::Ref(LexRef { r#ref: CowStr::new_static("com.atproto.repo.strongRef"), ..Default::default() }), ..Default::default() }), ); map.insert( SmolStr::new_static("license"), LexObjectProperty::String(LexString { ..Default::default() }), ); map.insert( SmolStr::new_static("name"), LexObjectProperty::String(LexString { ..Default::default() }), ); map.insert( SmolStr::new_static("previews"), LexObjectProperty::Array(LexArray { items: LexArrayItem::Ref(LexRef { r#ref: CowStr::new_static("#image"), ..Default::default() }), ..Default::default() }), ); map.insert( SmolStr::new_static("summary"), LexObjectProperty::String(LexString { ..Default::default() }), ); map.insert( SmolStr::new_static("tags"), LexObjectProperty::Array(LexArray { items: LexArrayItem::String(LexString { ..Default::default() }), ..Default::default() }), ); map }, ..Default::default() }), ); map }, ..Default::default() }}
pub mod actor_view_detailed_state {
pub use crate::builder_types::{Set, Unset, IsSet, IsUnset}; #[allow(unused)] use ::core::marker::PhantomData; mod sealed { pub trait Sealed {} } /// State trait tracking which required fields have been set pub trait State: sealed::Sealed { type Did; type Handle; type IndexedAt; type Record; type Viewer; } /// Empty state - all required fields are unset pub struct Empty(()); impl sealed::Sealed for Empty {} impl State for Empty { type Did = Unset; type Handle = Unset; type IndexedAt = Unset; type Record = Unset; type Viewer = Unset; } ///State transition - sets the `did` field to Set pub struct SetDid<St: State = Empty>(PhantomData<fn() -> St>); impl<St: State> sealed::Sealed for SetDid<St> {} impl<St: State> State for SetDid<St> { type Did = Set<members::did>; type Handle = St::Handle; type IndexedAt = St::IndexedAt; type Record = St::Record; type Viewer = St::Viewer; } ///State transition - sets the `handle` field to Set pub struct SetHandle<St: State = Empty>(PhantomData<fn() -> St>); impl<St: State> sealed::Sealed for SetHandle<St> {} impl<St: State> State for SetHandle<St> { type Did = St::Did; type Handle = Set<members::handle>; type IndexedAt = St::IndexedAt; type Record = St::Record; type Viewer = St::Viewer; } ///State transition - sets the `indexed_at` field to Set pub struct SetIndexedAt<St: State = Empty>(PhantomData<fn() -> St>); impl<St: State> sealed::Sealed for SetIndexedAt<St> {} impl<St: State> State for SetIndexedAt<St> { type Did = St::Did; type Handle = St::Handle; type IndexedAt = Set<members::indexed_at>; type Record = St::Record; type Viewer = St::Viewer; } ///State transition - sets the `record` field to Set pub struct SetRecord<St: State = Empty>(PhantomData<fn() -> St>); impl<St: State> sealed::Sealed for SetRecord<St> {} impl<St: State> State for SetRecord<St> { type Did = St::Did; type Handle = St::Handle; type IndexedAt = St::IndexedAt; type Record = Set<members::record>; type Viewer = St::Viewer; } ///State transition - sets the `viewer` field to Set pub struct SetViewer<St: State = Empty>(PhantomData<fn() -> St>); impl<St: State> sealed::Sealed for SetViewer<St> {} impl<St: State> State for SetViewer<St> { type Did = St::Did; type Handle = St::Handle; type IndexedAt = St::IndexedAt; type Record = St::Record; type Viewer = Set<members::viewer>; } /// Marker types for field names #[allow(non_camel_case_types)] pub mod members { ///Marker type for the `did` field pub struct did(()); ///Marker type for the `handle` field pub struct handle(()); ///Marker type for the `indexed_at` field pub struct indexed_at(()); ///Marker type for the `record` field pub struct record(()); ///Marker type for the `viewer` field pub struct viewer(()); }}
/// Builder for constructing an instance of this type.pub struct ActorViewDetailedBuilder< St: actor_view_detailed_state::State, S: BosStr = DefaultStr,> { _state: PhantomData<fn() -> St>, _fields: ( Option<UriValue<S>>, Option<S>, Option<S>, Option<Did<S>>, Option<S>, Option<i64>, Option<i64>, Option<Handle<S>>, Option<Datetime>, Option<Vec<UriValue<S>>>, Option<Vec<S>>, Option<S>, Option<Data<S>>, Option<i64>, Option<library::ActorViewerState<S>>, ), _type: PhantomData<fn() -> S>,}
impl ActorViewDetailed<DefaultStr> { /// Create a new builder for this type, using the default string type (DefaultStr = SmolStr) if needed pub fn new() -> ActorViewDetailedBuilder< actor_view_detailed_state::Empty, DefaultStr, > { ActorViewDetailedBuilder::new() }}
impl<S: BosStr> ActorViewDetailed<S> { /// Create a new builder for this type pub fn builder() -> ActorViewDetailedBuilder<actor_view_detailed_state::Empty, S> { ActorViewDetailedBuilder::builder() }}
impl ActorViewDetailedBuilder<actor_view_detailed_state::Empty, DefaultStr> { /// Create a new builder with all fields unset, using the default string type, if needed pub fn new() -> Self { ActorViewDetailedBuilder { _state: PhantomData, _fields: ( None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, ), _type: PhantomData, } }}
impl<S: BosStr> ActorViewDetailedBuilder<actor_view_detailed_state::Empty, S> { /// Create a new builder with all fields unset pub fn builder() -> Self { ActorViewDetailedBuilder { _state: PhantomData, _fields: ( None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, ), _type: PhantomData, } }}
impl<St: actor_view_detailed_state::State, S: BosStr> ActorViewDetailedBuilder<St, S> { /// Set the `avatar` field (optional) pub fn avatar(mut self, value: impl Into<Option<UriValue<S>>>) -> Self { self._fields.0 = value.into(); self } /// Set the `avatar` field to an Option value (optional) pub fn maybe_avatar(mut self, value: Option<UriValue<S>>) -> Self { self._fields.0 = value; self }}
impl<St: actor_view_detailed_state::State, S: BosStr> ActorViewDetailedBuilder<St, S> { /// Set the `defaultLicense` field (optional) pub fn default_license(mut self, value: impl Into<Option<S>>) -> Self { self._fields.1 = value.into(); self } /// Set the `defaultLicense` field to an Option value (optional) pub fn maybe_default_license(mut self, value: Option<S>) -> Self { self._fields.1 = value; self }}
impl<St: actor_view_detailed_state::State, S: BosStr> ActorViewDetailedBuilder<St, S> { /// Set the `description` field (optional) pub fn description(mut self, value: impl Into<Option<S>>) -> Self { self._fields.2 = value.into(); self } /// Set the `description` field to an Option value (optional) pub fn maybe_description(mut self, value: Option<S>) -> Self { self._fields.2 = value; self }}
impl<St, S: BosStr> ActorViewDetailedBuilder<St, S>where St: actor_view_detailed_state::State, St::Did: actor_view_detailed_state::IsUnset,{ /// Set the `did` field (required) pub fn did( mut self, value: impl Into<Did<S>>, ) -> ActorViewDetailedBuilder<actor_view_detailed_state::SetDid<St>, S> { self._fields.3 = Option::Some(value.into()); ActorViewDetailedBuilder { _state: PhantomData, _fields: self._fields, _type: PhantomData, } }}
impl<St: actor_view_detailed_state::State, S: BosStr> ActorViewDetailedBuilder<St, S> { /// Set the `displayName` field (optional) pub fn display_name(mut self, value: impl Into<Option<S>>) -> Self { self._fields.4 = value.into(); self } /// Set the `displayName` field to an Option value (optional) pub fn maybe_display_name(mut self, value: Option<S>) -> Self { self._fields.4 = value; self }}
impl<St: actor_view_detailed_state::State, S: BosStr> ActorViewDetailedBuilder<St, S> { /// Set the `followerCount` field (optional) pub fn follower_count(mut self, value: impl Into<Option<i64>>) -> Self { self._fields.5 = value.into(); self } /// Set the `followerCount` field to an Option value (optional) pub fn maybe_follower_count(mut self, value: Option<i64>) -> Self { self._fields.5 = value; self }}
impl<St: actor_view_detailed_state::State, S: BosStr> ActorViewDetailedBuilder<St, S> { /// Set the `followingCount` field (optional) pub fn following_count(mut self, value: impl Into<Option<i64>>) -> Self { self._fields.6 = value.into(); self } /// Set the `followingCount` field to an Option value (optional) pub fn maybe_following_count(mut self, value: Option<i64>) -> Self { self._fields.6 = value; self }}
impl<St, S: BosStr> ActorViewDetailedBuilder<St, S>where St: actor_view_detailed_state::State, St::Handle: actor_view_detailed_state::IsUnset,{ /// Set the `handle` field (required) pub fn handle( mut self, value: impl Into<Handle<S>>, ) -> ActorViewDetailedBuilder<actor_view_detailed_state::SetHandle<St>, S> { self._fields.7 = Option::Some(value.into()); ActorViewDetailedBuilder { _state: PhantomData, _fields: self._fields, _type: PhantomData, } }}
impl<St, S: BosStr> ActorViewDetailedBuilder<St, S>where St: actor_view_detailed_state::State, St::IndexedAt: actor_view_detailed_state::IsUnset,{ /// Set the `indexedAt` field (required) pub fn indexed_at( mut self, value: impl Into<Datetime>, ) -> ActorViewDetailedBuilder<actor_view_detailed_state::SetIndexedAt<St>, S> { self._fields.8 = Option::Some(value.into()); ActorViewDetailedBuilder { _state: PhantomData, _fields: self._fields, _type: PhantomData, } }}
impl<St: actor_view_detailed_state::State, S: BosStr> ActorViewDetailedBuilder<St, S> { /// Set the `links` field (optional) pub fn links(mut self, value: impl Into<Option<Vec<UriValue<S>>>>) -> Self { self._fields.9 = value.into(); self } /// Set the `links` field to an Option value (optional) pub fn maybe_links(mut self, value: Option<Vec<UriValue<S>>>) -> Self { self._fields.9 = value; self }}
impl<St: actor_view_detailed_state::State, S: BosStr> ActorViewDetailedBuilder<St, S> { /// Set the `printers` field (optional) pub fn printers(mut self, value: impl Into<Option<Vec<S>>>) -> Self { self._fields.10 = value.into(); self } /// Set the `printers` field to an Option value (optional) pub fn maybe_printers(mut self, value: Option<Vec<S>>) -> Self { self._fields.10 = value; self }}
impl<St: actor_view_detailed_state::State, S: BosStr> ActorViewDetailedBuilder<St, S> { /// Set the `pronouns` field (optional) pub fn pronouns(mut self, value: impl Into<Option<S>>) -> Self { self._fields.11 = value.into(); self } /// Set the `pronouns` field to an Option value (optional) pub fn maybe_pronouns(mut self, value: Option<S>) -> Self { self._fields.11 = value; self }}
impl<St, S: BosStr> ActorViewDetailedBuilder<St, S>where St: actor_view_detailed_state::State, St::Record: actor_view_detailed_state::IsUnset,{ /// Set the `record` field (required) pub fn record( mut self, value: impl Into<Data<S>>, ) -> ActorViewDetailedBuilder<actor_view_detailed_state::SetRecord<St>, S> { self._fields.12 = Option::Some(value.into()); ActorViewDetailedBuilder { _state: PhantomData, _fields: self._fields, _type: PhantomData, } }}
impl<St: actor_view_detailed_state::State, S: BosStr> ActorViewDetailedBuilder<St, S> { /// Set the `thingCount` field (optional) pub fn thing_count(mut self, value: impl Into<Option<i64>>) -> Self { self._fields.13 = value.into(); self } /// Set the `thingCount` field to an Option value (optional) pub fn maybe_thing_count(mut self, value: Option<i64>) -> Self { self._fields.13 = value; self }}
impl<St, S: BosStr> ActorViewDetailedBuilder<St, S>where St: actor_view_detailed_state::State, St::Viewer: actor_view_detailed_state::IsUnset,{ /// Set the `viewer` field (required) pub fn viewer( mut self, value: impl Into<library::ActorViewerState<S>>, ) -> ActorViewDetailedBuilder<actor_view_detailed_state::SetViewer<St>, S> { self._fields.14 = Option::Some(value.into()); ActorViewDetailedBuilder { _state: PhantomData, _fields: self._fields, _type: PhantomData, } }}
impl<St, S: BosStr> ActorViewDetailedBuilder<St, S>where St: actor_view_detailed_state::State, St::Did: actor_view_detailed_state::IsSet, St::Handle: actor_view_detailed_state::IsSet, St::IndexedAt: actor_view_detailed_state::IsSet, St::Record: actor_view_detailed_state::IsSet, St::Viewer: actor_view_detailed_state::IsSet,{ /// Build the final struct. pub fn build(self) -> ActorViewDetailed<S> { ActorViewDetailed { avatar: self._fields.0, default_license: self._fields.1, description: self._fields.2, did: self._fields.3.unwrap(), display_name: self._fields.4, follower_count: self._fields.5, following_count: self._fields.6, handle: self._fields.7.unwrap(), indexed_at: self._fields.8.unwrap(), links: self._fields.9, printers: self._fields.10, pronouns: self._fields.11, record: self._fields.12.unwrap(), thing_count: self._fields.13, viewer: self._fields.14.unwrap(), extra_data: Default::default(), } } /// Build the final struct with custom extra_data. pub fn build_with_data( self, extra_data: BTreeMap<SmolStr, Data<S>>, ) -> ActorViewDetailed<S> { ActorViewDetailed { avatar: self._fields.0, default_license: self._fields.1, description: self._fields.2, did: self._fields.3.unwrap(), display_name: self._fields.4, follower_count: self._fields.5, following_count: self._fields.6, handle: self._fields.7.unwrap(), indexed_at: self._fields.8.unwrap(), links: self._fields.9, printers: self._fields.10, pronouns: self._fields.11, record: self._fields.12.unwrap(), thing_count: self._fields.13, viewer: self._fields.14.unwrap(), extra_data: Some(extra_data), } }}
pub mod aspect_ratio_state {
pub use crate::builder_types::{Set, Unset, IsSet, IsUnset}; #[allow(unused)] use ::core::marker::PhantomData; mod sealed { pub trait Sealed {} } /// State trait tracking which required fields have been set pub trait State: sealed::Sealed { type Height; type Width; } /// Empty state - all required fields are unset pub struct Empty(()); impl sealed::Sealed for Empty {} impl State for Empty { type Height = Unset; type Width = Unset; } ///State transition - sets the `height` field to Set pub struct SetHeight<St: State = Empty>(PhantomData<fn() -> St>); impl<St: State> sealed::Sealed for SetHeight<St> {} impl<St: State> State for SetHeight<St> { type Height = Set<members::height>; type Width = St::Width; } ///State transition - sets the `width` field to Set pub struct SetWidth<St: State = Empty>(PhantomData<fn() -> St>); impl<St: State> sealed::Sealed for SetWidth<St> {} impl<St: State> State for SetWidth<St> { type Height = St::Height; type Width = Set<members::width>; } /// Marker types for field names #[allow(non_camel_case_types)] pub mod members { ///Marker type for the `height` field pub struct height(()); ///Marker type for the `width` field pub struct width(()); }}
/// Builder for constructing an instance of this type.pub struct AspectRatioBuilder<St: aspect_ratio_state::State, S: BosStr = DefaultStr> { _state: PhantomData<fn() -> St>, _fields: (Option<i64>, Option<i64>), _type: PhantomData<fn() -> S>,}
impl AspectRatio<DefaultStr> { /// Create a new builder for this type, using the default string type (DefaultStr = SmolStr) if needed pub fn new() -> AspectRatioBuilder<aspect_ratio_state::Empty, DefaultStr> { AspectRatioBuilder::new() }}
impl<S: BosStr> AspectRatio<S> { /// Create a new builder for this type pub fn builder() -> AspectRatioBuilder<aspect_ratio_state::Empty, S> { AspectRatioBuilder::builder() }}
impl AspectRatioBuilder<aspect_ratio_state::Empty, DefaultStr> { /// Create a new builder with all fields unset, using the default string type, if needed pub fn new() -> Self { AspectRatioBuilder { _state: PhantomData, _fields: (None, None), _type: PhantomData, } }}
impl<S: BosStr> AspectRatioBuilder<aspect_ratio_state::Empty, S> { /// Create a new builder with all fields unset pub fn builder() -> Self { AspectRatioBuilder { _state: PhantomData, _fields: (None, None), _type: PhantomData, } }}
impl<St, S: BosStr> AspectRatioBuilder<St, S>where St: aspect_ratio_state::State, St::Height: aspect_ratio_state::IsUnset,{ /// Set the `height` field (required) pub fn height( mut self, value: impl Into<i64>, ) -> AspectRatioBuilder<aspect_ratio_state::SetHeight<St>, S> { self._fields.0 = Option::Some(value.into()); AspectRatioBuilder { _state: PhantomData, _fields: self._fields, _type: PhantomData, } }}
impl<St, S: BosStr> AspectRatioBuilder<St, S>where St: aspect_ratio_state::State, St::Width: aspect_ratio_state::IsUnset,{ /// Set the `width` field (required) pub fn width( mut self, value: impl Into<i64>, ) -> AspectRatioBuilder<aspect_ratio_state::SetWidth<St>, S> { self._fields.1 = Option::Some(value.into()); AspectRatioBuilder { _state: PhantomData, _fields: self._fields, _type: PhantomData, } }}
impl<St, S: BosStr> AspectRatioBuilder<St, S>where St: aspect_ratio_state::State, St::Height: aspect_ratio_state::IsSet, St::Width: aspect_ratio_state::IsSet,{ /// Build the final struct. pub fn build(self) -> AspectRatio<S> { AspectRatio { height: self._fields.0.unwrap(), width: self._fields.1.unwrap(), extra_data: Default::default(), } } /// Build the final struct with custom extra_data. pub fn build_with_data( self, extra_data: BTreeMap<SmolStr, Data<S>>, ) -> AspectRatio<S> { AspectRatio { height: self._fields.0.unwrap(), width: self._fields.1.unwrap(), extra_data: Some(extra_data), } }}
pub mod chunk_state {
pub use crate::builder_types::{Set, Unset, IsSet, IsUnset}; #[allow(unused)] use ::core::marker::PhantomData; mod sealed { pub trait Sealed {} } /// State trait tracking which required fields have been set pub trait State: sealed::Sealed { type Blob; type Offset; type Size; } /// Empty state - all required fields are unset pub struct Empty(()); impl sealed::Sealed for Empty {} impl State for Empty { type Blob = Unset; type Offset = Unset; type Size = Unset; } ///State transition - sets the `blob` field to Set pub struct SetBlob<St: State = Empty>(PhantomData<fn() -> St>); impl<St: State> sealed::Sealed for SetBlob<St> {} impl<St: State> State for SetBlob<St> { type Blob = Set<members::blob>; type Offset = St::Offset; type Size = St::Size; } ///State transition - sets the `offset` field to Set pub struct SetOffset<St: State = Empty>(PhantomData<fn() -> St>); impl<St: State> sealed::Sealed for SetOffset<St> {} impl<St: State> State for SetOffset<St> { type Blob = St::Blob; type Offset = Set<members::offset>; type Size = St::Size; } ///State transition - sets the `size` field to Set pub struct SetSize<St: State = Empty>(PhantomData<fn() -> St>); impl<St: State> sealed::Sealed for SetSize<St> {} impl<St: State> State for SetSize<St> { type Blob = St::Blob; type Offset = St::Offset; type Size = Set<members::size>; } /// Marker types for field names #[allow(non_camel_case_types)] pub mod members { ///Marker type for the `blob` field pub struct blob(()); ///Marker type for the `offset` field pub struct offset(()); ///Marker type for the `size` field pub struct size(()); }}
/// Builder for constructing an instance of this type.pub struct ChunkBuilder<St: chunk_state::State, S: BosStr = DefaultStr> { _state: PhantomData<fn() -> St>, _fields: (Option<BlobRef<S>>, Option<i64>, Option<i64>), _type: PhantomData<fn() -> S>,}
impl Chunk<DefaultStr> { /// Create a new builder for this type, using the default string type (DefaultStr = SmolStr) if needed pub fn new() -> ChunkBuilder<chunk_state::Empty, DefaultStr> { ChunkBuilder::new() }}
impl<S: BosStr> Chunk<S> { /// Create a new builder for this type pub fn builder() -> ChunkBuilder<chunk_state::Empty, S> { ChunkBuilder::builder() }}
impl ChunkBuilder<chunk_state::Empty, DefaultStr> { /// Create a new builder with all fields unset, using the default string type, if needed pub fn new() -> Self { ChunkBuilder { _state: PhantomData, _fields: (None, None, None), _type: PhantomData, } }}
impl<S: BosStr> ChunkBuilder<chunk_state::Empty, S> { /// Create a new builder with all fields unset pub fn builder() -> Self { ChunkBuilder { _state: PhantomData, _fields: (None, None, None), _type: PhantomData, } }}
impl<St, S: BosStr> ChunkBuilder<St, S>where St: chunk_state::State, St::Blob: chunk_state::IsUnset,{ /// Set the `blob` field (required) pub fn blob( mut self, value: impl Into<BlobRef<S>>, ) -> ChunkBuilder<chunk_state::SetBlob<St>, S> { self._fields.0 = Option::Some(value.into()); ChunkBuilder { _state: PhantomData, _fields: self._fields, _type: PhantomData, } }}
impl<St, S: BosStr> ChunkBuilder<St, S>where St: chunk_state::State, St::Offset: chunk_state::IsUnset,{ /// Set the `offset` field (required) pub fn offset( mut self, value: impl Into<i64>, ) -> ChunkBuilder<chunk_state::SetOffset<St>, S> { self._fields.1 = Option::Some(value.into()); ChunkBuilder { _state: PhantomData, _fields: self._fields, _type: PhantomData, } }}
impl<St, S: BosStr> ChunkBuilder<St, S>where St: chunk_state::State, St::Size: chunk_state::IsUnset,{ /// Set the `size` field (required) pub fn size( mut self, value: impl Into<i64>, ) -> ChunkBuilder<chunk_state::SetSize<St>, S> { self._fields.2 = Option::Some(value.into()); ChunkBuilder { _state: PhantomData, _fields: self._fields, _type: PhantomData, } }}
impl<St, S: BosStr> ChunkBuilder<St, S>where St: chunk_state::State, St::Blob: chunk_state::IsSet, St::Offset: chunk_state::IsSet, St::Size: chunk_state::IsSet,{ /// Build the final struct. pub fn build(self) -> Chunk<S> { Chunk { blob: self._fields.0.unwrap(), offset: self._fields.1.unwrap(), size: self._fields.2.unwrap(), extra_data: Default::default(), } } /// Build the final struct with custom extra_data. pub fn build_with_data(self, extra_data: BTreeMap<SmolStr, Data<S>>) -> Chunk<S> { Chunk { blob: self._fields.0.unwrap(), offset: self._fields.1.unwrap(), size: self._fields.2.unwrap(), extra_data: Some(extra_data), } }}
pub mod feed_item_state {
pub use crate::builder_types::{Set, Unset, IsSet, IsUnset}; #[allow(unused)] use ::core::marker::PhantomData; mod sealed { pub trait Sealed {} } /// State trait tracking which required fields have been set pub trait State: sealed::Sealed { type Thing; } /// Empty state - all required fields are unset pub struct Empty(()); impl sealed::Sealed for Empty {} impl State for Empty { type Thing = Unset; } ///State transition - sets the `thing` field to Set pub struct SetThing<St: State = Empty>(PhantomData<fn() -> St>); impl<St: State> sealed::Sealed for SetThing<St> {} impl<St: State> State for SetThing<St> { type Thing = Set<members::thing>; } /// Marker types for field names #[allow(non_camel_case_types)] pub mod members { ///Marker type for the `thing` field pub struct thing(()); }}
/// Builder for constructing an instance of this type.pub struct FeedItemBuilder<St: feed_item_state::State, S: BosStr = DefaultStr> { _state: PhantomData<fn() -> St>, _fields: (Option<library::ThingViewBasic<S>>,), _type: PhantomData<fn() -> S>,}
impl FeedItem<DefaultStr> { /// Create a new builder for this type, using the default string type (DefaultStr = SmolStr) if needed pub fn new() -> FeedItemBuilder<feed_item_state::Empty, DefaultStr> { FeedItemBuilder::new() }}
impl<S: BosStr> FeedItem<S> { /// Create a new builder for this type pub fn builder() -> FeedItemBuilder<feed_item_state::Empty, S> { FeedItemBuilder::builder() }}
impl FeedItemBuilder<feed_item_state::Empty, DefaultStr> { /// Create a new builder with all fields unset, using the default string type, if needed pub fn new() -> Self { FeedItemBuilder { _state: PhantomData, _fields: (None,), _type: PhantomData, } }}
impl<S: BosStr> FeedItemBuilder<feed_item_state::Empty, S> { /// Create a new builder with all fields unset pub fn builder() -> Self { FeedItemBuilder { _state: PhantomData, _fields: (None,), _type: PhantomData, } }}
impl<St, S: BosStr> FeedItemBuilder<St, S>where St: feed_item_state::State, St::Thing: feed_item_state::IsUnset,{ /// Set the `thing` field (required) pub fn thing( mut self, value: impl Into<library::ThingViewBasic<S>>, ) -> FeedItemBuilder<feed_item_state::SetThing<St>, S> { self._fields.0 = Option::Some(value.into()); FeedItemBuilder { _state: PhantomData, _fields: self._fields, _type: PhantomData, } }}
impl<St, S: BosStr> FeedItemBuilder<St, S>where St: feed_item_state::State, St::Thing: feed_item_state::IsSet,{ /// Build the final struct. pub fn build(self) -> FeedItem<S> { FeedItem { thing: self._fields.0.unwrap(), extra_data: Default::default(), } } /// Build the final struct with custom extra_data. pub fn build_with_data(self, extra_data: BTreeMap<SmolStr, Data<S>>) -> FeedItem<S> { FeedItem { thing: self._fields.0.unwrap(), extra_data: Some(extra_data), } }}
pub mod feed_view_state {
pub use crate::builder_types::{Set, Unset, IsSet, IsUnset}; #[allow(unused)] use ::core::marker::PhantomData; mod sealed { pub trait Sealed {} } /// State trait tracking which required fields have been set pub trait State: sealed::Sealed { type Items; } /// Empty state - all required fields are unset pub struct Empty(()); impl sealed::Sealed for Empty {} impl State for Empty { type Items = Unset; } ///State transition - sets the `items` field to Set pub struct SetItems<St: State = Empty>(PhantomData<fn() -> St>); impl<St: State> sealed::Sealed for SetItems<St> {} impl<St: State> State for SetItems<St> { type Items = Set<members::items>; } /// Marker types for field names #[allow(non_camel_case_types)] pub mod members { ///Marker type for the `items` field pub struct items(()); }}
/// Builder for constructing an instance of this type.pub struct FeedViewBuilder<St: feed_view_state::State, S: BosStr = DefaultStr> { _state: PhantomData<fn() -> St>, _fields: (Option<S>, Option<Vec<library::FeedItem<S>>>), _type: PhantomData<fn() -> S>,}
impl FeedView<DefaultStr> { /// Create a new builder for this type, using the default string type (DefaultStr = SmolStr) if needed pub fn new() -> FeedViewBuilder<feed_view_state::Empty, DefaultStr> { FeedViewBuilder::new() }}
impl<S: BosStr> FeedView<S> { /// Create a new builder for this type pub fn builder() -> FeedViewBuilder<feed_view_state::Empty, S> { FeedViewBuilder::builder() }}
impl FeedViewBuilder<feed_view_state::Empty, DefaultStr> { /// Create a new builder with all fields unset, using the default string type, if needed pub fn new() -> Self { FeedViewBuilder { _state: PhantomData, _fields: (None, None), _type: PhantomData, } }}
impl<S: BosStr> FeedViewBuilder<feed_view_state::Empty, S> { /// Create a new builder with all fields unset pub fn builder() -> Self { FeedViewBuilder { _state: PhantomData, _fields: (None, None), _type: PhantomData, } }}
impl<St: feed_view_state::State, S: BosStr> FeedViewBuilder<St, S> { /// Set the `cursor` field (optional) pub fn cursor(mut self, value: impl Into<Option<S>>) -> Self { self._fields.0 = value.into(); self } /// Set the `cursor` field to an Option value (optional) pub fn maybe_cursor(mut self, value: Option<S>) -> Self { self._fields.0 = value; self }}
impl<St, S: BosStr> FeedViewBuilder<St, S>where St: feed_view_state::State, St::Items: feed_view_state::IsUnset,{ /// Set the `items` field (required) pub fn items( mut self, value: impl Into<Vec<library::FeedItem<S>>>, ) -> FeedViewBuilder<feed_view_state::SetItems<St>, S> { self._fields.1 = Option::Some(value.into()); FeedViewBuilder { _state: PhantomData, _fields: self._fields, _type: PhantomData, } }}
impl<St, S: BosStr> FeedViewBuilder<St, S>where St: feed_view_state::State, St::Items: feed_view_state::IsSet,{ /// Build the final struct. pub fn build(self) -> FeedView<S> { FeedView { cursor: self._fields.0, items: self._fields.1.unwrap(), extra_data: Default::default(), } } /// Build the final struct with custom extra_data. pub fn build_with_data(self, extra_data: BTreeMap<SmolStr, Data<S>>) -> FeedView<S> { FeedView { cursor: self._fields.0, items: self._fields.1.unwrap(), extra_data: Some(extra_data), } }}
pub mod file_state {
pub use crate::builder_types::{Set, Unset, IsSet, IsUnset}; #[allow(unused)] use ::core::marker::PhantomData; mod sealed { pub trait Sealed {} } /// State trait tracking which required fields have been set pub trait State: sealed::Sealed { type Chunks; type MimeType; type Size; } /// Empty state - all required fields are unset pub struct Empty(()); impl sealed::Sealed for Empty {} impl State for Empty { type Chunks = Unset; type MimeType = Unset; type Size = Unset; } ///State transition - sets the `chunks` field to Set pub struct SetChunks<St: State = Empty>(PhantomData<fn() -> St>); impl<St: State> sealed::Sealed for SetChunks<St> {} impl<St: State> State for SetChunks<St> { type Chunks = Set<members::chunks>; type MimeType = St::MimeType; type Size = St::Size; } ///State transition - sets the `mime_type` field to Set pub struct SetMimeType<St: State = Empty>(PhantomData<fn() -> St>); impl<St: State> sealed::Sealed for SetMimeType<St> {} impl<St: State> State for SetMimeType<St> { type Chunks = St::Chunks; type MimeType = Set<members::mime_type>; type Size = St::Size; } ///State transition - sets the `size` field to Set pub struct SetSize<St: State = Empty>(PhantomData<fn() -> St>); impl<St: State> sealed::Sealed for SetSize<St> {} impl<St: State> State for SetSize<St> { type Chunks = St::Chunks; type MimeType = St::MimeType; type Size = Set<members::size>; } /// Marker types for field names #[allow(non_camel_case_types)] pub mod members { ///Marker type for the `chunks` field pub struct chunks(()); ///Marker type for the `mime_type` field pub struct mime_type(()); ///Marker type for the `size` field pub struct size(()); }}
/// Builder for constructing an instance of this type.pub struct FileBuilder<St: file_state::State, S: BosStr = DefaultStr> { _state: PhantomData<fn() -> St>, _fields: (Option<Vec<library::Chunk<S>>>, Option<Bytes>, Option<S>, Option<i64>), _type: PhantomData<fn() -> S>,}
impl File<DefaultStr> { /// Create a new builder for this type, using the default string type (DefaultStr = SmolStr) if needed pub fn new() -> FileBuilder<file_state::Empty, DefaultStr> { FileBuilder::new() }}
impl<S: BosStr> File<S> { /// Create a new builder for this type pub fn builder() -> FileBuilder<file_state::Empty, S> { FileBuilder::builder() }}
impl FileBuilder<file_state::Empty, DefaultStr> { /// Create a new builder with all fields unset, using the default string type, if needed pub fn new() -> Self { FileBuilder { _state: PhantomData, _fields: (None, None, None, None), _type: PhantomData, } }}
impl<S: BosStr> FileBuilder<file_state::Empty, S> { /// Create a new builder with all fields unset pub fn builder() -> Self { FileBuilder { _state: PhantomData, _fields: (None, None, None, None), _type: PhantomData, } }}
impl<St, S: BosStr> FileBuilder<St, S>where St: file_state::State, St::Chunks: file_state::IsUnset,{ /// Set the `chunks` field (required) pub fn chunks( mut self, value: impl Into<Vec<library::Chunk<S>>>, ) -> FileBuilder<file_state::SetChunks<St>, S> { self._fields.0 = Option::Some(value.into()); FileBuilder { _state: PhantomData, _fields: self._fields, _type: PhantomData, } }}
impl<St: file_state::State, S: BosStr> FileBuilder<St, S> { /// Set the `digest` field (optional) pub fn digest(mut self, value: impl Into<Option<Bytes>>) -> Self { self._fields.1 = value.into(); self } /// Set the `digest` field to an Option value (optional) pub fn maybe_digest(mut self, value: Option<Bytes>) -> Self { self._fields.1 = value; self }}
impl<St, S: BosStr> FileBuilder<St, S>where St: file_state::State, St::MimeType: file_state::IsUnset,{ /// Set the `mimeType` field (required) pub fn mime_type( mut self, value: impl Into<S>, ) -> FileBuilder<file_state::SetMimeType<St>, S> { self._fields.2 = Option::Some(value.into()); FileBuilder { _state: PhantomData, _fields: self._fields, _type: PhantomData, } }}
impl<St, S: BosStr> FileBuilder<St, S>where St: file_state::State, St::Size: file_state::IsUnset,{ /// Set the `size` field (required) pub fn size( mut self, value: impl Into<i64>, ) -> FileBuilder<file_state::SetSize<St>, S> { self._fields.3 = Option::Some(value.into()); FileBuilder { _state: PhantomData, _fields: self._fields, _type: PhantomData, } }}
impl<St, S: BosStr> FileBuilder<St, S>where St: file_state::State, St::Chunks: file_state::IsSet, St::MimeType: file_state::IsSet, St::Size: file_state::IsSet,{ /// Build the final struct. pub fn build(self) -> File<S> { File { chunks: self._fields.0.unwrap(), digest: self._fields.1, mime_type: self._fields.2.unwrap(), size: self._fields.3.unwrap(), extra_data: Default::default(), } } /// Build the final struct with custom extra_data. pub fn build_with_data(self, extra_data: BTreeMap<SmolStr, Data<S>>) -> File<S> { File { chunks: self._fields.0.unwrap(), digest: self._fields.1, mime_type: self._fields.2.unwrap(), size: self._fields.3.unwrap(), extra_data: Some(extra_data), } }}
pub mod image_state {
pub use crate::builder_types::{Set, Unset, IsSet, IsUnset}; #[allow(unused)] use ::core::marker::PhantomData; mod sealed { pub trait Sealed {} } /// State trait tracking which required fields have been set pub trait State: sealed::Sealed { type Alt; type AspectRatio; type Image; } /// Empty state - all required fields are unset pub struct Empty(()); impl sealed::Sealed for Empty {} impl State for Empty { type Alt = Unset; type AspectRatio = Unset; type Image = Unset; } ///State transition - sets the `alt` field to Set pub struct SetAlt<St: State = Empty>(PhantomData<fn() -> St>); impl<St: State> sealed::Sealed for SetAlt<St> {} impl<St: State> State for SetAlt<St> { type Alt = Set<members::alt>; type AspectRatio = St::AspectRatio; type Image = St::Image; } ///State transition - sets the `aspect_ratio` field to Set pub struct SetAspectRatio<St: State = Empty>(PhantomData<fn() -> St>); impl<St: State> sealed::Sealed for SetAspectRatio<St> {} impl<St: State> State for SetAspectRatio<St> { type Alt = St::Alt; type AspectRatio = Set<members::aspect_ratio>; type Image = St::Image; } ///State transition - sets the `image` field to Set pub struct SetImage<St: State = Empty>(PhantomData<fn() -> St>); impl<St: State> sealed::Sealed for SetImage<St> {} impl<St: State> State for SetImage<St> { type Alt = St::Alt; type AspectRatio = St::AspectRatio; type Image = Set<members::image>; } /// Marker types for field names #[allow(non_camel_case_types)] pub mod members { ///Marker type for the `alt` field pub struct alt(()); ///Marker type for the `aspect_ratio` field pub struct aspect_ratio(()); ///Marker type for the `image` field pub struct image(()); }}
/// Builder for constructing an instance of this type.pub struct ImageBuilder<St: image_state::State, S: BosStr = DefaultStr> { _state: PhantomData<fn() -> St>, _fields: (Option<S>, Option<library::AspectRatio<S>>, Option<BlobRef<S>>), _type: PhantomData<fn() -> S>,}
impl Image<DefaultStr> { /// Create a new builder for this type, using the default string type (DefaultStr = SmolStr) if needed pub fn new() -> ImageBuilder<image_state::Empty, DefaultStr> { ImageBuilder::new() }}
impl<S: BosStr> Image<S> { /// Create a new builder for this type pub fn builder() -> ImageBuilder<image_state::Empty, S> { ImageBuilder::builder() }}
impl ImageBuilder<image_state::Empty, DefaultStr> { /// Create a new builder with all fields unset, using the default string type, if needed pub fn new() -> Self { ImageBuilder { _state: PhantomData, _fields: (None, None, None), _type: PhantomData, } }}
impl<S: BosStr> ImageBuilder<image_state::Empty, S> { /// Create a new builder with all fields unset pub fn builder() -> Self { ImageBuilder { _state: PhantomData, _fields: (None, None, None), _type: PhantomData, } }}
impl<St, S: BosStr> ImageBuilder<St, S>where St: image_state::State, St::Alt: image_state::IsUnset,{ /// Set the `alt` field (required) pub fn alt( mut self, value: impl Into<S>, ) -> ImageBuilder<image_state::SetAlt<St>, S> { self._fields.0 = Option::Some(value.into()); ImageBuilder { _state: PhantomData, _fields: self._fields, _type: PhantomData, } }}
impl<St, S: BosStr> ImageBuilder<St, S>where St: image_state::State, St::AspectRatio: image_state::IsUnset,{ /// Set the `aspectRatio` field (required) pub fn aspect_ratio( mut self, value: impl Into<library::AspectRatio<S>>, ) -> ImageBuilder<image_state::SetAspectRatio<St>, S> { self._fields.1 = Option::Some(value.into()); ImageBuilder { _state: PhantomData, _fields: self._fields, _type: PhantomData, } }}
impl<St, S: BosStr> ImageBuilder<St, S>where St: image_state::State, St::Image: image_state::IsUnset,{ /// Set the `image` field (required) pub fn image( mut self, value: impl Into<BlobRef<S>>, ) -> ImageBuilder<image_state::SetImage<St>, S> { self._fields.2 = Option::Some(value.into()); ImageBuilder { _state: PhantomData, _fields: self._fields, _type: PhantomData, } }}
impl<St, S: BosStr> ImageBuilder<St, S>where St: image_state::State, St::Alt: image_state::IsSet, St::AspectRatio: image_state::IsSet, St::Image: image_state::IsSet,{ /// Build the final struct. pub fn build(self) -> Image<S> { Image { alt: self._fields.0.unwrap(), aspect_ratio: self._fields.1.unwrap(), image: self._fields.2.unwrap(), extra_data: Default::default(), } } /// Build the final struct with custom extra_data. pub fn build_with_data(self, extra_data: BTreeMap<SmolStr, Data<S>>) -> Image<S> { Image { alt: self._fields.0.unwrap(), aspect_ratio: self._fields.1.unwrap(), image: self._fields.2.unwrap(), extra_data: Some(extra_data), } }}
pub mod image_view_state {
pub use crate::builder_types::{Set, Unset, IsSet, IsUnset}; #[allow(unused)] use ::core::marker::PhantomData; mod sealed { pub trait Sealed {} } /// State trait tracking which required fields have been set pub trait State: sealed::Sealed { type Fullsize; type Thumb; } /// Empty state - all required fields are unset pub struct Empty(()); impl sealed::Sealed for Empty {} impl State for Empty { type Fullsize = Unset; type Thumb = Unset; } ///State transition - sets the `fullsize` field to Set pub struct SetFullsize<St: State = Empty>(PhantomData<fn() -> St>); impl<St: State> sealed::Sealed for SetFullsize<St> {} impl<St: State> State for SetFullsize<St> { type Fullsize = Set<members::fullsize>; type Thumb = St::Thumb; } ///State transition - sets the `thumb` field to Set pub struct SetThumb<St: State = Empty>(PhantomData<fn() -> St>); impl<St: State> sealed::Sealed for SetThumb<St> {} impl<St: State> State for SetThumb<St> { type Fullsize = St::Fullsize; type Thumb = Set<members::thumb>; } /// Marker types for field names #[allow(non_camel_case_types)] pub mod members { ///Marker type for the `fullsize` field pub struct fullsize(()); ///Marker type for the `thumb` field pub struct thumb(()); }}
/// Builder for constructing an instance of this type.pub struct ImageViewBuilder<St: image_view_state::State, S: BosStr = DefaultStr> { _state: PhantomData<fn() -> St>, _fields: ( Option<S>, Option<library::AspectRatio<S>>, Option<UriValue<S>>, Option<UriValue<S>>, ), _type: PhantomData<fn() -> S>,}
impl ImageView<DefaultStr> { /// Create a new builder for this type, using the default string type (DefaultStr = SmolStr) if needed pub fn new() -> ImageViewBuilder<image_view_state::Empty, DefaultStr> { ImageViewBuilder::new() }}
impl<S: BosStr> ImageView<S> { /// Create a new builder for this type pub fn builder() -> ImageViewBuilder<image_view_state::Empty, S> { ImageViewBuilder::builder() }}
impl ImageViewBuilder<image_view_state::Empty, DefaultStr> { /// Create a new builder with all fields unset, using the default string type, if needed pub fn new() -> Self { ImageViewBuilder { _state: PhantomData, _fields: (None, None, None, None), _type: PhantomData, } }}
impl<S: BosStr> ImageViewBuilder<image_view_state::Empty, S> { /// Create a new builder with all fields unset pub fn builder() -> Self { ImageViewBuilder { _state: PhantomData, _fields: (None, None, None, None), _type: PhantomData, } }}
impl<St: image_view_state::State, S: BosStr> ImageViewBuilder<St, S> { /// Set the `alt` field (optional) pub fn alt(mut self, value: impl Into<Option<S>>) -> Self { self._fields.0 = value.into(); self } /// Set the `alt` field to an Option value (optional) pub fn maybe_alt(mut self, value: Option<S>) -> Self { self._fields.0 = value; self }}
impl<St: image_view_state::State, S: BosStr> ImageViewBuilder<St, S> { /// Set the `aspectRatio` field (optional) pub fn aspect_ratio( mut self, value: impl Into<Option<library::AspectRatio<S>>>, ) -> Self { self._fields.1 = value.into(); self } /// Set the `aspectRatio` field to an Option value (optional) pub fn maybe_aspect_ratio(mut self, value: Option<library::AspectRatio<S>>) -> Self { self._fields.1 = value; self }}
impl<St, S: BosStr> ImageViewBuilder<St, S>where St: image_view_state::State, St::Fullsize: image_view_state::IsUnset,{ /// Set the `fullsize` field (required) pub fn fullsize( mut self, value: impl Into<UriValue<S>>, ) -> ImageViewBuilder<image_view_state::SetFullsize<St>, S> { self._fields.2 = Option::Some(value.into()); ImageViewBuilder { _state: PhantomData, _fields: self._fields, _type: PhantomData, } }}
impl<St, S: BosStr> ImageViewBuilder<St, S>where St: image_view_state::State, St::Thumb: image_view_state::IsUnset,{ /// Set the `thumb` field (required) pub fn thumb( mut self, value: impl Into<UriValue<S>>, ) -> ImageViewBuilder<image_view_state::SetThumb<St>, S> { self._fields.3 = Option::Some(value.into()); ImageViewBuilder { _state: PhantomData, _fields: self._fields, _type: PhantomData, } }}
impl<St, S: BosStr> ImageViewBuilder<St, S>where St: image_view_state::State, St::Fullsize: image_view_state::IsSet, St::Thumb: image_view_state::IsSet,{ /// Build the final struct. pub fn build(self) -> ImageView<S> { ImageView { alt: self._fields.0, aspect_ratio: self._fields.1, fullsize: self._fields.2.unwrap(), thumb: self._fields.3.unwrap(), extra_data: Default::default(), } } /// Build the final struct with custom extra_data. pub fn build_with_data( self, extra_data: BTreeMap<SmolStr, Data<S>>, ) -> ImageView<S> { ImageView { alt: self._fields.0, aspect_ratio: self._fields.1, fullsize: self._fields.2.unwrap(), thumb: self._fields.3.unwrap(), extra_data: Some(extra_data), } }}
pub mod model_view_state {
pub use crate::builder_types::{Set, Unset, IsSet, IsUnset}; #[allow(unused)] use ::core::marker::PhantomData; mod sealed { pub trait Sealed {} } /// State trait tracking which required fields have been set pub trait State: sealed::Sealed { type Author; type Cid; type IndexedAt; type Name; type PartCount; type Record; type Uri; type Viewer; } /// Empty state - all required fields are unset pub struct Empty(()); impl sealed::Sealed for Empty {} impl State for Empty { type Author = Unset; type Cid = Unset; type IndexedAt = Unset; type Name = Unset; type PartCount = Unset; type Record = Unset; type Uri = Unset; type Viewer = Unset; } ///State transition - sets the `author` field to Set pub struct SetAuthor<St: State = Empty>(PhantomData<fn() -> St>); impl<St: State> sealed::Sealed for SetAuthor<St> {} impl<St: State> State for SetAuthor<St> { type Author = Set<members::author>; type Cid = St::Cid; type IndexedAt = St::IndexedAt; type Name = St::Name; type PartCount = St::PartCount; type Record = St::Record; type Uri = St::Uri; type Viewer = St::Viewer; } ///State transition - sets the `cid` field to Set pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>); impl<St: State> sealed::Sealed for SetCid<St> {} impl<St: State> State for SetCid<St> { type Author = St::Author; type Cid = Set<members::cid>; type IndexedAt = St::IndexedAt; type Name = St::Name; type PartCount = St::PartCount; type Record = St::Record; type Uri = St::Uri; type Viewer = St::Viewer; } ///State transition - sets the `indexed_at` field to Set pub struct SetIndexedAt<St: State = Empty>(PhantomData<fn() -> St>); impl<St: State> sealed::Sealed for SetIndexedAt<St> {} impl<St: State> State for SetIndexedAt<St> { type Author = St::Author; type Cid = St::Cid; type IndexedAt = Set<members::indexed_at>; type Name = St::Name; type PartCount = St::PartCount; type Record = St::Record; type Uri = St::Uri; type Viewer = St::Viewer; } ///State transition - sets the `name` field to Set pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>); impl<St: State> sealed::Sealed for SetName<St> {} impl<St: State> State for SetName<St> { type Author = St::Author; type Cid = St::Cid; type IndexedAt = St::IndexedAt; type Name = Set<members::name>; type PartCount = St::PartCount; type Record = St::Record; type Uri = St::Uri; type Viewer = St::Viewer; } ///State transition - sets the `part_count` field to Set pub struct SetPartCount<St: State = Empty>(PhantomData<fn() -> St>); impl<St: State> sealed::Sealed for SetPartCount<St> {} impl<St: State> State for SetPartCount<St> { type Author = St::Author; type Cid = St::Cid; type IndexedAt = St::IndexedAt; type Name = St::Name; type PartCount = Set<members::part_count>; type Record = St::Record; type Uri = St::Uri; type Viewer = St::Viewer; } ///State transition - sets the `record` field to Set pub struct SetRecord<St: State = Empty>(PhantomData<fn() -> St>); impl<St: State> sealed::Sealed for SetRecord<St> {} impl<St: State> State for SetRecord<St> { type Author = St::Author; type Cid = St::Cid; type IndexedAt = St::IndexedAt; type Name = St::Name; type PartCount = St::PartCount; type Record = Set<members::record>; type Uri = St::Uri; type Viewer = St::Viewer; } ///State transition - sets the `uri` field to Set pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>); impl<St: State> sealed::Sealed for SetUri<St> {} impl<St: State> State for SetUri<St> { type Author = St::Author; type Cid = St::Cid; type IndexedAt = St::IndexedAt; type Name = St::Name; type PartCount = St::PartCount; type Record = St::Record; type Uri = Set<members::uri>; type Viewer = St::Viewer; } ///State transition - sets the `viewer` field to Set pub struct SetViewer<St: State = Empty>(PhantomData<fn() -> St>); impl<St: State> sealed::Sealed for SetViewer<St> {} impl<St: State> State for SetViewer<St> { type Author = St::Author; type Cid = St::Cid; type IndexedAt = St::IndexedAt; type Name = St::Name; type PartCount = St::PartCount; type Record = St::Record; type Uri = St::Uri; type Viewer = Set<members::viewer>; } /// Marker types for field names #[allow(non_camel_case_types)] pub mod members { ///Marker type for the `author` field pub struct author(()); ///Marker type for the `cid` field pub struct cid(()); ///Marker type for the `indexed_at` field pub struct indexed_at(()); ///Marker type for the `name` field pub struct name(()); ///Marker type for the `part_count` field pub struct part_count(()); ///Marker type for the `record` field pub struct record(()); ///Marker type for the `uri` field pub struct uri(()); ///Marker type for the `viewer` field pub struct viewer(()); }}
/// Builder for constructing an instance of this type.pub struct ModelViewBuilder<St: model_view_state::State, S: BosStr = DefaultStr> { _state: PhantomData<fn() -> St>, _fields: ( Option<library::Actor<S>>, Option<Cid<S>>, Option<Vec<library::ImageView<S>>>, Option<Datetime>, Option<S>, Option<i64>, Option<Vec<library::ImageView<S>>>, Option<Data<S>>, Option<S>, Option<AtUri<S>>, Option<library::ViewerState<S>>, ), _type: PhantomData<fn() -> S>,}
impl ModelView<DefaultStr> { /// Create a new builder for this type, using the default string type (DefaultStr = SmolStr) if needed pub fn new() -> ModelViewBuilder<model_view_state::Empty, DefaultStr> { ModelViewBuilder::new() }}
impl<S: BosStr> ModelView<S> { /// Create a new builder for this type pub fn builder() -> ModelViewBuilder<model_view_state::Empty, S> { ModelViewBuilder::builder() }}
impl ModelViewBuilder<model_view_state::Empty, DefaultStr> { /// Create a new builder with all fields unset, using the default string type, if needed pub fn new() -> Self { ModelViewBuilder { _state: PhantomData, _fields: (None, None, None, None, None, None, None, None, None, None, None), _type: PhantomData, } }}
impl<S: BosStr> ModelViewBuilder<model_view_state::Empty, S> { /// Create a new builder with all fields unset pub fn builder() -> Self { ModelViewBuilder { _state: PhantomData, _fields: (None, None, None, None, None, None, None, None, None, None, None), _type: PhantomData, } }}
impl<St, S: BosStr> ModelViewBuilder<St, S>where St: model_view_state::State, St::Author: model_view_state::IsUnset,{ /// Set the `author` field (required) pub fn author( mut self, value: impl Into<library::Actor<S>>, ) -> ModelViewBuilder<model_view_state::SetAuthor<St>, S> { self._fields.0 = Option::Some(value.into()); ModelViewBuilder { _state: PhantomData, _fields: self._fields, _type: PhantomData, } }}
impl<St, S: BosStr> ModelViewBuilder<St, S>where St: model_view_state::State, St::Cid: model_view_state::IsUnset,{ /// Set the `cid` field (required) pub fn cid( mut self, value: impl Into<Cid<S>>, ) -> ModelViewBuilder<model_view_state::SetCid<St>, S> { self._fields.1 = Option::Some(value.into()); ModelViewBuilder { _state: PhantomData, _fields: self._fields, _type: PhantomData, } }}
impl<St: model_view_state::State, S: BosStr> ModelViewBuilder<St, S> { /// Set the `cover` field (optional) pub fn cover( mut self, value: impl Into<Option<Vec<library::ImageView<S>>>>, ) -> Self { self._fields.2 = value.into(); self } /// Set the `cover` field to an Option value (optional) pub fn maybe_cover(mut self, value: Option<Vec<library::ImageView<S>>>) -> Self { self._fields.2 = value; self }}
impl<St, S: BosStr> ModelViewBuilder<St, S>where St: model_view_state::State, St::IndexedAt: model_view_state::IsUnset,{ /// Set the `indexedAt` field (required) pub fn indexed_at( mut self, value: impl Into<Datetime>, ) -> ModelViewBuilder<model_view_state::SetIndexedAt<St>, S> { self._fields.3 = Option::Some(value.into()); ModelViewBuilder { _state: PhantomData, _fields: self._fields, _type: PhantomData, } }}
impl<St, S: BosStr> ModelViewBuilder<St, S>where St: model_view_state::State, St::Name: model_view_state::IsUnset,{ /// Set the `name` field (required) pub fn name( mut self, value: impl Into<S>, ) -> ModelViewBuilder<model_view_state::SetName<St>, S> { self._fields.4 = Option::Some(value.into()); ModelViewBuilder { _state: PhantomData, _fields: self._fields, _type: PhantomData, } }}
impl<St, S: BosStr> ModelViewBuilder<St, S>where St: model_view_state::State, St::PartCount: model_view_state::IsUnset,{ /// Set the `partCount` field (required) pub fn part_count( mut self, value: impl Into<i64>, ) -> ModelViewBuilder<model_view_state::SetPartCount<St>, S> { self._fields.5 = Option::Some(value.into()); ModelViewBuilder { _state: PhantomData, _fields: self._fields, _type: PhantomData, } }}
impl<St: model_view_state::State, S: BosStr> ModelViewBuilder<St, S> { /// Set the `previews` field (optional) pub fn previews( mut self, value: impl Into<Option<Vec<library::ImageView<S>>>>, ) -> Self { self._fields.6 = value.into(); self } /// Set the `previews` field to an Option value (optional) pub fn maybe_previews(mut self, value: Option<Vec<library::ImageView<S>>>) -> Self { self._fields.6 = value; self }}
impl<St, S: BosStr> ModelViewBuilder<St, S>where St: model_view_state::State, St::Record: model_view_state::IsUnset,{ /// Set the `record` field (required) pub fn record( mut self, value: impl Into<Data<S>>, ) -> ModelViewBuilder<model_view_state::SetRecord<St>, S> { self._fields.7 = Option::Some(value.into()); ModelViewBuilder { _state: PhantomData, _fields: self._fields, _type: PhantomData, } }}
impl<St: model_view_state::State, S: BosStr> ModelViewBuilder<St, S> { /// Set the `summary` field (optional) pub fn summary(mut self, value: impl Into<Option<S>>) -> Self { self._fields.8 = value.into(); self } /// Set the `summary` field to an Option value (optional) pub fn maybe_summary(mut self, value: Option<S>) -> Self { self._fields.8 = value; self }}
impl<St, S: BosStr> ModelViewBuilder<St, S>where St: model_view_state::State, St::Uri: model_view_state::IsUnset,{ /// Set the `uri` field (required) pub fn uri( mut self, value: impl Into<AtUri<S>>, ) -> ModelViewBuilder<model_view_state::SetUri<St>, S> { self._fields.9 = Option::Some(value.into()); ModelViewBuilder { _state: PhantomData, _fields: self._fields, _type: PhantomData, } }}
impl<St, S: BosStr> ModelViewBuilder<St, S>where St: model_view_state::State, St::Viewer: model_view_state::IsUnset,{ /// Set the `viewer` field (required) pub fn viewer( mut self, value: impl Into<library::ViewerState<S>>, ) -> ModelViewBuilder<model_view_state::SetViewer<St>, S> { self._fields.10 = Option::Some(value.into()); ModelViewBuilder { _state: PhantomData, _fields: self._fields, _type: PhantomData, } }}
impl<St, S: BosStr> ModelViewBuilder<St, S>where St: model_view_state::State, St::Author: model_view_state::IsSet, St::Cid: model_view_state::IsSet, St::IndexedAt: model_view_state::IsSet, St::Name: model_view_state::IsSet, St::PartCount: model_view_state::IsSet, St::Record: model_view_state::IsSet, St::Uri: model_view_state::IsSet, St::Viewer: model_view_state::IsSet,{ /// Build the final struct. pub fn build(self) -> ModelView<S> { ModelView { author: self._fields.0.unwrap(), cid: self._fields.1.unwrap(), cover: self._fields.2, indexed_at: self._fields.3.unwrap(), name: self._fields.4.unwrap(), part_count: self._fields.5.unwrap(), previews: self._fields.6, record: self._fields.7.unwrap(), summary: self._fields.8, uri: self._fields.9.unwrap(), viewer: self._fields.10.unwrap(), extra_data: Default::default(), } } /// Build the final struct with custom extra_data. pub fn build_with_data( self, extra_data: BTreeMap<SmolStr, Data<S>>, ) -> ModelView<S> { ModelView { author: self._fields.0.unwrap(), cid: self._fields.1.unwrap(), cover: self._fields.2, indexed_at: self._fields.3.unwrap(), name: self._fields.4.unwrap(), part_count: self._fields.5.unwrap(), previews: self._fields.6, record: self._fields.7.unwrap(), summary: self._fields.8, uri: self._fields.9.unwrap(), viewer: self._fields.10.unwrap(), extra_data: Some(extra_data), } }}
pub mod part_view_state {
pub use crate::builder_types::{Set, Unset, IsSet, IsUnset}; #[allow(unused)] use ::core::marker::PhantomData; mod sealed { pub trait Sealed {} } /// State trait tracking which required fields have been set pub trait State: sealed::Sealed { type Author; type Cid; type File; type IndexedAt; type Name; type Record; type Uri; type Viewer; } /// Empty state - all required fields are unset pub struct Empty(()); impl sealed::Sealed for Empty {} impl State for Empty { type Author = Unset; type Cid = Unset; type File = Unset; type IndexedAt = Unset; type Name = Unset; type Record = Unset; type Uri = Unset; type Viewer = Unset; } ///State transition - sets the `author` field to Set pub struct SetAuthor<St: State = Empty>(PhantomData<fn() -> St>); impl<St: State> sealed::Sealed for SetAuthor<St> {} impl<St: State> State for SetAuthor<St> { type Author = Set<members::author>; type Cid = St::Cid; type File = St::File; type IndexedAt = St::IndexedAt; type Name = St::Name; type Record = St::Record; type Uri = St::Uri; type Viewer = St::Viewer; } ///State transition - sets the `cid` field to Set pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>); impl<St: State> sealed::Sealed for SetCid<St> {} impl<St: State> State for SetCid<St> { type Author = St::Author; type Cid = Set<members::cid>; type File = St::File; type IndexedAt = St::IndexedAt; type Name = St::Name; type Record = St::Record; type Uri = St::Uri; type Viewer = St::Viewer; } ///State transition - sets the `file` field to Set pub struct SetFile<St: State = Empty>(PhantomData<fn() -> St>); impl<St: State> sealed::Sealed for SetFile<St> {} impl<St: State> State for SetFile<St> { type Author = St::Author; type Cid = St::Cid; type File = Set<members::file>; type IndexedAt = St::IndexedAt; type Name = St::Name; type Record = St::Record; type Uri = St::Uri; type Viewer = St::Viewer; } ///State transition - sets the `indexed_at` field to Set pub struct SetIndexedAt<St: State = Empty>(PhantomData<fn() -> St>); impl<St: State> sealed::Sealed for SetIndexedAt<St> {} impl<St: State> State for SetIndexedAt<St> { type Author = St::Author; type Cid = St::Cid; type File = St::File; type IndexedAt = Set<members::indexed_at>; type Name = St::Name; type Record = St::Record; type Uri = St::Uri; type Viewer = St::Viewer; } ///State transition - sets the `name` field to Set pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>); impl<St: State> sealed::Sealed for SetName<St> {} impl<St: State> State for SetName<St> { type Author = St::Author; type Cid = St::Cid; type File = St::File; type IndexedAt = St::IndexedAt; type Name = Set<members::name>; type Record = St::Record; type Uri = St::Uri; type Viewer = St::Viewer; } ///State transition - sets the `record` field to Set pub struct SetRecord<St: State = Empty>(PhantomData<fn() -> St>); impl<St: State> sealed::Sealed for SetRecord<St> {} impl<St: State> State for SetRecord<St> { type Author = St::Author; type Cid = St::Cid; type File = St::File; type IndexedAt = St::IndexedAt; type Name = St::Name; type Record = Set<members::record>; type Uri = St::Uri; type Viewer = St::Viewer; } ///State transition - sets the `uri` field to Set pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>); impl<St: State> sealed::Sealed for SetUri<St> {} impl<St: State> State for SetUri<St> { type Author = St::Author; type Cid = St::Cid; type File = St::File; type IndexedAt = St::IndexedAt; type Name = St::Name; type Record = St::Record; type Uri = Set<members::uri>; type Viewer = St::Viewer; } ///State transition - sets the `viewer` field to Set pub struct SetViewer<St: State = Empty>(PhantomData<fn() -> St>); impl<St: State> sealed::Sealed for SetViewer<St> {} impl<St: State> State for SetViewer<St> { type Author = St::Author; type Cid = St::Cid; type File = St::File; type IndexedAt = St::IndexedAt; type Name = St::Name; type Record = St::Record; type Uri = St::Uri; type Viewer = Set<members::viewer>; } /// Marker types for field names #[allow(non_camel_case_types)] pub mod members { ///Marker type for the `author` field pub struct author(()); ///Marker type for the `cid` field pub struct cid(()); ///Marker type for the `file` field pub struct file(()); ///Marker type for the `indexed_at` field pub struct indexed_at(()); ///Marker type for the `name` field pub struct name(()); ///Marker type for the `record` field pub struct record(()); ///Marker type for the `uri` field pub struct uri(()); ///Marker type for the `viewer` field pub struct viewer(()); }}
/// Builder for constructing an instance of this type.pub struct PartViewBuilder<St: part_view_state::State, S: BosStr = DefaultStr> { _state: PhantomData<fn() -> St>, _fields: ( Option<library::Actor<S>>, Option<Cid<S>>, Option<library::File<S>>, Option<S>, Option<Datetime>, Option<S>, Option<Vec<library::ImageView<S>>>, Option<Data<S>>, Option<AtUri<S>>, Option<library::ViewerState<S>>, ), _type: PhantomData<fn() -> S>,}
impl PartView<DefaultStr> { /// Create a new builder for this type, using the default string type (DefaultStr = SmolStr) if needed pub fn new() -> PartViewBuilder<part_view_state::Empty, DefaultStr> { PartViewBuilder::new() }}
impl<S: BosStr> PartView<S> { /// Create a new builder for this type pub fn builder() -> PartViewBuilder<part_view_state::Empty, S> { PartViewBuilder::builder() }}
impl PartViewBuilder<part_view_state::Empty, DefaultStr> { /// Create a new builder with all fields unset, using the default string type, if needed pub fn new() -> Self { PartViewBuilder { _state: PhantomData, _fields: (None, None, None, None, None, None, None, None, None, None), _type: PhantomData, } }}
impl<S: BosStr> PartViewBuilder<part_view_state::Empty, S> { /// Create a new builder with all fields unset pub fn builder() -> Self { PartViewBuilder { _state: PhantomData, _fields: (None, None, None, None, None, None, None, None, None, None), _type: PhantomData, } }}
impl<St, S: BosStr> PartViewBuilder<St, S>where St: part_view_state::State, St::Author: part_view_state::IsUnset,{ /// Set the `author` field (required) pub fn author( mut self, value: impl Into<library::Actor<S>>, ) -> PartViewBuilder<part_view_state::SetAuthor<St>, S> { self._fields.0 = Option::Some(value.into()); PartViewBuilder { _state: PhantomData, _fields: self._fields, _type: PhantomData, } }}
impl<St, S: BosStr> PartViewBuilder<St, S>where St: part_view_state::State, St::Cid: part_view_state::IsUnset,{ /// Set the `cid` field (required) pub fn cid( mut self, value: impl Into<Cid<S>>, ) -> PartViewBuilder<part_view_state::SetCid<St>, S> { self._fields.1 = Option::Some(value.into()); PartViewBuilder { _state: PhantomData, _fields: self._fields, _type: PhantomData, } }}
impl<St, S: BosStr> PartViewBuilder<St, S>where St: part_view_state::State, St::File: part_view_state::IsUnset,{ /// Set the `file` field (required) pub fn file( mut self, value: impl Into<library::File<S>>, ) -> PartViewBuilder<part_view_state::SetFile<St>, S> { self._fields.2 = Option::Some(value.into()); PartViewBuilder { _state: PhantomData, _fields: self._fields, _type: PhantomData, } }}
impl<St: part_view_state::State, S: BosStr> PartViewBuilder<St, S> { /// Set the `format` field (optional) pub fn format(mut self, value: impl Into<Option<S>>) -> Self { self._fields.3 = value.into(); self } /// Set the `format` field to an Option value (optional) pub fn maybe_format(mut self, value: Option<S>) -> Self { self._fields.3 = value; self }}
impl<St, S: BosStr> PartViewBuilder<St, S>where St: part_view_state::State, St::IndexedAt: part_view_state::IsUnset,{ /// Set the `indexedAt` field (required) pub fn indexed_at( mut self, value: impl Into<Datetime>, ) -> PartViewBuilder<part_view_state::SetIndexedAt<St>, S> { self._fields.4 = Option::Some(value.into()); PartViewBuilder { _state: PhantomData, _fields: self._fields, _type: PhantomData, } }}
impl<St, S: BosStr> PartViewBuilder<St, S>where St: part_view_state::State, St::Name: part_view_state::IsUnset,{ /// Set the `name` field (required) pub fn name( mut self, value: impl Into<S>, ) -> PartViewBuilder<part_view_state::SetName<St>, S> { self._fields.5 = Option::Some(value.into()); PartViewBuilder { _state: PhantomData, _fields: self._fields, _type: PhantomData, } }}
impl<St: part_view_state::State, S: BosStr> PartViewBuilder<St, S> { /// Set the `previews` field (optional) pub fn previews( mut self, value: impl Into<Option<Vec<library::ImageView<S>>>>, ) -> Self { self._fields.6 = value.into(); self } /// Set the `previews` field to an Option value (optional) pub fn maybe_previews(mut self, value: Option<Vec<library::ImageView<S>>>) -> Self { self._fields.6 = value; self }}
impl<St, S: BosStr> PartViewBuilder<St, S>where St: part_view_state::State, St::Record: part_view_state::IsUnset,{ /// Set the `record` field (required) pub fn record( mut self, value: impl Into<Data<S>>, ) -> PartViewBuilder<part_view_state::SetRecord<St>, S> { self._fields.7 = Option::Some(value.into()); PartViewBuilder { _state: PhantomData, _fields: self._fields, _type: PhantomData, } }}
impl<St, S: BosStr> PartViewBuilder<St, S>where St: part_view_state::State, St::Uri: part_view_state::IsUnset,{ /// Set the `uri` field (required) pub fn uri( mut self, value: impl Into<AtUri<S>>, ) -> PartViewBuilder<part_view_state::SetUri<St>, S> { self._fields.8 = Option::Some(value.into()); PartViewBuilder { _state: PhantomData, _fields: self._fields, _type: PhantomData, } }}
impl<St, S: BosStr> PartViewBuilder<St, S>where St: part_view_state::State, St::Viewer: part_view_state::IsUnset,{ /// Set the `viewer` field (required) pub fn viewer( mut self, value: impl Into<library::ViewerState<S>>, ) -> PartViewBuilder<part_view_state::SetViewer<St>, S> { self._fields.9 = Option::Some(value.into()); PartViewBuilder { _state: PhantomData, _fields: self._fields, _type: PhantomData, } }}
impl<St, S: BosStr> PartViewBuilder<St, S>where St: part_view_state::State, St::Author: part_view_state::IsSet, St::Cid: part_view_state::IsSet, St::File: part_view_state::IsSet, St::IndexedAt: part_view_state::IsSet, St::Name: part_view_state::IsSet, St::Record: part_view_state::IsSet, St::Uri: part_view_state::IsSet, St::Viewer: part_view_state::IsSet,{ /// Build the final struct. pub fn build(self) -> PartView<S> { PartView { author: self._fields.0.unwrap(), cid: self._fields.1.unwrap(), file: self._fields.2.unwrap(), format: self._fields.3, indexed_at: self._fields.4.unwrap(), name: self._fields.5.unwrap(), previews: self._fields.6, record: self._fields.7.unwrap(), uri: self._fields.8.unwrap(), viewer: self._fields.9.unwrap(), extra_data: Default::default(), } } /// Build the final struct with custom extra_data. pub fn build_with_data(self, extra_data: BTreeMap<SmolStr, Data<S>>) -> PartView<S> { PartView { author: self._fields.0.unwrap(), cid: self._fields.1.unwrap(), file: self._fields.2.unwrap(), format: self._fields.3, indexed_at: self._fields.4.unwrap(), name: self._fields.5.unwrap(), previews: self._fields.6, record: self._fields.7.unwrap(), uri: self._fields.8.unwrap(), viewer: self._fields.9.unwrap(), extra_data: Some(extra_data), } }}
pub mod thing_view_state {
pub use crate::builder_types::{Set, Unset, IsSet, IsUnset}; #[allow(unused)] use ::core::marker::PhantomData; mod sealed { pub trait Sealed {} } /// State trait tracking which required fields have been set pub trait State: sealed::Sealed { type Author; type Cid; type IndexedAt; type License; type LikeCount; type ModelCount; type Name; type PartCount; type Record; type SaveCount; type Uri; type Viewer; } /// Empty state - all required fields are unset pub struct Empty(()); impl sealed::Sealed for Empty {} impl State for Empty { type Author = Unset; type Cid = Unset; type IndexedAt = Unset; type License = Unset; type LikeCount = Unset; type ModelCount = Unset; type Name = Unset; type PartCount = Unset; type Record = Unset; type SaveCount = Unset; type Uri = Unset; type Viewer = Unset; } ///State transition - sets the `author` field to Set pub struct SetAuthor<St: State = Empty>(PhantomData<fn() -> St>); impl<St: State> sealed::Sealed for SetAuthor<St> {} impl<St: State> State for SetAuthor<St> { type Author = Set<members::author>; type Cid = St::Cid; type IndexedAt = St::IndexedAt; type License = St::License; type LikeCount = St::LikeCount; type ModelCount = St::ModelCount; type Name = St::Name; type PartCount = St::PartCount; type Record = St::Record; type SaveCount = St::SaveCount; type Uri = St::Uri; type Viewer = St::Viewer; } ///State transition - sets the `cid` field to Set pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>); impl<St: State> sealed::Sealed for SetCid<St> {} impl<St: State> State for SetCid<St> { type Author = St::Author; type Cid = Set<members::cid>; type IndexedAt = St::IndexedAt; type License = St::License; type LikeCount = St::LikeCount; type ModelCount = St::ModelCount; type Name = St::Name; type PartCount = St::PartCount; type Record = St::Record; type SaveCount = St::SaveCount; type Uri = St::Uri; type Viewer = St::Viewer; } ///State transition - sets the `indexed_at` field to Set pub struct SetIndexedAt<St: State = Empty>(PhantomData<fn() -> St>); impl<St: State> sealed::Sealed for SetIndexedAt<St> {} impl<St: State> State for SetIndexedAt<St> { type Author = St::Author; type Cid = St::Cid; type IndexedAt = Set<members::indexed_at>; type License = St::License; type LikeCount = St::LikeCount; type ModelCount = St::ModelCount; type Name = St::Name; type PartCount = St::PartCount; type Record = St::Record; type SaveCount = St::SaveCount; type Uri = St::Uri; type Viewer = St::Viewer; } ///State transition - sets the `license` field to Set pub struct SetLicense<St: State = Empty>(PhantomData<fn() -> St>); impl<St: State> sealed::Sealed for SetLicense<St> {} impl<St: State> State for SetLicense<St> { type Author = St::Author; type Cid = St::Cid; type IndexedAt = St::IndexedAt; type License = Set<members::license>; type LikeCount = St::LikeCount; type ModelCount = St::ModelCount; type Name = St::Name; type PartCount = St::PartCount; type Record = St::Record; type SaveCount = St::SaveCount; type Uri = St::Uri; type Viewer = St::Viewer; } ///State transition - sets the `like_count` field to Set pub struct SetLikeCount<St: State = Empty>(PhantomData<fn() -> St>); impl<St: State> sealed::Sealed for SetLikeCount<St> {} impl<St: State> State for SetLikeCount<St> { type Author = St::Author; type Cid = St::Cid; type IndexedAt = St::IndexedAt; type License = St::License; type LikeCount = Set<members::like_count>; type ModelCount = St::ModelCount; type Name = St::Name; type PartCount = St::PartCount; type Record = St::Record; type SaveCount = St::SaveCount; type Uri = St::Uri; type Viewer = St::Viewer; } ///State transition - sets the `model_count` field to Set pub struct SetModelCount<St: State = Empty>(PhantomData<fn() -> St>); impl<St: State> sealed::Sealed for SetModelCount<St> {} impl<St: State> State for SetModelCount<St> { type Author = St::Author; type Cid = St::Cid; type IndexedAt = St::IndexedAt; type License = St::License; type LikeCount = St::LikeCount; type ModelCount = Set<members::model_count>; type Name = St::Name; type PartCount = St::PartCount; type Record = St::Record; type SaveCount = St::SaveCount; type Uri = St::Uri; type Viewer = St::Viewer; } ///State transition - sets the `name` field to Set pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>); impl<St: State> sealed::Sealed for SetName<St> {} impl<St: State> State for SetName<St> { type Author = St::Author; type Cid = St::Cid; type IndexedAt = St::IndexedAt; type License = St::License; type LikeCount = St::LikeCount; type ModelCount = St::ModelCount; type Name = Set<members::name>; type PartCount = St::PartCount; type Record = St::Record; type SaveCount = St::SaveCount; type Uri = St::Uri; type Viewer = St::Viewer; } ///State transition - sets the `part_count` field to Set pub struct SetPartCount<St: State = Empty>(PhantomData<fn() -> St>); impl<St: State> sealed::Sealed for SetPartCount<St> {} impl<St: State> State for SetPartCount<St> { type Author = St::Author; type Cid = St::Cid; type IndexedAt = St::IndexedAt; type License = St::License; type LikeCount = St::LikeCount; type ModelCount = St::ModelCount; type Name = St::Name; type PartCount = Set<members::part_count>; type Record = St::Record; type SaveCount = St::SaveCount; type Uri = St::Uri; type Viewer = St::Viewer; } ///State transition - sets the `record` field to Set pub struct SetRecord<St: State = Empty>(PhantomData<fn() -> St>); impl<St: State> sealed::Sealed for SetRecord<St> {} impl<St: State> State for SetRecord<St> { type Author = St::Author; type Cid = St::Cid; type IndexedAt = St::IndexedAt; type License = St::License; type LikeCount = St::LikeCount; type ModelCount = St::ModelCount; type Name = St::Name; type PartCount = St::PartCount; type Record = Set<members::record>; type SaveCount = St::SaveCount; type Uri = St::Uri; type Viewer = St::Viewer; } ///State transition - sets the `save_count` field to Set pub struct SetSaveCount<St: State = Empty>(PhantomData<fn() -> St>); impl<St: State> sealed::Sealed for SetSaveCount<St> {} impl<St: State> State for SetSaveCount<St> { type Author = St::Author; type Cid = St::Cid; type IndexedAt = St::IndexedAt; type License = St::License; type LikeCount = St::LikeCount; type ModelCount = St::ModelCount; type Name = St::Name; type PartCount = St::PartCount; type Record = St::Record; type SaveCount = Set<members::save_count>; type Uri = St::Uri; type Viewer = St::Viewer; } ///State transition - sets the `uri` field to Set pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>); impl<St: State> sealed::Sealed for SetUri<St> {} impl<St: State> State for SetUri<St> { type Author = St::Author; type Cid = St::Cid; type IndexedAt = St::IndexedAt; type License = St::License; type LikeCount = St::LikeCount; type ModelCount = St::ModelCount; type Name = St::Name; type PartCount = St::PartCount; type Record = St::Record; type SaveCount = St::SaveCount; type Uri = Set<members::uri>; type Viewer = St::Viewer; } ///State transition - sets the `viewer` field to Set pub struct SetViewer<St: State = Empty>(PhantomData<fn() -> St>); impl<St: State> sealed::Sealed for SetViewer<St> {} impl<St: State> State for SetViewer<St> { type Author = St::Author; type Cid = St::Cid; type IndexedAt = St::IndexedAt; type License = St::License; type LikeCount = St::LikeCount; type ModelCount = St::ModelCount; type Name = St::Name; type PartCount = St::PartCount; type Record = St::Record; type SaveCount = St::SaveCount; type Uri = St::Uri; type Viewer = Set<members::viewer>; } /// Marker types for field names #[allow(non_camel_case_types)] pub mod members { ///Marker type for the `author` field pub struct author(()); ///Marker type for the `cid` field pub struct cid(()); ///Marker type for the `indexed_at` field pub struct indexed_at(()); ///Marker type for the `license` field pub struct license(()); ///Marker type for the `like_count` field pub struct like_count(()); ///Marker type for the `model_count` field pub struct model_count(()); ///Marker type for the `name` field pub struct name(()); ///Marker type for the `part_count` field pub struct part_count(()); ///Marker type for the `record` field pub struct record(()); ///Marker type for the `save_count` field pub struct save_count(()); ///Marker type for the `uri` field pub struct uri(()); ///Marker type for the `viewer` field pub struct viewer(()); }}
/// Builder for constructing an instance of this type.pub struct ThingViewBuilder<St: thing_view_state::State, S: BosStr = DefaultStr> { _state: PhantomData<fn() -> St>, _fields: ( Option<library::Actor<S>>, Option<Cid<S>>, Option<Vec<library::ImageView<S>>>, Option<StrongRef<S>>, Option<Datetime>, Option<Vec<StrongRef<S>>>, Option<S>, Option<i64>, Option<i64>, Option<S>, Option<i64>, Option<Vec<library::ImageView<S>>>, Option<Data<S>>, Option<i64>, Option<S>, Option<Vec<S>>, Option<AtUri<S>>, Option<library::ViewerState<S>>, ), _type: PhantomData<fn() -> S>,}
impl ThingView<DefaultStr> { /// Create a new builder for this type, using the default string type (DefaultStr = SmolStr) if needed pub fn new() -> ThingViewBuilder<thing_view_state::Empty, DefaultStr> { ThingViewBuilder::new() }}
impl<S: BosStr> ThingView<S> { /// Create a new builder for this type pub fn builder() -> ThingViewBuilder<thing_view_state::Empty, S> { ThingViewBuilder::builder() }}
impl ThingViewBuilder<thing_view_state::Empty, DefaultStr> { /// Create a new builder with all fields unset, using the default string type, if needed pub fn new() -> Self { ThingViewBuilder { _state: PhantomData, _fields: ( None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, ), _type: PhantomData, } }}
impl<S: BosStr> ThingViewBuilder<thing_view_state::Empty, S> { /// Create a new builder with all fields unset pub fn builder() -> Self { ThingViewBuilder { _state: PhantomData, _fields: ( None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, ), _type: PhantomData, } }}
impl<St, S: BosStr> ThingViewBuilder<St, S>where St: thing_view_state::State, St::Author: thing_view_state::IsUnset,{ /// Set the `author` field (required) pub fn author( mut self, value: impl Into<library::Actor<S>>, ) -> ThingViewBuilder<thing_view_state::SetAuthor<St>, S> { self._fields.0 = Option::Some(value.into()); ThingViewBuilder { _state: PhantomData, _fields: self._fields, _type: PhantomData, } }}
impl<St, S: BosStr> ThingViewBuilder<St, S>where St: thing_view_state::State, St::Cid: thing_view_state::IsUnset,{ /// Set the `cid` field (required) pub fn cid( mut self, value: impl Into<Cid<S>>, ) -> ThingViewBuilder<thing_view_state::SetCid<St>, S> { self._fields.1 = Option::Some(value.into()); ThingViewBuilder { _state: PhantomData, _fields: self._fields, _type: PhantomData, } }}
impl<St: thing_view_state::State, S: BosStr> ThingViewBuilder<St, S> { /// Set the `cover` field (optional) pub fn cover( mut self, value: impl Into<Option<Vec<library::ImageView<S>>>>, ) -> Self { self._fields.2 = value.into(); self } /// Set the `cover` field to an Option value (optional) pub fn maybe_cover(mut self, value: Option<Vec<library::ImageView<S>>>) -> Self { self._fields.2 = value; self }}
impl<St: thing_view_state::State, S: BosStr> ThingViewBuilder<St, S> { /// Set the `derivedFrom` field (optional) pub fn derived_from(mut self, value: impl Into<Option<StrongRef<S>>>) -> Self { self._fields.3 = value.into(); self } /// Set the `derivedFrom` field to an Option value (optional) pub fn maybe_derived_from(mut self, value: Option<StrongRef<S>>) -> Self { self._fields.3 = value; self }}
impl<St, S: BosStr> ThingViewBuilder<St, S>where St: thing_view_state::State, St::IndexedAt: thing_view_state::IsUnset,{ /// Set the `indexedAt` field (required) pub fn indexed_at( mut self, value: impl Into<Datetime>, ) -> ThingViewBuilder<thing_view_state::SetIndexedAt<St>, S> { self._fields.4 = Option::Some(value.into()); ThingViewBuilder { _state: PhantomData, _fields: self._fields, _type: PhantomData, } }}
impl<St: thing_view_state::State, S: BosStr> ThingViewBuilder<St, S> { /// Set the `intendedToWorkWith` field (optional) pub fn intended_to_work_with( mut self, value: impl Into<Option<Vec<StrongRef<S>>>>, ) -> Self { self._fields.5 = value.into(); self } /// Set the `intendedToWorkWith` field to an Option value (optional) pub fn maybe_intended_to_work_with( mut self, value: Option<Vec<StrongRef<S>>>, ) -> Self { self._fields.5 = value; self }}
impl<St, S: BosStr> ThingViewBuilder<St, S>where St: thing_view_state::State, St::License: thing_view_state::IsUnset,{ /// Set the `license` field (required) pub fn license( mut self, value: impl Into<S>, ) -> ThingViewBuilder<thing_view_state::SetLicense<St>, S> { self._fields.6 = Option::Some(value.into()); ThingViewBuilder { _state: PhantomData, _fields: self._fields, _type: PhantomData, } }}
impl<St, S: BosStr> ThingViewBuilder<St, S>where St: thing_view_state::State, St::LikeCount: thing_view_state::IsUnset,{ /// Set the `likeCount` field (required) pub fn like_count( mut self, value: impl Into<i64>, ) -> ThingViewBuilder<thing_view_state::SetLikeCount<St>, S> { self._fields.7 = Option::Some(value.into()); ThingViewBuilder { _state: PhantomData, _fields: self._fields, _type: PhantomData, } }}
impl<St, S: BosStr> ThingViewBuilder<St, S>where St: thing_view_state::State, St::ModelCount: thing_view_state::IsUnset,{ /// Set the `modelCount` field (required) pub fn model_count( mut self, value: impl Into<i64>, ) -> ThingViewBuilder<thing_view_state::SetModelCount<St>, S> { self._fields.8 = Option::Some(value.into()); ThingViewBuilder { _state: PhantomData, _fields: self._fields, _type: PhantomData, } }}
impl<St, S: BosStr> ThingViewBuilder<St, S>where St: thing_view_state::State, St::Name: thing_view_state::IsUnset,{ /// Set the `name` field (required) pub fn name( mut self, value: impl Into<S>, ) -> ThingViewBuilder<thing_view_state::SetName<St>, S> { self._fields.9 = Option::Some(value.into()); ThingViewBuilder { _state: PhantomData, _fields: self._fields, _type: PhantomData, } }}
impl<St, S: BosStr> ThingViewBuilder<St, S>where St: thing_view_state::State, St::PartCount: thing_view_state::IsUnset,{ /// Set the `partCount` field (required) pub fn part_count( mut self, value: impl Into<i64>, ) -> ThingViewBuilder<thing_view_state::SetPartCount<St>, S> { self._fields.10 = Option::Some(value.into()); ThingViewBuilder { _state: PhantomData, _fields: self._fields, _type: PhantomData, } }}
impl<St: thing_view_state::State, S: BosStr> ThingViewBuilder<St, S> { /// Set the `previews` field (optional) pub fn previews( mut self, value: impl Into<Option<Vec<library::ImageView<S>>>>, ) -> Self { self._fields.11 = value.into(); self } /// Set the `previews` field to an Option value (optional) pub fn maybe_previews(mut self, value: Option<Vec<library::ImageView<S>>>) -> Self { self._fields.11 = value; self }}
impl<St, S: BosStr> ThingViewBuilder<St, S>where St: thing_view_state::State, St::Record: thing_view_state::IsUnset,{ /// Set the `record` field (required) pub fn record( mut self, value: impl Into<Data<S>>, ) -> ThingViewBuilder<thing_view_state::SetRecord<St>, S> { self._fields.12 = Option::Some(value.into()); ThingViewBuilder { _state: PhantomData, _fields: self._fields, _type: PhantomData, } }}
impl<St, S: BosStr> ThingViewBuilder<St, S>where St: thing_view_state::State, St::SaveCount: thing_view_state::IsUnset,{ /// Set the `saveCount` field (required) pub fn save_count( mut self, value: impl Into<i64>, ) -> ThingViewBuilder<thing_view_state::SetSaveCount<St>, S> { self._fields.13 = Option::Some(value.into()); ThingViewBuilder { _state: PhantomData, _fields: self._fields, _type: PhantomData, } }}
impl<St: thing_view_state::State, S: BosStr> ThingViewBuilder<St, S> { /// Set the `summary` field (optional) pub fn summary(mut self, value: impl Into<Option<S>>) -> Self { self._fields.14 = value.into(); self } /// Set the `summary` field to an Option value (optional) pub fn maybe_summary(mut self, value: Option<S>) -> Self { self._fields.14 = value; self }}
impl<St: thing_view_state::State, S: BosStr> ThingViewBuilder<St, S> { /// Set the `tags` field (optional) pub fn tags(mut self, value: impl Into<Option<Vec<S>>>) -> Self { self._fields.15 = value.into(); self } /// Set the `tags` field to an Option value (optional) pub fn maybe_tags(mut self, value: Option<Vec<S>>) -> Self { self._fields.15 = value; self }}
impl<St, S: BosStr> ThingViewBuilder<St, S>where St: thing_view_state::State, St::Uri: thing_view_state::IsUnset,{ /// Set the `uri` field (required) pub fn uri( mut self, value: impl Into<AtUri<S>>, ) -> ThingViewBuilder<thing_view_state::SetUri<St>, S> { self._fields.16 = Option::Some(value.into()); ThingViewBuilder { _state: PhantomData, _fields: self._fields, _type: PhantomData, } }}
impl<St, S: BosStr> ThingViewBuilder<St, S>where St: thing_view_state::State, St::Viewer: thing_view_state::IsUnset,{ /// Set the `viewer` field (required) pub fn viewer( mut self, value: impl Into<library::ViewerState<S>>, ) -> ThingViewBuilder<thing_view_state::SetViewer<St>, S> { self._fields.17 = Option::Some(value.into()); ThingViewBuilder { _state: PhantomData, _fields: self._fields, _type: PhantomData, } }}
impl<St, S: BosStr> ThingViewBuilder<St, S>where St: thing_view_state::State, St::Author: thing_view_state::IsSet, St::Cid: thing_view_state::IsSet, St::IndexedAt: thing_view_state::IsSet, St::License: thing_view_state::IsSet, St::LikeCount: thing_view_state::IsSet, St::ModelCount: thing_view_state::IsSet, St::Name: thing_view_state::IsSet, St::PartCount: thing_view_state::IsSet, St::Record: thing_view_state::IsSet, St::SaveCount: thing_view_state::IsSet, St::Uri: thing_view_state::IsSet, St::Viewer: thing_view_state::IsSet,{ /// Build the final struct. pub fn build(self) -> ThingView<S> { ThingView { author: self._fields.0.unwrap(), cid: self._fields.1.unwrap(), cover: self._fields.2, derived_from: self._fields.3, indexed_at: self._fields.4.unwrap(), intended_to_work_with: self._fields.5, license: self._fields.6.unwrap(), like_count: self._fields.7.unwrap(), model_count: self._fields.8.unwrap(), name: self._fields.9.unwrap(), part_count: self._fields.10.unwrap(), previews: self._fields.11, record: self._fields.12.unwrap(), save_count: self._fields.13.unwrap(), summary: self._fields.14, tags: self._fields.15, uri: self._fields.16.unwrap(), viewer: self._fields.17.unwrap(), extra_data: Default::default(), } } /// Build the final struct with custom extra_data. pub fn build_with_data( self, extra_data: BTreeMap<SmolStr, Data<S>>, ) -> ThingView<S> { ThingView { author: self._fields.0.unwrap(), cid: self._fields.1.unwrap(), cover: self._fields.2, derived_from: self._fields.3, indexed_at: self._fields.4.unwrap(), intended_to_work_with: self._fields.5, license: self._fields.6.unwrap(), like_count: self._fields.7.unwrap(), model_count: self._fields.8.unwrap(), name: self._fields.9.unwrap(), part_count: self._fields.10.unwrap(), previews: self._fields.11, record: self._fields.12.unwrap(), save_count: self._fields.13.unwrap(), summary: self._fields.14, tags: self._fields.15, uri: self._fields.16.unwrap(), viewer: self._fields.17.unwrap(), extra_data: Some(extra_data), } }}
pub mod thing_view_basic_state {
pub use crate::builder_types::{Set, Unset, IsSet, IsUnset}; #[allow(unused)] use ::core::marker::PhantomData; mod sealed { pub trait Sealed {} } /// State trait tracking which required fields have been set pub trait State: sealed::Sealed { type Author; type Cid; type IndexedAt; type LikeCount; type ModelCount; type Name; type PartCount; type SaveCount; type Uri; type Viewer; } /// Empty state - all required fields are unset pub struct Empty(()); impl sealed::Sealed for Empty {} impl State for Empty { type Author = Unset; type Cid = Unset; type IndexedAt = Unset; type LikeCount = Unset; type ModelCount = Unset; type Name = Unset; type PartCount = Unset; type SaveCount = Unset; type Uri = Unset; type Viewer = Unset; } ///State transition - sets the `author` field to Set pub struct SetAuthor<St: State = Empty>(PhantomData<fn() -> St>); impl<St: State> sealed::Sealed for SetAuthor<St> {} impl<St: State> State for SetAuthor<St> { type Author = Set<members::author>; type Cid = St::Cid; type IndexedAt = St::IndexedAt; type LikeCount = St::LikeCount; type ModelCount = St::ModelCount; type Name = St::Name; type PartCount = St::PartCount; type SaveCount = St::SaveCount; type Uri = St::Uri; type Viewer = St::Viewer; } ///State transition - sets the `cid` field to Set pub struct SetCid<St: State = Empty>(PhantomData<fn() -> St>); impl<St: State> sealed::Sealed for SetCid<St> {} impl<St: State> State for SetCid<St> { type Author = St::Author; type Cid = Set<members::cid>; type IndexedAt = St::IndexedAt; type LikeCount = St::LikeCount; type ModelCount = St::ModelCount; type Name = St::Name; type PartCount = St::PartCount; type SaveCount = St::SaveCount; type Uri = St::Uri; type Viewer = St::Viewer; } ///State transition - sets the `indexed_at` field to Set pub struct SetIndexedAt<St: State = Empty>(PhantomData<fn() -> St>); impl<St: State> sealed::Sealed for SetIndexedAt<St> {} impl<St: State> State for SetIndexedAt<St> { type Author = St::Author; type Cid = St::Cid; type IndexedAt = Set<members::indexed_at>; type LikeCount = St::LikeCount; type ModelCount = St::ModelCount; type Name = St::Name; type PartCount = St::PartCount; type SaveCount = St::SaveCount; type Uri = St::Uri; type Viewer = St::Viewer; } ///State transition - sets the `like_count` field to Set pub struct SetLikeCount<St: State = Empty>(PhantomData<fn() -> St>); impl<St: State> sealed::Sealed for SetLikeCount<St> {} impl<St: State> State for SetLikeCount<St> { type Author = St::Author; type Cid = St::Cid; type IndexedAt = St::IndexedAt; type LikeCount = Set<members::like_count>; type ModelCount = St::ModelCount; type Name = St::Name; type PartCount = St::PartCount; type SaveCount = St::SaveCount; type Uri = St::Uri; type Viewer = St::Viewer; } ///State transition - sets the `model_count` field to Set pub struct SetModelCount<St: State = Empty>(PhantomData<fn() -> St>); impl<St: State> sealed::Sealed for SetModelCount<St> {} impl<St: State> State for SetModelCount<St> { type Author = St::Author; type Cid = St::Cid; type IndexedAt = St::IndexedAt; type LikeCount = St::LikeCount; type ModelCount = Set<members::model_count>; type Name = St::Name; type PartCount = St::PartCount; type SaveCount = St::SaveCount; type Uri = St::Uri; type Viewer = St::Viewer; } ///State transition - sets the `name` field to Set pub struct SetName<St: State = Empty>(PhantomData<fn() -> St>); impl<St: State> sealed::Sealed for SetName<St> {} impl<St: State> State for SetName<St> { type Author = St::Author; type Cid = St::Cid; type IndexedAt = St::IndexedAt; type LikeCount = St::LikeCount; type ModelCount = St::ModelCount; type Name = Set<members::name>; type PartCount = St::PartCount; type SaveCount = St::SaveCount; type Uri = St::Uri; type Viewer = St::Viewer; } ///State transition - sets the `part_count` field to Set pub struct SetPartCount<St: State = Empty>(PhantomData<fn() -> St>); impl<St: State> sealed::Sealed for SetPartCount<St> {} impl<St: State> State for SetPartCount<St> { type Author = St::Author; type Cid = St::Cid; type IndexedAt = St::IndexedAt; type LikeCount = St::LikeCount; type ModelCount = St::ModelCount; type Name = St::Name; type PartCount = Set<members::part_count>; type SaveCount = St::SaveCount; type Uri = St::Uri; type Viewer = St::Viewer; } ///State transition - sets the `save_count` field to Set pub struct SetSaveCount<St: State = Empty>(PhantomData<fn() -> St>); impl<St: State> sealed::Sealed for SetSaveCount<St> {} impl<St: State> State for SetSaveCount<St> { type Author = St::Author; type Cid = St::Cid; type IndexedAt = St::IndexedAt; type LikeCount = St::LikeCount; type ModelCount = St::ModelCount; type Name = St::Name; type PartCount = St::PartCount; type SaveCount = Set<members::save_count>; type Uri = St::Uri; type Viewer = St::Viewer; } ///State transition - sets the `uri` field to Set pub struct SetUri<St: State = Empty>(PhantomData<fn() -> St>); impl<St: State> sealed::Sealed for SetUri<St> {} impl<St: State> State for SetUri<St> { type Author = St::Author; type Cid = St::Cid; type IndexedAt = St::IndexedAt; type LikeCount = St::LikeCount; type ModelCount = St::ModelCount; type Name = St::Name; type PartCount = St::PartCount; type SaveCount = St::SaveCount; type Uri = Set<members::uri>; type Viewer = St::Viewer; } ///State transition - sets the `viewer` field to Set pub struct SetViewer<St: State = Empty>(PhantomData<fn() -> St>); impl<St: State> sealed::Sealed for SetViewer<St> {} impl<St: State> State for SetViewer<St> { type Author = St::Author; type Cid = St::Cid; type IndexedAt = St::IndexedAt; type LikeCount = St::LikeCount; type ModelCount = St::ModelCount; type Name = St::Name; type PartCount = St::PartCount; type SaveCount = St::SaveCount; type Uri = St::Uri; type Viewer = Set<members::viewer>; } /// Marker types for field names #[allow(non_camel_case_types)] pub mod members { ///Marker type for the `author` field pub struct author(()); ///Marker type for the `cid` field pub struct cid(()); ///Marker type for the `indexed_at` field pub struct indexed_at(()); ///Marker type for the `like_count` field pub struct like_count(()); ///Marker type for the `model_count` field pub struct model_count(()); ///Marker type for the `name` field pub struct name(()); ///Marker type for the `part_count` field pub struct part_count(()); ///Marker type for the `save_count` field pub struct save_count(()); ///Marker type for the `uri` field pub struct uri(()); ///Marker type for the `viewer` field pub struct viewer(()); }}
/// Builder for constructing an instance of this type.pub struct ThingViewBasicBuilder< St: thing_view_basic_state::State, S: BosStr = DefaultStr,> { _state: PhantomData<fn() -> St>, _fields: ( Option<library::Actor<S>>, Option<Cid<S>>, Option<Vec<library::ImageView<S>>>, Option<Datetime>, Option<i64>, Option<i64>, Option<S>, Option<i64>, Option<Vec<library::ImageView<S>>>, Option<i64>, Option<Vec<S>>, Option<AtUri<S>>, Option<library::ViewerState<S>>, ), _type: PhantomData<fn() -> S>,}
impl ThingViewBasic<DefaultStr> { /// Create a new builder for this type, using the default string type (DefaultStr = SmolStr) if needed pub fn new() -> ThingViewBasicBuilder<thing_view_basic_state::Empty, DefaultStr> { ThingViewBasicBuilder::new() }}
impl<S: BosStr> ThingViewBasic<S> { /// Create a new builder for this type pub fn builder() -> ThingViewBasicBuilder<thing_view_basic_state::Empty, S> { ThingViewBasicBuilder::builder() }}
impl ThingViewBasicBuilder<thing_view_basic_state::Empty, DefaultStr> { /// Create a new builder with all fields unset, using the default string type, if needed pub fn new() -> Self { ThingViewBasicBuilder { _state: PhantomData, _fields: ( None, None, None, None, None, None, None, None, None, None, None, None, None, ), _type: PhantomData, } }}
impl<S: BosStr> ThingViewBasicBuilder<thing_view_basic_state::Empty, S> { /// Create a new builder with all fields unset pub fn builder() -> Self { ThingViewBasicBuilder { _state: PhantomData, _fields: ( None, None, None, None, None, None, None, None, None, None, None, None, None, ), _type: PhantomData, } }}
impl<St, S: BosStr> ThingViewBasicBuilder<St, S>where St: thing_view_basic_state::State, St::Author: thing_view_basic_state::IsUnset,{ /// Set the `author` field (required) pub fn author( mut self, value: impl Into<library::Actor<S>>, ) -> ThingViewBasicBuilder<thing_view_basic_state::SetAuthor<St>, S> { self._fields.0 = Option::Some(value.into()); ThingViewBasicBuilder { _state: PhantomData, _fields: self._fields, _type: PhantomData, } }}
impl<St, S: BosStr> ThingViewBasicBuilder<St, S>where St: thing_view_basic_state::State, St::Cid: thing_view_basic_state::IsUnset,{ /// Set the `cid` field (required) pub fn cid( mut self, value: impl Into<Cid<S>>, ) -> ThingViewBasicBuilder<thing_view_basic_state::SetCid<St>, S> { self._fields.1 = Option::Some(value.into()); ThingViewBasicBuilder { _state: PhantomData, _fields: self._fields, _type: PhantomData, } }}
impl<St: thing_view_basic_state::State, S: BosStr> ThingViewBasicBuilder<St, S> { /// Set the `cover` field (optional) pub fn cover( mut self, value: impl Into<Option<Vec<library::ImageView<S>>>>, ) -> Self { self._fields.2 = value.into(); self } /// Set the `cover` field to an Option value (optional) pub fn maybe_cover(mut self, value: Option<Vec<library::ImageView<S>>>) -> Self { self._fields.2 = value; self }}
impl<St, S: BosStr> ThingViewBasicBuilder<St, S>where St: thing_view_basic_state::State, St::IndexedAt: thing_view_basic_state::IsUnset,{ /// Set the `indexedAt` field (required) pub fn indexed_at( mut self, value: impl Into<Datetime>, ) -> ThingViewBasicBuilder<thing_view_basic_state::SetIndexedAt<St>, S> { self._fields.3 = Option::Some(value.into()); ThingViewBasicBuilder { _state: PhantomData, _fields: self._fields, _type: PhantomData, } }}
impl<St, S: BosStr> ThingViewBasicBuilder<St, S>where St: thing_view_basic_state::State, St::LikeCount: thing_view_basic_state::IsUnset,{ /// Set the `likeCount` field (required) pub fn like_count( mut self, value: impl Into<i64>, ) -> ThingViewBasicBuilder<thing_view_basic_state::SetLikeCount<St>, S> { self._fields.4 = Option::Some(value.into()); ThingViewBasicBuilder { _state: PhantomData, _fields: self._fields, _type: PhantomData, } }}
impl<St, S: BosStr> ThingViewBasicBuilder<St, S>where St: thing_view_basic_state::State, St::ModelCount: thing_view_basic_state::IsUnset,{ /// Set the `modelCount` field (required) pub fn model_count( mut self, value: impl Into<i64>, ) -> ThingViewBasicBuilder<thing_view_basic_state::SetModelCount<St>, S> { self._fields.5 = Option::Some(value.into()); ThingViewBasicBuilder { _state: PhantomData, _fields: self._fields, _type: PhantomData, } }}
impl<St, S: BosStr> ThingViewBasicBuilder<St, S>where St: thing_view_basic_state::State, St::Name: thing_view_basic_state::IsUnset,{ /// Set the `name` field (required) pub fn name( mut self, value: impl Into<S>, ) -> ThingViewBasicBuilder<thing_view_basic_state::SetName<St>, S> { self._fields.6 = Option::Some(value.into()); ThingViewBasicBuilder { _state: PhantomData, _fields: self._fields, _type: PhantomData, } }}
impl<St, S: BosStr> ThingViewBasicBuilder<St, S>where St: thing_view_basic_state::State, St::PartCount: thing_view_basic_state::IsUnset,{ /// Set the `partCount` field (required) pub fn part_count( mut self, value: impl Into<i64>, ) -> ThingViewBasicBuilder<thing_view_basic_state::SetPartCount<St>, S> { self._fields.7 = Option::Some(value.into()); ThingViewBasicBuilder { _state: PhantomData, _fields: self._fields, _type: PhantomData, } }}
impl<St: thing_view_basic_state::State, S: BosStr> ThingViewBasicBuilder<St, S> { /// Set the `previews` field (optional) pub fn previews( mut self, value: impl Into<Option<Vec<library::ImageView<S>>>>, ) -> Self { self._fields.8 = value.into(); self } /// Set the `previews` field to an Option value (optional) pub fn maybe_previews(mut self, value: Option<Vec<library::ImageView<S>>>) -> Self { self._fields.8 = value; self }}
impl<St, S: BosStr> ThingViewBasicBuilder<St, S>where St: thing_view_basic_state::State, St::SaveCount: thing_view_basic_state::IsUnset,{ /// Set the `saveCount` field (required) pub fn save_count( mut self, value: impl Into<i64>, ) -> ThingViewBasicBuilder<thing_view_basic_state::SetSaveCount<St>, S> { self._fields.9 = Option::Some(value.into()); ThingViewBasicBuilder { _state: PhantomData, _fields: self._fields, _type: PhantomData, } }}
impl<St: thing_view_basic_state::State, S: BosStr> ThingViewBasicBuilder<St, S> { /// Set the `tags` field (optional) pub fn tags(mut self, value: impl Into<Option<Vec<S>>>) -> Self { self._fields.10 = value.into(); self } /// Set the `tags` field to an Option value (optional) pub fn maybe_tags(mut self, value: Option<Vec<S>>) -> Self { self._fields.10 = value; self }}
impl<St, S: BosStr> ThingViewBasicBuilder<St, S>where St: thing_view_basic_state::State, St::Uri: thing_view_basic_state::IsUnset,{ /// Set the `uri` field (required) pub fn uri( mut self, value: impl Into<AtUri<S>>, ) -> ThingViewBasicBuilder<thing_view_basic_state::SetUri<St>, S> { self._fields.11 = Option::Some(value.into()); ThingViewBasicBuilder { _state: PhantomData, _fields: self._fields, _type: PhantomData, } }}
impl<St, S: BosStr> ThingViewBasicBuilder<St, S>where St: thing_view_basic_state::State, St::Viewer: thing_view_basic_state::IsUnset,{ /// Set the `viewer` field (required) pub fn viewer( mut self, value: impl Into<library::ViewerState<S>>, ) -> ThingViewBasicBuilder<thing_view_basic_state::SetViewer<St>, S> { self._fields.12 = Option::Some(value.into()); ThingViewBasicBuilder { _state: PhantomData, _fields: self._fields, _type: PhantomData, } }}
impl<St, S: BosStr> ThingViewBasicBuilder<St, S>where St: thing_view_basic_state::State, St::Author: thing_view_basic_state::IsSet, St::Cid: thing_view_basic_state::IsSet, St::IndexedAt: thing_view_basic_state::IsSet, St::LikeCount: thing_view_basic_state::IsSet, St::ModelCount: thing_view_basic_state::IsSet, St::Name: thing_view_basic_state::IsSet, St::PartCount: thing_view_basic_state::IsSet, St::SaveCount: thing_view_basic_state::IsSet, St::Uri: thing_view_basic_state::IsSet, St::Viewer: thing_view_basic_state::IsSet,{ /// Build the final struct. pub fn build(self) -> ThingViewBasic<S> { ThingViewBasic { author: self._fields.0.unwrap(), cid: self._fields.1.unwrap(), cover: self._fields.2, indexed_at: self._fields.3.unwrap(), like_count: self._fields.4.unwrap(), model_count: self._fields.5.unwrap(), name: self._fields.6.unwrap(), part_count: self._fields.7.unwrap(), previews: self._fields.8, save_count: self._fields.9.unwrap(), tags: self._fields.10, uri: self._fields.11.unwrap(), viewer: self._fields.12.unwrap(), extra_data: Default::default(), } } /// Build the final struct with custom extra_data. pub fn build_with_data( self, extra_data: BTreeMap<SmolStr, Data<S>>, ) -> ThingViewBasic<S> { ThingViewBasic { author: self._fields.0.unwrap(), cid: self._fields.1.unwrap(), cover: self._fields.2, indexed_at: self._fields.3.unwrap(), like_count: self._fields.4.unwrap(), model_count: self._fields.5.unwrap(), name: self._fields.6.unwrap(), part_count: self._fields.7.unwrap(), previews: self._fields.8, save_count: self._fields.9.unwrap(), tags: self._fields.10, uri: self._fields.11.unwrap(), viewer: self._fields.12.unwrap(), extra_data: Some(extra_data), } }}