[{"data":1,"prerenderedAt":1610},["ShallowReactive",2],{"content-\u002Fdocs\u002Freference\u002Ftypes":3},{"id":4,"title":5,"body":6,"description":1592,"extension":1593,"meta":1594,"metaRows":1595,"navigation":1604,"path":1605,"seo":1606,"source":1607,"stem":1608,"__hash__":1609},"docs\u002Fdocs\u002Freference\u002Ftypes.md","Types reference",{"type":7,"value":8,"toc":1575},"minimark",[9,13,20,23,37,42,205,209,328,332,518,522,635,639,733,737,897,901,1045,1049,1118,1122,1161,1165,1471,1475,1502,1506,1512,1535,1547,1551],[10,11,5],"h1",{"id":12},"types-reference",[14,15,16],"blockquote",{},[17,18,19],"p",{},"Every public type Attaform exports, grouped by purpose. Inference handles the common cases; these are for advanced wiring (custom adapters, deeply nested generic helpers, type-safe consumer libraries).",[21,22],"docs-meta-table",{},[17,24,25,26,31,32,36],{},"This page is reference material, alphabetical-ish by purpose. Most consumers never reach for these directly; the ",[27,28,30],"a",{"href":29},"\u002Fdocs\u002Fschemas\u002Fcontract","Inference-first DX"," doctrine means ",[33,34,35],"code",{},"useForm"," + a schema gives you autocomplete on every reactive surface without naming the types.",[38,39,41],"h2",{"id":40},"form-configuration","Form configuration",[43,44,45,61],"table",{},[46,47,48],"thead",{},[49,50,51,55,58],"tr",{},[52,53,54],"th",{},"Type",[52,56,57],{},"Source",[52,59,60],{},"Purpose",[62,63,64,81,93,109,125,138,161,180],"tbody",{},[49,65,66,72,75],{},[67,68,69],"td",{},[33,70,71],{},"UseFormConfiguration\u003CForm>",[67,73,74],{},"runtime\u002Ftypes\u002Ftypes-api",[67,76,77,78,80],{},"The options bag passed to ",[33,79,35],{},".",[49,82,83,88,90],{},[67,84,85],{},[33,86,87],{},"UseFormReturnType\u003CForm, GetValue>",[67,89,74],{},[67,91,92],{},"The whole reactive return: values, fields, errors, meta, methods.",[49,94,95,100,103],{},[67,96,97],{},[33,98,99],{},"AttaformPluginOptions",[67,101,102],{},"runtime\u002Fcore\u002Fplugin",[67,104,105,106,80],{},"Options for ",[33,107,108],{},"createAttaform({ devtools, ssr })",[49,110,111,116,118],{},[67,112,113],{},[33,114,115],{},"FormKey",[67,117,74],{},[67,119,120,121,124],{},"The ",[33,122,123],{},"useForm({ key })"," identifier: distant lookup, error labelling, DevTools naming.",[49,126,127,132,135],{},[67,128,129],{},[33,130,131],{},"AttaformRegistry",[67,133,134],{},"runtime\u002Fcore\u002Fregistry",[67,136,137],{},"The per-Vue-app container every form registers into. Reached explicitly only for SSR or a custom plugin.",[49,139,140,145,147],{},[67,141,142],{},[33,143,144],{},"HistoryPlugin",[67,146,74],{},[67,148,149,150,153,154,157,158,80],{},"What ",[33,151,152],{},"historyPlugin()"," from ",[33,155,156],{},"attaform\u002Fhistory"," returns; passed via ",[33,159,160],{},"useForm({ history })",[49,162,163,172,174],{},[67,164,165,168,169],{},[33,166,167],{},"ValidateOn"," \u002F ",[33,170,171],{},"ValidateOnConfig",[67,173,74],{},[67,175,176,179],{},[33,177,178],{},"validateOn"," field and its discriminated config.",[49,181,182,187,189],{},[67,183,184],{},[33,185,186],{},"DisplayState",[67,188,74],{},[67,190,191,192,195,196,195,199,195,202,80],{},"The display-state verdict: ",[33,193,194],{},"idle"," | ",[33,197,198],{},"pending",[33,200,201],{},"error",[33,203,204],{},"success",[38,206,208],{"id":207},"reactive-surfaces","Reactive surfaces",[43,210,211,221],{},[46,212,213],{},[49,214,215,217,219],{},[52,216,54],{},[52,218,57],{},[52,220,60],{},[62,222,223,235,250,266,278,292,304,316],{},[49,224,225,230,232],{},[67,226,227],{},[33,228,229],{},"FieldState\u003CValue>",[67,231,74],{},[67,233,234],{},"The 37-property per-leaf reactive bundle.",[49,236,237,242,244],{},[67,238,239],{},[33,240,241],{},"FieldStateMap\u003CForm>",[67,243,74],{},[67,245,246,247,80],{},"The proxy shape exposing ",[33,248,249],{},"form.fields",[49,251,252,257,259],{},[67,253,254],{},[33,255,256],{},"FieldStateMapEntry\u003CForm, P>",[67,258,74],{},[67,260,261,262,265],{},"One node in that proxy: a ",[33,263,264],{},"FieldState"," on a leaf, a nested map on a container.",[49,267,268,273,275],{},[67,269,270],{},[33,271,272],{},"FormMeta\u003CForm>",[67,274,74],{},[67,276,277],{},"Form-level aggregates over every field's state.",[49,279,280,285,287],{},[67,281,282],{},[33,283,284],{},"FormErrorsSurface\u003CForm>",[67,286,74],{},[67,288,246,289,80],{},[33,290,291],{},"form.errors",[49,293,294,299,301],{},[67,295,296],{},[33,297,298],{},"FormErrorRecord",[67,300,74],{},[67,302,303],{},"The per-path error array shape.",[49,305,306,311,313],{},[67,307,308],{},[33,309,310],{},"ErrorsProxyShape\u003CForm>",[67,312,74],{},[67,314,315],{},"Type-level view of the errors proxy for advanced helpers.",[49,317,318,323,325],{},[67,319,320],{},[33,321,322],{},"WriteMeta",[67,324,74],{},[67,326,327],{},"Metadata attached to a mutation (source, batch flags).",[38,329,331],{"id":330},"validation","Validation",[43,333,334,344],{},[46,335,336],{},[49,337,338,340,342],{},[52,339,54],{},[52,341,57],{},[52,343,60],{},[62,345,346,362,388,404,416,435,455,467,485,506],{},[49,347,348,353,355],{},[67,349,350],{},[33,351,352],{},"ValidationError",[67,354,74],{},[67,356,357,358,361],{},"The error shape (",[33,359,360],{},"{ path, message, code, data? }","). Form identity lives on the response envelope, not per entry.",[49,363,364,369,371],{},[67,365,366],{},[33,367,368],{},"ErrorInput",[67,370,74],{},[67,372,149,373,376,377,380,381,384,385,387],{},[33,374,375],{},"form.setErrors"," accepts: an ",[33,378,379],{},"Error"," or ",[33,382,383],{},"{ message?, path?, code?, data? }",". Foreign fields are stripped during normalization, so ",[33,386,352],{}," is a subtype.",[49,389,390,395,397],{},[67,391,392],{},[33,393,394],{},"Json",[67,396,74],{},[67,398,399,400,403],{},"JSON-serialisable value; the type of the optional ",[33,401,402],{},"data"," payload.",[49,405,406,411,413],{},[67,407,408],{},[33,409,410],{},"ValidationResponse\u003CForm>",[67,412,74],{},[67,414,415],{},"Discriminated success-or-failure validation result with parsed data.",[49,417,418,423,425],{},[67,419,420],{},[33,421,422],{},"ValidationResponseWithoutValue\u003CForm>",[67,424,74],{},[67,426,427,428,430,431,434],{},"Same shape minus the ",[33,429,402],{}," payload (the settled half of ",[33,432,433],{},"validate()","'s status).",[49,436,437,442,444],{},[67,438,439],{},[33,440,441],{},"ParseOptions",[67,443,74],{},[67,445,446,447,450,451,454],{},"Options bag for ",[33,448,449],{},"form.parse","; ",[33,452,453],{},"commit: true"," writes the verdict to the error store and cancels in-flight field runs.",[49,456,457,462,464],{},[67,458,459],{},[33,460,461],{},"ReactiveValidationStatus\u003CForm>",[67,463,74],{},[67,465,466],{},"Discriminated pending-vs-settled reactive validation status.",[49,468,469,477,479],{},[67,470,471,168,474],{},[33,472,473],{},"PendingValidationStatus",[33,475,476],{},"SettledValidationStatus",[67,478,74],{},[67,480,481,482,80],{},"The two branches of ",[33,483,484],{},"ReactiveValidationStatus",[49,486,487,498,500],{},[67,488,489,168,492,168,495],{},[33,490,491],{},"HandleSubmit",[33,493,494],{},"OnSubmit",[33,496,497],{},"OnError",[67,499,74],{},[67,501,120,502,505],{},[33,503,504],{},"handleSubmit"," callback signatures.",[49,507,508,513,515],{},[67,509,510],{},[33,511,512],{},"SubmitHandler\u003CForm>",[67,514,74],{},[67,516,517],{},"Generic handler type for typed user submit functions.",[38,519,521],{"id":520},"schema-contract","Schema contract",[43,523,524,534],{},[46,525,526],{},[49,527,528,530,532],{},[52,529,54],{},[52,531,57],{},[52,533,60],{},[62,535,536,548,563,581,593,605,623],{},[49,537,538,543,545],{},[67,539,540],{},[33,541,542],{},"AbstractSchema\u003CForm, GetValue>",[67,544,74],{},[67,546,547],{},"The 15-method + 5-optional contract custom adapters implement.",[49,549,550,555,557],{},[67,551,552],{},[33,553,554],{},"SchemaParseResult\u003CForm>",[67,556,74],{},[67,558,149,559,562],{},[33,560,561],{},"validateAtPath"," settles as: a verdict with no form key.",[49,564,565,570,572],{},[67,566,567],{},[33,568,569],{},"SchemaParseSuccess\u003CForm>",[67,571,74],{},[67,573,120,574,577,578,80],{},[33,575,576],{},"success: true"," arm of ",[33,579,580],{},"SchemaParseResult",[49,582,583,588,590],{},[67,584,585],{},[33,586,587],{},"SchemaParseErrorWithData\u003CForm>",[67,589,74],{},[67,591,592],{},"Failed, but partial data came back with the errors.",[49,594,595,600,602],{},[67,596,597],{},[33,598,599],{},"SchemaParseErrorWithoutData",[67,601,74],{},[67,603,604],{},"Failed with no data (for example a top-level type mismatch).",[49,606,607,612,614],{},[67,608,609],{},[33,610,611],{},"SlimPrimitiveKind",[67,613,74],{},[67,615,616,195,619,622],{},[33,617,618],{},"'string'",[33,620,621],{},"'number'"," | … (typeof-style kinds).",[49,624,625,630,632],{},[67,626,627],{},[33,628,629],{},"FieldMetaPayload",[67,631,74],{},[67,633,634],{},"Schema-attached metadata: label, description, placeholder, meta.",[38,636,638],{"id":637},"path-types","Path types",[43,640,641,651],{},[46,642,643],{},[49,644,645,647,649],{},[52,646,54],{},[52,648,57],{},[52,650,60],{},[62,652,653,666,678,690,702,714],{},[49,654,655,660,663],{},[67,656,657],{},[33,658,659],{},"FlatPath\u003CForm>",[67,661,662],{},"runtime\u002Ftypes\u002Ftypes-core",[67,664,665],{},"Every reachable dotted path through the form.",[49,667,668,673,675],{},[67,669,670],{},[33,671,672],{},"PartialFlatPath\u003CForm>",[67,674,662],{},[67,676,677],{},"Same but allowing partial-prefix paths.",[49,679,680,685,687],{},[67,681,682],{},[33,683,684],{},"ArrayPath\u003CForm>",[67,686,662],{},[67,688,689],{},"Every reachable path whose value is an array, optional or not.",[49,691,692,697,699],{},[67,693,694],{},[33,695,696],{},"RecordPath\u003CForm>",[67,698,662],{},[67,700,701],{},"Every reachable path whose value is an open-keyed record.",[49,703,704,709,711],{},[67,705,706],{},[33,707,708],{},"JoinSegments\u003CSegments>",[67,710,662],{},[67,712,713],{},"Type-level join of a segment tuple into a dotted string.",[49,715,716,727,730],{},[67,717,718,168,721,168,724],{},[33,719,720],{},"Path",[33,722,723],{},"PathKey",[33,725,726],{},"Segment",[67,728,729],{},"runtime\u002Fcore\u002Fpaths",[67,731,732],{},"Canonicalized runtime path representation.",[38,734,736],{"id":735},"shape-helpers","Shape helpers",[43,738,739,749],{},[46,740,741],{},[49,742,743,745,747],{},[52,744,54],{},[52,746,57],{},[52,748,60],{},[62,750,751,763,775,793,813,828,840,852,864,885],{},[49,752,753,758,760],{},[67,754,755],{},[33,756,757],{},"GenericForm",[67,759,662],{},[67,761,762],{},"The most-permissive form shape; used in generics that constrain.",[49,764,765,770,772],{},[67,766,767],{},[33,768,769],{},"DeepPartial\u003CT>",[67,771,662],{},[67,773,774],{},"Every leaf made optional, recursively.",[49,776,777,785,787],{},[67,778,779,168,782],{},[33,780,781],{},"DefaultValuesInput\u003CSchema>",[33,783,784],{},"DefaultValuesShape\u003CForm>",[67,786,662],{},[67,788,120,789,792],{},[33,790,791],{},"defaultValues"," argument shape vs. the resolved tree.",[49,794,795,800,802],{},[67,796,797],{},[33,798,799],{},"WriteShape\u003CSchema>",[67,801,662],{},[67,803,804,805,808,809,812],{},"The shape ",[33,806,807],{},"setValue"," accepts (",[33,810,811],{},"z.input","-equivalent).",[49,814,815,823,825],{},[67,816,817,168,820],{},[33,818,819],{},"NestedReadType\u003CT, P>",[33,821,822],{},"NestedType\u003CT, P>",[67,824,662],{},[67,826,827],{},"Walk a type to the value at a path.",[49,829,830,835,837],{},[67,831,832],{},[33,833,834],{},"LiftedValueShape\u003CT>",[67,836,662],{},[67,838,839],{},"Helper for variant-memory and discriminated-union plumbing.",[49,841,842,847,849],{},[67,843,844],{},[33,845,846],{},"ArrayItem\u003CT>",[67,848,662],{},[67,850,851],{},"Element type of an array.",[49,853,854,859,861],{},[67,855,856],{},[33,857,858],{},"RecordValue\u003CT, P>",[67,860,662],{},[67,862,863],{},"Value type of a record.",[49,865,866,880,882],{},[67,867,868,168,871,168,874,168,877],{},[33,869,870],{},"IsTuple\u003CT>",[33,872,873],{},"IsUnion\u003CT>",[33,875,876],{},"KeyofUnion\u003CT>",[33,878,879],{},"ValueOfUnion\u003CT>",[67,881,662],{},[67,883,884],{},"Type-level predicates and unions over generic values.",[49,886,887,892,894],{},[67,888,889],{},[33,890,891],{},"Primitive",[67,893,662],{},[67,895,896],{},"The base primitive set.",[38,898,900],{"id":899},"binding","Binding",[43,902,903,913],{},[46,904,905],{},[49,906,907,909,911],{},[52,908,54],{},[52,910,57],{},[52,912,60],{},[62,914,915,930,945,960,984,996,1011,1030],{},[49,916,917,922,924],{},[67,918,919],{},[33,920,921],{},"RegisterDirective",[67,923,74],{},[67,925,120,926,929],{},[33,927,928],{},"v-register"," directive type.",[49,931,932,940,942],{},[67,933,934,168,937],{},[33,935,936],{},"RegisterValue",[33,938,939],{},"RegisterOptions",[67,941,74],{},[67,943,944],{},"The value the directive accepts; the per-register options shape.",[49,946,947,952,954],{},[67,948,949],{},[33,950,951],{},"RegisterFlatPath\u003CForm>",[67,953,74],{},[67,955,956,957,80],{},"Paths bindable through ",[33,958,959],{},"register",[49,961,962,970,972],{},[67,963,964,168,967],{},[33,965,966],{},"RegisterTextModifier",[33,968,969],{},"RegisterSelectModifier",[67,971,74],{},[67,973,120,974,168,977,168,980,983],{},[33,975,976],{},".lazy",[33,978,979],{},".trim",[33,981,982],{},".number"," modifier types.",[49,985,986,991,993],{},[67,987,988],{},[33,989,990],{},"RegisterTransform\u003CV>",[67,992,74],{},[67,994,995],{},"Custom DOM ↔ value transform shape.",[49,997,998,1003,1005],{},[67,999,1000],{},[33,1001,1002],{},"CustomDirectiveRegisterAssignerFn",[67,1004,74],{},[67,1006,120,1007,1010],{},[33,1008,1009],{},"assignKey"," custom-assigner signature.",[49,1012,1013,1018,1021],{},[67,1014,1015],{},[33,1016,1017],{},"UseRegisterOptions",[67,1019,1020],{},"runtime\u002Fcomposables\u002Fuse-register",[67,1022,105,1023,1026,1027,1029],{},[33,1024,1025],{},"useRegister",", including the inner element to re-bind a parent's ",[33,1028,928],{}," onto.",[49,1031,1032,1037,1039],{},[67,1033,1034],{},[33,1035,1036],{},"UseRegisterReturn\u003CV>",[67,1038,1020],{},[67,1040,149,1041,1044],{},[33,1042,1043],{},"useRegister\u003CV>()"," returns.",[38,1046,1048],{"id":1047},"set-mutate","Set \u002F mutate",[43,1050,1051,1061],{},[46,1052,1053],{},[49,1054,1055,1057,1059],{},[52,1056,54],{},[52,1058,57],{},[52,1060,60],{},[62,1062,1063,1075,1090,1102],{},[49,1064,1065,1070,1072],{},[67,1066,1067],{},[33,1068,1069],{},"SetValuePayload\u003CForm>",[67,1071,74],{},[67,1073,1074],{},"Whole-form merge payload shape.",[49,1076,1077,1082,1084],{},[67,1078,1079],{},[33,1080,1081],{},"SetValueCallback\u003CForm>",[67,1083,74],{},[67,1085,120,1086,1089],{},[33,1087,1088],{},"(prev) => next"," callback signature.",[49,1091,1092,1097,1099],{},[67,1093,1094],{},[33,1095,1096],{},"MetaTrackerValue",[67,1098,74],{},[67,1100,1101],{},"Internal \"I'm mutating\" flag exposed for advanced consumers.",[49,1103,1104,1109,1112],{},[67,1105,1106],{},[33,1107,1108],{},"Unset",[67,1110,1111],{},"runtime\u002Fcore\u002Funset",[67,1113,120,1114,1117],{},[33,1115,1116],{},"unset"," sentinel's brand type.",[38,1119,1121],{"id":1120},"ssr-payload","SSR payload",[43,1123,1124,1134],{},[46,1125,1126],{},[49,1127,1128,1130,1132],{},[52,1129,54],{},[52,1131,57],{},[52,1133,60],{},[62,1135,1136,1149],{},[49,1137,1138,1143,1146],{},[67,1139,1140],{},[33,1141,1142],{},"SerializedAttaformState",[67,1144,1145],{},"runtime\u002Fcore\u002Fserialize",[67,1147,1148],{},"The SSR payload shape.",[49,1150,1151,1156,1158],{},[67,1152,1153],{},[33,1154,1155],{},"SerializedFormData",[67,1157,134],{},[67,1159,1160],{},"Single form's serialized state.",[38,1162,1164],{"id":1163},"wizard","Wizard",[43,1166,1167,1177],{},[46,1168,1169],{},[49,1170,1171,1173,1175],{},[52,1172,54],{},[52,1174,57],{},[52,1176,60],{},[62,1178,1179,1192,1204,1225,1246,1262,1278,1300,1322,1337,1356,1374,1393,1416,1437,1451],{},[49,1180,1181,1186,1189],{},[67,1182,1183],{},[33,1184,1185],{},"UseWizardReturnType\u003CForms>",[67,1187,1188],{},"runtime\u002Ftypes\u002Ftypes-wizard",[67,1190,1191],{},"The whole wizard return: current, statuses, navigation.",[49,1193,1194,1199,1201],{},[67,1195,1196],{},[33,1197,1198],{},"WizardOptions\u003CForms>",[67,1200,1188],{},[67,1202,1203],{},"The options bag.",[49,1205,1206,1217,1219],{},[67,1207,1208,168,1211,168,1214],{},[33,1209,1210],{},"AnyForm",[33,1212,1213],{},"FormKeyOf\u003CF>",[33,1215,1216],{},"KeysOf\u003CForms>",[67,1218,1188],{},[67,1220,1221,1222,80],{},"Helpers for typing forms passed to ",[33,1223,1224],{},"useWizard",[49,1226,1227,1232,1234],{},[67,1228,1229],{},[33,1230,1231],{},"WizardNavOptions",[67,1233,1188],{},[67,1235,1236,1237,168,1240,168,1243,80],{},"Options forwarded to ",[33,1238,1239],{},"next",[33,1241,1242],{},"back",[33,1244,1245],{},"goTo",[49,1247,1248,1253,1255],{},[67,1249,1250],{},[33,1251,1252],{},"StepSlot\u003CForms>",[67,1254,1188],{},[67,1256,1257,1258,1261],{},"One position in the source ",[33,1259,1260],{},"steps"," array: a form, a string, a function, or a wrapped marker.",[49,1263,1264,1269,1271],{},[67,1265,1266],{},[33,1267,1268],{},"CompiledStep\u003CForms>",[67,1270,1188],{},[67,1272,1273,1274,1277],{},"One resolved position, as ",[33,1275,1276],{},"wizard.steps"," exposes it.",[49,1279,1280,1288,1290],{},[67,1281,1282,168,1285],{},[33,1283,1284],{},"GateMarker",[33,1286,1287],{},"LazyMarker",[67,1289,1188],{},[67,1291,149,1292,1295,1296,1299],{},[33,1293,1294],{},"gate(step)"," and ",[33,1297,1298],{},"lazy(fn)"," return. Opaque brands; you never construct one.",[49,1301,1302,1310,1312],{},[67,1303,1304,168,1307],{},[33,1305,1306],{},"FormStatus",[33,1308,1309],{},"FormStatusSeed",[67,1311,1188],{},[67,1313,149,1314,1317,1318,1321],{},[33,1315,1316],{},"wizard.statuses[key]"," reads, and the shape ",[33,1319,1320],{},"defaultStatuses"," seeds it with.",[49,1323,1324,1329,1331],{},[67,1325,1326],{},[33,1327,1328],{},"WizardStatusesProxy\u003CS>",[67,1330,1188],{},[67,1332,1333,1334,80],{},"The call-or-read proxy behind ",[33,1335,1336],{},"wizard.statuses",[49,1338,1339,1347,1349],{},[67,1340,1341,168,1344],{},[33,1342,1343],{},"WizardCtx\u003CForms>",[33,1345,1346],{},"WizardCtxForm",[67,1348,1188],{},[67,1350,1351,1352,1355],{},"What a function slot receives, and how a form looks through its ",[33,1353,1354],{},"ctx.forms"," lookup.",[49,1357,1358,1366,1368],{},[67,1359,1360,168,1363],{},[33,1361,1362],{},"WizardOnSubmit",[33,1364,1365],{},"WizardOnError",[67,1367,1188],{},[67,1369,120,1370,1373],{},[33,1371,1372],{},"wizard.handleSubmit"," callback signatures. Both span every step, not the active one.",[49,1375,1376,1381,1383],{},[67,1377,1378],{},[33,1379,1380],{},"WizardSubmitContext\u003CForms>",[67,1382,1188],{},[67,1384,1385,1386,1388,1389,1392],{},"The context ",[33,1387,1372],{},"'s ",[33,1390,1391],{},"onSubmit"," receives.",[49,1394,1395,1400,1402],{},[67,1396,1397],{},[33,1398,1399],{},"WizardAggregateError",[67,1401,1188],{},[67,1403,1404,1405,1408,1409,1411,1412,1415],{},"One entry in ",[33,1406,1407],{},"wizard.allErrors[key]",": a ",[33,1410,352],{}," plus the ",[33,1413,1414],{},"formKey"," that produced it.",[49,1417,1418,1426,1428],{},[67,1419,1420,168,1423],{},[33,1421,1422],{},"WizardPersistFn",[33,1424,1425],{},"WizardRestoreFn",[67,1427,1188],{},[67,1429,120,1430,168,1433,1436],{},[33,1431,1432],{},"persist",[33,1434,1435],{},"restore"," callback signatures for step round-tripping.",[49,1438,1439,1444,1446],{},[67,1440,1441],{},[33,1442,1443],{},"WizardRestoreState",[67,1445,1188],{},[67,1447,149,1448,1450],{},[33,1449,1435],{}," hands back: the active step's key, in an open-ended object.",[49,1452,1453,1458,1461],{},[67,1454,1455],{},[33,1456,1457],{},"InjectWizardInput",[67,1459,1460],{},"runtime\u002Fcomposables\u002Finject-wizard",[67,1462,1463,1464,1467,1468,80],{},"The object form of ",[33,1465,1466],{},"injectWizard","'s argument, mirroring ",[33,1469,1470],{},"injectForm",[38,1472,1474],{"id":1473},"devtools","DevTools",[43,1476,1477,1487],{},[46,1478,1479],{},[49,1480,1481,1483,1485],{},[52,1482,54],{},[52,1484,57],{},[52,1486,60],{},[62,1488,1489],{},[49,1490,1491,1496,1499],{},[67,1492,1493],{},[33,1494,1495],{},"AttaformDevtoolsBridge",[67,1497,1498],{},"runtime\u002Fcore\u002Fdevtools-shared",[67,1500,1501],{},"The window-bridge contract the Nuxt overlay consumes.",[38,1503,1505],{"id":1504},"internal-only-not-for-direct-consumption","Internal-only (not for direct consumption)",[17,1507,1508,1509,1511],{},"These types ride on internal helpers and are exported for advanced custom-adapter authors. The ",[27,1510,30],{"href":29}," doctrine means everyday consumers never need them:",[1513,1514,1515,1525,1530],"ul",{},[1516,1517,1518,168,1521,1524],"li",{},[33,1519,1520],{},"StorageLeaf",[33,1522,1523],{},"StorageShape",": the slim-write-shape internal representations the runtime walks.",[1516,1526,1527,1529],{},[33,1528,672],{},": used by the path-prefix matchers inside the runtime.",[1516,1531,1532,1534],{},[33,1533,834],{},": variant-memory plumbing.",[17,1536,1537,1538,1541,1542,1541,1544,1546],{},"Treat them as appendix items: stable enough to reference, but the public-facing surfaces (",[33,1539,1540],{},"UseFormReturnType",", ",[33,1543,264],{},[33,1545,352],{},") are what consumer code should depend on.",[38,1548,1550],{"id":1549},"where-to-next","Where to next",[1513,1552,1553,1559,1568],{},[1516,1554,1555,1558],{},[27,1556,1557],{"href":29},"The schema contract",": the high-level model these types implement.",[1516,1560,1561,1567],{},[27,1562,1564],{"href":1563},"\u002Fdocs\u002Fschemas\u002Fabstract-schema",[33,1565,1566],{},"AbstractSchema",": when you need the contract for a non-Zod schema library.",[1516,1569,1570,1574],{},[27,1571,1573],{"href":1572},"\u002Fdocs\u002Freference\u002Fentry-points","Entry-point reference",": which subpath each type ships from.",{"title":1576,"searchDepth":1577,"depth":1577,"links":1578},"",2,[1579,1580,1581,1582,1583,1584,1585,1586,1587,1588,1589,1590,1591],{"id":40,"depth":1577,"text":41},{"id":207,"depth":1577,"text":208},{"id":330,"depth":1577,"text":331},{"id":520,"depth":1577,"text":521},{"id":637,"depth":1577,"text":638},{"id":735,"depth":1577,"text":736},{"id":899,"depth":1577,"text":900},{"id":1047,"depth":1577,"text":1048},{"id":1120,"depth":1577,"text":1121},{"id":1163,"depth":1577,"text":1164},{"id":1473,"depth":1577,"text":1474},{"id":1504,"depth":1577,"text":1505},{"id":1549,"depth":1577,"text":1550},"Every public type Attaform exports, grouped by purpose. Inference flows from useForm; consumers rarely need to reach for these directly, but they're documented for advanced wiring.","md",{},[1596,1599,1602],{"label":1597,"value":1598},"Category","Reference",{"label":1600,"value":1601},"Doctrine","inference-first; types exposed but rarely needed",{"label":57,"value":1603,"kind":33},"src\u002Fruntime\u002Ftypes\u002Ftypes-api.ts + types-core.ts",true,"\u002Fdocs\u002Freference\u002Ftypes",{"title":5,"description":1592},null,"docs\u002Freference\u002Ftypes","0Nz9-Lck30yr7ptbZd5HG-qo2ltG0xxLAOP2MohoFUc",1792377967459]