import { U as Uuid, R as RecordsResult, $ as MergeFieldSource, _ as MergeFieldSemanticType, Z as MergeFieldModifier, a2 as OverridePolicy, z as Delivery, g as Timestamp, M as Freshness, l as RecordDocument } from './record-C3thPhpR.cjs'; export { s as ABSENCE_REASONS, t as ACTOR_VOCABULARY, u as AbsenceReason, A as Actor, v as COMPUTE_ON, w as CONTEXT_POLICIES, C as ComputeOn, c as ContextPolicy, x as DECLARABLE_FIELD_KINDS, y as DELIVERIES, D as DeclarableFieldKind, E as ENTITY_TOKENS, B as EntityToken, G as FIELD_SENSITIVITIES, I as FIELD_SOURCES, J as FORMULA_NODE_RESULTS, K as FRESHNESS, o as FieldBehavior, b as FieldSensitivity, F as FieldSource, L as ForbiddenEnvelopeWord, H as HiddenFieldNotice, N as KERNEL_TABLES, Q as KernelTableName, V as KeysetRow, W as MERGE_FIELD_MODIFIERS, X as MERGE_FIELD_SEMANTIC_TYPES, Y as MERGE_FIELD_SOURCES, a0 as ON_DELETE, a1 as OVERRIDE_POLICIES, O as OnDelete, a3 as PARITY_FIELD_TYPES, a4 as PER_VALUE_ACCESS_WORDS, p as ParityFieldType, a5 as PerValueAccessWord, P as PgError, q as PredictedRefusal, a6 as ProvenancePointer, a7 as RELATION_BINDINGS, a8 as RELATION_CARDINALITIES, a9 as RELATION_FLAVORS, aa as RETIRED_ACTOR_WORDS, ab as RULE_NODE_KINDS, ac as RULE_USES, n as ReadRow, r as ReadValue, ad as RecordChange, ae as RecordChangeResult, af as RecordGraphWritten, ag as RecordKeysetPage, ah as RecordPage, m as RecordPageSort, ai as RecordRead, aj as RecordRevision, j as RecordsError, k as RecordsErrorCode, f as RelationBinding, e as RelationCardinality, d as RelationFlavor, ak as RetiredActorWord, h as RuleNodeKind, i as RuleUse, al as STORAGE_MODES, am as STORE_DOORS, an as STORE_KNOBS, ao as STORE_REFUSAL_CODES, ap as StaleWriteDetail, S as StorageMode, aq as StoreDoorName, ar as StoreRefusalCode, as as StoredRecord, at as TABLE_DISPLAYS, au as TABLE_ORIGINS, av as TABLE_TYPES, a as TableDisplay, aw as TableOrigin, T as TableType, ax as VALUE_ALTERNATE_KEYS, ay as VALUE_ENVELOPE_KEYS, az as ValueAlternate, aA as ValueAlternateKey, aB as ValueEnvelope, aC as ValueEnvelopeKey, aD as ValueSource, aE as WriteConflict, aF as err, aG as isLockedStub, aH as isRecordsErr, aI as ok, aJ as splitLockedRows, aK as unwrapRecords } from './record-C3thPhpR.cjs'; import { cX as TableDuplicateProgress, cY as TableDuplicated, Q as CaptureFileRef, S as CaptureOutcome } from './client-CCDI4mfn.cjs'; import { RecordsClient } from './core/index.cjs'; export { A as ARCHIVE_LANES, a as ARCHIVE_LANE_LABEL, b as ARCHIVE_LANE_MEANS, c as AUTOMATION_APP_TRIGGERS, d as ActionRefusal, e as ActionRunResult, f as AdminTable, g as AnonTokenBinding, h as ArchiveLane, i as ArchivedChecklistTemplate, j as ArchivedDoorRow, k as ArchivedForm, l as ArchivedRow, n as AutomationAction, o as AutomationAppTrigger, p as AutomationAppTriggerTerms, q as AutomationComparison, r as AutomationDeclared, s as AutomationFilter, t as AutomationFlipped, u as AutomationItem, v as AutomationLastRun, w as AutomationList, x as AutomationRevision, y as AutomationRevisions, z as AutomationRun, B as AutomationRunStatus, C as AutomationRuns, D as AutomationSpec, E as AutomationStep, G as AutomationTested, H as AutomationToken, I as AutomationTrigger, J as AutomationValue, K as AutomationValues, L as AutomationWeekday, M as AutomationWhen, N as BUILT_KIND_WORD, O as CHOICE_NUDGES, P as CaptureField, U as CaptureQuestion, V as CaptureSheetFace, W as CaptureSheetSummary, X as ChecklistDeclared, Y as ChecklistRequirement, Z as ChecklistRequirementKind, _ as ChecklistRoleSpec, $ as ChecklistRunStarted, a0 as ChecklistRunStep, a1 as ChecklistRunSummary, a2 as ChecklistSpec, a3 as ChecklistStepCompleted, a4 as ChecklistStepSpec, a5 as ChecklistTemplateShape, a6 as ChecklistTemplateSummary, a7 as ChecklistTrigger, a8 as ChecklistTriggerKind, a9 as ChoiceCellBack, aa as ChoiceLike, ab as ChoiceNudge, ac as ChoiceOption, ad as ChoiceRehome, ae as ChoiceUsage, af as ChoicesRehomed, ag as CommentThreadRead, ah as CommentWritten, ai as ConversationScope, aj as ConversationScopeContext, ak as CustomFieldTableType, al as DEFAULT_ARCHIVE_LANE, an as DRILL_CHART_TOKENS, ao as DRILL_DESCRIPTION_MAX, ap as DRILL_DOORS, aq as DRILL_SCHEMA, ar as DataHomeTable, as as DecorationColor, at as DecorationPath, au as DecorationRule, av as DecorationRuleOp, aw as DecorationTarget, ax as DocRenderRow, ay as DocSignatureCheck, az as DocSignatureRow, aA as DocTemplateRow, aB as DocToken, aC as DocUnresolvedToken, aD as DrillAdHocOp, aE as DrillAnswer, aF as DrillAnswerRow, aG as DrillChartToken, aH as DrillDeclaration, aI as DrillDefinition, aJ as DrillDimension, aK as DrillFinding, aL as DrillGrain, aM as DrillHaving, aN as DrillLane, aO as DrillLevel, aP as DrillMeasure, aQ as DrillMeasureOp, aR as DrillMeasureWhereValue, aS as DrillPath, aT as DrillQuestion, aU as DrillRecords, aV as DrillRowsPage, aW as DrillSource, aX as DrillView, aY as EnrichAlternate, aZ as EnrichCell, a_ as EnrichDeclared, a$ as EnrichDueRow, b0 as EnrichRun, b1 as EnrichSource, b2 as Enrichment, b3 as EnrichmentSummary, b4 as EntityBackLinkItem, b5 as EntityBackLinks, b6 as EntityFieldRights, b7 as EntityFieldValue, b8 as EntityFieldsAcross, b9 as EntityRecordMatch, ba as EntityRecordRead, bb as EntityRecordsFound, bc as EntityRowWritten, bd as EntityTableFacts, be as ExternalPrincipalCard, F as FieldDrift, bf as FieldDriftAspect, bg as FieldHistoryEntry, bi as FieldRetypePreview, bj as FieldRetyped, bk as FormArchiveAnswer, bl as FormulaHistoryEntry, bm as FormulaParse, bn as FormulaPreview, bo as GridLayout, bp as GridLayoutMode, bq as GridRowHeight, br as HistoryActor, bs as HistoryActorKind, bt as HistoryChange, bu as HistoryRetention, bv as Home, bw as ImportBatchResult, bx as ImportColumnPlan, by as ImportColumnsDeclared, bz as ImportFinished, bA as ImportOpened, bB as ImportOutcome, bC as ImportPlan, bD as ImportPolicy, bE as ImportProposal, bF as ImportReport, bG as ImportRun, bH as InboundAddress, bI as InboundDeclared, bJ as InboxCounts, bK as InboxStateChange, bL as IoExportPage, bM as MigrationEntry, bN as MigrationUndone, bO as NewEntityFieldDeclaration, bP as OutsideShareAnswer, bQ as PIPELINE_RULE_KINDS, bR as ParentExtracted, bS as Pipeline, bT as PipelineColumn, bU as PipelineDeclared, bV as PipelineGate, bW as PipelineGatePreview, bX as PipelineMissingField, bY as PipelineMoveMany, bZ as PipelineMoveManyItem, b_ as PipelineMoveManyResult, b$ as PipelineMoveResult, c0 as PipelineMoveVerdict, c1 as PipelineRule, c2 as PipelineRuleKind, c3 as PipelineSpec, c4 as PipelineStage, c5 as PipelineVerdict, c7 as PublishBinding, c8 as PublishBindingKind, cb as ROW_LABEL_FORMULA_MAX_LENGTH, cc as ROW_WEB_NOT_READY, cd as RecordChangeAction, ce as RecordComment, cf as RecordEvent, cg as RecordFollowSet, ch as RecordFollowers, ci as RecordHeader, cj as RecordHistoryEntry, ck as RecordMoved, cm as RecordRowControls, cn as RecordScopeComment, co as RecordScopeContext, cp as RecordScopeField, cq as RecordScopeHistoryEntry, cr as RecordScopeRelation, cs as RecordScopeWithheld, ct as RecordSplit, cv as RecordsMerged, cw as RegisteredTable, cx as ResolvedPublishBinding, cy as ResolvedPublishBindingKind, cz as RestorePreview, cA as RestoreResult, cB as RetypeBehaviour, cC as RetypePreview, cD as RowAction, cE as RowActionStep, cF as RowDefaultsApplied, cG as SHOWN_TO_LABEL, cH as SHOWN_TO_VALUES, cI as SHOWN_TO_WHO_MAY_CHANGE, cJ as STAGE_RULE_ENFORCEMENT, cK as STAGE_RULE_ON_FAIL, cL as ShownTo, cM as StagePending, cN as StagePendingOnBoard, cO as StageRuleEnforcement, cP as StageRuleOnFail, cQ as StageRuleWarning, cR as SyncAutoRefresh, cS as Table, T as TableArchiveProgress, cT as TableCapacity, cU as TableCopyInProgress, cV as TableCopySpec, cW as TableDecorations, c_ as TableHome, c$ as TableHomeDestination, d0 as TableLevel, d1 as TableLevelApproval, d2 as TableLevelFacts, d3 as TableLevelSet, d4 as TableListEntry, d6 as TableMoved, d7 as TablePlacement, d8 as TablePlacementFact, d9 as TableReaderRule, da as TableRestoreProgress, db as TableRowCount, dc as TableRowDefaults, dd as TableRowDefaultsPatch, de as TableRowLabel, df as TableSyncAnswer, dg as TableSyncResult, dh as TableSyncSettings, di as TableSyncSource, dj as TableSyncSourceDocument, dk as TableSyncSpec, dl as TableWebhook, dm as TableWebhookDeclared, dn as TypedChoiceDecision, dp as ViewLayout, dq as ViewOrderSet, dr as WorkApprovalDecision, ds as WorkApprovalFiled, dt as WorkApprovalState, du as WorkApprover, dv as WorkAssignment, dw as WorkAssignmentField, dx as WorkChange, dy as WorkDecideMany, dz as WorkDecideManyItem, dA as WorkDecideManyResult, dB as WorkDecideVerdict, dC as WorkDueState, dD as WorkGraph, dE as WorkInboxItem, dF as WorkInboxKind, dG as WorkInboxView, dH as WorkInstantiation, dI as WorkListFlavour, dJ as WorkListItem, dK as WorkOrigin, dL as WorkRecordState, dM as WorkSlotHold, dN as WorkState, dO as WorkTemplateNode, dP as WorkTemplateRelation, dQ as WorkTurn, dR as actionRefusals, dS as archivedByLine, dT as archivedWhen, dU as asChoiceNudge, dW as automationWebhookUrl, dX as choiceSlug, dY as choiceValuesOf, dZ as choicesOf, d_ as clearsRowLabel, e0 as decideTypedChoice, e1 as declareDrillDefinition, e2 as drillAnswerOf, e3 as drillFindingKnob, e4 as emptyArchiveLine, e5 as exportPageXlsx, e6 as holdsARetiredChoice, e8 as isArchiveLane, e9 as isAutomationAppTrigger, ea as isFoundation, eb as isShownTo, ec as isTheChosen, ed as keptGroups, ee as keptOutOfSight, ef as keptTableHref, eg as levelHasShownTo, eh as looksLikeAnId, ei as mayDrag, ej as moveConsequence, ek as moveInOrder, el as offeredAsContext, em as optionKey, en as optionLabel, eo as parseFieldDrift, ep as parseTableCopiesInProgress, eq as parseTableDuplicateProgress, er as parseTableDuplicated, es as parseTableHome, et as parseTableMoved, ev as previewRetype, ew as previewRuleChange, ex as recordChangeTrigger, ey as recordSourceKey, ez as recordSourceTable, eB as recordsUseSentence, eC as rehomeSentence, eD as removedChoicesInUse, eE as ruleThatRefuses, eF as rulesWithTopStar, eG as sameDocument, eH as scopeChip, eI as sheetSyncSpec, eJ as valueConverts, eK as withRowCounts, eM as withTablePlacement } from './client-CCDI4mfn.cjs'; export { M as MyLevel, O as OpLedger, P as PermissionLevel, g as RecordsActor, d as RecordsChangeSink, R as RecordsConfig, c as RecordsDataSource, b as RecordsErrorSink, h as RecordsFilter, f as RecordsRealtimePort, i as RecordsResolverPort, j as RecordsResponse, k as RecordsTableQuery, a as RowAgentPort, e as RowAgentTarget, S as STORE_PERMISSION_LEVELS, l as asPermissionLevel, m as atLeast, n as createOpLedger, o as defaultOpLedger, p as forgetAllOps, q as highestLevel, r as isOwnOp, s as mintOpId, t as rememberedOpCount } from './ports-BSd-1p1l.cjs'; import { m as CoercibleField, K as KernelTargets } from './field-BJBjyD8y.cjs'; export { A as ADDRESS_PARTS, c as AGENT_WRITER_WORDS, d as AddressPart, e as AddressValue, B as BARCODE_SYMBOLOGIES, f as BUTTON_DOES, g as ButtonDoes, h as ButtonPressed, i as ButtonSettings, C as ChoiceOptions, j as CoerceOptions, k as Coerced, l as CoercedAnswers, n as FIELD_KINDS, F as Field, o as FieldDuplicated, p as FieldKind, q as FieldOptionEdit, r as FieldPatch, s as FieldProposal, b as FieldRule, a as FieldTypeWord, N as NEWER_FIELD_KINDS, t as NOT_A_MEMBER_WORDS, u as NewFieldDeclaration, v as NewerFieldKind, P as ParityFieldTypeDescriptor, w as PersonStamp, R as RelationDisplay, x as RelationNameIndex, y as RelationNameMatch, z as RelationNamesAnswer, S as STATUS_GROUPS, D as STATUS_GROUP_WORDS, E as SYSTEM_WRITER_WORDS, G as StatusGroup, T as TableProposal, H as addressFromText, I as addressMapUrl, J as addressValueText, L as allowsOtherValues, M as buttonNeeds, O as buttonOf, Q as buttonUrlPlaceholders, U as coerceTypedAnswer, V as coerceTypedAnswers, W as coercionLabel, X as durationText, Y as entityReferenceKindsOf, Z as fieldKindFor, _ as isAddressValue, $ as isButtonField, a0 as isEntityReferenceConfig, a1 as isPersonStamp, a2 as newerKindExportWords, a3 as newerKindOf, a4 as newerKindWords, a5 as personStampText, a6 as ratingMaxOf, a7 as readTypedDuration, a8 as relationNameIndexOf, a9 as relationNameKey, aa as relationNamesIn, ab as richTextPlain, ac as safeLinkHref, ad as splitListCell, ae as statusGroupOf } from './field-BJBjyD8y.cjs'; export { h as PickListDocument, j as PickListIndexDocument, k as PickListIndexEntry, l as PickListItem, m as PickListItemInput } from './pickListDoors-cMy0JEig.cjs'; export { B as BookingAvailability, a as BookingDeclared, b as BookingSummary, c as BookingWindow, d as FormResults, e as FormRoute, F as FormSummary, f as Rule, g as RuleAnswer, R as RuleExpression, h as bookingPath, p as publicFormPath } from './rule-Ch4aZVWV.cjs'; export { D as DEFAULT_PORTAL_ARCHIVE_FILTER, F as FormLookOptions, a as PORTAL_ACCENTS, b as PORTAL_ARCHIVE_FILTERS, P as PortalAccent, c as PortalArchiveAnswer, d as PortalArchiveFilter, e as PortalCard, f as PortalConfig, g as PortalConfigInput, h as PortalFooterLink, i as PortalFormAnswer, j as PortalFormInput, k as PortalFormRef, l as PortalFormSpec, m as PortalInvitation, n as PortalPreviewRow, o as PortalPrincipal, p as PortalRevocation, q as PortalStage, r as PortalStyle, s as PortalStyleInput, t as PortalSummary, u as PortalTableExposure, v as PortalTableRef, w as PublicPicture, x as emptyPortalArchiveLine, y as isPortalAccent, z as isPortalArchiveFilter, A as portalArchiveConsequence, B as portalConfirmLine, C as portalPath, E as portalTitleTypedBack } from './portal-Cd8TMBAQ.cjs'; export { A as AggregateBucket, e as AggregateCompare, f as AggregateCompareKind, g as AggregateCompareWindows, h as AggregateDelta, b as AggregateFilter, j as AggregateGroupValue, c as AggregateMeasure, a as AggregateOperation, k as AggregateRow, l as AggregateWindow, m as DashboardBlock, D as DashboardBlockKind, n as DashboardBlockResult, o as DashboardRunResult, p as DashboardSummary, q as DashboardTarget, r as DashboardTargetBase, s as DashboardTargetOp, t as DashboardTargetResult, u as DashboardTotals, v as DigestPreview, F as FilterWords, I as InterfaceRead, w as InterfaceRows, x as InterfaceRowsField, M as MySubscription, Q as QuietHours, R as RecordFilter, y as RowTemplateRow, z as SavedViewColorBy, B as SavedViewDefinition, C as SavedViewLayout, d as SavedViewRow, E as SavedViewSpecIn, G as StoreFilter, H as StuckRow, J as Subscription, K as SubscriptionBlock, S as SubscriptionCadence, L as SubscriptionSpec, N as callersTimeZone, O as cellMatchesWords, P as filterWordsOf, T as hasQuietHours, i as isRuleFilter, U as liftWithheld, V as measureKey, W as stableFilterKey, X as withCallersClock } from './subscription-BRwuydeh.cjs'; export { R as RELATIVE_DAY_KINDS, a as RelativeDayKind, b as RelativeFieldLookup, c as RelativeWindowOptions, h as holdsRelativeDays, l as lookupFromFields, r as readersTimeZone, d as relativeWindowBounds, e as resolveRelativeDays, s as setReadersTimeZone, w as weekStartIndexOf } from './relativeDays-CFZpGUdI.cjs'; export { a as EntityRef, E as EntityRefWithWords, b as EntityReferenceKind, R as REVERSE_LINKS_PAGE_MAX, c as REVERSE_LINKS_RECORDS_PER_CALL, d as Relation, e as RelationCarries, f as RelationCoordinate, g as RelationIcons, h as RelationProperties, i as RelationTarget, j as RelationWordsManyArgs, k as ReverseColumn, l as ReverseLink, m as ReverseLinks, n as ReverseLinksFieldsArgs, o as ReverseLinksManyArgs, S as SourceArchived, p as entityReferenceKinds, q as entityReferenceSearch, r as entityReferenceWords, s as entityRefsOf, t as entityRefsToWrite, u as isReverseField, v as sourceArchivedOf } from './relation-DuY2Eis-.cjs'; export { O as ObjectKind, a as ObjectOrganizationAnswer, c as OpeningViewShape, R as RecordOrganizationPort, W as WHERE_ID_OPENS_DOOR, r as readObjectOrganizationAnswer, d as readOpeningViewShape, b as resolveObjectOrganization, w as whereIdOpensPort } from './objectOrganization-DLLY7HMV.cjs'; export { TABLE_KIND_PREFIX, TableKindFacts, TableRenderSchema, TableSchemaMode, fieldKindOf, isTableKind, tableIdOf, tableJsonSchema, tableKindMapping, tableKindSlug, tableRenderSchema } from './table-kind/index.cjs'; import './doors-CBiSnfzU.cjs'; /** Anything that names the record types it applies to: a Field, or one of its Rules. */ interface NamesRecordTypes { applies_to_types?: readonly string[] | null | undefined; } /** Asked of `client.fields` / `useFields`: every column of the table, whichever record types it applies to. */ declare const EVERY_RECORD_TYPE = "*"; /** * The record type of one record: the value of its table's type field (a choice's key), or undefined when the * table has no type field or the record has no type yet. A list value reads as its first choice. */ declare function recordTypeOf(table: { type_field?: string | null | undefined; } | null | undefined, document: Record | null | undefined): string | undefined; /** A column every record has (it names no record types). */ declare function fieldAppliesToEveryType(field: NamesRecordTypes): boolean; /** * Whether a column applies to a record of this type. A column that names no types applies to every record; one * that names types applies only to a record whose type is one of them, compared as words (the store also * matches a choice's id, so a column declared by option id may read as applying here only after the store says * so — a screen asks the store when it matters). */ declare function fieldAppliesToType(field: NamesRecordTypes, recordType: string | null | undefined): boolean; /** The record types a column names, as they were written. Empty for a column every record has. */ declare function typesOfField(field: NamesRecordTypes): string[]; type Json = Record; /** * THE NUMBER FORMAT A ROLLUP OR LOOKUP INHERITS from the column it reads (BUTTON-STAMPS; the store's * custom._picked_look twin): the column's own chosen number look whole, else money keeps its currency, a percent * stays a percent and a number keeps its unit as a suffix. `undefined` when the column has no number format worth * carrying. */ declare function pickedLookOf(field: Json): { id: string; options?: Json; } | undefined; /** * THE NUMBER FORMAT A FORMULA COLUMN SHOWS when the template declares none: a label that says percent is a * percent; otherwise a formula that does arithmetic with money columns (and never divides by one: a ratio is not * money) shows money in that currency — "Net to client" = offer − fee − costs − liens reads "$18,247", not * "18,247" (ADVERSARIAL-3 D8). `fields` are the table's columns as the store keeps them (their `display_format` * already inherited). `undefined` when nothing is worth carrying — a formula answering words stays words. */ declare function formulaLookOf(formula: string, field: Json, fields: readonly Json[]): { id: string; options?: Json; } | undefined; /** Does this stored field read as a rollup or a lookup (a column that reads another table's column)? */ declare function isDerivedField(f: Json): boolean; /** * THE NUMBER FORMAT A ROLLUP OR LOOKUP SHOWS when it declares none (ROLLUP-FORMAT): that of the column it reads * ("Material cost per unit (USD)" = sum of the BOM lines' "Line cost" reads "$56", a lookup of a money column reads * "$"). sum / min / max / avg keep the source's look; count and the other measures stay plain numbers. `farFieldsOf` * answers the candidate far tables' columns (their own looks already worked out) for the field's `via` link; the * first candidate that holds the picked column and has a look worth carrying wins. `undefined` otherwise. */ declare function derivedLookOf(field: Json, farFieldsOf: (via: string) => ReadonlyArray): { id: string; options?: Json; } | undefined; /** * THE DISPLAY FALLBACK: every formula column with no declared `display_format` gets the inferred one, so an older * install or a hand-made formula reads "$18,247" / "42%" like a new one. A declared format is never touched; a * formula with nothing worth carrying stays as it is. Returns the same array when nothing changed. */ declare function withFormulaLooks(fields: readonly F[]): F[]; /** * THE DISPLAY FALLBACK FOR ROLLUPS AND LOOKUPS: every rollup / lookup with no declared `display_format` gets the * look of the column it reads (`derivedLookOf`). A formula that reads such a column is worked out again after, so * chains (lookup -> formula -> rollup) settle. Never touches a declared format. */ declare function withDerivedLooks(fields: readonly F[], farFieldsOf: (via: string) => ReadonlyArray): F[]; type WithFormat = CoercibleField & { display_format?: unknown; key?: string; }; /** Whether a Field is a record number. */ declare function isAutonumberField(field: CoercibleField | null | undefined): boolean; /** A record number's prefix ("TASK-"), or "" when it has none or the Field is not a record number. */ declare function autonumberPrefixOf(field: WithFormat | null | undefined): string; /** A record number as a person reads it: its prefix and the number ("TASK-42"); null when there is none. */ declare function autonumberWords(field: WithFormat, value: unknown): string | null; /** * A prefix as it stands before its number (walk 2026-10-08 D4): "TASK" reads "TASK-2", as the * Prefix box's own placeholder promises; a prefix that already ends in a separator ("TASK-", * "INV #", "PO/") is kept as typed. The same rule as the grid's `autonumber` format * (@ai-matrx/design-system field-formats), so a card, a copy and a cell never disagree. */ declare function autonumberJoin(prefix: string): string; /** * A SEARCH FOR A RECORD NUMBER BY ITS WORDS. "TASK-42", "task-42" or "TASK 42" names record 42 of the record * number whose prefix is "TASK-": the store keeps 42, so the words are turned into that column's number. * Null when the words name no record number of these Fields. */ declare function autonumberSearchOf(fields: readonly F[], words: string): { field: F; number: number; } | null; /** * A read's filter with "this record number is N" added (AND). The flat shape takes the column's key; a rule * expression is wrapped in an `and` with `{op: eq, args: [{field: id}, {const: N}]}`. */ declare function filterWithAutonumber(filter: Record | null | undefined, field: { id: string; key: string; }, n: number): Record; type WallParts = { year: number; month: number; day: number; hour: number; minute: number; second: number; }; /** The wall clock `at` shows in the person's zone (the device's when none is saved). */ declare function wallPartsInZone(at: Date): WallParts; /** The instant at which the person's wall clock reads these fields (the device's clock when no zone is saved). */ declare function instantFromWallInZone(year: number, month: number, day: number, hour?: number, minute?: number, second?: number): Date; type TypedDate = { ok: true; day: string; /** ISO instant, only when a time of day was read or asked for. */ instant: string | null; } | { ok: false; why: string; }; /** The order a locale writes a numeric date in: "mdy", "dmy" or "ymd". */ declare function localeDateOrder(locale?: string): "mdy" | "dmy" | "ymd"; /** Sheets' and Excel's two-digit-year window: 00–29 → 2000–2029, 30–99 → 1930–1999. */ declare function twoDigitYear(yy: number): number; type TypedTime = { ok: true; /** 24-hour `HH:MM`, or `HH:MM:SS` when seconds were typed. */ value: string; } | { ok: false; why: string; }; /** Read one typed time of day. Never throws; never guesses. */ declare function readTypedTime(raw: string): TypedTime; /** * Read one typed date. `withTime` is true for a date-and-time column. Never throws; never guesses. */ declare function readTypedDate(raw: string, opts?: { withTime?: boolean; locale?: string; }): TypedDate; /** * THE TEXT AN EDITOR OPENS WITH for a stored day or instant — the inverse of `readTypedDate`, so * a cell opened by Enter or a double-click shows words this reader reads back to the SAME value * (grids review 3, 2026-09-30: those paths used to open the browser's own date picker, which lost * the time and saved "now"). The day is numeric in the locale's own order with a four-digit year; * a time of day follows as `2:30 PM` (a 12-hour locale) or `14:30` (a 24-hour one). An unreadable * stored value opens as the stored characters, untouched. */ declare function typedDateText(value: unknown, opts?: { withTime?: boolean; locale?: string; }): string; /** A time of day in the words `readTypedTime` reads back: `2:30 PM` or `14:30`, by the locale's clock. */ declare function typedTimeText(hours: number, minutes: number, locale?: string): string; /** How well one text matches what was typed: 4 exact, 3 starts with, 2 a word starts with, 1 contains, 0 not at all. */ type TypedMatchScore = 0 | 1 | 2 | 3 | 4; /** * How well `text` matches what was typed. An empty search matches everything at the lowest rank * that still shows (1), so an empty box lists every item in its own order. */ declare function typedMatchScore(text: string, typed: string): TypedMatchScore; /** * The items that match what was typed, best first; ties keep the given order. `textsOf` answers the * words an item is found by — its NAME first, then anything that tells two apart (a second line). * The name ranks at its full strength; a second line only ever finds an item (it ranks as * "contains"), so `Sun` puts Sunny Okafor before the Patricia Marsh who lives on Sunset Blvd. */ declare function rankTypedMatches(items: readonly T[], typed: string, textsOf: (item: T) => string | readonly string[]): T[]; type TypedNumber = { ok: true; value: number; } | { ok: false; why: string; }; declare function readTypedNumber(raw: string): TypedNumber; interface BaseTable { id: Uuid; name: string; } interface BasePort { /** `RecordsClient.tableDuplicate`: one table, with its own passes looped until done. */ tableDuplicate(args: { tableId: Uuid; withRecords?: boolean; name?: string | null; organizationId?: Uuid | null; onProgress?: (progress: TableDuplicateProgress) => void; }): Promise>; /** `custom.base_copy_finish`: {old table id: its copy's id} → how many link columns and cells now point inside the copy. */ finish(args: { organizationId: Uuid; pairs: Record; }): Promise>; /** * `custom.copy_table_extras`: {source table id: its copy's id} → the automations (switched OFF) and pages every copy now carries, * with the copy's own column and view ids. THE ONE home of that step — the base-move job in aidream calls the same function. */ copyTableExtras(args: { organizationId: Uuid; pairs: Record; }): Promise>; /** `RecordsClient.tableArchive` / its restore: put a copy away, or bring it back to be copied from. */ archive?(tableId: Uuid): Promise>; unarchive?(tableId: Uuid): Promise>; /** The door that makes a table's Home today (`declareTable`): a new record "" in the person kernel. A NEW base is a new Home. */ createHome?(name: string): Promise>; /** The one door that moves a table between Homes: `custom.record_reparent` (`RecordsClient.recordReparent`). Pages and automations ride on their table. */ moveInto?(tableId: Uuid, homeId: Uuid): Promise>; } interface BaseCopyProgress { /** 1-based position of the table being copied, and how many there are. */ at: number; of: number; tableName: string; pass: TableDuplicateProgress | null; } interface BaseCopied { /** The NEW Home every copied table now lives in (a copy is its own base); null when the port cannot make Homes. */ homeId: Uuid | null; /** Source table id → its copy. */ pairs: Record; tables: Array<{ from: BaseTable; copy: BaseTable; records: number; }>; relinkedColumns: number; relinkedCells: number; /** Automations copied (every one OFF) and pages copied, with every table id inside them pointing at the copies. */ automations: number; pages: number; /** One sentence per automation or page that could not be copied. */ extrasRefused: string[]; /** What a copy never carries, from the per-table door's own words, once per table. */ notCopied: string[]; } type BaseCopyResult = { ok: true; data: BaseCopied; } /** * The table it stopped at; the copies made before it are named so they can be opened or archived. * `strayCopyId`: the store made a copy of `stoppedAt` before the refusal (a pass failed, or its * answer could not be read), so a table exists that `made` does not name — null when none did. */ | { ok: false; error: unknown; stoppedAt: BaseTable; made: BaseCopied["tables"]; strayCopyId: Uuid | null; }; /** The copy a `tableDuplicate` refusal says the store had already made (`detail.copyId`), or null. */ declare function copyIdOfRefusal(error: unknown): Uuid | null; /** "Harbor Studio (copy)", the same word the table dialog offers. */ declare function baseCopyName(name: string): string; /** "Harbor Studio (restored 10/15/2026)". */ declare function restoredBaseName(name: string, on: string): string; /** Duplicate every table of a base. `names` (by source table id) overrides the "" a copy is given. */ declare function duplicateBase(port: BasePort, args: { organizationId: Uuid; tables: readonly BaseTable[]; withRecords: boolean; /** The copy's name for each table; default the source's own name (the copies live together in the new base). */ nameFor?: (table: BaseTable) => string; onProgress?: (p: BaseCopyProgress) => void; /** Put the copies in a NEW Home with this name (a base is a Home); absent keeps each copy where the per-table door put it. */ homeName?: string; }): Promise; interface BaseSnapshotRecord { label: string; origin: "manual" | "schedule"; /** Source table → the put-away copy that holds its columns, views and records as they were. */ tables: Array<{ table_id: Uuid; snapshot_table_id: Uuid; name: string; records: number; }>; } /** Take a snapshot: copy every table WITH records, then put each copy away so no list shows it. */ declare function snapshotBase(port: BasePort, args: { organizationId: Uuid; tables: readonly BaseTable[]; label: string; origin?: "manual" | "schedule"; onProgress?: (p: BaseCopyProgress) => void; }): Promise<{ ok: true; snapshot: BaseSnapshotRecord; } /** `leftInLists`: copies that could NOT be put away (each still in the lists) — empty when the failure left nothing behind. */ | { ok: false; error: unknown; stoppedAt: BaseTable; leftInLists: Uuid[]; }>; /** Restore a snapshot as a NEW base: each put-away copy is brought back, copied under its own name, and put away again. */ declare function restoreSnapshot(port: BasePort, args: { organizationId: Uuid; snapshot: BaseSnapshotRecord; baseName?: string; restoredOn?: string; onProgress?: (p: BaseCopyProgress) => void; }): Promise; /** One file waiting to go up, with its bytes until they have. */ interface QueuedCaptureFile { field: string; name: string; mime_type: string; size_bytes: number; duration_ms?: number | null | undefined; /** The bytes. Dropped once `uploaded` is set, so the queue does not hold them twice. */ blob?: Blob | null | undefined; /** Set once the platform's byte store has them. */ uploaded?: { file_id?: string | null | undefined; url?: string | null | undefined; } | null | undefined; } /** `waiting` → `sending` → `landed`, or `refused` when the door has decided. */ type QueuedCaptureState = "waiting" | "sending" | "landed" | "refused"; interface QueuedCapture { /** Minted on the phone when the capture was taken. The row's key AND the door's. */ client_key: string; organization_id: string; sheet_id: string; sheet_title?: string | undefined; answers: Record; files: QueuedCaptureFile[]; device: string | null; /** The moment the PHONE took it — never the moment the signal came back. */ captured_at: string; location: Record | null; state: QueuedCaptureState; attempts: number; /** The door's own words, or the network's. Always something a person can act on. */ last_error: string | null; record_id: string | null; replayed: boolean; queued_at: string; landed_at: string | null; } interface CaptureQueueCounts { waiting: number; sending: number; refused: number; landed: number; } /** What one pass of `sync` did, item by item. Never a single boolean. */ interface CaptureSyncReport { attempted: number; landed: number; replayed: number; refused: number; deferred: number; outcomes: Array<{ client_key: string; state: QueuedCaptureState; record_id: string | null; replay: boolean; says: string | null; }>; /** Set when the pass stopped early because the network went away again. */ stopped_because?: string; } /** The two calls the queue makes on the outside world. Injected, so this file is headless. */ interface CaptureQueuePorts { /** Put the bytes in the platform's ONE byte store and answer with the reference. */ uploadFile(file: QueuedCaptureFile, item: QueuedCapture): Promise<{ file_id?: string | null; url?: string | null; }>; /** `client.captureSubmit`. */ submit(args: { sheet_id: string; client_key: string; answers: Record; files: CaptureFileRef[]; device?: string | null; captured_at?: string | null; location?: Record | null; }): Promise<{ ok: boolean; data?: CaptureOutcome | null; error?: { message?: string; code?: string; } | null; }>; } /** The smallest store the queue needs. IndexedDB in a browser, a Map in a test. */ interface CaptureQueueStore { all(): Promise; put(item: QueuedCapture): Promise; remove(clientKey: string): Promise; meta(key: string): Promise; setMeta(key: string, value: string): Promise; } /** * THE TWO REFUSALS WORTH REPEATING, and they are the package's own list, not a guess. * `results.ts` says it in as many words: `stale_read` (40001) and `timed_out` (57014) are * "the only two refusals in this list worth repeating"; `store_limit` (53400) is the third * — the store ran out of something and the same call works in a quieter moment. * * EVERYTHING ELSE THE DOOR NAMES IS A DECISION. This was the other way round until a real * browser ran it (2026-09-20): the check listed SQLSTATEs, and `RecordsClient` hands back * its own WORD — `invalid_argument`, `door` — with the sqlstate beside it. So a capture the * store had refused by name was filed as a hiccup and queued again forever, which is the * exact silent hole this file's decision 4 exists to prevent. The unit suite passed because * it fed the check SQLSTATEs: it was testing the assumption, not the client. */ declare const REFUSALS_WORTH_REPEATING: ReadonlySet; /** * Did the door DECIDE, or did the attempt merely fail? A failure with no code at all is a * network failure and waits; a refusal the store named is a decision and stays. */ declare function isDecided(error: { code?: string | null; sqlstate?: string | null; } | null | undefined): boolean; /** * A key that is unique on a phone that has been offline for a day and has never spoken to * a server. `crypto.randomUUID` where it exists; otherwise random bytes, and only then the * clock — because two captures in the same millisecond on two phones is exactly the case * that must not collide. */ declare function mintClientKey(): string; /** The IndexedDB store. Returns null where there is no IndexedDB at all. */ declare function indexedDbStore(name?: string): CaptureQueueStore | null; /** The in-memory store — for a test, and for a browser with storage switched off. */ declare function memoryStore(): CaptureQueueStore; interface CaptureQueueOptions { ports: CaptureQueuePorts; store?: CaptureQueueStore | null; /** Watch `online` and drain when the signal comes back. Default true in a browser. */ autoSync?: boolean; /** Told when anything changes, so a badge can say how many are waiting. */ onChange?: (counts: CaptureQueueCounts, items: QueuedCapture[]) => void; now?: () => Date; } interface CaptureQueue { /** Write one capture to disk. Returns its client key; the network is not asked here. */ enqueue(input: { organization_id: string; sheet_id: string; sheet_title?: string; answers: Record; files?: Array>; device?: string | null; captured_at?: string | null; location?: Record | null; client_key?: string; }): Promise; list(): Promise; counts(): Promise; /** Send everything waiting, oldest first, one at a time. Safe to call at any moment. */ sync(): Promise; /** Try one refused item again — after the person has fixed what the door named. */ retry(clientKey: string, patch?: { answers?: Record; }): Promise; /** Throw one away. The only thing that ever removes a capture nobody sent. */ discard(clientKey: string): Promise; /** Forget what has already landed. Never touches anything still waiting. */ clearLanded(): Promise; lastSyncedAt(): Promise; isOnline(): boolean; dispose(): void; } declare function openCaptureQueue(opts: CaptureQueueOptions): CaptureQueue; /** * DYN-14 / DYN-15. An ordered list of merge fields ENDING IN A LITERAL, or the * decision to block the turn, or a named absence. No unresolved value is ever * rendered blank or left as a literal placeholder. */ type MissingBehavior = { kind: "fallback"; chain: Array<{ merge_field_key: string; } | { literal: unknown; }>; } | { kind: "block_turn"; } | { kind: "named_absence"; say: string; }; /** DYN-16. Applied AFTER resolution, on the merge field and never on the Field. */ interface MergeFieldTransform { /** e.g. `currency`, `upper`, `date`; the organization's own list. */ name: string; options?: Record; } /** DYN-1. A Record of the kernel Table `Merge Field`. */ interface MergeField { id: Uuid; organization_id: Uuid; key: string; label: string; /** DYN-3. Exactly one of eight. Relationships and rules are NOT sources. */ source: MergeFieldSource; /** DYN-4. What it resolves INTO. The consumer never learns which. */ semantic_type: MergeFieldSemanticType; /** §A. Any number. Never fused into the source. */ modifiers: MergeFieldModifier[]; /** * DYN-12. Exactly one, and it drives the input surface. It OUTRANKS the * precedence ladder: `server_fixed` is not offered as an input at all, and a * value sent for one anyway is discarded and recorded — never merged. */ override_policy: OverridePolicy; /** * DYN-13. Whether an override is POSSIBLE and WHO MAY perform it are two * settings. This is the second one: an access level or an organization role. */ override_requires: string | null; /** DYN-16. */ format: MergeFieldTransform | null; /** DYN-17. `inline`, `on_demand`, or `auto` by budget. A value in no tier is a defect. */ delivery?: Delivery; /** DYN-14. Declared, always. */ missing?: MissingBehavior; /** * What the source needs: for `record`, the starting record and the chain; for * `tool`, the connection token and the freshness ceiling (DYN-20); for * `literal`, the literal. */ source_config: Record; created_by: Uuid | null; updated_by: Uuid | null; created_at: Timestamp; updated_at: Timestamp; version: number; metadata: Record; visibility: string; } /** DYN-8. The triple the RUN gets. Every audit question is answerable from it. */ interface ResolutionTriple { record_id: Uuid | null; field_id: Uuid | null; value_version: number | null; } /** DYN-22. The one provenance row per merge field per turn. */ interface MergeFieldProvenance { merge_field_id: Uuid; declared_source: MergeFieldSource; /** Which source actually answered — the fallback chain makes these differ. */ actual_source: MergeFieldSource | null; record_id: Uuid | null; field_id: Uuid | null; value_version: number | null; rule_id: Uuid | null; rule_version: number | null; /** DYN-11. Who overrode it, and every LOSER of the ladder, not only the winner. */ override_by: Uuid | null; losers?: Array<{ source: MergeFieldSource; value: unknown; why_lost: string; }>; /** DYN-11/DYN-12. A value a client sent for a field it may not supply, discarded and recorded. */ discarded_attempt?: { value: unknown; because: string; } | null; resolved_at: Timestamp; freshness: Freshness; outcome: string; } /** * What a consumer gets back. `pending` is a first-class answer, not a blank: * until the server's resolver exists, a merge field says so and says WHY * (AGT-N-7 — anything that could not be delivered is named, never omitted). */ type MergeFieldResolution = { state: "resolved"; /** The rendered string the prompt gets. */ rendered: string; value: unknown; triple: ResolutionTriple; provenance: MergeFieldProvenance; } | { state: "absent"; /** DYN-14's named absence — what the screen says instead of a blank. */ say: string; reason: string; provenance: MergeFieldProvenance | null; } | { state: "pending"; /** WHY it is pending, in the words a person can act on. Never empty. */ reason: string; }; interface ChooseAlternateArgs { record_id: Uuid; field_key: string; /** Position in the field's `alternates` list as the record holds it. */ alternate_index: number; /** When given, the alternate holding this rank is chosen instead — the list a screen drew may be ordered differently. */ rank?: number; } /** The patch that makes alternate `alternate_index` of `field_key` the value. Pure; exported for tests. */ declare function alternatePatch(document: RecordDocument, field_key: string, alternate_index: number, rank?: number): { ok: true; patch: Record; } | { ok: false; message: string; }; declare function chooseAlternate(client: Pick, { record_id, field_key, alternate_index, rank }: ChooseAlternateArgs): Promise>; /** One period a value was true between. `from`/`to` are `YYYY-MM-DD`; `null` is open-ended. */ interface ValuePeriod { from: string | null; to: string | null; value: unknown; } interface SetValuePeriodsArgs { record_id: Uuid; field_key: string; /** The whole list, in any order. An empty list clears the field's dates. */ periods: ValuePeriod[]; /** `YYYY-MM-DD` — the day whose period becomes the plain value. Defaults to today (UTC). */ today?: string; } /** The periods a document holds for one field, oldest first. Pure. */ declare function valuePeriodsOf(document: RecordDocument | null | undefined, field_key: string): ValuePeriod[]; /** The period true on `day` (`YYYY-MM-DD`), or null. Half-open: true from `from`, no longer true on `to`. */ declare function periodInForce(periods: ValuePeriod[], day: string): ValuePeriod | null; /** Why a list of periods cannot be stored, in a person's words — or null when it can. Pure. */ declare function valuePeriodsProblem(periods: ValuePeriod[]): string | null; /** The patch that stores `periods` on `field_key`, keeping every other field's envelope. Pure; exported for tests. */ declare function valuePeriodsPatch(document: RecordDocument, field_key: string, periods: ValuePeriod[], today: string): { ok: true; patch: Record; } | { ok: false; message: string; }; /** * STORE WHEN A VALUE WAS TRUE. Reads the record's own document (`recordAsOf`, recorded now) after its * version, writes the whole `_values` block back with this field's periods replaced, against that version. * Refused when any field is hidden from the reader (the block could not be copied whole). */ declare function setValuePeriods(client: Pick, { record_id, field_key, periods, today }: SetValuePeriodsArgs): Promise>; type AiPresetKey = "summarize" | "keywords" | "categorize" | "translate" | "extract" | "sentiment" | "describe_image"; /** What the person must still say after choosing a preset. */ type AiPresetAsk = "language" | "what"; /** Spaces' autofill kinds (`features/spaces/data/sources.ts`); `custom` carries the instruction. */ type AiAutofillKind = "summary" | "keywords" | "translation" | "custom"; interface AiFieldPreset { key: AiPresetKey; label: string; autofillKind: AiAutofillKind; /** The one thing still to ask: a language (Translate) or what to pull out (Extract). */ ask?: AiPresetAsk; /** The column kind the preset needs: Categorize fills a choice column, Describe image reads an attachment column. */ needs?: "choice" | "attachment"; /** * The platform job (mandate key) that fills a column made from this preset when it is not the plain text one. Describe image * is filled by a model that can SEE: the server shows it the row's picture attachments (the attachment columns named in the * column's `inputs`). Every preset without a `mandate` runs as `table.column_fill`. */ mandate?: string; } declare const AI_FIELD_PRESETS: readonly AiFieldPreset[]; declare function aiFieldPreset(key: string): AiFieldPreset | undefined; interface AiPresetContext { /** The language for Translate ("Spanish"); what to pull out for Extract ("the invoice number"). */ answer?: string | undefined; /** The names of the columns the preset reads, when the person narrowed it (e.g. the attachment column). */ reads?: readonly string[] | undefined; } /** * The instruction a preset writes. It is a plain sentence a person can read and edit; it names no model and no table. A preset that * still needs an answer (language, what to extract) and was given none returns `null`, so a screen never saves half a sentence. */ declare function presetInstruction(key: AiPresetKey, ctx?: AiPresetContext): string | null; /** * The columns a preset's model must read, as the `inputs` of the column's enrichment. Describe image reads the table's attachment * columns (without them the model is shown nothing and answers "nothing found"); every other preset reads none by name, so the * answer is `undefined` and the declaration stays as it was. */ declare function presetInputs(key: AiPresetKey | undefined, attachmentColumnKeys: readonly string[]): string[] | undefined; /** * Which presets a column may offer: Categorize only for a choice column (the server passes the column's own choices to the * mandate), Describe image only when the table has an attachment column to read. Everything else fits any column. */ declare function presetsFor(args: { targetIsChoice: boolean; hasAttachmentColumn: boolean; }): readonly AiFieldPreset[]; /** Whether a column of this sensitivity is within the ceiling; an unknown word (either side) is never read by default. */ declare function withinSensitivityCeiling(sensitivity: string | null | undefined, ceiling: string): boolean; /** The slice of a Field the default-inputs question reads. */ type EnrichInputField = CoercibleField & { key: string; archived_at?: string | null; source?: string | null; sensitivity?: string | null; context_policy?: string | null; }; /** * THE DEFAULT `inputs` of a new AI column: the record's OTHER readable fields, by key. A column saved with no inputs hands the * model nothing to read (every row comes back "nothing to find"), so both homes of AI columns - the table page's "Let AI fill" and * Spaces' "AI autofill" - start from this list. Left out: the column itself, other AI columns (no loops), retired columns, * pictures/links/people/rolled-up values (a text model cannot read them), and anything the store would refuse an enrichment * to read (sensitivity above the organization's ceiling - `recordsLimits().enrichmentSensitivityCeiling`, the knob * custom/enrichment_sensitivity_ceiling - or a column that says no agent may see it). `on_request` columns are fetched only when * asked, so they are not read by default either. */ declare function defaultEnrichInputs(fields: readonly EnrichInputField[], targetKey: string, ceiling?: string, kernel?: KernelTargets): string[]; export { AI_FIELD_PRESETS, CaptureFileRef, CaptureOutcome, CoercibleField, Delivery, EVERY_RECORD_TYPE, Freshness, KernelTargets, MergeFieldModifier, MergeFieldSemanticType, MergeFieldSource, OverridePolicy, REFUSALS_WORTH_REPEATING, RecordDocument, RecordsResult, TableDuplicateProgress, TableDuplicated, Timestamp, Uuid, aiFieldPreset, alternatePatch, autonumberJoin, autonumberPrefixOf, autonumberSearchOf, autonumberWords, baseCopyName, chooseAlternate, copyIdOfRefusal, defaultEnrichInputs, derivedLookOf, duplicateBase, fieldAppliesToEveryType, fieldAppliesToType, filterWithAutonumber, formulaLookOf, indexedDbStore, instantFromWallInZone, isAutonumberField, isDecided, isDerivedField, localeDateOrder, memoryStore, mintClientKey, openCaptureQueue, periodInForce, pickedLookOf, presetInputs, presetInstruction, presetsFor, rankTypedMatches, readTypedDate, readTypedNumber, readTypedTime, recordTypeOf, restoreSnapshot, restoredBaseName, setValuePeriods, snapshotBase, twoDigitYear, typedDateText, typedMatchScore, typedTimeText, typesOfField, valuePeriodsOf, valuePeriodsPatch, valuePeriodsProblem, wallPartsInZone, withDerivedLooks, withFormulaLooks, withinSensitivityCeiling }; export type { AiAutofillKind, AiFieldPreset, AiPresetAsk, AiPresetContext, AiPresetKey, BaseCopied, BaseCopyProgress, BaseCopyResult, BasePort, BaseSnapshotRecord, BaseTable, CaptureQueue, CaptureQueueCounts, CaptureQueueOptions, CaptureQueuePorts, CaptureQueueStore, CaptureSyncReport, ChooseAlternateArgs, EnrichInputField, MergeField, MergeFieldProvenance, MergeFieldResolution, MergeFieldTransform, MissingBehavior, NamesRecordTypes, QueuedCapture, QueuedCaptureFile, QueuedCaptureState, ResolutionTriple, SetValuePeriodsArgs, TypedDate, TypedMatchScore, TypedNumber, TypedTime, ValuePeriod, WallParts };