@stndrds/schema 1.0.0-alpha.277 → 1.0.0-alpha.279

package/dist/index.d.ts

@@ -1,23 +1,23 @@
-import { S as SortRule, F as FilterState, V as ViewType, a as ViewConfig, C as ConfigOverrides, P as PermissionScope, A as Action, b as FilterOperator, c as SystemResource, d as ProviderName, M as ModelDefinition, e as AgentSchedule, f as AgentExecutionConfig, g as AgentApprovalPolicy, T as TriggerEventType, h as AgentTriggerBlueprint, i as AgentBlueprint, D as DetailViewConfig, j as DetailViewDefinition, k as SidePanelConfig, l as Field, m as AttributeGroupField, n as FieldGroup, R as RelationGroup, G as Group, o as TableTab, p as CreateMode, q as Tab, L as ListViewConfig, r as ListViewDefinition, s as ViewDefinition, t as ListViewTab, u as FilterValue, v as FilterRule, w as DynamicValue, x as RelativeDateValue } from './index-AJeEKoy6.js';
-export { y as AIAvailableModel, z as AIBatchAnswerValue, B as AIBatchQuestion, E as AIBatchQuestionAnswer, H as AIBatchQuestionOption, I as AIBatchQuestionType, J as AIChatMessage, K as AIChatMessagePart, N as AIChatMessagePartType, O as AIChatNotification, Q as AICompactionSummary, U as AIMemoryEntry, W as AIMemoryType, X as AIMessageRole, Y as AIProviderMetrics, Z as AIQuestion, _ as AIQuestionAnswer, $ as AIQuestionOption, a0 as AIQuestionType, a1 as AISubagentStatus, a2 as AITodoItem, a3 as AITodoList, a4 as AITodoStatus, a5 as AIToolCall, a6 as AIToolCallStatus, a7 as AIUsageMetrics, a8 as ALL_ACTIONS, a9 as AccessLevel, aa as ActivityTab, ab as AddAttributeInput, ac as AdvancedFilterState, ad as AgentConfig, ae as AgentDashboard, af as AgentDefinition, ag as AgentEvent, ah as AgentMessageAttachment, ai as AgentMessagePart, aj as AgentMission, ak as AgentMissionArtifact, al as AgentMissionPage, am as AgentMissionPolicy, an as AgentMissionRubric, ao as AgentMissionRubricCriterion, ap as AgentMissionStatus, aq as AgentMissionVerification, ar as AgentMissionView, as as AgentRequiredPermission, at as AgentRun, au as AgentRunStatus, av as AgentSession, aw as AgentSessionMessage, ax as AgentSessionMode, ay as AgentSessionStatus, az as AgentTodoPlan, aA as AgentTodoPlanStatus, aB as AgentTodoPlanView, aC as AgentToolCall, aD as AgentTriggerDefinition, aE as AgentTriggerType, aF as ApprovalMode, aG as AssignRoleInput, aH as CompactionStrategy, aI as CreateCustomObjectInput, aJ as CreatePermissionInput, aK as CreateRoleInput, aL as CreateViewInput, aM as CriticConfig, aN as CurrencyFilterValue, aO as CustomTab, aP as DEFAULT_APPROVAL_POLICY, aQ as DocumentsTab, aR as EdgeQuantifier, aS as EffectivePermissions, aT as EmailsTab, aU as ExtendedFilterRule, aV as FilterCombinator, aW as FilterGroup, aX as FormDensity, aY as FormSubmittedAgentEvent, aZ as FormTab, a_ as FormsTab, a$ as HumanRequestNeed, b0 as InverseSource, b1 as ListViewLayout, b2 as MAX_TODOS, b3 as MAX_TODO_DESCRIPTION_CHARS, b4 as MAX_TODO_ID_CHARS, b5 as MAX_TODO_RESULT_CHARS, b6 as MentionEntityType, b7 as MentionReference, b8 as MentionedContext, b9 as MentionedEntityContext, ba as NO_VALUE_OPERATORS, bb as NoValueOperator, bc as OPERATORS_BY_TYPE, bd as ObjectPermissions, be as Permission, bf as PhoneFilterValue, bg as QueryState, bh as ReasoningPartData, bi as RecordAgentEvent, bj as RelationOption, bk as RelationOptionsResponse, bl as RelationSource, bm as RetryPolicy, bn as RichtextTab, bo as Role, bp as SESSION_TERMINAL_STATUSES, bq as SessionApprovalMode, br as SortDirection, bs as StreamEventCompactionEnd, bt as StreamEventCompactionFailed, bu as StreamEventCompactionStart, bv as StreamEventMessagePersisted, bw as StreamEventMessageUpdated, bx as StreamEventMissionUpdate, by as StreamEventTodoPlanUpdate, bz as StreamEventUsage, bA as SystemPermissions, bB as TODO_PLAN_STATUSES, bC as TODO_STATUSES, bD as TabType, bE as TableSource, bF as TerminalSessionStatus, bG as TextPartData, bH as ThinkingPartData, bI as ToolImpact, bJ as ToolPartData, bK as ToolPartErrorCode, bL as ToolPartState, bM as UpdateObjectInput, bN as UpdateRoleInput, bO as UpdateViewInput, bP as UserRoleAssignment, bQ as ViewOverlay, bR as accessLevelToActions, bS as actionsToAccessLevel, bT as agentDisplayName, bU as getRollupFilterOperators, bV as isDetailView, bW as isFieldGroup, bX as isListView, bY as isNoValueOperator, bZ as isRelationGroup, b_ as isTerminalSessionStatus, b$ as multiselectOptionWriteSchema, c0 as parseAttributeConfig, c1 as parseAttributeConfigForCreate, c2 as parseAttributeConfigForUpdate, c3 as selectOptionWriteSchema, c4 as statusGroupSchema, c5 as statusOptionWriteSchema } from './index-AJeEKoy6.js';
-import { i as ComputedValueType, j as ComputedReturnType, f as AttributeType, k as ComputedOptionsSource, l as ComputedDependency, m as ComputedPlan, e as RollupAttribute, n as ComputedFormulaAstNode, A as Attribute, o as LocationGranularity, p as Location, F as FormulaAttribute, D as DateAttribute, q as DateRangeValue, r as DocumentAttribute, d as StatusAttribute, c as SelectAttribute, b as MultiselectAttribute, s as Phone, t as Currency, U as UserAttribute, T as TextAttribute, u as PropertySchema, g as CheckboxAttribute, C as CurrencyAttribute, v as TimeFormat, N as NumberAttribute, P as PhoneAttribute, O as Option, L as LocationAttribute, w as FormulaReturnType, R as RelationAttribute, B as BilateralConfig, S as SingleRelationAttribute, M as MultiRelationAttribute, x as RelationTarget, a as RichtextAttribute, y as RollupFunction, z as UserReferenceType } from './attributes-_b3Db8vT.js';
-export { E as AttributeGroup, G as BaseAttribute, h as ComputedAttributeState, H as ComputedFieldKind, I as ComputedFormulaBinaryNode, J as ComputedFormulaBinaryOperator, K as ComputedFormulaCallNode, Q as ComputedFormulaLiteralNode, V as ComputedFormulaParseError, W as ComputedFormulaPathNode, X as ComputedStateStatus, Y as DateFormat, Z as DateValue, _ as NumberUnit, $ as OptionPropertyAttribute, a0 as PropertyAttribute, a1 as PropertyType, a2 as RELATION_TARGET_ANY, a3 as RichTextAttribute, a4 as StatusGroup, a5 as hasOptions, a6 as inferInverseCardinality, a7 as isAttributeSortable, a8 as isBilateralRelation, a9 as isUniversalRelation, aa as parseComputedFormula, ab as resolvePropertyDefinitions } from './attributes-_b3Db8vT.js';
+import { S as SortRule, F as FilterState, V as ViewType, a as ViewConfig, C as ConfigOverrides, b as FilterOperator, D as DetailViewConfig, c as DetailViewDefinition, d as SidePanelConfig, e as Field, A as AttributeGroupField, f as FieldGroup, R as RelationGroup, G as Group, T as TableTab, g as CreateMode, E as EmailsTab, M as MeetingsTab, h as Tab, L as ListViewConfig, i as ListViewDefinition, j as ViewDefinition, k as ListViewTab, l as FilterValue, m as FilterRule, n as DynamicValue, o as RelativeDateValue } from './index-SpFpkWVC.js';
+export { p as ActivityTab, q as AddAttributeInput, r as AdvancedFilterState, s as CreateCustomObjectInput, t as CreateViewInput, u as CurrencyFilterValue, v as CustomTab, w as DayMonthValue, x as DocumentsTab, y as EdgeQuantifier, z as ExtendedFilterRule, B as FilterCombinator, H as FilterGroup, I as FormDensity, J as FormTab, K as FormsTab, N as InverseSource, O as ListViewLayout, P as NO_VALUE_OPERATORS, Q as NoValueOperator, U as OPERATORS_BY_TYPE, W as PhoneFilterValue, X as QueryState, Y as RelationOption, Z as RelationOptionsResponse, _ as RelationSource, $ as RichtextTab, a0 as SortDirection, a1 as TabType, a2 as TableSource, a3 as UpdateObjectInput, a4 as UpdateViewInput, a5 as ViewOverlay, a6 as getRollupFilterOperators, a7 as isDetailView, a8 as isFieldGroup, a9 as isListView, aa as isNoValueOperator, ab as isRelationGroup, ac as multiselectOptionWriteSchema, ad as parseAttributeConfig, ae as parseAttributeConfigForCreate, af as parseAttributeConfigForUpdate, ag as selectOptionWriteSchema, ah as statusGroupSchema, ai as statusOptionWriteSchema } from './index-SpFpkWVC.js';
+import { i as ComputedValueType, j as ComputedReturnType, f as AttributeType, k as ComputedOptionsSource, l as ComputedDependency, m as ComputedPlan, e as RollupAttribute, n as ComputedFormulaAstNode, A as Attribute, o as LocationGranularity, p as Location, F as FormulaAttribute, D as DateAttribute, q as DateRangeValue, r as DocumentAttribute, d as StatusAttribute, c as SelectAttribute, b as MultiselectAttribute, s as Phone, t as Currency, U as UserAttribute, T as TextAttribute, u as PropertySchema, g as CheckboxAttribute, C as CurrencyAttribute, v as TimeFormat, w as PropertyAttribute, x as FormulaReturnType, L as LocationAttribute, O as Option, N as NumberAttribute, P as PhoneAttribute, R as RelationAttribute, B as BilateralConfig, S as SingleRelationAttribute, M as MultiRelationAttribute, y as RelationTarget, a as RichtextAttribute, z as RollupFunction, E as UserReferenceType } from './attributes-D8eHv5Kf.js';
+export { G as AttributeGroup, H as BaseAttribute, h as ComputedAttributeState, I as ComputedFieldKind, J as ComputedFormulaBinaryNode, K as ComputedFormulaBinaryOperator, Q as ComputedFormulaCallNode, V as ComputedFormulaLiteralNode, W as ComputedFormulaParseError, X as ComputedFormulaPathNode, Y as ComputedStateStatus, Z as DateFormat, _ as DateValue, $ as NumberUnit, a0 as OptionPropertyAttribute, a1 as PropertyType, a2 as RELATION_TARGET_ANY, a3 as RichTextAttribute, a4 as StatusGroup, a5 as hasOptions, a6 as inferInverseCardinality, a7 as isAttributeSortable, a8 as isBilateralRelation, a9 as isUniversalRelation, aa as parseComputedFormula, ab as resolvePropertyDefinitions } from './attributes-D8eHv5Kf.js';
 import { IconName, MimeType, ColorId, CountryIso3, CurrencyCode } from '@stndrds/constants';
 import { Uuid, TenantId } from './utils.js';
 export { UserId, asTenantId, asUserId, deepEqual, generateId, indexBy } from './utils.js';
-import { a as ObjectRecord, D as DocumentLayout, T as Timestamps, R as ResourceVisibility, O as ObjectDefinition, L as ListViewTabVisibility } from './objects-A1ED9af-.js';
-export { b as DocumentLayoutVariant, F as FolderPreset, c as LIST_VIEW_TAB_VISIBILITIES, M as MAX_PRESET_DEPTH, d as ObjectAttribute, P as PresetNode, e as RESERVED_ATTRIBUTE_NAMES, f as RESERVED_OBJECT_NAMES, g as RESOURCE_VISIBILITIES, h as ReservedAttributeName, i as ReservedObjectName, S as SYSTEM_FIELD_NAMES, j as SystemFieldName } from './objects-A1ED9af-.js';
-import { M as MigrationDefinition } from './migrations-DcuJZ8qO.js';
-export { B as BuiltInTransform, S as SchemaOperation } from './migrations-DcuJZ8qO.js';
+import { a as ObjectRecord, D as DocumentLayout, T as Timestamps, R as ResourceVisibility, O as ObjectDefinition, L as ListViewTabVisibility } from './objects-DgFojgwH.js';
+export { b as DocumentLayoutVariant, F as FolderPreset, c as LIST_VIEW_TAB_VISIBILITIES, M as MAX_PRESET_DEPTH, d as ObjectAttribute, P as PresetNode, e as RESERVED_ATTRIBUTE_NAMES, f as RESERVED_OBJECT_NAMES, g as RESOURCE_VISIBILITIES, h as ReservedAttributeName, i as ReservedObjectName, S as SYSTEM_FIELD_NAMES, j as SystemFieldName, p as parseResourceVisibility } from './objects-DgFojgwH.js';
+import { M as MigrationDefinition } from './migrations-B1kkIhIX.js';
+export { B as BuiltInTransform, S as SchemaOperation } from './migrations-B1kkIhIX.js';
 import { ValidationError } from './exceptions.js';
 export { AccessDeniedError, AttributeInUseError, AttributeNotFoundError, AttributeUsage, ChangeTypeNotSupportedError, ConcurrentModificationError, DestructiveSyncNotAllowedError, DuplicateError, ForbiddenError, MemoryNotFoundError, MigrationTimeoutError, NotFoundError, NotImplementedError, ObjectNotFoundError, ObjectReferencedError, OrphanSystemAttributeError, ProtectedResourceError, ProtectedRoleError, RecordNotFoundError, RecordReference, RecordReferencedError, RepositoryError, RepositoryOperation, RoleNotFoundError, SchemaError, SchemaErrorCode, SchemaPlanNotFoundError, SearchBackendError, StorageError, StorageOperation, SyncCascadeError, SyncConflictError, SyncError, SystemEntityImmutableError, ValidationErrorDetail, isAttributeInUseError, isNotFoundError, isObjectReferencedError, isProtectedResourceError, isRecordReferencedError, isSchemaError, isValidationError } from './exceptions.js';
 import { StandardSchemaV1 } from '@standard-schema/spec';
 export { StandardSchemaV1 } from '@standard-schema/spec';
 import z, { z as z$1 } from 'zod';
-export { V as ValidationMessages } from './types-DqLi1tx1.js';
+export { V as ValidationMessages } from './types-DYYFto8d.js';
 export { DEFAULT_VALIDATION_MESSAGES, formatZodErrors } from './validation/core/index.js';
-export { S as SCHEMA_LIMITS, c as colorIdSchema, d as detailTabSchema, a as detailViewConfigSchema, i as iconNameSchema, b as inverseSourceSchema, l as listViewConfigSchema, e as listViewTabSchema, p as parseViewConfig, r as relationSourceSchema, t as tableSourceSchema, v as viewConfigByTypeSchema, f as viewTypeSchema } from './all-D5SkjRst.js';
-export { a as createFormAttributeValidator, r as rejectUnknownAttributesOrThrow, b as validateDraft, d as validateDraftOrThrow, e as validateObject, f as validateObjectOrThrow } from './helpers-vQ6kp8ET.js';
+export { S as SCHEMA_LIMITS, c as colorIdSchema, d as detailTabSchema, a as detailViewConfigSchema, i as iconNameSchema, b as inverseSourceSchema, l as listViewConfigSchema, e as listViewTabSchema, p as parseViewConfig, r as relationSourceSchema, t as tableSourceSchema, v as viewConfigByTypeSchema, f as viewTypeSchema } from './all-C_tC90ZM.js';
+export { a as createFormAttributeValidator, r as rejectUnknownAttributesOrThrow, b as validateDraft, d as validateDraftOrThrow, e as validateObject, f as validateObjectOrThrow } from './helpers-DyoPqiSz.js';
 export { createCheckboxValidator } from './validation/primitives/checkbox.js';
 export { createDateValidator } from './validation/primitives/date.js';
 export { createNumberValidator } from './validation/primitives/number.js';
@@ -118,7 +118,25 @@ interface ListOptions {
     include?: string[];
 }
 
-type CountMode = "none" | "estimated" | "exact";
+declare const COUNT_MODES: readonly ["none", "estimated", "exact"];
+type CountMode = (typeof COUNT_MODES)[number];
+/**
+ * Narrow an untrusted value from an edge (HTTP body, query string) to a
+ * {@link CountMode}, or reject it.
+ *
+ * It lives beside the union so whoever changes the union sees the one gate that
+ * admits values into it. A `countMode` typed as `CountMode` on a request body is
+ * a claim, not a check: the mailbox endpoints forwarded the raw value into
+ * `list_email_thread_summaries`, which raises SQLSTATE 22023 for anything
+ * outside the three — and 22023 is not a mapped state, so plain bad input came
+ * back as a 500.
+ *
+ * Throws {@link ValidationError} rather than a transport exception so it can be
+ * used below the controller layer; the HTTP filter maps its code to 400.
+ */
+declare function parseCountMode(value: unknown): CountMode;
+/** As {@link parseCountMode}, but absent stays absent rather than defaulting. */
+declare function parseOptionalCountMode(value: unknown): CountMode | undefined;
 /**
  * Row cap for `countMode: "estimated"`.
  *
@@ -126,7 +144,9 @@ type CountMode = "none" | "estimated" | "exact";
  * tenant. Below the cap the count happens to be exact; at the cap it means "at
  * least this many", and `totalIsExact` is what tells the two apart.
  *
- * Mirrored in `list_filtered_object_records`; change both together.
+ * Mirrored in two SQL functions — `list_filtered_object_records` and
+ * `list_email_thread_summaries` (the mailbox toolbar's count) — each carrying
+ * the literal rather than reading this constant. Change all three together.
  */
 declare const ESTIMATED_COUNT_CAP = 10000;
 /** Canonical continuation metadata shared by collection and search responses. */
@@ -701,6 +721,245 @@ interface AssignActorRoleInput {
     assignedBy?: Uuid | null;
 }
 
+/**
+ * Scope of a permission rule.
+ * - `object`: Controls access to an entire object type (business data)
+ * - `system`: Controls access to platform resources (people, workspace, API keys, etc.)
+ */
+type PermissionScope = "object" | "system";
+/**
+ * Actions that can be performed on a resource.
+ *
+ * `observe` is intentionally excluded from `ALL_ACTIONS` ("full" preset) — it
+ * is only meaningful for runnable resources (agent sessions) where it grants
+ * read-only visibility on the run timeline without implying CRUD.
+ */
+type Action = "read" | "create" | "update" | "delete" | "manage" | "observe";
+/**
+ * System resources that can be managed.
+ * - `people`: User profiles, invitations, roles and permissions
+ * - `workspace`: Tenant settings and workspace-level configuration
+ * - `architect`: Architect settings, templates, and configurations
+ */
+type SystemResource = "people" | "workspace" | "architect" | "feature-flags" | "files" | "views" | "forms" | "documents" | "audit" | "api-keys" | "connectors" | "env-vars" | "session";
+/**
+ * Preset access levels for simplified permission configuration.
+ * - `full`: All CRUD actions
+ * - `read-only`: Only read action
+ * - `none`: No actions
+ * - `custom`: Manual selection of individual actions
+ */
+type AccessLevel = "full" | "read-only" | "none" | "custom";
+declare const ALL_ACTIONS: Action[];
+/**
+ * Derive an AccessLevel from a list of actions.
+ */
+declare function actionsToAccessLevel(actions: Action[]): AccessLevel;
+/**
+ * Convert an AccessLevel preset to its corresponding actions.
+ */
+declare function accessLevelToActions(level: Exclude<AccessLevel, "custom">): Action[];
+/**
+ * Role definition - Groups permissions together.
+ *
+ * Roles are tenant-scoped and can be system-defined (immutable) or custom.
+ *
+ * @example
+ * ```typescript
+ * const ownerRole: Role = {
+ *   id: "role-123",
+ *   tenantId: "tenant-456",
+ *   name: "owner",
+ *   label: "Owner",
+ *   description: "Full access to all platform features and data",
+ *   system: true,
+ *   createdAt: new Date(),
+ *   updatedAt: new Date(),
+ * };
+ * ```
+ */
+interface Role extends Timestamps {
+    id: Uuid;
+    tenantId: Uuid;
+    /**
+     * Technical name (unique per tenant, used in code).
+     * Examples: "owner", "member", "sales_manager"
+     */
+    name: string;
+    /**
+     * Display name shown in UI.
+     */
+    label: string;
+    /**
+     * Optional description of the role's purpose.
+     */
+    description?: string;
+    /**
+     * If true, this role cannot be modified or deleted.
+     * Used for built-in roles like "owner".
+     */
+    system: boolean;
+}
+/**
+ * Permission definition - Grants specific actions on a target.
+ *
+ * A permission belongs to a role and defines what actions are allowed
+ * on a specific target (object or system resource).
+ *
+ * @example
+ * ```typescript
+ * // Allow read and update on companies object
+ * const permission: Permission = {
+ *   id: "perm-123",
+ *   roleId: "role-456",
+ *   scope: "object",
+ *   target: "companies",
+ *   actions: ["read", "update"],
+ *   createdAt: new Date(),
+ * };
+ *
+ * // Wildcard permission for all objects
+ * const wildcardPerm: Permission = {
+ *   id: "perm-789",
+ *   roleId: "role-456",
+ *   scope: "object",
+ *   target: "*",
+ *   actions: ["read", "create", "update", "delete"],
+ *   createdAt: new Date(),
+ * };
+ * ```
+ */
+interface Permission {
+    id: Uuid;
+    roleId: Uuid;
+    /**
+     * Scope of this permission.
+     */
+    scope: PermissionScope;
+    /**
+     * Target of the permission.
+     * - For `object` scope: object name (e.g., "companies") or "*" for all
+     * - For `system` scope: system resource (e.g., "people", "workspace") or "*" for all
+     */
+    target: string;
+    /**
+     * Actions allowed on the target.
+     */
+    actions: Action[];
+    createdAt: Date;
+}
+/**
+ * Links a user profile to a role within a tenant.
+ *
+ * A user can have multiple roles, and their permissions are additive (union).
+ *
+ * Note: `userProfileId` references UserProfile.id from the user_profiles table,
+ * NOT the auth provider ID (authId). This keeps permissions tied to the
+ * application's user management, not the authentication layer.
+ */
+interface UserRoleAssignment {
+    id: Uuid;
+    /**
+     * User profile ID (UserProfile.id from user_profiles table).
+     * This links to the application's user management system,
+     * not the auth provider's user ID.
+     */
+    userProfileId: Uuid;
+    roleId: Uuid;
+    tenantId: Uuid;
+    /**
+     * When the role was assigned.
+     */
+    assignedAt: Date;
+    /**
+     * Actor ID of who assigned this role (for audit trail).
+     */
+    assignedBy?: Uuid;
+}
+/**
+ * Computed permissions for a user.
+ *
+ * This is the merged result of all roles assigned to a user.
+ * Returned by the API for permission checks.
+ */
+interface EffectivePermissions {
+    /**
+     * Object-level permissions.
+     * Key is the object name, value is array of allowed actions.
+     * Special key "*" means permission applies to all objects.
+     */
+    objectPermissions: Record<string, Action[]>;
+    /**
+     * System-level permissions.
+     * Key is the system resource (people, workspace), value is array of allowed actions.
+     * Special key "*" means permission applies to all system resources.
+     */
+    systemPermissions: Record<string, Action[]>;
+}
+/**
+ * Permissions for a specific object.
+ * Convenience type for frontend use.
+ */
+interface ObjectPermissions {
+    canRead: boolean;
+    canCreate: boolean;
+    canUpdate: boolean;
+    canDelete: boolean;
+    canManage: boolean;
+}
+/**
+ * Permissions for a specific system resource.
+ * Convenience type for frontend use.
+ */
+interface SystemPermissions {
+    canRead: boolean;
+    canCreate: boolean;
+    canUpdate: boolean;
+    canDelete: boolean;
+    canManage: boolean;
+}
+/**
+ * Input for creating a new role.
+ * TenantId is automatically set from TenantContext.
+ */
+interface CreateRoleInput {
+    name: string;
+    label: string;
+    description?: string;
+    /** Framework-owned default roles are system:true (immutable, auto-assignable). Custom roles default false. */
+    system?: boolean;
+}
+/**
+ * Input for updating an existing role.
+ */
+interface UpdateRoleInput {
+    label?: string;
+    description?: string;
+}
+/**
+ * Input for creating a permission.
+ */
+interface CreatePermissionInput {
+    scope: PermissionScope;
+    target: string;
+    /**
+     * Actions allowed on the target.
+     */
+    actions: Action[];
+}
+/**
+ * Input for assigning a role to a user.
+ */
+interface AssignRoleInput {
+    /**
+     * User profile ID (UserProfile.id).
+     */
+    userProfileId: Uuid;
+    roleId: Uuid;
+    tenantId: Uuid;
+    assignedBy?: Uuid;
+}
+
 /**
  * Legacy permission payload stored with an API key.
  * Runtime authorization uses the API key actor's effective permissions.
@@ -778,6 +1037,54 @@ interface EnvVarEntry {
     updatedAt: string;
 }
 
+/**
+ * Type of mentionable entity
+ */
+type MentionEntityType = "user" | "record" | (string & {});
+/**
+ * A mention reference stored with a message
+ */
+interface MentionReference {
+    /** Unique ID for this mention instance */
+    id: string;
+    /** Entity type (user, record, or custom) */
+    type: MentionEntityType;
+    /** Entity ID (user ID or record ID) */
+    entityId: string;
+    /** Display label at time of mention (cached for display even if entity is deleted) */
+    label: string;
+    /** Object name for records, undefined for users */
+    objectName?: string;
+    /** Start position in the message text */
+    startIndex: number;
+    /** End position in the message text */
+    endIndex: number;
+}
+/**
+ * Context data for a mentioned entity (sent to AI)
+ */
+interface MentionedEntityContext {
+    /** Entity type */
+    type: MentionEntityType;
+    /** Entity ID */
+    entityId: string;
+    /** Display label */
+    label: string;
+    /** Object name for records */
+    objectName?: string;
+    /** Additional context data (record values, user details, etc.) */
+    data?: Record<string, unknown>;
+}
+/**
+ * Full mention context for AI
+ */
+interface MentionedContext {
+    /** All mentioned entities with their context data */
+    entities: MentionedEntityContext[];
+    /** Summary text for AI system prompt */
+    summary: string;
+}
+
 declare const NOTIFICATION_KINDS: readonly ["fyi", "task", "question", "handoff", "system"];
 type NotificationKind = (typeof NOTIFICATION_KINDS)[number];
 declare const NOTIFICATION_PRIORITIES: readonly ["low", "normal", "high", "urgent"];
@@ -1054,113 +1361,1248 @@ interface FieldHistoryEntry {
 }
 
 /**
- * The minimum every capability predicate in this file reads: the type, plus
- * whatever else of a full `Attribute` the caller happens to hold. Exported so
- * callers that only have a partial attribute — a plan's proposed attribute, a
- * schema snapshot row — can ask the same questions as callers holding the real
- * thing, instead of restating the rules.
- */
-type AttributeLike = Pick<Attribute, "type"> & Partial<Attribute>;
-type AttributeLifecycleCapabilities = {
-    active: boolean;
-    deprecated: boolean;
-    visibleInArchitect: boolean;
-    visibleInRuntime: boolean;
-    warningWhenDeprecated: boolean;
-};
-type AttributeStorageMode = "value" | "edge" | "computed";
-type AttributeCardinality = "one" | "many";
-type AttributePolymorphicCapability = "none" | "code-only" | "internal";
-type AttributeStorageCapabilities = {
-    mode: AttributeStorageMode;
-    cardinality: AttributeCardinality;
-    edgeBacked: boolean;
-    preservesExistingValues: boolean;
-    qualifiedProperties: boolean;
-    polymorphic: AttributePolymorphicCapability;
-    maxItems: boolean;
-};
-type AttributeRequiredCapability = "allowed" | "forbidden";
-type AttributeDefaultValueCapability = "static" | "automatic" | "forbidden";
-type AttributeAuthoringCapabilities = {
-    editable: boolean;
-    readOnly: boolean;
-    directEdit: boolean;
-    required: AttributeRequiredCapability;
-    defaultValue: AttributeDefaultValueCapability;
-    placeholder: boolean;
-    maxItems: boolean;
-};
-type AttributePresentationCapabilities = {
-    formField: boolean;
-    tableCell: boolean;
-    defaultColumn: boolean;
-    compactDisplay: boolean;
-    popoverEditor: boolean;
-    placeholder: boolean;
-    warningWhenDeprecated: boolean;
-};
-type AttributeQueryCapabilities = {
-    filterable: boolean;
-    searchable: boolean;
-    sortable: boolean;
-    groupable: boolean;
-    kanbanGroupable: boolean;
-    operators: readonly FilterOperator[];
-};
-type AttributeAgentCapabilities = {
-    readable: boolean;
-    writable: boolean;
-    compactReadable: boolean;
-    contentReadable: boolean;
-    requiresDedicatedTool: boolean;
-};
-type AttributeExchangeCapabilities = {
-    importable: boolean;
-    exportable: boolean;
-    schemaExportable: boolean;
-    metadataExportable: boolean;
-};
-type AttributeCapabilities = {
-    lifecycle: AttributeLifecycleCapabilities;
-    storage: AttributeStorageCapabilities;
-    authoring: AttributeAuthoringCapabilities;
-    presentation: AttributePresentationCapabilities;
-    query: AttributeQueryCapabilities;
-    agent: AttributeAgentCapabilities;
-    exchange: AttributeExchangeCapabilities;
-};
-declare const ATTRIBUTE_FILTER_OPERATORS: Readonly<Record<Exclude<AttributeType, "rollup">, readonly FilterOperator[]>>;
-declare function getAttributeCapabilities(attribute: AttributeLike): AttributeCapabilities;
-declare function getAttributeFilterOperators(attribute: AttributeLike): readonly FilterOperator[];
-declare function isAttributeFilterable(attribute: AttributeLike): boolean;
-declare function isAttributeSearchable(attribute: AttributeLike): boolean;
-declare function isAttributeGroupable(attribute: AttributeLike): boolean;
-declare function isAttributeKanbanGroupable(attribute: AttributeLike): boolean;
+ * Outcome of a compaction pass: a no-op (context already small enough), an LLM
+ * `summary`, or a degraded `truncation` (the summarizer failed/timed out/returned
+ * empty, so older messages were dropped and a notice injected). Canonical home —
+ * `runtime` re-exports this and `react` imports it; never duplicate the literals.
+ */
+type CompactionStrategy = "no-op" | "summary" | "truncation";
+type AgentRunStatus = "pending" | "running" | "completed" | "failed" | "cancelled" | "paused";
+type AgentSessionStatus = "active" | "idle" | "completed" | "failed" | "cancelled" | "waiting_human" | "waiting_agents" | "timeout" | "expired";
+/**
+ * The flat {@link AgentSessionStatus} word answers three independent questions
+ * at once (is it running? what is it parked on? how did it end?) — which is
+ * how `timeout`/`expired` once closed sessions the browser kept reconnecting
+ * to. The structured form separates the axes so predicates become structural
+ * (`phase === "terminal"`) and a new park reason can never be forgotten by a
+ * hand-enumerated list.
+ */
+type SessionPhase = "queued" | "running" | "parked" | "terminal";
+/** What a parked session waits on. Extensible: a new reason is a new value here, never a new predicate. */
+type SessionParkedOn = "human" | "agents";
+/** How a terminal session ended — the exact legacy words, unchanged. */
+type SessionOutcome = "completed" | "failed" | "cancelled" | "timeout" | "expired";
+/**
+ * Structured session state. Illegal combinations are unrepresentable at the
+ * database (CHECK constraints) and refused by the single runtime writer
+ * (`resolveSessionState`, which throws instead of emitting):
+ * - `parkedOn` present iff `phase === "parked"`;
+ * - `humanRequestIds` present iff `parkedOn === "human"` — the in-flight
+ *   request ids (AI SDK vocabulary verbatim: `approvalId` for approval-gated
+ *   calls, `toolCallId` for `ask_questions`) the UI must render;
+ * - `outcome` present iff `phase === "terminal"`.
+ */
+interface SessionState {
+    phase: SessionPhase;
+    parkedOn?: SessionParkedOn;
+    humanRequestIds?: string[];
+    outcome?: SessionOutcome;
+}
+/** Structural terminality — replaces membership tests against a hand-kept list. */
+declare function isTerminalState(state: SessionState): boolean;
+/**
+ * The 1:1 legacy mapping, both directions. `sessionStateToLegacyStatus` is the
+ * TS mirror of the migration's generated `status` column (byte-identical
+ * words); `legacyStatusToSessionState` reads rows written before the
+ * migration's backfill — which cannot know `humanRequestIds`, so a legacy
+ * `waiting_human` maps to `parked`/`human` with an empty id list (the runtime
+ * writer itself refuses to EMIT that shape; only legacy reads produce it).
+ */
+declare function sessionStateToLegacyStatus(state: SessionState): AgentSessionStatus;
+declare function legacyStatusToSessionState(status: AgentSessionStatus): SessionState;
+/**
+ * Statuses a session never leaves. Lives beside the union it partitions so
+ * every consumer shares it — runtime orchestration decides whether to keep
+ * working, and the React realtime lifecycle decides whether to stay connected.
+ * Splitting them is how `timeout` and `expired` came to close a session on the
+ * server while the browser kept reconnecting to it.
+ */
+declare const SESSION_TERMINAL_STATUSES: readonly ["completed", "failed", "cancelled", "timeout", "expired"];
+type TerminalSessionStatus = (typeof SESSION_TERMINAL_STATUSES)[number];
+declare function isTerminalSessionStatus(status: AgentSessionStatus): status is TerminalSessionStatus;
+type AgentSessionMode = "interactive" | "autonomous";
+/** Whether a class of tool call is confirmed by a human or executed straight away. */
+type ApprovalMode = "ask" | "auto";
+/**
+ * An agent's declared stance per risk class. Code-owned and versioned: there is
+ * deliberately no policy table (see the `agent_execution_policies` guardrail).
+ */
+interface AgentApprovalPolicy {
+    mutation: ApprovalMode;
+    destructive: ApprovalMode;
+    outward: ApprovalMode;
+}
+declare const DEFAULT_APPROVAL_POLICY: AgentApprovalPolicy;
+/**
+ * The switch shown at the bottom-left of the composer. `auto` relaxes
+ * `mutation` only — deletions and outward sends keep asking.
+ */
+type SessionApprovalMode = "manual" | "auto";
+/** What the agent may do: investigate/plan, or execute the approved work. */
+type AgentWorkMode = "execute" | "plan";
+declare const TODO_PLAN_STATUSES: readonly ["active", "completed", "abandoned"];
+type AgentTodoPlanStatus = (typeof TODO_PLAN_STATUSES)[number];
+type TriggerEventType = "record.created" | "record.updated" | "record.deleted" | "form.submitted" | "agent.completed" | "webhook" | "schedule";
+type AgentTriggerType = Extract<TriggerEventType, "record.created" | "record.updated" | "record.deleted">;
+type ProviderName = "anthropic" | "openai" | "google" | "mistral";
+interface ModelDefinition {
+    provider: ProviderName;
+    model: string;
+    maxTokens?: number;
+    /**
+     * Total context window in tokens (e.g. 200000 for Claude Sonnet).
+     * Required by the compaction subsystem when this model is used as the
+     * summary model; optional otherwise.
+     */
+    contextWindow?: number;
+}
+interface RetryPolicy {
+    maxRetries: number;
+    backoffMs: number;
+    backoffMultiplier: number;
+}
+interface AgentExecutionConfig {
+    maxConcurrentRuns: number;
+    retryPolicy: RetryPolicy;
+    timeoutMs: number;
+    costLimitUsd?: number;
+}
+/**
+ * Shared base config used by AgentDefinition, inline runs, and AgentSession.
+ */
+interface AgentConfig {
+    systemPrompt: string;
+    model: ModelDefinition;
+    tools?: string[];
+    /**
+     * MCP servers whose tools mount into this agent's toolchain. Ids opt in
+     * explicitly; `"all"` mounts every server the viewer can see. Absent means
+     * none — so agents that predate this field are tool-identical.
+     */
+    mcpServers?: string[] | "all";
+    timeoutMs?: number;
+    costLimitUsd?: number | null;
+    canDelegate: boolean;
+    maxDepth: number;
+    maxTreeCostUsd?: number;
+    critic?: CriticConfig;
+}
+interface CriticConfig {
+    enabled: boolean;
+    model?: ModelDefinition;
+    systemPrompt?: string;
+    maxRetries?: number;
+}
+/**
+ * Standalone trigger definition (replaces embedded AgentTrigger[]).
+ * Triggers are now first-class entities with their own lifecycle.
+ */
+interface AgentTriggerDefinition {
+    id: string;
+    tenantId: string;
+    definitionId: string;
+    name?: string;
+    eventType: TriggerEventType;
+    objectId?: string;
+    watchedFields?: string[];
+    formDefinitionId?: string;
+    sourceAgentId?: string;
+    webhookPath?: string;
+    cronExpression?: string;
+    timezone?: string;
+    filter?: FilterState;
+    inputBuilder?: string;
+    debounceMs?: number;
+    enabled: boolean;
+    lastFiredAt?: Date;
+    createdAt: Date;
+    updatedAt: Date;
+}
+interface AgentSchedule {
+    cron: string;
+    timezone?: string;
+    enabled: boolean;
+    input?: Record<string, unknown>;
+    inputBuilder?: string;
+}
 /**
- * The type a filter on this attribute actually compares against. Identity for
- * every ordinary attribute; for a rollup it unfolds the aggregation:
- * `earliest`/`latest` compare dates, `original` compares the target attribute's
- * own type, and every other function (count/sum/avg/min/max/…) compares numbers.
- *
- * This is the single place that knowledge lives: operator resolution and value
- * canonicalization both read it, so a rollup can never be offered numeric
- * operators while its value is canonicalized as something else.
+ * Declarative trigger carried by an {@link AgentBlueprint}. The boot sync
+ * reconciles the agent's AgentTriggerDefinition rows to match, using `name`
+ * as the stable identity.
  */
-declare function resolveEffectiveFilterType(attribute: AttributeLike): AttributeType;
-
 /**
- * Common configuration for all builders (Objects & Attributes)
+ * System permission an actor must hold to see and use an agent. When
+ * declared, the agent listing and session-creation gates hide/refuse the
+ * agent for any actor lacking `action` on `resource` — checked via
+ * `PermissionService.canAccessSystemByActor`. Absent by default: the
+ * overwhelming majority of agents are visible to every actor.
  */
-interface BuilderConfig {
-    /**
-     * Technical name (snake_case, kebab-case, camelCase)
-     * Used as identifier in database and API
-     */
+interface AgentRequiredPermission {
+    resource: SystemResource;
+    action: Action;
+}
+interface AgentTriggerBlueprint {
+    name: string;
+    eventType: TriggerEventType;
+    objectId?: string;
+    watchedFields?: string[];
+    formDefinitionId?: string;
+    sourceAgentId?: string;
+    webhookPath?: string;
+    cronExpression?: string;
+    timezone?: string;
+    filter?: FilterState;
+    inputBuilder?: string;
+    debounceMs?: number;
+    enabled: boolean;
+}
+/**
+ * Code-declared agent definition produced by the `agent()` builder.
+ * Contains everything an AgentDefinition needs except runtime-assigned
+ * fields (id, tenantId, createdBy, timestamps). `system: true` blueprints
+ * are seeded/reconciled at boot and immutable through the public API.
+ */
+interface AgentBlueprint {
     name: string;
     /**
-     * Human-readable label
-     * Used in UI
+     * Display text shown wherever this agent's identity is rendered in the
+     * UI — `undefined` falls back to `name`. A separate concern from `name`
+     * on purpose: `name` is the stable identity the boot sync matches rows
+     * on (`system-agent-sync.service.ts`), so renaming the display text (or
+     * translating it) must never require touching that identity.
+     */
+    label?: string;
+    icon?: string;
+    description?: string;
+    systemPrompt: string;
+    model: ModelDefinition;
+    tools?: string[];
+    schedule?: AgentSchedule;
+    config: AgentExecutionConfig;
+    canDelegate?: boolean;
+    maxDepth?: number;
+    maxTreeCostUsd?: number;
+    /**
+     * MCP servers this agent may use (see `AgentConfig.mcpServers`). Absent
+     * means none — an agent that never declares this stays tool-identical to
+     * one predating the field. Reconciled by the boot sync like the other
+     * optional config fields (`SYNCED_FIELDS`).
+     */
+    mcpServers?: string[] | "all";
+    system: boolean;
+    /** Code-declared agents are workspace-visible; private is runtime-only. */
+    visibility: ResourceVisibility;
+    triggers: AgentTriggerBlueprint[];
+    requiredPermission?: AgentRequiredPermission;
+    approval?: AgentApprovalPolicy;
+}
+interface AgentMessageAttachment {
+    id: string;
+    name: string;
+    mimeType: string;
+    size: number;
+}
+/**
+ * The text to show wherever an agent's identity is rendered — its `label`
+ * when declared, else its technical `name` verbatim (never capitalised or
+ * otherwise transformed here: every existing agent must keep rendering
+ * exactly as it does today until it explicitly declares a `label`).
+ */
+declare function agentDisplayName(agent: Pick<AgentBlueprint, "name" | "label">): string;
+/** A lightweight todo plan scoped to one agent session. */
+interface AgentTodoPlan {
+    id: string;
+    tenantId: string;
+    sessionId: string;
+    activationMessageId?: string;
+    status: AgentTodoPlanStatus;
+    todos: AITodoItem[];
+    version: number;
+    createdBy?: string;
+    createdAt: Date;
+    updatedAt: Date;
+    completedAt?: Date;
+}
+/** UI-safe todo plan lifecycle snapshot returned by REST and realtime surfaces. */
+interface AgentTodoPlanView {
+    id: string;
+    sessionId: string;
+    status: AgentTodoPlanStatus;
+    todos: AITodoItem[];
+    version: number;
+    createdAt: string;
+    updatedAt: string;
+    completedAt?: string;
+}
+interface AgentDefinition {
+    id: string;
+    tenantId: string;
+    name: string;
+    /** Display text shown wherever this agent's identity is rendered — see `AgentBlueprint.label`. `undefined` falls back to `name`. */
+    label?: string;
+    icon?: string;
+    description?: string;
+    systemPrompt: string;
+    model: ModelDefinition;
+    tools?: string[];
+    schedule?: AgentSchedule;
+    config: AgentExecutionConfig;
+    /**
+     * MCP servers this definition may use (see `AgentConfig.mcpServers`).
+     * Absent means none — a definition that predates this field is
+     * tool-identical to one that never sets it. The opt-in is narrowed further
+     * by the viewer's visibility at resolution time (`buildMcpToolset`); a
+     * server id here that the viewer cannot see yields no tools from it.
+     */
+    mcpServers?: string[] | "all";
+    /** Code-declared (immutable via public API); reconciled by the boot sync. */
+    system: boolean;
+    visibility: ResourceVisibility;
+    ownedBy: string | null;
+    createdBy: string;
+    createdAt: Date;
+    updatedAt: Date;
+    deletedAt?: Date;
+    canDelegate?: boolean;
+    maxDepth?: number;
+    maxTreeCostUsd?: number;
+    critic?: CriticConfig;
+    autoDecide?: boolean;
+    requiredPermission?: AgentRequiredPermission;
+}
+interface AgentRun {
+    id: string;
+    definitionId?: string;
+    parentRunId?: string;
+    depth: number;
+    inlineConfig?: AgentConfig;
+    tenantId: string;
+    createdBy?: string;
+    status: AgentRunStatus;
+    retryCount: number;
+    input: Record<string, unknown>;
+    output?: Record<string, unknown>;
+    error?: string;
+    tokenUsage?: {
+        input: number;
+        output: number;
+    };
+    costUsd?: number;
+    startedAt?: Date;
+    completedAt?: Date;
+    createdAt: Date;
+    sessionId?: string;
+    rootRunId?: string;
+    triggerId?: string;
+    /** Source domain-event id that launched this run; used for redelivery idempotency. */
+    sourceEventId?: string;
+    treeCostUsd?: number;
+    effectiveSystemPrompt?: string;
+    /** Monotonic fencing token, incremented on each lease acquisition. */
+    attemptId?: number;
+    /** Worker id currently holding the execution lease (null when free). */
+    leaseOwner?: string;
+    /** When the current lease expires; a run is re-acquirable once past this. */
+    leaseExpiresAt?: Date;
+}
+interface AgentSession {
+    id: string;
+    tenantId: string;
+    mode: AgentSessionMode;
+    /** Legacy flat word — read from the generated SQL column during the phase 1 transition; derived, never written directly. */
+    status: AgentSessionStatus;
+    /**
+     * Structured state (phase 1) — the read model of the `phase` / `parked_on` /
+     * `outcome` / `human_request_ids` columns. The single turn-end writer is
+     * `resolveSessionState`; out-of-band terminalizations use
+     * `terminalSessionState`. UI reads THIS, never the flat word.
+     */
+    state: SessionState;
+    /**
+     * D4's SECOND approval level: the human's per-conversation switch. The first
+     * level is the agent's own code-declared {@link AgentApprovalPolicy}; both
+     * are read together by `requiresApproval`, and this one relaxes the
+     * `mutation` class ONLY.
+     *
+     * Required on read, not optional: the column is `NOT NULL DEFAULT 'auto'`,
+     * so every read path yields a concrete posture. Writes may omit it — see
+     * `AgentRepository.createSession`, whose input type drops it precisely
+     * because the default lives in the database.
+     */
+    approvalMode: SessionApprovalMode;
+    /** Orthogonal to approvalMode: Plan removes execution tools altogether. */
+    workMode: AgentWorkMode;
+    /** Monotonic CAS token for mode transitions and stale approval replay. */
+    workModeVersion: number;
+    /** On-demand tool groups already loaded for this session; stored truth, never inferred from history. */
+    loadedToolsets: string[];
+    definitionId?: string;
+    inlineConfig?: AgentConfig;
+    parentSessionId?: string;
+    rootSessionId: string;
+    depth: number;
+    missionPrompt?: string;
+    treeCostUsd: number;
+    name?: string;
+    metadata?: Record<string, unknown>;
+    createdBy?: string;
+    createdAt: Date;
+    updatedAt: Date;
+    completedAt?: Date;
+    expiresAt?: Date;
+    archivedAt?: Date;
+    /** Per-actor read marker. Populated by list endpoints when the caller is known. */
+    lastReadAt?: Date;
+    /** Convenience flag: true when session has activity since `lastReadAt` (or never read). */
+    isUnread?: boolean;
+}
+type ToolPartState = "streaming" | "running" | "completed" | "error";
+/**
+ * Structured cause for a tool part that ended in `state: "error"` without the
+ * tool having run. Lets the UI render a localized explanation instead of the
+ * raw error string.
+ */
+type ToolPartErrorCode = "output_limit_reached" | "interrupted";
+/**
+ * Damage measured from a tool's input WITHOUT executing it — what a
+ * confirmation card states so the human decides on numbers rather than on a
+ * tool name (D3: "the confirmation quantifies the damage").
+ *
+ * Lives here, in the contracts package, because it is written to the message
+ * part (see `approvalImpact` below) and therefore crosses runtime, adapters
+ * and UI alike. The runtime's `ToolPreview`/`ToolRiskEntry` re-export it
+ * rather than redefining it.
+ */
+interface ToolImpact {
+    /** One human sentence, used as the confirmation title. */
+    label: string;
+    /**
+     * The authorization gate refused the call.
+     *
+     * A flag rather than a wording: the label is written server-side, where no
+     * recipient locale is in reach, so a refusal used to read "Suppression
+     * refusée" to every user in every language. The card renders its own copy
+     * from this.
+     */
+    denied?: boolean;
+    /**
+     * What a delete preview is about to remove, as data rather than as a
+     * sentence. The label is written server-side with no recipient locale in
+     * reach, so "Supprimer 12 records" reached every user in every language —
+     * and its thousands separator was pinned to `fr-FR` besides. The card
+     * composes its own headline from this.
+     */
+    deletion?: {
+        /** The record or document's own name; data, not copy. */
+        target?: string;
+        /** How many are going, when there is no single target to name. */
+        count?: number;
+        /** Days the deletion can still be undone, if it can. */
+        restorableDays?: number;
+    };
+    /** Named counts, e.g. `{ records: 1284, brokenLinks: 63 }`. */
+    counts?: Record<string, number>;
+    warnings?: string[];
+}
+/**
+ * LEGACY (chantier Q, 2026-08-09): the required-vs-optional split on human
+ * requests was deleted — a question never blocks anything, and an
+ * approval-family request always gates the turn, so nothing decides between
+ * the two values anymore. The type and the `humanRequestNeed` part field
+ * below survive only because persisted rows still carry the stamp; no reader
+ * consults it.
+ */
+type HumanRequestNeed = "required" | "optional";
+type AgentMessagePart = {
+    type: "text";
+    text: string;
+} | {
+    type: "reasoning";
+    text: string;
+} | {
+    type: "error";
+    error: string;
+    errorClass?: string;
+} | {
+    type: "tool";
+    toolCallId: string;
+    name: string;
+    args: Record<string, unknown>;
+    result?: unknown;
+    error?: string;
+    errorCode?: ToolPartErrorCode;
+    state: ToolPartState;
+    durationMs?: number;
+    /**
+     * Set when this call was suspended by the approval gate (a risky tool
+     * awaiting a human decision — see `toolApproval` in the AI SDK config).
+     * The part legitimately stays in its current state (`running`) with no
+     * result/error while the human decides; presence of this id is what
+     * distinguishes "waiting on a human" from "crashed mid-call" on resume,
+     * for ANY tool name — unlike the HITL exemption, which is keyed on a
+     * fixed set of tool names (`ask_questions`).
+     */
+    approvalId?: string;
+    /**
+     * What this suspended call would do, measured ONCE at suspension time
+     * from the tool's declared `preview` (D13). Persisted next to
+     * `approvalId` instead of being recomputed per reader: the same card is
+     * rendered by three hosts (composer, notification queue, record
+     * banner), and a queue of ten pending requests would otherwise fire ten
+     * previews per host. The UI therefore shows it dated ("12 records · 4
+     * min ago"), bounded by the 24h expiry.
+     *
+     * Absent when the tool declares no `preview` (a `mutation`-class tool
+     * cannot have one, by construction of `ToolRiskEntry`) or when the
+     * preview threw — a broken preview must never swallow the suspension.
+     */
+    approvalImpact?: ToolImpact;
+    /**
+     * The human's decision on `approvalId`: `true` approved, `false` refused.
+     * Absent while the decision is still pending. The approver's identity is
+     * carried by the audit trail, not this field.
+     */
+    approved?: boolean;
+    /**
+     * The human's optional rationale for `approved` (Finding 3, final
+     * review): why they decided as they did. Purely informational — it
+     * never changes what executes, only what the agent (and any audit
+     * reader) is told about the decision.
+     */
+    approvalReason?: string;
+    /**
+     * LEGACY (chantier Q): the required-vs-optional split is gone — see
+     * {@link HumanRequestNeed}. Approval suspensions still stamp
+     * `"required"` (a statement of fact on the row), but no reader
+     * consults the field anymore.
+     */
+    humanRequestNeed?: HumanRequestNeed;
+    /**
+     * Whether the session's `auto` mode would have let THIS call through —
+     * i.e. whether offering "always allow this here" on its card would be
+     * honest. Computed server-side at suspension by re-evaluating the one
+     * owner of the decision (`requiresApproval`) with `sessionMode: "auto"`,
+     * so it can never drift from the policy: it IS the policy, asked a
+     * different question.
+     *
+     * It exists because the card cannot infer it. The tempting shortcut —
+     * "no measured impact means `mutation`, since only `destructive` and
+     * `outward` carry a `preview`" — is false: a preview that threw or timed
+     * out also yields no impact, so a deletion would masquerade as a
+     * mutation and the card would promise an ease the mode does not grant.
+     *
+     * Absent means "do not offer it", which is the fail-closed reading a
+     * pre-migration row must produce.
+     */
+    approvalRelaxableByAuto?: boolean;
+} | {
+    type: "file";
+    fileId: string;
+    name: string;
+    mimeType: string;
+} | {
+    type: "compaction";
+    state: "in-progress";
+    reason: "preflight_threshold" | "overflow_recovery";
+    estimatedTokens?: number;
+    reportedTokens?: number;
+} | {
+    type: "compaction";
+    state: "completed";
+    tokensBefore: number;
+    tokensAfter: number;
+    tokensSaved: number;
+    strategy: CompactionStrategy;
+    durationMs: number;
+    /**
+     * Raw summary text produced by the summarizer LLM. Persisted so that
+     * follow-up turns can reuse it instead of re-running the summarizer.
+     */
+    summary?: string;
+} | {
+    type: "compaction";
+    state: "failed";
+    /** Human-readable reason from the CompactionImpossibleError. */
+    reason: string;
+    durationMs?: number;
+};
+/**
+ * Persisted message in an agent session.
+ * Unified type for both interactive and autonomous sessions.
+ */
+interface AgentSessionMessage {
+    id: string;
+    sessionId: string;
+    tenantId?: string;
+    runId?: string;
+    role: "user" | "assistant" | "system" | "tool";
+    parts: AgentMessagePart[];
+    attachments?: AgentMessageAttachment[];
+    mentions?: MentionReference[];
+    model?: ModelDefinition;
+    tokenUsage?: {
+        input: number;
+        output: number;
+    };
+    metadata?: Record<string, unknown>;
+    createdAt: Date;
+}
+interface AgentToolCall {
+    id: string;
+    name: string;
+    arguments: Record<string, unknown>;
+    result?: unknown;
+    error?: string;
+    durationMs?: number;
+    /** Set by turn reconciliation when the tool call was cut off before completing. */
+    errorCode?: ToolPartErrorCode;
+}
+interface RecordAgentEvent {
+    type: AgentTriggerType;
+    objectId: string;
+    recordId: string;
+    tenantId: string;
+    data?: Record<string, unknown>;
+}
+interface FormSubmittedAgentEvent {
+    type: "form.submitted";
+    tenantId: string;
+    formId: string;
+    formName: string;
+    submissionId: string;
+    createdBy?: string;
+    createdRecordIds: Record<string, string>;
+    data: {
+        formId: string;
+        formName: string;
+        submissionId: string;
+        createdBy?: string;
+        createdRecordIds: Record<string, string>;
+        slotValues: Record<string, Record<string, unknown>>;
+        stepValues: Record<string, Record<string, unknown>>;
+    };
+}
+type AgentEvent = RecordAgentEvent | FormSubmittedAgentEvent;
+interface AgentDashboard {
+    activeRuns: number;
+    pendingRuns: number;
+    failedToday: number;
+    completedToday: number;
+    totalCostToday: number;
+    totalCostWeek: number;
+}
+/**
+ * Message role in a conversation
+ */
+type AIMessageRole = "user" | "assistant";
+/**
+ * An AI model available for selection by the user.
+ * Configured on the backend and exposed via GET /agent/models.
+ */
+interface AIAvailableModel {
+    /** Model identifier exposed to the UI (e.g. "claude-sonnet-4-6") */
+    id: string;
+    /**
+     * Provider model ID sent to the underlying SDK. Defaults to `id` when omitted.
+     * Use this to register multiple registry entries (different `contextWindow`,
+     * `label`, etc.) that route to the same upstream model — e.g. a test entry
+     * with a reduced context window for QA of the compaction system.
+     */
+    apiModelId?: string;
+    /** Provider name (e.g. "anthropic", "google") */
+    provider: string;
+    /** Display label (e.g. "Claude 4.6 Sonnet") */
+    label: string;
+    /** Whether this is the default model */
+    isDefault?: boolean;
+    /**
+     * Total context window in tokens. Optional — resolved from the vendored
+     * models.dev snapshot when omitted. Set explicitly only for a deliberate cap
+     * (e.g. a QA reduced-window entry).
+     */
+    contextWindow?: number;
+    /**
+     * Maximum output tokens. Optional — resolved from the models.dev snapshot when
+     * omitted. Set explicitly only for a deliberate cap.
+     */
+    maxOutputTokens?: number;
+    /**
+     * Set true for a model newer than the models.dev snapshot. When true,
+     * `contextWindow` and `maxOutputTokens` MUST be provided explicitly. Token
+     * cost stays unknown (never developer-specified) until the snapshot lists it.
+     */
+    unverified?: boolean;
+    /** If true, this model is used for generating compaction summaries */
+    isCompactionModel?: boolean;
+    /** If true, this model is used for fast utility generations (regex, formula, …) */
+    isUtilityModel?: boolean;
+}
+/**
+ * Tool call status during execution
+ */
+type AIToolCallStatus = "pending" | "running" | "streaming" | "success" | "error";
+/**
+ * Tool call information for chat UI
+ */
+interface AIToolCall {
+    /** Unique tool call ID */
+    id: string;
+    /** Tool name */
+    name: string;
+    /** Tool arguments */
+    args?: Record<string, unknown>;
+    /** Tool result (when complete) */
+    result?: unknown;
+    /** Error message if failed */
+    error?: string;
+    /** Execution status */
+    status: AIToolCallStatus;
+}
+/**
+ * Part type for message content
+ */
+type AIChatMessagePartType = "text" | "attachment" | "tool" | "thinking" | "reasoning" | "todo" | "question" | "error" | "approval" | "record" | "search-results" | "compaction" | (string & {});
+/**
+ * Data for text part
+ */
+interface TextPartData {
+    text: string;
+    isStreaming?: boolean;
+    /**
+     * Mentions to paint as chips inside {@link text}, rather than leaving the
+     * `@Label` the composer wrote as bare prose.
+     *
+     * Carried on the part and not on the message because the part registry hands a
+     * component its `data` and nothing else — a message-level field would mean a
+     * new context or a wider registry contract to deliver one string. Only user
+     * messages have any: an assistant writes `@` as ordinary text.
+     */
+    mentions?: MentionReference[];
+}
+/**
+ * Data for tool part (same as AIToolCall)
+ */
+interface ToolPartData {
+    id: string;
+    name: string;
+    args?: Record<string, unknown>;
+    result?: unknown;
+    error?: string;
+    errorCode?: ToolPartErrorCode;
+    status: AIToolCallStatus;
+    /** Raw JSON string accumulating during tool-input streaming (cleared on tool_input_end) */
+    partialInput?: string;
+    /**
+     * Set when this call is suspended pending a human approval decision — mirrors
+     * `AgentMessagePart`'s `"tool"` variant so a reloaded conversation still shows
+     * the call as awaiting a human rather than as a generic "running" state.
+     */
+    approvalId?: string;
+    /**
+     * What the suspended call would do, as measured ONCE at suspension time and
+     * persisted on the part (D13) — never recomputed by the renderer. Because
+     * the number is a snapshot of that moment and the request lives up to 24h,
+     * the card must show it DATED ("3 records · il y a 4 min") rather than as a
+     * live count. Absent when the tool declared no preview, or when the preview
+     * threw: a degraded card, never a lost one.
+     */
+    approvalImpact?: ToolImpact;
+    /**
+     * The human's decision, once recorded: `true` approved, `false` refused,
+     * `undefined` still pending. It has to reach the renderer, not just the
+     * request: between the decision and the end of the re-execution the part
+     * legitimately stays `running` WITH its `approvalId`, so a card keyed on
+     * `approvalId` alone would come back offering two live buttons on a request
+     * that is already settled.
+     */
+    approved?: boolean;
+    /**
+     * Whether the session's `auto` mode would have let this call through, so the
+     * card knows if "always allow this here" is an honest offer. Mirrors
+     * `AgentMessagePart`'s field of the same name — see it for why the card
+     * cannot derive this itself. Absent means do not offer it.
+     */
+    approvalRelaxableByAuto?: boolean;
+}
+/**
+ * Data for thinking part
+ */
+interface ThinkingPartData {
+    isStreaming: boolean;
+    startTime?: number;
+}
+/**
+ * Data for reasoning part (Extended Thinking content)
+ */
+interface ReasoningPartData {
+    /** Reasoning content (accumulated during streaming) */
+    content: string;
+    /** Whether reasoning is still streaming */
+    isStreaming: boolean;
+    /** Start timestamp for elapsed time display */
+    startTime?: number;
+}
+/**
+ * A part of a chat message.
+ * Parts are ordered chronologically as they arrive from the stream.
+ */
+interface AIChatMessagePart {
+    /** Part type */
+    type: AIChatMessagePartType;
+    /** Unique part ID */
+    id: string;
+    /** Part-specific data */
+    data: unknown;
+}
+/**
+ * Terminal status of a dispatched subagent, mirrored onto the parent-visible
+ * notification. `completed` reads as success; everything else reads as failure.
+ */
+type AISubagentStatus = "completed" | "failed" | "cancelled" | "timeout" | "expired";
+/**
+ * Narrow, UI-ready projection of an `agent-notification` message. Derived by the
+ * react mapper from the raw `AgentSessionMessage.metadata` so the UI never has to
+ * touch untrusted wrapper text: the title comes from {@link childName}/{@link status}
+ * and {@link body} is the child's report already unwrapped from its `<subagent_result>`
+ * envelope.
+ */
+interface AIChatNotification {
+    childSessionId: string;
+    childName: string;
+    status: AISubagentStatus;
+    /** Child's report, unwrapped from the `<subagent_result>` envelope; rendered as markdown. */
+    body: string;
+}
+/**
+ * Chat message for runtime/streaming.
+ *
+ * All content is represented as ordered parts (text, tools, thinking, etc.)
+ * Parts are in chronological order as they arrive from the stream.
+ *
+ * Used in:
+ * - useAgentChat hook
+ * - AI chat UI components
+ * - Stream processing
+ */
+interface AIChatMessage {
+    /** Unique message ID */
+    id: string;
+    /** Message role */
+    role: AIMessageRole;
+    /** Ordered message parts (text, tools, thinking, etc.) */
+    parts: AIChatMessagePart[];
+    /** Whether the message is still streaming */
+    isStreaming?: boolean;
+    /** Message timestamp */
+    timestamp?: Date;
+    /** Error message if the message failed */
+    error?: string;
+    /**
+     * Present only for subagent-completion notifications. When set, the UI renders
+     * a compact collapsible callout in the agent flow instead of a user bubble, and
+     * ignores {@link parts} (which still hold the raw wrapper text).
+     */
+    notification?: AIChatNotification;
+    /**
+     * Tokens reported by the provider after this message completed. The `input`
+     * value reflects the size of the conversation Anthropic actually saw on
+     * that turn — used by the chat composer to render a context-window
+     * progress ring.
+     */
+    tokenUsage?: {
+        input: number;
+        output: number;
+    };
+}
+/**
+ * Question types supported by the agent
+ */
+type AIQuestionType = "text" | "choice" | "confirm" | "multiselect";
+/**
+ * Option for choice/multiselect questions
+ */
+interface AIQuestionOption {
+    value: string;
+    label: string;
+    description?: string;
+}
+/**
+ * Question from the agent to the user
+ */
+interface AIQuestion {
+    /** Unique question ID */
+    id: string;
+    /** Question type */
+    type: AIQuestionType;
+    /** Question text */
+    question: string;
+    /** Options for choice/multiselect */
+    options?: AIQuestionOption[];
+    /** Placeholder for text input */
+    placeholder?: string;
+    /** Whether answer is required */
+    required?: boolean;
+    /** Min selections for multiselect */
+    minSelections?: number;
+    /** Max selections for multiselect */
+    maxSelections?: number;
+}
+/**
+ * Answer format for questions
+ */
+type AIQuestionAnswer = {
+    type: "text";
+    value: string;
+} | {
+    type: "choice";
+    value: string;
+} | {
+    type: "confirm";
+    value: boolean;
+} | {
+    type: "multiselect";
+    value: string[];
+};
+/**
+ * Option for batch questions
+ */
+interface AIBatchQuestionOption {
+    /** Value returned when selected */
+    value: string;
+    /** Display label */
+    label: string;
+    /**
+     * What choosing this option means, or what it costs. Rendered under the
+     * label, in the quiet weight: a batch of bare labels asks the human to
+     * infer the trade-off the agent already knows.
+     */
+    description?: string;
+}
+/**
+ * Kind of field a batch question is answered with.
+ *
+ * `record` (constraining the answer to a real `recordId`) is deliberately
+ * absent: it needs a record selector, which is a feature of its own rather
+ * than a field variant.
+ */
+type AIBatchQuestionType = "choice" | "text" | "boolean";
+/**
+ * Question in a batch (for ask_questions tool)
+ */
+interface AIBatchQuestion {
+    /** Unique question ID */
+    id: string;
+    /** Question text to display */
+    question: string;
+    /**
+     * Kind of field to answer with. Optional for backwards compatibility: when
+     * absent it is derived from the shape — `options` present means `choice`,
+     * otherwise `text`. Only `boolean` cannot be derived, so it must be declared.
+     */
+    type?: AIBatchQuestionType;
+    /** Predefined options (if provided, displayed as buttons) */
+    options?: AIBatchQuestionOption[];
+    /**
+     * Several options may be chosen at once, and the answer comes back as an
+     * array. Decided by the agent per question, because only it knows whether
+     * the choices are mutually exclusive; a human forced to pick one of three
+     * non-exclusive options answers a question nobody asked.
+     */
+    multiSelect?: boolean;
+    /** Allow custom text input in addition to options */
+    allowCustomAnswer?: boolean;
+    /** Placeholder for custom input field */
+    placeholder?: string;
+}
+/**
+ * A single answer, in the type the question asked for. A `boolean` question
+ * answered with the string `"true"` would leave the model re-parsing display
+ * text — the same class of mistake as returning an option's label instead of
+ * its value. A `multiSelect` question answers with the array for the same
+ * reason: joining it into `"a, b"` would hand the model a string to split back
+ * apart, and one whose separator can appear inside a value.
+ */
+type AIBatchAnswerValue = string | boolean | string[];
+/**
+ * Answer returned by the AgentQuestions widget
+ */
+interface AIBatchQuestionAnswer {
+    /** True if user skipped all questions */
+    skipped: boolean;
+    /** Map of question ID to the answer given, in the question's own type */
+    answers: Record<string, AIBatchAnswerValue>;
+}
+/**
+ * Todo item status
+ */
+declare const TODO_STATUSES: readonly ["pending", "in_progress", "completed", "blocked"];
+type AITodoStatus = (typeof TODO_STATUSES)[number];
+/**
+ * Todo item in a task list
+ */
+interface AITodoItem {
+    id: string;
+    description: string;
+    status: AITodoStatus;
+    result?: string;
+    updatedAt?: number;
+}
+/**
+ * Persisted bounds on a todo, beside the type they constrain.
+ *
+ * Both sides of the wire enforce them: the runtime zod schema when it writes,
+ * and the React projection parser when it reads an untrusted payload back.
+ * React cannot import the runtime, which is why these numbers used to be
+ * copied there under a "keep aligned with the canonical persisted schema"
+ * comment — a synchronisation the compiler could not check.
+ */
+declare const MAX_TODOS = 50;
+declare const MAX_TODO_ID_CHARS = 80;
+declare const MAX_TODO_DESCRIPTION_CHARS = 500;
+declare const MAX_TODO_RESULT_CHARS = 2000;
+/**
+ * Todo list managed by the agent
+ */
+interface AITodoList {
+    items: AITodoItem[];
+    progress: number;
+    isComplete: boolean;
+}
+/**
+ * AI Usage Metrics record
+ */
+interface AIUsageMetrics {
+    id: string;
+    tenantId: string;
+    date: Date;
+    requestCount: number;
+    totalTokens: number;
+    totalCost: number;
+    providerBreakdown: Record<string, AIProviderMetrics>;
+    toolUsage: Record<string, number>;
+}
+/**
+ * Provider-specific metrics
+ */
+interface AIProviderMetrics {
+    requests: number;
+    tokens: number;
+    cost: number;
+}
+/**
+ * Memory type for categorization
+ *
+ * - `soul`: Tenant identity and persona (admin-managed)
+ * - `user`: Per-user facts and preferences
+ * - `daily`: Auto-generated daily summaries
+ * - `session`: Auto-generated conversation summaries
+ */
+type AIMemoryType = "soul" | "user" | "daily" | "session";
+/**
+ * Advanced memory entry for OpenClaw-style memory system
+ */
+interface AIMemoryEntry {
+    id: string;
+    tenantId: string;
+    userId: string | null;
+    conversationId: string | null;
+    type: AIMemoryType;
+    content: string;
+    embedding: number[] | null;
+    importance: number;
+    source: string;
+    createdAt: Date;
+    updatedAt: Date;
+    expiresAt: Date | null;
+}
+/**
+ * Compaction summary for conversation history compression
+ */
+interface AICompactionSummary {
+    id: string;
+    tenantId: string;
+    userId: string;
+    conversationId: string;
+    summary: string;
+    originalMessageCount: number;
+    tokenCountBefore: number;
+    tokenCountAfter: number;
+    compactedAt: Date;
+}
+
+declare const NATIVE_AGENT_UI_PART_IDS_METADATA_KEY = "__stndrdsNativeUiPartIds";
+declare const NATIVE_AGENT_UI_PART_IDS_METADATA_SCHEMA_VERSION: 1;
+type NativeAgentUIPartIds = Readonly<Record<string, string>>;
+interface NativeAgentUIPartIdsMetadata {
+    readonly schemaVersion: typeof NATIVE_AGENT_UI_PART_IDS_METADATA_SCHEMA_VERSION;
+    readonly partIds: NativeAgentUIPartIds;
+}
+/** Stable metadata key for a native AI SDK part in the durable message-wide part order. */
+declare function nativeAgentUIPartIdMetadataKey(part: AgentMessagePart, partIndex: number): string | undefined;
+/**
+ * Validates the versioned client-visible native ID map against the durable
+ * message shape. Legacy row-ID maps deliberately fail closed.
+ */
+declare function parseNativeAgentUIPartIdsMetadata(message: Pick<AgentSessionMessage, "parts" | "metadata">): NativeAgentUIPartIds;
+/** Usage information rendered alongside an agent response. */
+interface AgentUsageView {
+    inputTokens: number;
+    outputTokens: number;
+    totalTokens: number;
+    cacheReadTokens?: number;
+    cacheCreationTokens?: number;
+    contextWindow: number;
+    residentTokens: number;
+    utilization: number;
+    costUsd?: number;
+}
+/** Data payloads carried by the AI SDK UI message stream for agent sessions. */
+interface AgentUIDataTypes {
+    "session-named": {
+        name: string;
+    };
+    "compaction-start": {
+        reason: "preflight_threshold" | "overflow_recovery";
+        estimatedTokens?: number;
+        reportedTokens?: number;
+    };
+    "compaction-end": {
+        tokensBefore: number;
+        tokensAfter: number;
+        tokensSaved: number;
+        strategy: CompactionStrategy;
+        durationMs: number;
+        summary?: string;
+    };
+    "compaction-failed": {
+        reason: string;
+    };
+    usage: AgentUsageView;
+    "message-persisted": {
+        message: AgentSessionMessage;
+    };
+    "message-updated": {
+        message: AgentSessionMessage;
+    };
+    "todo-plan-update": {
+        plan: AgentTodoPlanView;
+    };
+    "approval-context": {
+        approvalId: string;
+        toolCallId: string;
+        impact?: ToolImpact;
+        relaxableByAuto?: boolean;
+    };
+}
+
+/**
+ * The minimum every capability predicate in this file reads: the type, plus
+ * whatever else of a full `Attribute` the caller happens to hold. Exported so
+ * callers that only have a partial attribute — a plan's proposed attribute, a
+ * schema snapshot row — can ask the same questions as callers holding the real
+ * thing, instead of restating the rules.
+ */
+type AttributeLike = Pick<Attribute, "type"> & Partial<Attribute>;
+type AttributeLifecycleCapabilities = {
+    active: boolean;
+    deprecated: boolean;
+    visibleInArchitect: boolean;
+    visibleInRuntime: boolean;
+    warningWhenDeprecated: boolean;
+};
+type AttributeStorageMode = "value" | "edge" | "computed";
+type AttributeCardinality = "one" | "many";
+type AttributePolymorphicCapability = "none" | "code-only" | "internal";
+type AttributeStorageCapabilities = {
+    mode: AttributeStorageMode;
+    cardinality: AttributeCardinality;
+    edgeBacked: boolean;
+    preservesExistingValues: boolean;
+    qualifiedProperties: boolean;
+    polymorphic: AttributePolymorphicCapability;
+    maxItems: boolean;
+};
+type AttributeRequiredCapability = "allowed" | "forbidden";
+type AttributeDefaultValueCapability = "static" | "automatic" | "forbidden";
+type AttributeAuthoringCapabilities = {
+    editable: boolean;
+    readOnly: boolean;
+    directEdit: boolean;
+    required: AttributeRequiredCapability;
+    defaultValue: AttributeDefaultValueCapability;
+    placeholder: boolean;
+    maxItems: boolean;
+};
+type AttributePresentationCapabilities = {
+    formField: boolean;
+    tableCell: boolean;
+    defaultColumn: boolean;
+    compactDisplay: boolean;
+    popoverEditor: boolean;
+    placeholder: boolean;
+    warningWhenDeprecated: boolean;
+};
+type AttributeQueryCapabilities = {
+    filterable: boolean;
+    searchable: boolean;
+    sortable: boolean;
+    groupable: boolean;
+    kanbanGroupable: boolean;
+    operators: readonly FilterOperator[];
+};
+type AttributeAgentCapabilities = {
+    readable: boolean;
+    writable: boolean;
+    compactReadable: boolean;
+    contentReadable: boolean;
+    requiresDedicatedTool: boolean;
+};
+type AttributeExchangeCapabilities = {
+    importable: boolean;
+    exportable: boolean;
+    schemaExportable: boolean;
+    metadataExportable: boolean;
+};
+type AttributeCapabilities = {
+    lifecycle: AttributeLifecycleCapabilities;
+    storage: AttributeStorageCapabilities;
+    authoring: AttributeAuthoringCapabilities;
+    presentation: AttributePresentationCapabilities;
+    query: AttributeQueryCapabilities;
+    agent: AttributeAgentCapabilities;
+    exchange: AttributeExchangeCapabilities;
+};
+declare const ATTRIBUTE_FILTER_OPERATORS: Readonly<Record<Exclude<AttributeType, "rollup">, readonly FilterOperator[]>>;
+declare function getAttributeCapabilities(attribute: AttributeLike): AttributeCapabilities;
+declare function getAttributeFilterOperators(attribute: AttributeLike): readonly FilterOperator[];
+declare function isAttributeFilterable(attribute: AttributeLike): boolean;
+declare function isAttributeSearchable(attribute: AttributeLike): boolean;
+declare function isAttributeGroupable(attribute: AttributeLike): boolean;
+declare function isAttributeKanbanGroupable(attribute: AttributeLike): boolean;
+/**
+ * The type a filter on this attribute actually compares against. Identity for
+ * every ordinary attribute; for a rollup it unfolds the aggregation:
+ * `earliest`/`latest` compare dates, `original` compares the target attribute's
+ * own type, and every other function (count/sum/avg/min/max/…) compares numbers.
+ *
+ * This is the single place that knowledge lives: operator resolution and value
+ * canonicalization both read it, so a rollup can never be offered numeric
+ * operators while its value is canonicalized as something else.
+ */
+declare function resolveEffectiveFilterType(attribute: AttributeLike): AttributeType;
+
+/**
+ * Common configuration for all builders (Objects & Attributes)
+ */
+interface BuilderConfig {
+    /**
+     * Technical name (snake_case, kebab-case, camelCase)
+     * Used as identifier in database and API
+     */
+    name: string;
+    /**
+     * Human-readable label
+     * Used in UI
      */
     label: string;
 }
@@ -1584,6 +3026,27 @@ interface FormFreeFieldRef {
 type FormFieldRef = FormSlotFieldRef | FormFreeFieldRef;
 declare function isFormSlotFieldRef(f: FormFieldRef): f is FormSlotFieldRef;
 declare function isFormFreeFieldRef(f: FormFieldRef): f is FormFreeFieldRef;
+/**
+ * Whether a form field must be filled.
+ *
+ * An explicit `required` on the field always wins — dropping it from a field is
+ * how a form makes it optional. Only when the field says nothing does the
+ * underlying attribute's own `required` apply, and then for a `create` slot
+ * alone: that is the one mode which always writes a record, so a `select`,
+ * `optional`, or `create_if_not_empty` slot's object cannot bind the form.
+ *
+ * Lives here because both sides need the same answer. The interface used to
+ * resolve it one way and `FormService` another, so the interface demanded
+ * values the API accepted and the submission only failed later, at record
+ * creation, naming an attribute rather than the field the user was looking at
+ * (#1927). One function, imported by both, instead of a comment asking them to
+ * agree.
+ */
+declare function resolveFieldRequired(input: {
+    fieldRequired: boolean | undefined;
+    slotMode?: string;
+    attributeRequired: boolean | undefined;
+}): boolean;
 /** All slot ids a slot field writes to: the primary followed by any additional slots. */
 declare function getSlotFieldTargets(field: FormSlotFieldRef): string[];
 
@@ -1996,9 +3459,21 @@ type CustomAttributeValue = Exclude<Attribute, FormulaAttribute | RollupAttribut
  * Adds support for custom attributes (added via UI) to a record type
  * Preserves autocompletion for known attributes while allowing additional properties
  */
-type WithCustomAttributes$1<T> = T & {
+type WithCustomAttributes<T> = T & {
     [key: string]: CustomAttributeValue;
 };
+/**
+ * The open custom-key index for a *stored record*, which carries metadata the
+ * attribute value union does not describe.
+ *
+ * `WithCustomAttributes` alone cannot be intersected with {@link RecordMetadata}:
+ * an index signature constrains every property of the literal, so `createdAt:
+ * Date` and `metadata: Record<string, unknown>` are rejected by the very type
+ * that requires them — leaving `ExtractRecord` inhabitable by nothing.
+ */
+type WithCustomRecordAttributes<T> = T & {
+    [key: string]: CustomAttributeValue | RecordMetadata[keyof RecordMetadata];
+};
 /**
  * Base metadata fields present on all records.
  * These are added by the system and always available.
@@ -2073,7 +3548,7 @@ type ExtractRecord<TBuilder> = TBuilder extends {
     _types: {
         record: infer R;
     };
-} ? WithCustomAttributes$1<R> & RecordMetadata : never;
+} ? WithCustomRecordAttributes<R & RecordMetadata> : never;
 /**
  * Extract the record type without custom attributes (strict mode)
  * Use this when you only want the defined attributes
@@ -2093,7 +3568,7 @@ type ExtractRecordInput<TBuilder> = TBuilder extends {
     _types: {
         input: infer R;
     };
-} ? WithoutSystemFields<WithCustomAttributes$1<R>> : never;
+} ? WithCustomAttributes<WithoutSystemFields<R>> : never;
 /**
  * Extract the input type without custom attributes (strict mode)
  * Omits system fields (id, createdAt, updatedAt) as they are managed automatically.
@@ -2112,7 +3587,7 @@ type ExtractRecordUpdate<TBuilder> = TBuilder extends {
     _types: {
         update: infer R;
     };
-} ? WithoutSystemFields<WithCustomAttributes$1<R>> : never;
+} ? WithCustomAttributes<WithoutSystemFields<R>> : never;
 /**
  * Extract the update type without custom attributes (strict mode)
  * Omits system fields (id, createdAt, updatedAt) as they are managed automatically.
@@ -2345,6 +3820,10 @@ type UserStatus = "active" | "suspended";
  * Use in validators (e.g., `@IsIn(USER_STATUSES)`) to keep a single source of truth.
  */
 declare const USER_STATUSES: readonly UserStatus[];
+/** User preference applied only when a conversation has no session yet. */
+type UserWorkPosture = "plan" | "manual" | "auto";
+/** Canonical values accepted by profile transports and persistence. */
+declare const USER_WORK_POSTURES: readonly UserWorkPosture[];
 /**
  * User Profile - Represents application user data (authorization)
  *
@@ -2405,6 +3884,8 @@ interface UserProfile extends Timestamps {
      * - suspended: Temporarily blocked by admin
      */
     status: UserStatus;
+    /** Explicit posture used to initialize each new conversation draft. */
+    defaultWorkPosture: UserWorkPosture;
     /**
      * Last login timestamp (updated on each successful auth)
      */
@@ -2437,6 +3918,7 @@ interface UpdateUserProfile {
     avatarUrl?: string | null;
     status?: UserStatus;
     lastLoginAt?: Date;
+    defaultWorkPosture?: UserWorkPosture;
 }
 /**
  * Data for inviting a new user by email.
@@ -2675,29 +4157,58 @@ declare const BYTE_UNIT_LABELS: readonly ["B", "KB", "MB", "GB", "TB"];
 declare function formatByteSize(bytes: number): string;
 
 /**
- * The strictest reading of "no value": nullish, or the empty string.
- *
- * This is a SHAPE test, not a semantic one. It does not trim, does not recurse
- * into objects, and does not treat `[]` as empty — callers that format a value,
- * diff it, or decide whether to render a placeholder want exactly that, because
- * `"   "`, `[]` and `{ city: "" }` are all things a user can see.
+ * Four emptiness predicates live in this codebase, and each answers a different
+ * question. None of them is interchangeable with another, and every shape where
+ * they disagree is asserted from both sides in `tests/lib/empty.test.ts`:
  *
- * Three richer predicates deliberately live elsewhere and answer different
- * questions; none of them is interchangeable with this one:
+ * - `isNullishOrEmptyString` (below) — nullish or the empty string, nothing
+ *   else. A shape test, for callers that format, diff, or decide whether to
+ *   render a placeholder.
+ * - `isValuePresent` (below) — the single answer to "is a required field
+ *   satisfied?". Also trims, and treats `[]` as absent.
  * - `isEmptyValue` (validation/object/empty-value) also trims and treats an
  *   all-empty object as empty. It gates `withEmptyToNull`, which lets an
  *   optional attribute skip format validation when it is blank.
- * - `isValuePresent` (validation/object/helpers) also trims, and backs
- *   `getMissingRequiredAttributes`.
  * - the filter operators' own `isEmpty` (filters/operators) also treats `[]` as
  *   empty, because that is what `is_empty` means to a user writing a filter.
+ */
+/**
+ * The strictest reading of "no value": nullish, or the empty string.
+ *
+ * This is a SHAPE test, not a semantic one. It does not trim, does not recurse
+ * into objects, and does not treat `[]` as empty — callers that format a value,
+ * diff it, or decide whether to render a placeholder want exactly that, because
+ * `"   "`, `[]` and `{ city: "" }` are all things a user can see.
  *
  * Declared as a type guard rather than a plain boolean: it replaced inline
  * `x === null || x === undefined || x === ""` expressions, and TypeScript
  * narrows on those. A boolean-returning helper would have silently widened
  * every negative branch that used to be narrowed.
  */
-declare function isNullishOrEmptyString(value: unknown): value is null | undefined | "";
+declare function isNullishOrEmptyString(value: unknown): value is null | undefined | "";
+/**
+ * Whether a value satisfies a required field: it holds something a user would
+ * see. Nullish, a whitespace-only string, and `[]` all count as absent. Every
+ * required-field gate in the stack calls this.
+ *
+ * The semantics are the interface's, because they are what users are told. When
+ * the gates disagreed the server was the looser one, so the UI refused a value
+ * the API then accepted and the required error never cleared: a required `text`
+ * took `"   "` (#1813), a required `multiselect` took `[]`, a required
+ * `richtext` took `"   "` (#2167).
+ *
+ * Objects are deliberately out of scope: `{}` and `{ city: "" }` are present
+ * here, so a required `location` holding an empty object still passes this
+ * gate. Recursing into an object is `isEmptyValue`'s job — that is the
+ * predicate carrying the all-empty-object branch — and widening required
+ * satisfaction to match it is a separate decision about a different set of
+ * types.
+ *
+ * Deliberately NOT a type guard: unlike `isNullishOrEmptyString` it has no
+ * narrowable negative form (`"   "` is still a `string`), and every caller
+ * branches on it rather than narrowing through it.
+ */
+declare function isValuePresent(value: unknown): boolean;
 
 /**
  * The one definition of what `format: email | url | slug` means.
@@ -2850,6 +4361,15 @@ declare function validateLabelExpression(expression: string): {
  * @returns The transformed string
  */
 declare function applyPipes(value: string, pipes: string[]): string;
+/**
+ * Default fallback value when expression resolves to empty string.
+ *
+ * Exported because it is a sentinel, not a caption: the runtime writes it where
+ * no user locale exists, and it is persisted and indexed. A reader that wants to
+ * show a record's name in the reader's own language has to recognise this exact
+ * value rather than guess at one — see `recordDisplayLabel` in `@stndrds/ui`.
+ */
+declare const DEFAULT_LABEL_FALLBACK = "(Untitled)";
 /**
  * Render a label expression template with values
  *
@@ -2964,14 +4484,51 @@ interface UserLike {
 /**
  * Get user display name from firstName and lastName, falling back to email prefix.
  *
+ * A name made only of whitespace is not a name: it falls back to the address
+ * like an absent one, rather than drawing a person as a blank. That matters
+ * beyond rendering now — this value is PERSISTED into `actors.display_name`
+ * (#2214), where a row naming someone `"   "` cannot be told apart from a real
+ * one and nothing rewrites it afterwards.
+ *
  * @param user - User object with optional firstName, lastName, and email
  * @returns Display name string
  *
  * @example
  * getUserDisplayName({ firstName: "John", lastName: "Doe" }) // "John Doe"
  * getUserDisplayName({ email: "admin@example.com" }) // "admin"
+ * getUserDisplayName({ firstName: "   ", email: "admin@example.com" }) // "admin"
  */
 declare function getUserDisplayName(user: UserLike): string;
+/**
+ * Derive up to two initials from a label, for avatars and monograms.
+ *
+ * This is the single rule: every surface that draws a person derives its
+ * initials here, so two views of the same actor cannot disagree (#2104 — the
+ * activity feed and the sidebar showed different initials for one user).
+ *
+ * Two details are deliberate:
+ *
+ * - **Punctuation split only for a single word.** A label that is one word is
+ *   split again on `.`, `_` and `-`, so an e-mail local part like
+ *   `"marie.curie"` yields `"MC"` instead of `"M"`. Splitting on those
+ *   characters unconditionally would regress hyphenated names:
+ *   `"Jean-Paul Sartre"` must give `"JS"`, not `"JP"`.
+ * - **First letter or digit, not first character.** A word may start with a
+ *   quote or other decoration, so `"'Marie Curie'"` still gives `"MC"` (#1928,
+ *   where decorated senders produced punctuation initials).
+ *
+ * @param label - Display name, e-mail local part, or any human label
+ * @param fallback - Returned verbatim when no initial can be derived; may be
+ *   multiple characters (e.g. a monogram such as `"⚙"`)
+ * @returns Up to two uppercase initials, or `fallback`
+ *
+ * @example
+ * deriveInitials("Marie Curie", "?") // "MC"
+ * deriveInitials("marie.curie", "?") // "MC"
+ * deriveInitials("Jean-Paul Sartre", "?") // "JS"
+ * deriveInitials("🔥", "?") // "?"
+ */
+declare function deriveInitials(label: string | undefined, fallback: string): string;
 
 /**
  * Type guard for the { start, end } range shape stored on date attributes
@@ -3010,6 +4567,23 @@ declare const RECORD_CREATOR_ROOT_ACTOR_METADATA_KEY = "__creatorRootActorId";
  */
 declare function getRecordCreatorPrincipalId(record: Pick<ObjectRecord, "createdBy" | "metadata">): string | undefined;
 
+/**
+ * Does an action list grant `action`?
+ *
+ * `"*"` is a wildcard, not a literal action name — the contract published in
+ * `content/docs/04-permissions.mdx`. Readers that compared literally shipped a
+ * role granted `*` that listed every MCP tool and then returned an empty
+ * schema: one reader honoured the wildcard, the next did not.
+ *
+ * It lives in `@stndrds/schema` rather than beside the permission service
+ * because the browser needs it too, and `packages/ui` / `packages/react` do not
+ * depend on `@stndrds/runtime`. That package boundary is why the sidebar and the
+ * hooks each grew their own literal comparison instead of calling this.
+ */
+declare function includesAction(actions: readonly string[] | undefined, action: Action): boolean;
+/** Capability flags every surface derives from one action list. */
+declare function buildPermissionFlags(actions: readonly string[]): ObjectPermissions;
+
 /**
  * Attribute fields stored in dedicated database columns (not in config JSONB).
  * Used to determine which properties are extracted into the config column during sync.
@@ -3691,7 +5265,9 @@ interface RelationBuilderInitOptions {
  * Union of attribute builders allowed as qualified relation properties.
  * Matches PropertyType — excludes complex types (formula, rollup, relation, etc.)
  */
-type PropertyAttributeBuilder = TextAttributeBuilder<string, boolean> | NumberAttributeBuilder<string, boolean> | CheckboxAttributeBuilder<string, boolean> | DateAttributeBuilder<string, boolean> | PhoneAttributeBuilder<string, boolean> | CurrencyAttributeBuilder<string, boolean> | StatusAttributeBuilder<string, readonly Option[], boolean> | SelectAttributeBuilder<string, readonly Option[], boolean> | MultiselectAttributeBuilder<string, readonly Option[], boolean> | LocationAttributeBuilder<string, boolean>;
+type PropertyAttributeBuilder = {
+    build(): PropertyAttribute;
+};
 /**
  * Base builder for relation attributes (single and multi).
  * Carries shared methods: to(), toAny(), qualifyWith(), bilateral()
@@ -4233,31 +5809,54 @@ type ExtractBuilderInfo<T> = T extends {
     required: T["required"];
 } : never;
 /**
- * Flatten and simplify an intersection type for better IDE display
- */
-type Flatten<T> = T extends object ? {
+ * Collapse an intersection into a single object literal, for IDE display and to
+ * keep the accumulator flat as `.attribute()` calls chain.
+ *
+ * This is the only mapped type applied to the *whole* accumulated record per
+ * step, and that count is what sets the inference ceiling. (The per-attribute
+ * `{ [K in TName]: ... }` below is a mapped type too, but it spans one key, not
+ * the record.) The previous shape wrapped `Flatten` around an unconditional
+ * `Omit` — itself a `Pick`, so a second whole-record mapped type — and paid two
+ * per attribute.
+ *
+ * Measured with a uniform `text().required()` chain: the old shape was clean at
+ * 49 attributes and raised TS2589 at 50; this one is clean at 98 and raises it
+ * at 99. The CONTACT fixture in
+ * `tests/builders/big-object-type-inference.test.ts` declares 67 attributes,
+ * above the old ceiling — which is why its earliest-declared attributes silently
+ * degraded to `any`. Real objects mix attribute types and cost more per step
+ * than that uniform chain, so treat 98 as an upper bound, not a guarantee.
+ */
+type Flatten<T> = {
     [K in keyof T]: T[K];
-} : T;
+};
 /**
- * Add a required attribute to the record type
+ * Add a required attribute to the record type.
+ *
+ * `Omit` runs only when the name is already on the accumulator. That branch is
+ * what makes the later declaration win a redeclaration — without it the two
+ * declarations would intersect — while leaving the ordinary path, a name that
+ * does not collide, at the single whole-record mapped type `Flatten` describes.
  */
-type WithRequiredAttr<TRecord extends Record<string, unknown>, TName extends string, TValue> = Flatten<Omit<TRecord, TName> & {
+type WithRequiredAttr<TRecord extends Record<string, unknown>, TName extends string, TValue> = Flatten<(TName extends keyof TRecord ? Omit<TRecord, TName> : TRecord) & {
     [K in TName]: TValue;
 }>;
 /**
- * Add an optional attribute to the record type
+ * Add an optional attribute to the record type. See `WithRequiredAttr` for why
+ * the `Omit` is conditional.
  */
-type WithOptionalAttr<TRecord extends Record<string, unknown>, TName extends string, TValue> = Flatten<Omit<TRecord, TName> & {
+type WithOptionalAttr<TRecord extends Record<string, unknown>, TName extends string, TValue> = Flatten<(TName extends keyof TRecord ? Omit<TRecord, TName> : TRecord) & {
     [K in TName]?: TValue;
 }>;
 /**
- * Add support for custom attributes (added via UI) to a record type
- */
-type WithCustomAttributes<T> = T & {
-    [key: string]: CustomAttributeValue;
-};
-/**
- * Add an attribute to the accumulated record type
+ * Add an attribute to the accumulated record type.
+ *
+ * Branch here, on `TRequired`, rather than folding the two aliases above into
+ * one `Flatten<... & (TRequired extends true ? ... : ...)>`. The folded form
+ * looks tidier and survives a uniform `text()` chain, but it was measured to
+ * put the required/optional conditional *inside* the whole-record intersection,
+ * which costs enough instantiation depth to drop the CONTACT fixture back below
+ * the limit: 7 × TS2589 at 67 attributes, versus 0 in this shape.
  */
 type AddAttribute<TRecord extends Record<string, unknown>, TName extends string, TAttr extends Attribute, TRequired extends boolean> = TRequired extends true ? WithRequiredAttr<TRecord, TName, InferAttributeValue<TAttr>> : WithOptionalAttr<TRecord, TName, InferAttributeValue<TAttr>>;
 /**
@@ -4298,6 +5897,11 @@ type AddAttribute<TRecord extends Record<string, unknown>, TName extends string,
  * ```
  */
 declare class ObjectBuilder<TRecord extends Record<string, unknown> = {}> implements StandardSchemaV1<unknown, Record<string, unknown>> {
+    /**
+     * `attributes` and `name` are both seeded in the constructor and never
+     * cleared, so they are pinned non-optional here rather than re-checked (or
+     * defaulted) at every use site.
+     */
     private obj;
     private _labelExpression?;
     private _embeddingExpression?;
@@ -4334,11 +5938,11 @@ declare class ObjectBuilder<TRecord extends Record<string, unknown> = {}> implem
      */
     readonly $infer: {
         /** Full record type with custom attributes and metadata (same as ExtractRecord) */
-        record: WithCustomAttributes<TRecord> & RecordMetadata;
+        record: WithCustomRecordAttributes<TRecord & RecordMetadata>;
         /** Input type for creating records, omits system fields (same as ExtractRecordInput) */
-        create: WithoutSystemFields<WithCustomAttributes<TRecord>>;
+        create: WithCustomAttributes<WithoutSystemFields<TRecord>>;
         /** Partial type for updating records, omits system fields (same as ExtractRecordUpdate) */
-        update: WithoutSystemFields<WithCustomAttributes<{
+        update: WithCustomAttributes<WithoutSystemFields<{
             [K in keyof TRecord]?: TRecord[K];
         }>>;
     };
@@ -4418,6 +6022,7 @@ declare class ObjectBuilder<TRecord extends Record<string, unknown> = {}> implem
      * into the TRecord generic, enabling full inference.
      *
      * @param attr - Attribute definition or builder (auto-builds if builder)
+     * @throws DuplicateError if the name is already declared on this object
      */
     attribute<TBuilder extends {
         _types: unknown;
@@ -4425,10 +6030,31 @@ declare class ObjectBuilder<TRecord extends Record<string, unknown> = {}> implem
     /**
      * Add multiple attributes at once
      * Note: For full type inference, prefer chaining .attribute() calls
+     *
+     * @throws DuplicateError if a name is declared twice, inside this batch or
+     *   against an attribute already declared on this object
      */
     attributes(attrs: Array<Attribute | {
         build: () => Attribute;
     }>): this;
+    /**
+     * Build any builders, reject duplicate names, then commit — the single push
+     * path behind `attribute()` and `attributes()`, so both entry points share
+     * one builder detection and one uniqueness guarantee.
+     *
+     * The check runs on the resulting array (already committed + incoming), so one
+     * call catches both a collision inside a single `.attributes([...])` batch and
+     * one spanning several calls.
+     *
+     * Names are compared with raw `===`. Postgres stores `attributes.name` as
+     * plain `text` under a deterministic collation, so `x` and `X` are two
+     * distinct attributes there; folding case here would reject a pair the
+     * database accepts.
+     *
+     * @throws DuplicateError with `SchemaErrorCode.DUPLICATE_ATTRIBUTE`
+     * @internal
+     */
+    private pushAttributes;
     /**
      * Set metadata. Merges with any previously set metadata (preserves keys
      * written by other builder methods like `.order()`).
@@ -4793,17 +6419,16 @@ declare class ActivityTabConfig {
     build(): DetailViewDefinition;
 }
 /**
- * Builder for configuring emails tabs.
- *
- * @example
- * .tab("emails", "Emails").emails().emailAttributes("email", "backup_email")
+ * Shared builder for the tabs that associate provider data to a record by
+ * matching address-bearing attributes: emails and meetings. Both carry exactly
+ * the same configuration, so the terminal methods live here once.
  */
-declare class EmailsTabConfig {
+declare abstract class AddressMatchedTabConfig<T extends EmailsTab | MeetingsTab> {
     private view;
     private tabData;
     /** @internal */
-    constructor(view: DetailViewBuilder, base: BaseTabConfig);
-    /** Set the text attributes whose values are matched against email participants. */
+    constructor(view: DetailViewBuilder, base: BaseTabConfig, type: T["type"]);
+    /** Set the text attributes whose values are matched against participants. */
     emailAttributes(...attributeIds: string[]): this;
     /**
      * Continue building with a new tab
@@ -4818,6 +6443,26 @@ declare class EmailsTabConfig {
      */
     build(): DetailViewDefinition;
 }
+/**
+ * Builder for configuring emails tabs.
+ *
+ * @example
+ * .tab("emails", "Emails").emails().emailAttributes("email", "backup_email")
+ */
+declare class EmailsTabConfig extends AddressMatchedTabConfig<EmailsTab> {
+    /** @internal */
+    constructor(view: DetailViewBuilder, base: BaseTabConfig);
+}
+/**
+ * Builder for configuring meetings tabs.
+ *
+ * @example
+ * .tab("meetings", "Meetings").meetings().emailAttributes("email", "backup_email")
+ */
+declare class MeetingsTabConfig extends AddressMatchedTabConfig<MeetingsTab> {
+    /** @internal */
+    constructor(view: DetailViewBuilder, base: BaseTabConfig);
+}
 /**
  * Builder for configuring documents tabs
  *
@@ -4941,6 +6586,11 @@ declare class TabBuilder {
      * @example .emails().emailAttributes("email", "backup_email")
      */
     emails(): EmailsTabConfig;
+    /**
+     * Create a meetings tab (query-time association via email-bearing attributes)
+     * @example .meetings().emailAttributes("email", "backup_email")
+     */
+    meetings(): MeetingsTabConfig;
     /**
      * Create a forms tab to launch and track form instances linked to this record
      * @example .tab("forms", "Forms").forms()
@@ -6193,206 +7843,32 @@ declare function getActiveTab(config: ListViewConfig, tabId?: string): ListViewT
  *     .field("client", "firstName")
  *     .field("client", "email")
  *   .build();
- *
- * formRegistry.register(ONBOARDING);
- * ```
- */
-declare class FormRegistry {
-    private forms;
-    /**
-     * Register a form definition (or array of definitions).
-     * @throws Error if a form with the same name is already registered.
-     */
-    register(formOrForms: FormDefinition | FormDefinition[]): this;
-    /**
-     * Get a form definition by name.
-     */
-    get(name: string): FormDefinition | undefined;
-    /**
-     * Get all registered form definitions.
-     */
-    getAll(): FormDefinition[];
-    /**
-     * List all registered form names.
-     */
-    listNames(): string[];
-}
-
-declare const formRegistry: FormRegistry;
-
-/**
- * Event types emitted by write paths.
- * New types are added as handlers are implemented.
- */
-type EventType = "record.created" | "record.updated" | "record.deleted" | "record.restored" | "record.purged" | "form.submitted" | "schema.attribute.created" | "schema.attribute.updated" | "schema.attribute.deleted" | "schema.object.created" | "schema.object.deleted" | "tenant.created" | "memory.retrieved" | "agent.session.completed";
-/**
- * Typed payload map — each event type has a specific data shape.
- */
-interface EventDataMap {
-    "record.created": {
-        objectId: string;
-        objectName: string;
-        recordId: string;
-        values: Record<string, unknown>;
-    };
-    "record.updated": {
-        objectId: string;
-        objectName: string;
-        recordId: string;
-        /** Only the names of fields that changed */
-        changedFields: string[];
-        /** Only the changed fields' previous values */
-        oldValues: Record<string, unknown>;
-        /** Only the changed fields' new values */
-        newValues: Record<string, unknown>;
-    };
-    "record.deleted": {
-        objectId: string;
-        objectName: string;
-        recordId: string;
-        /** Snapshot of record values at the moment of deletion */
-        values: Record<string, unknown>;
-    };
-    "record.restored": {
-        objectId: string;
-        objectName: string;
-        recordId: string;
-    };
-    "record.purged": {
-        objectId: string;
-        objectName: string;
-        recordId: string;
-    };
-    "form.submitted": {
-        formId: string;
-        formName: string;
-        submissionId: string;
-        createdBy: string | null;
-        createdRecordIds: Record<string, string>;
-        slotValues: Record<string, Record<string, unknown>>;
-        stepValues: Record<string, Record<string, unknown>>;
-    };
-    /**
-     * Emitted after a custom attribute is added to an object. Triggers the
-     * unified `SchemaSyncHandler` which converges the search index settings
-     * (filterable/sortable/searchable) to the live schema.
-     */
-    "schema.attribute.created": {
-        objectId: string;
-        attributeId: string;
-    };
-    /**
-     * Emitted after an attribute mutation (label/required/config). The
-     * `SchemaSyncHandler` reconciles index settings; downstream reindex is
-     * handled separately by `ObjectSchemaService.updateObject` when needed.
-     */
-    "schema.attribute.updated": {
-        objectId: string;
-        attributeId: string;
-    };
-    /**
-     * Emitted after a custom attribute is deleted from an object. Triggers
-     * the unified `SchemaSyncHandler` to drop the attribute from the index
-     * settings.
-     */
-    "schema.attribute.deleted": {
-        objectId: string;
-        attributeId: string;
-    };
-    /**
-     * Emitted after a custom object is created. Triggers the unified
-     * `SchemaSyncHandler` to provision per-tenant index settings.
-     */
-    "schema.object.created": {
-        objectId: string;
-    };
-    /**
-     * Emitted after a custom object is deleted. Triggers the unified
-     * `SchemaSyncHandler` so the search adapter can clean up dangling settings.
-     */
-    "schema.object.deleted": {
-        objectId: string;
-    };
-    /**
-     * Emitted on initial provisioning of a tenant. Triggers the unified
-     * `SchemaSyncHandler` to bootstrap the tenant's search index settings.
-     */
-    "tenant.created": {
-        /** The tenant identifier (mirrors the envelope `tenantId` for convenience). */
-        tenantId: string;
-    };
-    /**
-     * Emitted when memories are retrieved via search. Passive event for
-     * observability and downstream handlers (e.g. Task 8 container forwarding).
-     */
-    "memory.retrieved": {
-        memoryIds: string[];
-        query: string;
-    };
-    /**
-     * Emitted whenever an agent session reaches a terminal status (`completed`,
-     * `failed`, `cancelled`, `timeout`, `expired`). Consumed by the
-     * `AgentCompletionHandler` to notify parent sessions when a dispatched
-     * child session finishes.
-     */
-    "agent.session.completed": {
-        sessionId: string;
-        parentSessionId?: string;
-        rootSessionId: string;
-        status: "completed" | "failed" | "cancelled" | "timeout" | "expired";
-        mode: "interactive" | "autonomous";
-        /** Durable identity of this exact terminal transition. */
-        completionOccurrenceId: string;
-        /** Exact assistant message persisted by this turn, when one exists. */
-        childMessageId?: string;
-    };
-}
-/**
- * A typed domain event.
- * The generic parameter T narrows `data` to the correct payload shape.
- */
-interface DomainEvent<T extends EventType = EventType> {
-    id: string;
-    type: T;
-    tenantId: string;
-    userId: string | null;
-    timestamp: string;
-    data: EventDataMap[T];
-    /** Free-form metadata propagated from write-path callers (e.g. provenance for loop guards). */
-    metadata?: Record<string, unknown>;
-}
-
-type LiveChannelKind = "workspace" | "object" | "record" | "view" | "agent" | "user" | "conversation";
-type LiveChannel = {
-    kind: "workspace";
-    tenantId: string;
-} | {
-    kind: "object";
-    objectId: string;
-} | {
-    kind: "record";
-    objectId: string;
-    recordId: string;
-} | {
-    kind: "view";
-    viewId: string;
-} | {
-    kind: "agent";
-    tenantId: string;
-} | {
-    kind: "user";
-    actorId: string;
-} | {
-    kind: "conversation";
-    sessionId: string;
-};
-declare function liveChannelKey(channel: LiveChannel): string;
-declare function parseLiveChannelKey(key: string): LiveChannel | null;
+ *
+ * formRegistry.register(ONBOARDING);
+ * ```
+ */
+declare class FormRegistry {
+    private forms;
+    /**
+     * Register a form definition (or array of definitions).
+     * @throws Error if a form with the same name is already registered.
+     */
+    register(formOrForms: FormDefinition | FormDefinition[]): this;
+    /**
+     * Get a form definition by name.
+     */
+    get(name: string): FormDefinition | undefined;
+    /**
+     * Get all registered form definitions.
+     */
+    getAll(): FormDefinition[];
+    /**
+     * List all registered form names.
+     */
+    listNames(): string[];
+}
 
-declare const LIVE_STREAM_START_CURSOR = "0-0";
-declare function isLiveStreamCursor(value: unknown): value is string;
-declare function assertLiveStreamCursor(cursor: string | null, label?: string): asserts cursor is string | null;
-declare function compareLiveStreamCursors(left: string, right: string): -1 | 0 | 1;
+declare const formRegistry: FormRegistry;
 
 type RecordFieldPatch = {
     fieldKey: string;
@@ -6583,6 +8059,269 @@ declare function isLiveEventType(value: unknown): value is LiveEventType;
 declare function isLiveEventPayload(payload: unknown): payload is LiveEventPayload;
 declare function isLiveEventPayloadForType(type: string, payload: unknown): payload is LiveEventPayload;
 
+/**
+ * Event types emitted by write paths.
+ * New types are added as handlers are implemented.
+ */
+type EventType = "record.created" | "record.updated" | "record.deleted" | "record.restored" | "record.purged" | "form.submitted" | "schema.attribute.created" | "schema.attribute.updated" | "schema.attribute.deleted" | "schema.object.created" | "schema.object.deleted" | "tenant.created" | "memory.retrieved" | "realtime.publish" | "agent.session.completed" | "agent.session.turn.completed" | "calendar.meeting.ended" | "calendar.meeting.transcript.created";
+/** Announced once per meeting, by the sweep that watches for end times passing.
+ * Nothing at the provider signals the end of a meeting, so this is derived. */
+interface CalendarMeetingEndedData {
+    eventId: string;
+    title: string | null;
+    startsAt: string | null;
+    endsAt: string | null;
+    conferenceJoinUrl: string | null;
+    /** Canonicalized addresses of everyone on the invite. */
+    participantAddresses: string[];
+    /** Records the meeting resolved to at the moment it ended. */
+    linkedRecordIds: string[];
+}
+/** Announced once per meeting, when a bot's recording has been transcribed and
+ * stored. Distinct from `calendar.meeting.ended`: a meeting ends whether or not
+ * anything recorded it, and a transcript can arrive minutes later. */
+interface CalendarMeetingTranscriptCreatedData {
+    transcriptId: string;
+    eventId: string;
+    provider: string;
+    language: string | null;
+    segmentCount: number;
+    /** Recording length, or null when the provider reported no bounds. */
+    durationMs: number | null;
+}
+/**
+ * Typed payload map — each event type has a specific data shape.
+ */
+interface EventDataMap {
+    "realtime.publish": {
+        channel: string;
+        type: LiveEventPayload["type"];
+        payload: LiveEventPayload;
+        actorId: string | null;
+        correlationId: string | null;
+        occurredAt: string;
+        schemaVersion: 1;
+    };
+    "record.created": {
+        objectId: string;
+        objectName: string;
+        recordId: string;
+        values: Record<string, unknown>;
+    };
+    "record.updated": {
+        objectId: string;
+        objectName: string;
+        recordId: string;
+        /** Only the names of fields that changed */
+        changedFields: string[];
+        /** Only the changed fields' previous values */
+        oldValues: Record<string, unknown>;
+        /** Only the changed fields' new values */
+        newValues: Record<string, unknown>;
+        /**
+         * The record's WHOLE value set after the write, unchanged attributes
+         * included — what `record.created` and `record.deleted` already carry.
+         *
+         * A consumer asking "does this record now match?" cannot answer from the
+         * diff: an attribute absent from `newValues` is one the write did not
+         * touch, not one the record lacks, and reading it as absent makes an
+         * `is_empty` rule fire on a populated field (#1887).
+         *
+         * Optional because the event journal is durable: entries written before
+         * this field existed still replay, and must fall back to the diff.
+         *
+         * Two things it is NOT. Computed attributes carry their pre-write value:
+         * they are recalculated in a job after the write, so no payload assembled
+         * at write time can hold their result. And the envelope is journaled inside
+         * the write RPC, so a write that loses an optimistic-concurrency race and
+         * replays still reports the values it read before the conflict. Treat it as
+         * the state this write intended, which for every non-computed attribute
+         * under no concurrent writer is the state it produced.
+         */
+        values?: Record<string, unknown>;
+    };
+    "record.deleted": {
+        objectId: string;
+        objectName: string;
+        recordId: string;
+        /** Snapshot of record values at the moment of deletion */
+        values: Record<string, unknown>;
+    };
+    "record.restored": {
+        objectId: string;
+        objectName: string;
+        recordId: string;
+    };
+    "record.purged": {
+        objectId: string;
+        objectName: string;
+        recordId: string;
+    };
+    "form.submitted": {
+        formId: string;
+        formName: string;
+        submissionId: string;
+        createdBy: string | null;
+        createdRecordIds: Record<string, string>;
+        slotValues: Record<string, Record<string, unknown>>;
+        stepValues: Record<string, Record<string, unknown>>;
+    };
+    /**
+     * Emitted after a custom attribute is added to an object. Triggers the
+     * unified `SchemaSyncHandler` which converges the search index settings
+     * (filterable/sortable/searchable) to the live schema.
+     */
+    "schema.attribute.created": {
+        objectId: string;
+        attributeId: string;
+    };
+    /**
+     * Emitted after an attribute mutation (label/required/config). The
+     * `SchemaSyncHandler` reconciles index settings; downstream reindex is
+     * handled separately by `ObjectSchemaService.updateObject` when needed.
+     */
+    "schema.attribute.updated": {
+        objectId: string;
+        attributeId: string;
+    };
+    /**
+     * Emitted after a custom attribute is deleted from an object. Triggers
+     * the unified `SchemaSyncHandler` to drop the attribute from the index
+     * settings.
+     */
+    "schema.attribute.deleted": {
+        objectId: string;
+        attributeId: string;
+    };
+    /**
+     * Emitted after a custom object is created. Triggers the unified
+     * `SchemaSyncHandler` to provision per-tenant index settings.
+     */
+    "schema.object.created": {
+        objectId: string;
+    };
+    /**
+     * Emitted after a custom object is deleted. Triggers the unified
+     * `SchemaSyncHandler` so the search adapter can clean up dangling settings.
+     */
+    "schema.object.deleted": {
+        objectId: string;
+    };
+    /**
+     * Emitted on initial provisioning of a tenant. Triggers the unified
+     * `SchemaSyncHandler` to bootstrap the tenant's search index settings.
+     */
+    "tenant.created": {
+        /** The tenant identifier (mirrors the envelope `tenantId` for convenience). */
+        tenantId: string;
+    };
+    /**
+     * Emitted when memories are retrieved via search. Passive event for
+     * observability and downstream handlers (e.g. Task 8 container forwarding).
+     */
+    "memory.retrieved": {
+        memoryIds: string[];
+        query: string;
+    };
+    /**
+     * Emitted whenever an agent session reaches a terminal status (`completed`,
+     * `failed`, `cancelled`, `timeout`, `expired`). Consumed by the
+     * `AgentCompletionHandler` to notify parent sessions when a dispatched
+     * child session finishes.
+     */
+    "agent.session.completed": {
+        sessionId: string;
+        parentSessionId?: string;
+        rootSessionId: string;
+        status: "completed" | "failed" | "cancelled" | "timeout" | "expired";
+        mode: "interactive" | "autonomous";
+        /** Durable identity of this exact terminal transition. */
+        completionOccurrenceId: string;
+        /** Exact assistant message persisted by this turn, when one exists. */
+        childMessageId?: string;
+    };
+    /**
+     * Emitted after one successful agent turn commits its resumable or terminal
+     * state. Unlike `agent.session.completed`, this is about a model turn, not
+     * the lifetime of the conversation.
+     */
+    "agent.session.turn.completed": {
+        sessionId: string;
+        parentSessionId?: string;
+        rootSessionId: string;
+        /** Redundant with parentSessionId so older child rows still fail closed. */
+        depth: number;
+        status: "idle" | "completed";
+        mode: "interactive" | "autonomous";
+    };
+    "calendar.meeting.ended": CalendarMeetingEndedData;
+    "calendar.meeting.transcript.created": CalendarMeetingTranscriptCreatedData;
+}
+/**
+ * A typed domain event.
+ * The generic parameter T narrows `data` to the correct payload shape.
+ */
+interface DomainEvent<T extends EventType = EventType> {
+    id: string;
+    type: T;
+    tenantId: string;
+    userId: string | null;
+    timestamp: string;
+    data: EventDataMap[T];
+    /** Free-form metadata propagated from write-path callers (e.g. provenance for loop guards). */
+    metadata?: Record<string, unknown>;
+}
+
+declare const AGENT_UI_BATCH_MAX_BYTES = 204800;
+declare const AGENT_UI_BATCH_MAX_ITEMS = 256;
+type AgentUIMessageBatchItem<TChunk = unknown> = {
+    sequence: number;
+    content?: {
+        kind: "text" | "reasoning";
+        startOffset: number;
+        endOffset: number;
+    };
+    chunk: TChunk;
+};
+type AgentUIMessageBatch<TChunk = unknown> = {
+    schemaVersion: 1;
+    batchId: string;
+    tenantId: string;
+    sessionId: string;
+    streamId: string;
+    sequenceStart: number;
+    sequenceEnd: number;
+    items: AgentUIMessageBatchItem<TChunk>[];
+};
+declare function isAgentUIMessageBatch(value: unknown): value is AgentUIMessageBatch;
+
+type LiveChannelKind = "workspace" | "object" | "record" | "view" | "agent" | "user" | "conversation";
+type LiveChannel = {
+    kind: "workspace";
+    tenantId: string;
+} | {
+    kind: "object";
+    objectId: string;
+} | {
+    kind: "record";
+    objectId: string;
+    recordId: string;
+} | {
+    kind: "view";
+    viewId: string;
+} | {
+    kind: "agent";
+    tenantId: string;
+} | {
+    kind: "user";
+    actorId: string;
+} | {
+    kind: "conversation";
+    sessionId: string;
+};
+declare function liveChannelKey(channel: LiveChannel): string;
+declare function parseLiveChannelKey(key: string): LiveChannel | null;
+
 type UnknownRecord = Record<string, unknown>;
 type LiveEventEnvelope = {
     id: string;
@@ -6595,36 +8334,8 @@ type LiveEventEnvelope = {
     correlationId?: string | null;
     schemaVersion?: number;
 };
-type LiveSubscribePayload = {
-    channel: string;
-    cursor: string | null;
-};
-type LiveUnsubscribePayload = {
-    channel?: string;
-};
-type LiveReplayCompletePayload = {
-    channel: string;
-    cursor: string | null;
-};
-type LiveGapPayload = {
-    channel: string;
-    requestedAfterId?: string | null;
-    oldestAvailableId?: string | null;
-    [key: string]: unknown;
-};
-type LiveErrorPayload = {
-    channel: string;
-    code?: string;
-    message?: string;
-    [key: string]: unknown;
-};
 declare function getLiveProtocolPayloadChannel(payload: unknown): string | null;
 declare function isLiveEventEnvelope(payload: unknown): payload is LiveEventEnvelope;
-declare function parseLiveSubscribePayload(payload: unknown): LiveSubscribePayload | null;
-declare function parseLiveUnsubscribePayload(payload: unknown): LiveUnsubscribePayload | null;
-declare function isLiveReplayCompletePayload(payload: unknown): payload is LiveReplayCompletePayload;
-declare function isLiveGapPayload(payload: unknown): payload is LiveGapPayload;
-declare function isLiveErrorPayload(payload: unknown): payload is LiveErrorPayload;
 
 interface OperatorSpec {
     /** Attribute types this operator applies to. Used by both UI and evaluators. */
@@ -6823,8 +8534,14 @@ declare function resolveUtcDayBounds(ms: number): IsWithinBounds | null;
 /** Format a UTC millisecond bound as the `YYYY-MM-DD` day string Postgres compares against. */
 declare function toUtcDayString(ms: number): string;
 
-/** Built-in external connector providers (v1). */
-type ConnectorProviderId = "gmail" | "outlook";
+/** Built-in external connector providers. Mirrors the runtime's
+ * `ConnectorProvider`: mail and calendar are separate keys per vendor, because
+ * the scopes differ and a user may connect one without the other. */
+type ConnectorProviderId = "gmail" | "outlook" | "google-calendar" | "outlook-calendar";
+/** Providers that sync a mailbox. */
+type EmailConnectorProviderId = Extract<ConnectorProviderId, "gmail" | "outlook">;
+/** Providers that sync a calendar. */
+type CalendarConnectorProviderId = Extract<ConnectorProviderId, "google-calendar" | "outlook-calendar">;
 /** Connection lifecycle status, mirrored from `connector_connections.status`. */
 type ConnectionStatusId = "active" | "reauth_required" | "error" | "disconnected";
 /**
@@ -6856,6 +8573,13 @@ interface StartConnectorAuthInput {
 interface StartConnectorAuthResult {
     authorizeUrl: string;
 }
+/**
+ * Providers this deployment holds OAuth credentials for. A provider absent from
+ * the list cannot start an authorization flow, so its card is not offered.
+ */
+interface ConnectorProvidersResult {
+    providers: ConnectorProviderId[];
+}
 /** Input to attach a Microsoft shared mailbox to an existing Outlook connection. */
 interface AddSharedMailboxInput {
     /** Shared mailbox SMTP address (e.g. contact@company.com). */
@@ -6928,7 +8652,14 @@ interface ConnectMcpServerInput {
 }
 
 type EmailProvider = "gmail" | "outlook";
-type EmailVisibility = "shared" | "private";
+/**
+ * How a connected mailbox is shared, NOT a record's visibility. Deliberately
+ * distinct from `ResourceVisibility`: a connection is `shared` or `private`,
+ * while the EMAILS it syncs carry `workspace | private` like every other
+ * resource. Collapsing the two is what let email run a second visibility system
+ * (#1907) — do not merge them back.
+ */
+type MailboxAccountVisibility = "shared" | "private";
 type EmailDirection = "inbound" | "outbound";
 type MailboxReadState = "all" | "unread" | "read";
 type ConnectionStatus = "active" | "reauth_required" | "error" | "disconnected";
@@ -6949,7 +8680,8 @@ interface EmailAttachmentMeta {
 interface MailboxEmail {
     id: string;
     threadId: string;
-    connectionId: string;
+    /** Null once the importing connection has been deleted — the email is kept, its origin is not. */
+    connectionId: string | null;
     messageId: string;
     fromAddress: string;
     fromName: string;
@@ -6960,7 +8692,7 @@ interface MailboxEmail {
     hasRemoteContent: boolean;
     sentAt: string;
     direction: EmailDirection;
-    visibility: EmailVisibility;
+    visibility: ResourceVisibility;
     isRead: boolean;
     labels: string[];
     attachments: EmailAttachmentMeta[];
@@ -6978,13 +8710,14 @@ interface MailboxThread {
     snippet: string;
     hasAttachments: boolean;
     participants: EmailParticipantRef[];
-    accountId: string;
+    /** Null once the connection that imported the latest message has been deleted. */
+    accountId: string | null;
 }
 interface MailboxAccount {
     id: string;
     provider: EmailProvider;
     externalAccountId: string;
-    visibility: EmailVisibility;
+    visibility: MailboxAccountVisibility;
     status: ConnectionStatus;
 }
 interface MailboxCursor {
@@ -6997,10 +8730,30 @@ interface MailboxQuery {
     readState?: MailboxReadState;
     limit?: number;
     cursor?: MailboxCursor;
+    /**
+     * Whether the response carries {@link MailboxListResponse.total}, in the
+     * records list's vocabulary. Defaults to `"exact"`: the thread-summary query
+     * already aggregates the whole matching set before it slices a page, so the
+     * count adds no scan it was not doing anyway. Pass `"none"` when the caller
+     * has the number already — every page after the first of one infinite list.
+     */
+    countMode?: CountMode;
 }
 interface MailboxListResponse {
     threads: MailboxThread[];
     nextCursor?: MailboxCursor;
+    /**
+     * Threads matching the QUERY — account, search, read state — not the page.
+     * `null` under `countMode: "none"`, which is "not counted" and never "zero".
+     */
+    total: number | null;
+    /**
+     * False when `total` is a lower bound rather than the real count, exactly as
+     * on the records page: see `ContinuationPage.totalIsExact`. Absent when
+     * nothing was counted. Derive it from the response, never from the requested
+     * mode.
+     */
+    totalIsExact?: boolean;
 }
 interface MailboxThreadDetail {
     threadId: string;
@@ -7008,6 +8761,67 @@ interface MailboxThreadDetail {
     emails: MailboxEmail[];
 }
 
+/** Wire types for the meetings surface. Mirrors `types/emails.ts`: these are the
+ * shapes the API returns and the UI renders, deliberately narrower than the
+ * runtime's persisted `CalendarEvent`. */
+type MeetingStatus = "confirmed" | "tentative" | "cancelled";
+type MeetingParticipantRole = "organizer" | "required" | "optional";
+type MeetingResponseStatus = "accepted" | "declined" | "tentative" | "needs_action";
+interface MeetingParticipantRef {
+    address: string;
+    name?: string;
+    role: MeetingParticipantRole;
+    responseStatus?: MeetingResponseStatus;
+}
+/** A record a meeting was associated to at read time, by participant address.
+ * There is no stored link — see the calendar design note. */
+interface MeetingLinkedRecord {
+    recordId: string;
+    objectId: string;
+    objectName: string;
+    /** Display label resolved from the record, when the API could resolve one. */
+    label?: string;
+}
+interface Meeting {
+    id: string;
+    title: string | null;
+    description: string | null;
+    location: string | null;
+    startsAt: string | null;
+    endsAt: string | null;
+    isAllDay: boolean;
+    status: MeetingStatus;
+    organizer: MeetingParticipantRef | null;
+    conferenceProvider: string | null;
+    conferenceJoinUrl: string | null;
+    htmlLink: string | null;
+    participants: MeetingParticipantRef[];
+    linkedRecords: MeetingLinkedRecord[];
+}
+interface MeetingsQuery {
+    /** Text match over title, description and location. */
+    search?: string;
+    /** Inclusive ISO lower bound on the start. */
+    since?: string;
+    /** Exclusive ISO upper bound on the start. */
+    before?: string;
+    /** Restrict to meetings involving one of these addresses. */
+    addresses?: string[];
+    /** Restrict to meetings linked to this record. */
+    recordId?: string;
+    /** Email attribute IDs to match on when filtering by recordId. */
+    emailAttributeIds?: string[];
+    /** `asc` lists what is coming next (the default view), `desc` reads history. */
+    order?: "asc" | "desc";
+    limit?: number;
+    offset?: number;
+}
+interface MeetingsListResponse {
+    meetings: Meeting[];
+    /** Offset to request next, absent when the page was the last one. */
+    nextOffset?: number;
+}
+
 /**
  * Serializes a value into deterministic JSON: object keys are sorted
  * recursively, array order is preserved, `undefined` object entries are
@@ -7060,6 +8874,21 @@ declare function dateInTimezone(date: Date, timezone: string): string;
  */
 declare function resolveAttributeDefaultValue(attribute: Attribute, ctx: DefaultResolutionContext): unknown;
 
+/**
+ * Build the stable title shown while an agent-generated title is unavailable.
+ */
+declare function buildAgentFallbackTitle(message: string): string;
+interface ConversationDisplayTitleInput {
+    readonly generated?: string;
+    readonly firstUserText?: string;
+    readonly emptyLabel: string;
+}
+/**
+ * Resolve a conversation title monotonically from generated, optimistic, then
+ * empty state without exposing storage placeholders such as `Session N`.
+ */
+declare function conversationDisplayTitle(input: ConversationDisplayTitleInput): string;
+
 /**
  * The subset of a view definition that participates in sync hashing.
  *
@@ -7473,9 +9302,13 @@ type SchemaPlanStatus = "proposed" | "applying" | "applied" | "failed" | "reject
 /**
  * What actually happened when a plan was applied.
  *
- * `adapter.transaction()` is not a real SQL transaction on this platform
- * (PostgREST has no transaction primitive), so a plan that fails midway
- * leaves its already-applied entries in place. `applied` is persisted
+ * `applied` was designed when `adapter.transaction()` was not a real SQL
+ * transaction (PostgREST had no transaction primitive) and a plan that failed
+ * midway genuinely left its already-applied entries in place. That is no
+ * longer true — `adapter-postgres` is the only database adapter and its
+ * transaction rolls back — so `applied` can name entries the rollback has
+ * since undone (#2279). Treat it as "what apply believed it had done when it
+ * stopped", not as a guarantee about the schema. `applied` is persisted
  * incrementally — after every step that lands, not only at the end — so a
  * process crash between two steps still leaves a readable record of exactly
  * what landed, even though `status` is then stuck at `"applying"` forever
@@ -7507,6 +9340,8 @@ interface SchemaPlanOutcome {
  */
 interface StoredSchemaPlan {
     id: Uuid;
+    /** Conversation that proposed the plan; null/absent only for historical rows. */
+    sourceSessionId?: Uuid | null;
     /**
      * The server-prepared payload, never the agent's raw proposal: `propose`
      * verifies each view target's `baselineToken` and converts the plan into
@@ -7973,4 +9808,4 @@ type SchemaPlanProposalInput = z$1.input<typeof structuralSchemaPlanSchema>;
 type ParsedSchemaPlanProposal = z$1.output<typeof schemaPlanSchema>;
 type ParsedPersistedSchemaPlan = z$1.output<typeof persistedSchemaPlanSchema>;
 
-export { type AIGenerationInputMap, type AIGenerationResult, type AIGenerationType, type AIGenerationUsage, ALLOWED_PROPERTY_TYPES, ALL_SYSTEM_RESOURCES, ATTRIBUTE_FILTER_OPERATORS, AUDIT_ACTIONS, AUDIT_RESOURCE_TYPES, type AcceptsCandidate, Action, ActivityTabConfig, type Actor, type ActorRoleAssignment, type ActorStatus, type ActorType, type AddSharedMailboxInput, AgentApprovalPolicy, AgentBlueprint, AgentBuilder, type AgentBuilderConfig, AgentExecutionConfig, AgentSchedule, type AgentSessionPatchLiveEvent, AgentTriggerBlueprint, type AgentUnreadPatchLiveEvent, type ApiKey, type ApiKeyAuthContext, type ApiKeyPermission, type ApiKeyWithSecret, type AssignActorRoleInput, Attribute, type AttributeAgentCapabilities, type AttributeAuthoringCapabilities, type AttributeCapabilities, type AttributeCardinality, type AttributeDefaultValueCapability, type AttributeExchangeCapabilities, AttributeGroupField, type AttributeLifecycleCapabilities, type AttributeLike, type AttributePolymorphicCapability, type AttributePresentationCapabilities, type AttributeQueryCapabilities, type AttributeRequiredCapability, type AttributeStorageCapabilities, type AttributeStorageMode, AttributeType, type AuditAction, type AuditActorType, type AuditChange, type AuditListOptions, type AuditLogEntry, type AuditResourceType, type AuditServiceOptions, type AuditSortField, type AuthorizedGlobalSearchResult, type AuthorizedRecordSearchResult, type AuthorizedSearchPage, BEHAVIOR_PROPERTIES, BROWSER_PREVIEW_STATUSES, BYTE_UNIT_LABELS, BilateralConfig, type BoundingBox, type BrowserPreviewDescriptor, type BrowserPreviewStatus, type BrowserPreviewUpdatedLiveEvent, type BuilderConfig, type ByteMagnitude, COMPUTED_FUNCTIONS, COMPUTED_FUNCTION_METADATA, COMPUTED_FUNCTION_NAMES, CONNECTOR_CALLBACK_PARAM, type ChannelRevokedLiveEvent, CheckboxAttribute, type CollectionPage, type CollectionRequest, type CollectionResponse, type CompileComputedFormulaInput, type ComputedCompileAttribute, type ComputedCompileObject, type ComputedCompileSchema, ComputedDependency, type ComputedDependencyGraphNode, ComputedFormulaAstNode, ComputedFormulaCompileError, type ComputedFormulaResult, type ComputedFunctionCategory, type ComputedFunctionMetadata, type ComputedFunctionName, type ComputedFunctionSignature, ComputedOptionsSource, ComputedPlan, ComputedReturnType, ComputedValueType, ConfigOverrides, type ConnectMcpServerInput, type ConnectionStatus, type ConnectionStatusId, type ConnectionView, type ConnectorCallbackStatusValue, type ConnectorProviderId, type ConnectorScope, type ContinuationPage, type ConversationRenamedLiveEvent, type CountMode, type CreateActorInput, type CreateApiKeyInput, type CreateAuditLogInput, type CreateDBAttribute, type CreateDBForm, type CreateDBFormSubmission, type CreateDBObject, type CreateDBView, type CreateDBViewOverlay, type CreateDocument, type CreateDocumentLink, type CreateFile, CreateMode, type CreateNotificationInput, type CreateNotificationRecipientInput, type CreateObjectRecord, type CreateReflexInput, type CreateReflexVersionInput, type CreateUserProfile, Currency, CurrencyAttribute, type CustomAttributeValue, type CustomObjectInfo, CustomTabConfig, type DBAttribute, type DBForm, type DBFormSubmission, type DBObject, type DBView, type DBViewOverlay, type DBViewSyncResolution, DB_COLUMN_FIELDS, DEFAULT_AGENT_EXECUTION_CONFIG, DEFAULT_ROLES, DEFAULT_ROLE_DESCRIPTIONS, DEFAULT_ROLE_LABELS, DEFAULT_ROLE_PERMISSIONS, DOCUMENT_SYSTEM_ATTRIBUTES, DateAttribute, DateRangeValue, type DefaultResolutionContext, type DefaultRoleName, type DeletedMode, DetailViewBuilder, DetailViewConfig, DetailViewDefinition, type Document, DocumentAttribute, type DocumentFile, type DocumentKind, DocumentLayout, type DocumentListOptions, type DocumentWithFiles, type DocumentWithSubCount, DocumentsTabConfig, type DomainEvent, type DriftAttributeInfo, DynamicValue, type DynamicValueResolver, EMPTY_VALUE_PLACEHOLDER, ESTIMATED_COUNT_CAP, type Eager, type EmailAttachmentMeta, type EmailDirection, type EmailParticipantRef, type EmailParticipantRole, type EmailProvider, type EmailVisibility, EmailsTabConfig, type EnvVarEntry, type EnvVarScope, type EventDataMap, type EventType, type ExtractRecord, type ExtractRecordInput, type ExtractRecordInputStrict, type ExtractRecordStrict, type ExtractRecordUpdate, type ExtractRecordUpdateStrict, FORM_FORBIDDEN_ATTRIBUTE_TYPES, type FeatureFlagDefinition, type FeatureFlagsConfig, type FeatureFlagsRepository, type FeatureGate, Field, FieldGroup, type FieldHistoryEntry, type File, type FileListOptions, type FileOcrStatus, FilterOperator, FilterRule, FilterState, FilterValue, type FlagLevel, type FlagOverride, FlagRegistry, type FlagResolutionContext, FlagService, type FlagValueType, FormBuilder, type FormDefinition, type FormFieldRef, type FormFieldsRow, type FormFreeFieldRef, type FormHeadingRow, FormRegistry, type FormRow, FormRowBuilder, type FormSeparatorRow, type FormSlot, type FormSlotFieldRef, type FormStatus, type FormStep, FormStepBuilder, type FormSubmission, type FormSubmissionStatus, type FormTextRow, FormulaAttribute, type FormulaGenerationAttribute, type FormulaGenerationInput, FormulaReturnType, type GeocodingAdapter, type GeocodingAutocompleteParams, type GeocodingParams, type GeocodingSuggestion, type GlobalSearchGroupedOptions, type GlobalSearchGroupedResult, type GlobalSearchOptions, type GlobalSearchResultItem, Group, GroupBuilder, IDENTITY_PROPERTIES, type InferAttributeValue, type InferQualifiedProps, type InviteUserInput, type IsWithinBounds, LIVE_EVENT_TYPES, LIVE_STREAM_START_CURSOR, type ListOptions, ListViewBuilder, ListViewConfig, ListViewDefinition, ListViewTab, ListViewTabConfigBuilder, ListViewTabVisibility, type LiveChannel, type LiveChannelKind, type LiveErrorPayload, type LiveEventEnvelope, type LiveEventPayload, type LiveEventType, type LiveGapPayload, type LiveNotification, type LiveNotificationRecipient, type LiveNotificationRecipientPatch, type LiveReplayCompletePayload, type LiveSubscribePayload, type LiveUnsubscribePayload, Location, LocationAttribute, LocationGranularity, MEMORY_LIST_VIEW, MEMORY_OBJECT, MEMORY_VIEW, type MailboxAccount, type MailboxCursor, type MailboxEmail, type MailboxListResponse, type MailboxQuery, type MailboxReadState, type MailboxThread, type MailboxThreadDetail, type McpCatalogEntry, type McpServerAuthInput, type McpServerAuthType, type McpServerStatus, type McpServerView, MigrationDefinition, ModelDefinition, MultiRelationAttribute, MultiselectAttribute, NOTIFICATION_INBOX_STATES, NOTIFICATION_KINDS, NOTIFICATION_PRIORITIES, NOTIFICATION_SENSITIVITIES, NOTIFICATION_TYPES_V1, NOTIFICATION_TYPE_AGENT_QUESTION_REQUESTED, NOTIFICATION_TYPE_AGENT_SESSION_COMPLETED, NOTIFICATION_TYPE_AGENT_SESSION_FAILED, NOTIFICATION_TYPE_AGENT_SESSION_TIMEOUT, NOTIFICATION_TYPE_AGENT_SESSION_WAITING_HUMAN, NOTIFICATION_TYPE_AGENT_TASK_ASSIGNED, NOTIFICATION_WORK_STATES, NoopGeocodingAdapter, type Notification, type NotificationCountPatchLiveEvent, type NotificationCounts, type NotificationCreatedLiveEvent, type NotificationInboxState, type NotificationKind, type NotificationListParams, type NotificationListResult, type NotificationPriority, type NotificationRecipient, type NotificationRecipientPatchLiveEvent, type NotificationSensitivity, type NotificationSubject, type NotificationType, type NotificationV1Type, type NotificationWithRecipient, type NotificationWorkState, NumberAttribute, OPERATOR_SPECS, ObjectBuilder, type ObjectConfig, ObjectDefinition, ObjectRecord, type OcrAdapter, type OcrInput, type OcrOptions, type OcrPage, type OcrResult, type OcrTextBlock, type OperatorSpec, Option, PRESENTATION_PROPERTIES, type PageInfo, type PageOptions, type PageResponse, type ParsedAttribute, type ParsedPersistedSchemaPlan, type ParsedSchemaPlanProposal, PermissionScope, type PersistedDefaultViewTarget, type PersistedSchemaPlan, type PersistedSchemaPlanAdditive, Phone, PhoneAttribute, type PlannedAttribute, type PlannedAttributeRemoval, type PlannedObject, type PlannedObjectRemoval, type PlannedRename, PropertySchema, type ProposedDefaultViewTarget, ProviderName, QUALIFIED_SEPARATOR, type QualifiedDocumentAttributeBuilder, type QualifiedDocumentBrand, RECORD_CREATOR_ROOT_ACTOR_METADATA_KEY, REMOVED_OPERATOR_REPLACEMENTS, type RecordCreatedLiveEvent, type RecordDeletedLiveEvent, type RecordDocuments, type RecordFieldPatch, type RecordLiveSnapshot, type RecordMetadata, type RecordPatchLiveEvent, type RecordRemovedLiveEvent, type Reflex, type ReflexRun, type ReflexState, type ReflexVersion, type ReflexVersionStatus, type RegexGenerationInput, RelationAttribute, RelationGroup, RelationGroupBuilder, RelationTarget, RelativeDateValue, type ResolutionContext, type ResolvedFlag, ResourceVisibility, type ReverseGeocodingParams, RichtextAttribute, RichtextTabConfig, RollupAttribute, RollupFunction, type RunEffect, type RunMode, SCHEMA_PLAN_LIMITS, SKILL_LIST_VIEW, SKILL_OBJECT, SKILL_VIEW, STANDARD_SCHEMA_VENDOR, SYNONYM_ALIASES, SYSTEM_ATTRIBUTES, SYSTEM_ATTRIBUTE_I18N_KEYS, SYSTEM_FILTER_ATTRIBUTE_TYPES, SYSTEM_RESOURCES, SYSTEM_RESOURCE_LABELS, type SchemaDriftResult, type SchemaPlan, type SchemaPlanAdditive, type SchemaPlanAdditiveBase, type SchemaPlanChangeSet, type SchemaPlanDestructive, type SchemaPlanDraft, type SchemaPlanDraftResponse, type SchemaPlanDraftState, type SchemaPlanDraftStatus, type SchemaPlanDraftWrite, type SchemaPlanImpact, type SchemaPlanImpactEntry, type SchemaPlanOutcome, type SchemaPlanProposalInput, type SchemaPlanSampleData, type SchemaPlanStatus, type SchemaPlanViewChanges, type SchemaState, type SearchOptions, SelectAttribute, SidePanelConfig, type SidebarExtraItem, SingleRelationAttribute, type SlotMode, SortRule, type StandardSchemaIssue, type StandardSchemaResult, type StartConnectorAuthInput, type StartConnectorAuthResult, type StaticFlagDefault, StatusAttribute, type StorageProvider, type StoredSchemaPlan, type SystemAttribute, type SystemAttributeI18nKey, type SystemFields, type SystemObjectDriftInfo, SystemResource, TEXT_FORMAT_PATTERNS, TODAY_DEFAULT, Tab, TabBuilder, TableTab, TableTabConfig, TenantId, type TenantSettings, TextAttribute, TimeFormat, Timestamps, TriggerEventType, USER_STATUSES, type UpdateActorInput, type UpdateDBAttribute, type UpdateDBForm, type UpdateDBFormSubmission, type UpdateDBObject, type UpdateDBView, type UpdateDBViewOverlay, type UpdateDocument, type UpdateFile, type UpdateUserProfile, type UpsertDBAttribute, type UpsertDBObject, type UpsertDBView, UserAttribute, type UserLike, type UserProfile, UserReferenceType, type UserStatus, Uuid, ValidationError, type ValueRef, type ViewBaselineOrigin, type ViewChange, ViewConfig, type ViewConfigDelta, ViewDefinition, type ViewProjectionStaleLiveEvent, type ViewStateEntry, type ViewStateResolution, type ViewSyncPayload, ViewType, type WithCustomAttributes$1 as WithCustomAttributes, type WithoutSystemFields, agent, applyPipes, applyRelationProps, assertAcyclicComputedDependencies, assertLiveStreamCursor, booleanFlag, buildPropertySchema, buildQualifiedAttribute, canonicalStringify, canonicalizeFilterValue, checkbox, collectQualifiedRuleIssues, compareLiveStreamCursors, compileComputedFormula, compileRollupAttribute, computeByteMagnitude, createFlagRegistry, createFlagService, createStandardSchemaProps, currency, currentActor, date, dateInTimezone, dateValueStart, destructiveSchema, detailView, document, evaluateComputedAst, evaluateComputedFormula, evaluateComputedFormulaWithResult, evaluateFilterState, evaluateRecordFilterState, extractAttributeNames, extractCurrencyFilterValue, extractFilterValue, extractValueRefs, flagRegistry, form, formRegistry, formatAttributeValue, formatByteSize, formatComputedResult, formatLocationValue, formula, generateDefaultDetailView, generateDefaultListView, getActiveTab, getAttributeCapabilities, getAttributeFilterOperators, getErrorMessage, getLiveProtocolPayloadChannel, getOperatorPolarity, getRecordCreatorPrincipalId, getSlotFieldTargets, getSystemAttributeI18nKey, getSystemAttributeList, getUserDisplayName, group, hasDestructiveEntries, inferRollupReturnType, isAttributeFilterable, isAttributeGroupable, isAttributeKanbanGroupable, isAttributeSearchable, isCheckboxEquality, isComputedFunctionName, isDateRangeValue, isDefaultRole, isDocumentAttribute, isDynamicValue, isEmptyObject, isFormDefinition, isFormFieldsRow, isFormFreeFieldRef, isFormHeadingRow, isFormSeparatorRow, isFormSlotFieldRef, isFormTextRow, isLabelExpression, isLiveErrorPayload, isLiveEventEnvelope, isLiveEventPayload, isLiveEventPayloadForType, isLiveEventType, isLiveGapPayload, isLiveReplayCompletePayload, isLiveStreamCursor, isManagedSystemAttribute, isNotEmpty, isNullishOrEmptyString, isPlainRecord, isRelativeDateValue, isSetMembershipOperator, isStandardSchema, jsonFlag, listView, liveChannelKey, location, matchesAccepts, multiselect, normalizeDateValue, normalizeFilterRule, normalizeForEdgeRpc, normalizeOperator, now, number, numberFlag, object, parseLiveChannelKey, parseLiveSubscribePayload, parseLiveUnsubscribePayload, parseQualifiedAttribute, persistedDefaultViewTargetSchema, persistedSchemaPlanSchema, phone, plannedAttributeSchema, plannedInlineAttributeSchema, plannedObjectSchema, proposedDefaultViewTargetSchema, registry, relation, relationGroup, relationPropertyDefs, renderLabelExpression, resetViewToDefault, resolveAttributeDefaultValue, resolveEffectiveFilterType, resolveIsWithinBounds, resolveTextPattern, resolveUtcDayBounds, richtext, rollup, rollupToFormulaExpression, schemaPlanSchema, select, status, stringFlag, text, toMultiValueOperator, toUndefinedIfEmpty, toUtcDayString, today, user, validateAttributeName, validateLabelExpression, validateObjectName, validateQualifiedRule, validateViewName, viewRegistry, viewStateKey, viewSyncPayload };
+export { AGENT_UI_BATCH_MAX_BYTES, AGENT_UI_BATCH_MAX_ITEMS, type AIAvailableModel, type AIBatchAnswerValue, type AIBatchQuestion, type AIBatchQuestionAnswer, type AIBatchQuestionOption, type AIBatchQuestionType, type AIChatMessage, type AIChatMessagePart, type AIChatMessagePartType, type AIChatNotification, type AICompactionSummary, type AIGenerationInputMap, type AIGenerationResult, type AIGenerationType, type AIGenerationUsage, type AIMemoryEntry, type AIMemoryType, type AIMessageRole, type AIProviderMetrics, type AIQuestion, type AIQuestionAnswer, type AIQuestionOption, type AIQuestionType, type AISubagentStatus, type AITodoItem, type AITodoList, type AITodoStatus, type AIToolCall, type AIToolCallStatus, type AIUsageMetrics, ALLOWED_PROPERTY_TYPES, ALL_ACTIONS, ALL_SYSTEM_RESOURCES, ATTRIBUTE_FILTER_OPERATORS, AUDIT_ACTIONS, AUDIT_RESOURCE_TYPES, type AcceptsCandidate, type AccessLevel, type Action, ActivityTabConfig, type Actor, type ActorRoleAssignment, type ActorStatus, type ActorType, type AddSharedMailboxInput, type AgentApprovalPolicy, type AgentBlueprint, AgentBuilder, type AgentBuilderConfig, type AgentConfig, type AgentDashboard, type AgentDefinition, type AgentEvent, type AgentExecutionConfig, type AgentMessageAttachment, type AgentMessagePart, type AgentRequiredPermission, type AgentRun, type AgentRunStatus, type AgentSchedule, type AgentSession, type AgentSessionMessage, type AgentSessionMode, type AgentSessionPatchLiveEvent, type AgentSessionStatus, type AgentTodoPlan, type AgentTodoPlanStatus, type AgentTodoPlanView, type AgentToolCall, type AgentTriggerBlueprint, type AgentTriggerDefinition, type AgentTriggerType, type AgentUIDataTypes, type AgentUIMessageBatch, type AgentUIMessageBatchItem, type AgentUnreadPatchLiveEvent, type AgentUsageView, type AgentWorkMode, type ApiKey, type ApiKeyAuthContext, type ApiKeyPermission, type ApiKeyWithSecret, type ApprovalMode, type AssignActorRoleInput, type AssignRoleInput, Attribute, type AttributeAgentCapabilities, type AttributeAuthoringCapabilities, type AttributeCapabilities, type AttributeCardinality, type AttributeDefaultValueCapability, type AttributeExchangeCapabilities, AttributeGroupField, type AttributeLifecycleCapabilities, type AttributeLike, type AttributePolymorphicCapability, type AttributePresentationCapabilities, type AttributeQueryCapabilities, type AttributeRequiredCapability, type AttributeStorageCapabilities, type AttributeStorageMode, AttributeType, type AuditAction, type AuditActorType, type AuditChange, type AuditListOptions, type AuditLogEntry, type AuditResourceType, type AuditServiceOptions, type AuditSortField, type AuthorizedGlobalSearchResult, type AuthorizedRecordSearchResult, type AuthorizedSearchPage, BEHAVIOR_PROPERTIES, BROWSER_PREVIEW_STATUSES, BYTE_UNIT_LABELS, BilateralConfig, type BoundingBox, type BrowserPreviewDescriptor, type BrowserPreviewStatus, type BrowserPreviewUpdatedLiveEvent, type BuilderConfig, type ByteMagnitude, COMPUTED_FUNCTIONS, COMPUTED_FUNCTION_METADATA, COMPUTED_FUNCTION_NAMES, CONNECTOR_CALLBACK_PARAM, COUNT_MODES, type CalendarConnectorProviderId, type CalendarMeetingEndedData, type CalendarMeetingTranscriptCreatedData, type ChannelRevokedLiveEvent, CheckboxAttribute, type CollectionPage, type CollectionRequest, type CollectionResponse, type CompactionStrategy, type CompileComputedFormulaInput, type ComputedCompileAttribute, type ComputedCompileObject, type ComputedCompileSchema, ComputedDependency, type ComputedDependencyGraphNode, ComputedFormulaAstNode, ComputedFormulaCompileError, type ComputedFormulaResult, type ComputedFunctionCategory, type ComputedFunctionMetadata, type ComputedFunctionName, type ComputedFunctionSignature, ComputedOptionsSource, ComputedPlan, ComputedReturnType, ComputedValueType, ConfigOverrides, type ConnectMcpServerInput, type ConnectionStatus, type ConnectionStatusId, type ConnectionView, type ConnectorCallbackStatusValue, type ConnectorProviderId, type ConnectorProvidersResult, type ConnectorScope, type ContinuationPage, type ConversationDisplayTitleInput, type ConversationRenamedLiveEvent, type CountMode, type CreateActorInput, type CreateApiKeyInput, type CreateAuditLogInput, type CreateDBAttribute, type CreateDBForm, type CreateDBFormSubmission, type CreateDBObject, type CreateDBView, type CreateDBViewOverlay, type CreateDocument, type CreateDocumentLink, type CreateFile, CreateMode, type CreateNotificationInput, type CreateNotificationRecipientInput, type CreateObjectRecord, type CreatePermissionInput, type CreateReflexInput, type CreateReflexVersionInput, type CreateRoleInput, type CreateUserProfile, type CriticConfig, Currency, CurrencyAttribute, type CustomAttributeValue, type CustomObjectInfo, CustomTabConfig, type DBAttribute, type DBForm, type DBFormSubmission, type DBObject, type DBView, type DBViewOverlay, type DBViewSyncResolution, DB_COLUMN_FIELDS, DEFAULT_AGENT_EXECUTION_CONFIG, DEFAULT_APPROVAL_POLICY, DEFAULT_LABEL_FALLBACK, DEFAULT_ROLES, DEFAULT_ROLE_DESCRIPTIONS, DEFAULT_ROLE_LABELS, DEFAULT_ROLE_PERMISSIONS, DOCUMENT_SYSTEM_ATTRIBUTES, DateAttribute, DateRangeValue, type DefaultResolutionContext, type DefaultRoleName, type DeletedMode, DetailViewBuilder, DetailViewConfig, DetailViewDefinition, type Document, DocumentAttribute, type DocumentFile, type DocumentKind, DocumentLayout, type DocumentListOptions, type DocumentWithFiles, type DocumentWithSubCount, DocumentsTabConfig, type DomainEvent, type DriftAttributeInfo, DynamicValue, type DynamicValueResolver, EMPTY_VALUE_PLACEHOLDER, ESTIMATED_COUNT_CAP, type Eager, type EffectivePermissions, type EmailAttachmentMeta, type EmailConnectorProviderId, type EmailDirection, type EmailParticipantRef, type EmailParticipantRole, type EmailProvider, EmailsTab, EmailsTabConfig, type EnvVarEntry, type EnvVarScope, type EventDataMap, type EventType, type ExtractRecord, type ExtractRecordInput, type ExtractRecordInputStrict, type ExtractRecordStrict, type ExtractRecordUpdate, type ExtractRecordUpdateStrict, FORM_FORBIDDEN_ATTRIBUTE_TYPES, type FeatureFlagDefinition, type FeatureFlagsConfig, type FeatureFlagsRepository, type FeatureGate, Field, FieldGroup, type FieldHistoryEntry, type File, type FileListOptions, type FileOcrStatus, FilterOperator, FilterRule, FilterState, FilterValue, type FlagLevel, type FlagOverride, FlagRegistry, type FlagResolutionContext, FlagService, type FlagValueType, FormBuilder, type FormDefinition, type FormFieldRef, type FormFieldsRow, type FormFreeFieldRef, type FormHeadingRow, FormRegistry, type FormRow, FormRowBuilder, type FormSeparatorRow, type FormSlot, type FormSlotFieldRef, type FormStatus, type FormStep, FormStepBuilder, type FormSubmission, type FormSubmissionStatus, type FormSubmittedAgentEvent, type FormTextRow, FormulaAttribute, type FormulaGenerationAttribute, type FormulaGenerationInput, FormulaReturnType, type GeocodingAdapter, type GeocodingAutocompleteParams, type GeocodingParams, type GeocodingSuggestion, type GlobalSearchGroupedOptions, type GlobalSearchGroupedResult, type GlobalSearchOptions, type GlobalSearchResultItem, Group, GroupBuilder, type HumanRequestNeed, IDENTITY_PROPERTIES, type InferAttributeValue, type InferQualifiedProps, type InviteUserInput, type IsWithinBounds, LIVE_EVENT_TYPES, type ListOptions, ListViewBuilder, ListViewConfig, ListViewDefinition, ListViewTab, ListViewTabConfigBuilder, ListViewTabVisibility, type LiveChannel, type LiveChannelKind, type LiveEventEnvelope, type LiveEventPayload, type LiveEventType, type LiveNotification, type LiveNotificationRecipient, type LiveNotificationRecipientPatch, Location, LocationAttribute, LocationGranularity, MAX_TODOS, MAX_TODO_DESCRIPTION_CHARS, MAX_TODO_ID_CHARS, MAX_TODO_RESULT_CHARS, MEMORY_LIST_VIEW, MEMORY_OBJECT, MEMORY_VIEW, type MailboxAccount, type MailboxAccountVisibility, type MailboxCursor, type MailboxEmail, type MailboxListResponse, type MailboxQuery, type MailboxReadState, type MailboxThread, type MailboxThreadDetail, type McpCatalogEntry, type McpServerAuthInput, type McpServerAuthType, type McpServerStatus, type McpServerView, type Meeting, type MeetingLinkedRecord, type MeetingParticipantRef, type MeetingParticipantRole, type MeetingResponseStatus, type MeetingStatus, type MeetingsListResponse, type MeetingsQuery, MeetingsTab, MeetingsTabConfig, type MentionEntityType, type MentionReference, type MentionedContext, type MentionedEntityContext, MigrationDefinition, type ModelDefinition, MultiRelationAttribute, MultiselectAttribute, NATIVE_AGENT_UI_PART_IDS_METADATA_KEY, NATIVE_AGENT_UI_PART_IDS_METADATA_SCHEMA_VERSION, NOTIFICATION_INBOX_STATES, NOTIFICATION_KINDS, NOTIFICATION_PRIORITIES, NOTIFICATION_SENSITIVITIES, NOTIFICATION_TYPES_V1, NOTIFICATION_TYPE_AGENT_QUESTION_REQUESTED, NOTIFICATION_TYPE_AGENT_SESSION_COMPLETED, NOTIFICATION_TYPE_AGENT_SESSION_FAILED, NOTIFICATION_TYPE_AGENT_SESSION_TIMEOUT, NOTIFICATION_TYPE_AGENT_SESSION_WAITING_HUMAN, NOTIFICATION_TYPE_AGENT_TASK_ASSIGNED, NOTIFICATION_WORK_STATES, type NativeAgentUIPartIds, type NativeAgentUIPartIdsMetadata, NoopGeocodingAdapter, type Notification, type NotificationCountPatchLiveEvent, type NotificationCounts, type NotificationCreatedLiveEvent, type NotificationInboxState, type NotificationKind, type NotificationListParams, type NotificationListResult, type NotificationPriority, type NotificationRecipient, type NotificationRecipientPatchLiveEvent, type NotificationSensitivity, type NotificationSubject, type NotificationType, type NotificationV1Type, type NotificationWithRecipient, type NotificationWorkState, NumberAttribute, OPERATOR_SPECS, ObjectBuilder, type ObjectConfig, ObjectDefinition, type ObjectPermissions, ObjectRecord, type OcrAdapter, type OcrInput, type OcrOptions, type OcrPage, type OcrResult, type OcrTextBlock, type OperatorSpec, Option, PRESENTATION_PROPERTIES, type PageInfo, type PageOptions, type PageResponse, type ParsedAttribute, type ParsedPersistedSchemaPlan, type ParsedSchemaPlanProposal, type Permission, type PermissionScope, type PersistedDefaultViewTarget, type PersistedSchemaPlan, type PersistedSchemaPlanAdditive, Phone, PhoneAttribute, type PlannedAttribute, type PlannedAttributeRemoval, type PlannedObject, type PlannedObjectRemoval, type PlannedRename, PropertyAttribute, PropertySchema, type ProposedDefaultViewTarget, type ProviderName, QUALIFIED_SEPARATOR, type QualifiedDocumentAttributeBuilder, type QualifiedDocumentBrand, RECORD_CREATOR_ROOT_ACTOR_METADATA_KEY, REMOVED_OPERATOR_REPLACEMENTS, type ReasoningPartData, type RecordAgentEvent, type RecordCreatedLiveEvent, type RecordDeletedLiveEvent, type RecordDocuments, type RecordFieldPatch, type RecordLiveSnapshot, type RecordMetadata, type RecordPatchLiveEvent, type RecordRemovedLiveEvent, type Reflex, type ReflexRun, type ReflexState, type ReflexVersion, type ReflexVersionStatus, type RegexGenerationInput, RelationAttribute, RelationGroup, RelationGroupBuilder, RelationTarget, RelativeDateValue, type ResolutionContext, type ResolvedFlag, ResourceVisibility, type RetryPolicy, type ReverseGeocodingParams, RichtextAttribute, RichtextTabConfig, type Role, RollupAttribute, RollupFunction, type RunEffect, type RunMode, SCHEMA_PLAN_LIMITS, SESSION_TERMINAL_STATUSES, SKILL_LIST_VIEW, SKILL_OBJECT, SKILL_VIEW, STANDARD_SCHEMA_VENDOR, SYNONYM_ALIASES, SYSTEM_ATTRIBUTES, SYSTEM_ATTRIBUTE_I18N_KEYS, SYSTEM_FILTER_ATTRIBUTE_TYPES, SYSTEM_RESOURCES, SYSTEM_RESOURCE_LABELS, type SchemaDriftResult, type SchemaPlan, type SchemaPlanAdditive, type SchemaPlanAdditiveBase, type SchemaPlanChangeSet, type SchemaPlanDestructive, type SchemaPlanDraft, type SchemaPlanDraftResponse, type SchemaPlanDraftState, type SchemaPlanDraftStatus, type SchemaPlanDraftWrite, type SchemaPlanImpact, type SchemaPlanImpactEntry, type SchemaPlanOutcome, type SchemaPlanProposalInput, type SchemaPlanSampleData, type SchemaPlanStatus, type SchemaPlanViewChanges, type SchemaState, type SearchOptions, SelectAttribute, type SessionApprovalMode, type SessionOutcome, type SessionParkedOn, type SessionPhase, type SessionState, SidePanelConfig, type SidebarExtraItem, SingleRelationAttribute, type SlotMode, SortRule, type StandardSchemaIssue, type StandardSchemaResult, type StartConnectorAuthInput, type StartConnectorAuthResult, type StaticFlagDefault, StatusAttribute, type StorageProvider, type StoredSchemaPlan, type SystemAttribute, type SystemAttributeI18nKey, type SystemFields, type SystemObjectDriftInfo, type SystemPermissions, type SystemResource, TEXT_FORMAT_PATTERNS, TODAY_DEFAULT, TODO_PLAN_STATUSES, TODO_STATUSES, Tab, TabBuilder, TableTab, TableTabConfig, TenantId, type TenantSettings, type TerminalSessionStatus, TextAttribute, type TextPartData, type ThinkingPartData, TimeFormat, Timestamps, type ToolImpact, type ToolPartData, type ToolPartErrorCode, type ToolPartState, type TriggerEventType, USER_STATUSES, USER_WORK_POSTURES, type UpdateActorInput, type UpdateDBAttribute, type UpdateDBForm, type UpdateDBFormSubmission, type UpdateDBObject, type UpdateDBView, type UpdateDBViewOverlay, type UpdateDocument, type UpdateFile, type UpdateRoleInput, type UpdateUserProfile, type UpsertDBAttribute, type UpsertDBObject, type UpsertDBView, UserAttribute, type UserLike, type UserProfile, UserReferenceType, type UserRoleAssignment, type UserStatus, type UserWorkPosture, Uuid, ValidationError, type ValueRef, type ViewBaselineOrigin, type ViewChange, ViewConfig, type ViewConfigDelta, ViewDefinition, type ViewProjectionStaleLiveEvent, type ViewStateEntry, type ViewStateResolution, type ViewSyncPayload, ViewType, type WithCustomAttributes, type WithCustomRecordAttributes, type WithoutSystemFields, accessLevelToActions, actionsToAccessLevel, agent, agentDisplayName, applyPipes, applyRelationProps, assertAcyclicComputedDependencies, booleanFlag, buildAgentFallbackTitle, buildPermissionFlags, buildPropertySchema, buildQualifiedAttribute, canonicalStringify, canonicalizeFilterValue, checkbox, collectQualifiedRuleIssues, compileComputedFormula, compileRollupAttribute, computeByteMagnitude, conversationDisplayTitle, createFlagRegistry, createFlagService, createStandardSchemaProps, currency, currentActor, date, dateInTimezone, dateValueStart, deriveInitials, destructiveSchema, detailView, document, evaluateComputedAst, evaluateComputedFormula, evaluateComputedFormulaWithResult, evaluateFilterState, evaluateRecordFilterState, extractAttributeNames, extractCurrencyFilterValue, extractFilterValue, extractValueRefs, flagRegistry, form, formRegistry, formatAttributeValue, formatByteSize, formatComputedResult, formatLocationValue, formula, generateDefaultDetailView, generateDefaultListView, getActiveTab, getAttributeCapabilities, getAttributeFilterOperators, getErrorMessage, getLiveProtocolPayloadChannel, getOperatorPolarity, getRecordCreatorPrincipalId, getSlotFieldTargets, getSystemAttributeI18nKey, getSystemAttributeList, getUserDisplayName, group, hasDestructiveEntries, includesAction, inferRollupReturnType, isAgentUIMessageBatch, isAttributeFilterable, isAttributeGroupable, isAttributeKanbanGroupable, isAttributeSearchable, isCheckboxEquality, isComputedFunctionName, isDateRangeValue, isDefaultRole, isDocumentAttribute, isDynamicValue, isEmptyObject, isFormDefinition, isFormFieldsRow, isFormFreeFieldRef, isFormHeadingRow, isFormSeparatorRow, isFormSlotFieldRef, isFormTextRow, isLabelExpression, isLiveEventEnvelope, isLiveEventPayload, isLiveEventPayloadForType, isLiveEventType, isManagedSystemAttribute, isNotEmpty, isNullishOrEmptyString, isPlainRecord, isRelativeDateValue, isSetMembershipOperator, isStandardSchema, isTerminalSessionStatus, isTerminalState, isValuePresent, jsonFlag, legacyStatusToSessionState, listView, liveChannelKey, location, matchesAccepts, multiselect, nativeAgentUIPartIdMetadataKey, normalizeDateValue, normalizeFilterRule, normalizeForEdgeRpc, normalizeOperator, now, number, numberFlag, object, parseCountMode, parseLiveChannelKey, parseNativeAgentUIPartIdsMetadata, parseOptionalCountMode, parseQualifiedAttribute, persistedDefaultViewTargetSchema, persistedSchemaPlanSchema, phone, plannedAttributeSchema, plannedInlineAttributeSchema, plannedObjectSchema, proposedDefaultViewTargetSchema, registry, relation, relationGroup, relationPropertyDefs, renderLabelExpression, resetViewToDefault, resolveAttributeDefaultValue, resolveEffectiveFilterType, resolveFieldRequired, resolveIsWithinBounds, resolveTextPattern, resolveUtcDayBounds, richtext, rollup, rollupToFormulaExpression, schemaPlanSchema, select, sessionStateToLegacyStatus, status, stringFlag, text, toMultiValueOperator, toUndefinedIfEmpty, toUtcDayString, today, user, validateAttributeName, validateLabelExpression, validateObjectName, validateQualifiedRule, validateViewName, viewRegistry, viewStateKey, viewSyncPayload };