@resistdesign/voltra 3.0.0-alpha.43 → 3.0.0-alpha.45

package/api/ORM/ORMRouteMap.d.ts

@@ -17,6 +17,17 @@
 import { BaseTypeInfoORMServiceConfig, TypeInfoORMDACConfig } from "./TypeInfoORMService";
 import { AuthInfo, RouteAuthConfig, RouteMap } from "../Router/Types";
 import { TypeInfoORMAPI } from "../../common/TypeInfoORM";
+/**
+ * Optional configuration for Type Info ORM route-map behavior.
+ */
+export type TypeInfoORMRouteMapConfig = {
+    /**
+     * Whether update handlers should forward field operators from request args.
+     *
+     * Defaults to `true`.
+     */
+    allowUpdateFieldOperators?: boolean;
+};
 /**
  * A collection of errors that can occur when creating or using a Type Info ORM Route Map.
  * */
@@ -52,4 +63,8 @@ getAccessingRoleId?: (authInfo: AuthInfo) => string,
 /**
  * Optional route-level auth configuration.
  */
-authConfig?: RouteAuthConfig) => RouteMap;
+authConfig?: RouteAuthConfig, 
+/**
+ * Optional route-map behavior config.
+ */
+routeMapConfig?: TypeInfoORMRouteMapConfig) => RouteMap;

package/api/ORM/TypeInfoORMService.d.ts

@@ -8,7 +8,7 @@
 import { LiteralValue, TypeInfo, TypeInfoDataItem, TypeInfoField, TypeInfoMap, TypeOperation } from "../../common/TypeParsing/TypeInfo";
 import { CustomTypeInfoFieldValidatorMap } from "../../common/TypeParsing/Validation";
 import { ComparisonOperators, FieldCriterion, ListItemsConfig, ListItemsResults, ListRelationshipsConfig, SearchCriteria } from "../../common/SearchTypes";
-import { DeleteRelationshipResults, RelationshipOperation, TypeInfoORMAPI, TypeInfoORMContext } from "../../common/TypeInfoORM";
+import { DeleteRelationshipResults, RelationshipOperation, TypeInfoORMAPI, TypeInfoORMContext, TypeInfoORMUpdateConfig } from "../../common/TypeInfoORM";
 import { DataItemDBDriver, IndexingRelationshipDriver, ItemRelationshipDBDriver } from "./drivers";
 import { BaseItemRelationshipInfo, ItemRelationshipInfo, ItemRelationshipInfoKeys, ItemRelationshipInfoType, ItemRelationshipOriginatingItemInfo } from "../../common/ItemRelationshipInfoTypes";
 import { DACAccessResult, DACDataItemResourceAccessResultMap, DACRole } from "../DataAccessControl";
@@ -171,6 +171,64 @@ export type TypeInfoORMIndexingConfig = {
         }) => void;
     };
 };
+/**
+ * Optional field overrides for manual indexing maintenance operations.
+ */
+export type TypeInfoORMManualIndexingConfig = {
+    /**
+     * Explicit full-text field name(s) to target instead of the configured defaults.
+     *
+     * Supply the previous field set when cleaning up after a schema/config change.
+     */
+    fullTextIndexFields?: string | string[];
+};
+/**
+ * Optional field overrides for manual index replacement/reindex operations.
+ */
+export type TypeInfoORMReplaceIndexingConfig = {
+    /**
+     * Full-text field name(s) to remove from the previous snapshot.
+     */
+    previousFullTextIndexFields?: string | string[];
+    /**
+     * Full-text field name(s) to add for the next snapshot.
+     */
+    nextFullTextIndexFields?: string | string[];
+};
+/**
+ * Options for reindexing a stored item from the backing driver.
+ */
+export type TypeInfoORMReindexStoredItemConfig = TypeInfoORMReplaceIndexingConfig & {
+    /**
+     * Optional previous snapshot to remove before indexing the current stored item.
+     */
+    previousItem?: Partial<TypeInfoDataItem>;
+};
+/**
+ * Options for reindexing all currently stored items of a type.
+ */
+export type TypeInfoORMReindexStoredTypeConfig = TypeInfoORMReplaceIndexingConfig & {
+    /**
+     * Maximum number of items to load per driver page.
+     */
+    itemsPerPage?: number;
+    /**
+     * Optional previous snapshots keyed by primary field value.
+     *
+     * Use this when a schema/config change requires cleanup of previously indexed
+     * full-text fields before the current item is reindexed.
+     */
+    previousItemsByPrimaryField?: Record<string, Partial<TypeInfoDataItem>>;
+};
+/**
+ * Results from reindexing all currently stored items of a type.
+ */
+export type TypeInfoORMReindexStoredTypeResults = {
+    /**
+     * Number of stored items that were reindexed.
+     */
+    processedCount: number;
+};
 /**
  * The basis for the configuration for the TypeInfoORMService.
  * */
@@ -350,7 +408,7 @@ export declare class TypeInfoORMService implements TypeInfoORMAPI {
     /**
      * Optional override for the index field.
      */
-    override?: string) => string[];
+    override?: string | string[]) => string[];
     /**
      * @returns True when the operator maps to full-text search.
      */
@@ -480,6 +538,18 @@ export declare class TypeInfoORMService implements TypeInfoORMAPI {
      * Item to extract structured fields from.
      */
     item: Partial<TypeInfoDataItem>) => StructuredDocFieldsRecord;
+    /**
+     * @returns Item snapshot normalized for indexing operations.
+     */
+    protected getIndexedItemSnapshot: (
+    /**
+     * Type name used to clean the item.
+     */
+    typeName: string, 
+    /**
+     * Item snapshot to normalize.
+     */
+    item: Partial<TypeInfoDataItem>) => Partial<TypeInfoDataItem>;
     /**
      * @returns Mapped structured query.
      */
@@ -511,7 +581,7 @@ export declare class TypeInfoORMService implements TypeInfoORMAPI {
     /**
      * Optional override for the index field.
      */
-    indexFieldOverride?: string): Promise<void>;
+    indexFieldOverride?: string | string[]): Promise<void>;
     /**
      * @returns Promise resolved once removal is complete.
      */
@@ -527,7 +597,7 @@ export declare class TypeInfoORMService implements TypeInfoORMAPI {
     /**
      * Optional override for the index field.
      */
-    indexFieldOverride?: string): Promise<void>;
+    indexFieldOverride?: string | string[]): Promise<void>;
     /**
      * @returns Promise resolved once replacement is complete.
      */
@@ -547,7 +617,71 @@ export declare class TypeInfoORMService implements TypeInfoORMAPI {
     /**
      * Optional override for the index field.
      */
-    indexFieldOverride?: string): Promise<void>;
+    indexFieldOverride?: string | string[]): Promise<void>;
+    /**
+     * Write the provided item snapshot into the configured indexes.
+     *
+     * Use this when data was created or modified outside `TypeInfoORMService`.
+     *
+     * @param typeName Type name for the indexed item.
+     * @param item Item snapshot to index.
+     * @param config Optional full-text field overrides.
+     * @returns Promise resolved when manual indexing completes.
+     */
+    indexItemIndexes: (typeName: string, item: Partial<TypeInfoDataItem>, config?: TypeInfoORMManualIndexingConfig) => Promise<void>;
+    /**
+     * Remove the provided item snapshot from the configured indexes.
+     *
+     * Use this when data was deleted outside `TypeInfoORMService`.
+     *
+     * @param typeName Type name for the indexed item.
+     * @param item Item snapshot to remove from the indexes.
+     * @param config Optional full-text field overrides.
+     * @returns Promise resolved when index cleanup completes.
+     */
+    removeItemIndexes: (typeName: string, item: Partial<TypeInfoDataItem>, config?: TypeInfoORMManualIndexingConfig) => Promise<void>;
+    /**
+     * Replace one indexed item snapshot with another.
+     *
+     * Use this when an existing stored item changed outside `TypeInfoORMService`
+     * or when a schema/config change requires removing old full-text fields and
+     * indexing a new field set.
+     *
+     * @param typeName Type name for the indexed item.
+     * @param previousItem Previous item snapshot to remove.
+     * @param nextItem Next item snapshot to index.
+     * @param config Optional previous/next full-text field overrides.
+     * @returns Promise resolved when replacement indexing completes.
+     */
+    replaceItemIndexes: (typeName: string, previousItem: Partial<TypeInfoDataItem>, nextItem: Partial<TypeInfoDataItem>, config?: TypeInfoORMReplaceIndexingConfig) => Promise<void>;
+    /**
+     * Reindex the current stored item using the configured driver.
+     *
+     * When no previous snapshot is supplied, the current stored item is used for
+     * both removal and indexing to refresh existing postings without duplication.
+     * Supply `previousItem` when an out-of-band update changed indexed field
+     * values, otherwise old full-text tokens cannot be removed safely.
+     *
+     * @param typeName Type name to reindex.
+     * @param primaryFieldValue Primary field value for the stored item.
+     * @param config Optional previous snapshot and full-text field overrides.
+     * @returns True when reindexing completed.
+     */
+    reindexStoredItem: (typeName: string, primaryFieldValue: LiteralValue, config?: TypeInfoORMReindexStoredItemConfig) => Promise<boolean>;
+    /**
+     * Reindex all currently stored items for a type.
+     *
+     * This is intended for maintenance passes after out-of-band writes or
+     * schema/index configuration changes. Deleted items still require explicit
+     * cleanup via {@link removeItemIndexes}, because full-text token removal
+     * needs a prior snapshot of indexed field values. For out-of-band updates
+     * that changed indexed values, provide `previousItemsByPrimaryField`.
+     *
+     * @param typeName Type name to reindex.
+     * @param config Paging, previous snapshots, and full-text field overrides.
+     * @returns Count of processed stored items.
+     */
+    reindexStoredType: (typeName: string, config?: TypeInfoORMReindexStoredTypeConfig) => Promise<TypeInfoORMReindexStoredTypeResults>;
     /**
      * @returns Promise resolved once indexing is complete.
      */
@@ -604,6 +738,10 @@ export declare class TypeInfoORMService implements TypeInfoORMAPI {
      * Whether the item is a partial update.
      */
     itemIsPartial?: boolean) => void;
+    /**
+     * Validate update operator config against the target TypeInfo fields.
+     */
+    protected validateUpdateConfig: (typeName: string, item: TypeInfoDataItem, updateConfig?: TypeInfoORMUpdateConfig) => void;
     /**
      * @returns Cleaned item with selected fields and DAC constraints applied.
      */
@@ -719,9 +857,10 @@ export declare class TypeInfoORMService implements TypeInfoORMAPI {
      * The `item` **must always** contain its **primary field value**.
      * @param typeName Type name to update.
      * @param item Item payload to update.
+     * @param updateConfig Optional per-field operator config.
      * @returns True when the update succeeded.
      * */
-    update: (typeName: string, item: TypeInfoDataItem, context?: TypeInfoORMContext) => Promise<boolean>;
+    update: (typeName: string, item: TypeInfoDataItem, updateConfig?: TypeInfoORMUpdateConfig, context?: TypeInfoORMContext) => Promise<boolean>;
     /**
      * Delete an existing item of the given type.
      * @param typeName Type name to delete.

package/api/ORM/drivers/DynamoDBDataItemDBDriver.d.ts

@@ -7,6 +7,7 @@
 import { DataItemDBDriver, DataItemDBDriverConfig, SupportedDataItemDBDriverEntry } from "./common/Types";
 import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
 import { TypeInfoDataItem } from "../../../common/TypeParsing/TypeInfo";
+import { TypeInfoORMUpdateConfig } from "../../../common/TypeInfoORM";
 import { ListItemsConfig, ListItemsResults } from "../../../common/SearchTypes";
 /**
  * A {@link DataItemDBDriver} that uses DynamoDB as its database.
@@ -59,7 +60,7 @@ export declare class DynamoDBDataItemDBDriver<ItemType extends TypeInfoDataItem,
     /**
      * Partial update payload for the item.
      */
-    updatedItem: Partial<ItemType>) => Promise<boolean>;
+    updatedItem: Partial<ItemType>, updateConfig?: TypeInfoORMUpdateConfig) => Promise<boolean>;
     /**
      * Delete an item from the database.
      * @returns True when an item was deleted.

package/api/ORM/drivers/InMemoryDataItemDBDriver.d.ts

@@ -1,6 +1,7 @@
 import { DataItemDBDriver, DataItemDBDriverConfig, SupportedDataItemDBDriverEntry } from "./common/Types";
 import type { TypeInfoDataItem } from "../../../common/TypeParsing/TypeInfo";
 import type { ListItemsConfig, ListItemsResults } from "../../../common/SearchTypes";
+import { TypeInfoORMUpdateConfig } from "../../../common/TypeInfoORM";
 /**
  * In-memory data item driver for testing and local usage.
  */
@@ -34,7 +35,7 @@ export declare class InMemoryDataItemDBDriver<ItemType extends TypeInfoDataItem,
      * @param updatedItem Partial update payload for the item.
      * @returns True when the item was updated.
      */
-    updateItem: (uniqueIdentifier: ItemType[UniquelyIdentifyingFieldName], updatedItem: Partial<ItemType>) => Promise<boolean>;
+    updateItem: (uniqueIdentifier: ItemType[UniquelyIdentifyingFieldName], updatedItem: Partial<ItemType>, updateConfig?: TypeInfoORMUpdateConfig) => Promise<boolean>;
     /**
      * Delete an item from memory.
      * @param uniqueIdentifier Unique identifier value for the item.

package/api/ORM/drivers/common/Types.d.ts

@@ -1,6 +1,7 @@
 import { TypeInfoDataItem, TypeInfoPack } from "../../../../common/TypeParsing/TypeInfo";
 import { ItemRelationshipInfo, ItemRelationshipInfoIdentifyingKeys } from "../../../../common/ItemRelationshipInfoTypes";
 import { ListItemsConfig, ListItemsResults } from "../../../../common/SearchTypes";
+import type { TypeInfoORMUpdateConfig } from "../../../../common/TypeInfoORM/Types";
 /**
  * The errors that can be thrown by a {@link DataItemDBDriver}.
  * */
@@ -24,7 +25,11 @@ export declare enum DATA_ITEM_DB_DRIVER_ERRORS {
     /**
      * Search operator is not supported by the driver.
      */
-    SEARCH_COMPARISON_OPERATOR_NOT_SUPPORTED = "SEARCH_COMPARISON_OPERATOR_NOT_SUPPORTED"
+    SEARCH_COMPARISON_OPERATOR_NOT_SUPPORTED = "SEARCH_COMPARISON_OPERATOR_NOT_SUPPORTED",
+    /**
+     * Update operator is not supported by the driver.
+     */
+    UPDATE_OPERATOR_NOT_SUPPORTED = "UPDATE_OPERATOR_NOT_SUPPORTED"
 }
 /**
  * The generic type for a database driver configuration.
@@ -70,7 +75,7 @@ export type DataItemDBDriver<ItemType extends TypeInfoDataItem, UniquelyIdentify
      * @param updatedItem Partial update payload for the item.
      * @returns True when the item was updated.
      */
-    updateItem: (uniqueIdentifier: ItemType[UniquelyIdentifyingFieldName], updatedItem: Partial<ItemType>) => Promise<boolean>;
+    updateItem: (uniqueIdentifier: ItemType[UniquelyIdentifyingFieldName], updatedItem: Partial<ItemType>, updateConfig?: TypeInfoORMUpdateConfig) => Promise<boolean>;
     /**
      * Delete an item from the data store.
      * @param uniqueIdentifier Unique identifier value for the item.

package/api/ORM/getTypeInfoORMIndexingConfigFromTypeInfoMap.d.ts

@@ -0,0 +1,31 @@
+import type { TypeInfoMap } from "../../common/TypeParsing/TypeInfo";
+import type { TypeInfoORMIndexingConfig } from "./TypeInfoORMService";
+/**
+ * Base indexing config accepted by {@link getTypeInfoORMIndexingConfigFromTypeInfoMap}.
+ *
+ * The utility derives only field lists from `TypeInfo` tags. Concrete backends,
+ * readers, writers, and other runtime dependencies must be supplied here when
+ * a tagged field requires that indexing mode.
+ */
+export type TypeInfoORMIndexingConfigSeed = Omit<TypeInfoORMIndexingConfig, "fullText" | "structured"> & {
+    /**
+     * Optional full-text runtime dependencies and existing field map.
+     */
+    fullText?: TypeInfoORMIndexingConfig["fullText"];
+    /**
+     * Optional structured runtime dependencies and existing field map.
+     */
+    structured?: TypeInfoORMIndexingConfig["structured"];
+};
+/**
+ * Derive ORM indexing field configuration from `TypeInfoField.tags.indexed`.
+ *
+ * The returned config preserves the supplied runtime dependencies and merges
+ * any generated field names into existing `fullText.defaultIndexFieldByType`
+ * and `structured.indexedFieldsByType` entries.
+ *
+ * @param typeInfoMap Type definitions to scan for indexing tags.
+ * @param baseConfig Runtime indexing dependencies and any existing field lists.
+ * @returns ORM indexing config with generated field lists merged in.
+ */
+export declare const getTypeInfoORMIndexingConfigFromTypeInfoMap: (typeInfoMap: TypeInfoMap, baseConfig?: TypeInfoORMIndexingConfigSeed) => TypeInfoORMIndexingConfig;

package/api/ORM/index.d.ts

@@ -4,6 +4,7 @@
 export * from "./drivers";
 export * from "./TypeInfoORMService";
 export * from "./DACUtils";
+export * from "./getTypeInfoORMIndexingConfigFromTypeInfoMap";
 export * from "./ORMRouteMap";
 export * from "../DataAccessControl";
 export * from "../Router/Types";

package/api/index.js

@@ -1,4 +1,4 @@
-import { ITEM_RELATIONSHIP_DAC_RESOURCE_NAME, ComparisonOperators } from '../chunk-7AMEFPPP.js';
+import { TypeInfoORMUpdateOperators, ITEM_RELATIONSHIP_DAC_RESOURCE_NAME, ComparisonOperators } from '../chunk-RUNXRISF.js';
 import { getNoErrorDescriptor, getErrorDescriptor, ERROR_MESSAGE_CONSTANTS, validateTypeOperationAllowed, getValidityValue, validateTypeInfoValue, validateTypeInfoFieldValue } from '../chunk-YCTVEW2I.js';
 import { mergeStringPaths, getPathString, getPathArray } from '../chunk-WNFRDIBW.js';
 import '../chunk-I2KLQ2HA.js';
@@ -4540,6 +4540,7 @@ var DATA_ITEM_DB_DRIVER_ERRORS = /* @__PURE__ */ ((DATA_ITEM_DB_DRIVER_ERRORS2)
   DATA_ITEM_DB_DRIVER_ERRORS2["ITEM_NOT_FOUND"] = "ITEM_NOT_FOUND";
   DATA_ITEM_DB_DRIVER_ERRORS2["MISSING_UNIQUE_IDENTIFIER"] = "MISSING_UNIQUE_IDENTIFIER";
   DATA_ITEM_DB_DRIVER_ERRORS2["SEARCH_COMPARISON_OPERATOR_NOT_SUPPORTED"] = "SEARCH_COMPARISON_OPERATOR_NOT_SUPPORTED";
+  DATA_ITEM_DB_DRIVER_ERRORS2["UPDATE_OPERATOR_NOT_SUPPORTED"] = "UPDATE_OPERATOR_NOT_SUPPORTED";
   return DATA_ITEM_DB_DRIVER_ERRORS2;
 })(DATA_ITEM_DB_DRIVER_ERRORS || {});
 
@@ -5778,8 +5779,9 @@ var createFilterExpression = (fieldCriteria, logicalOperator) => {
   }
   return output;
 };
-var buildUpdateExpression = (updatedItem, uniquelyIdentifyingFieldName) => {
-  const updateExpressionParts = [];
+var buildUpdateExpression = (updatedItem, uniquelyIdentifyingFieldName, updateConfig) => {
+  const setExpressionParts = [];
+  const addExpressionParts = [];
   const attributeNames = {};
   const attributeValues = {};
   for (const f in updatedItem) {
@@ -5787,13 +5789,35 @@ var buildUpdateExpression = (updatedItem, uniquelyIdentifyingFieldName) => {
     if (f !== uniquelyIdentifyingFieldName && typeof value !== "undefined") {
       const placeholderName = `#${f}`;
       const placeholderValue = `:${f}`;
-      updateExpressionParts.push(`${placeholderName} = ${placeholderValue}`);
+      const operator = updateConfig?.fieldOperators?.[f];
       attributeNames[placeholderName] = f;
       attributeValues[placeholderValue] = marshall(value);
+      if (operator === TypeInfoORMUpdateOperators.NUMBER.INCREMENT) {
+        addExpressionParts.push(`${placeholderName} ${placeholderValue}`);
+        continue;
+      }
+      if (operator === TypeInfoORMUpdateOperators.NUMBER.DECREMENT) {
+        const decrementPlaceholderValue = `:${f}_decrement`;
+        addExpressionParts.push(
+          `${placeholderName} ${decrementPlaceholderValue}`
+        );
+        attributeValues[decrementPlaceholderValue] = marshall(
+          -value
+        );
+        continue;
+      }
+      setExpressionParts.push(`${placeholderName} = ${placeholderValue}`);
     }
   }
+  const expressionParts = [];
+  if (setExpressionParts.length > 0) {
+    expressionParts.push(`SET ${setExpressionParts.join(", ")}`);
+  }
+  if (addExpressionParts.length > 0) {
+    expressionParts.push(`ADD ${addExpressionParts.join(", ")}`);
+  }
   return {
-    UpdateExpression: `SET ${updateExpressionParts.join(", ")}`,
+    UpdateExpression: expressionParts.join(" "),
     ExpressionAttributeNames: attributeNames,
     ExpressionAttributeValues: attributeValues
   };
@@ -5872,7 +5896,7 @@ var DynamoDBDataItemDBDriver = class {
    * Update an item in the database.
    * @returns True when an item was updated.
    */
-  updateItem = async (uniqueIdentifier, updatedItem) => {
+  updateItem = async (uniqueIdentifier, updatedItem, updateConfig) => {
     const { tableName, uniquelyIdentifyingFieldName } = this.config;
     const {
       [uniquelyIdentifyingFieldName]: _unusedUniqueIdentifier,
@@ -5887,7 +5911,8 @@ var DynamoDBDataItemDBDriver = class {
         ReturnValues: "ALL_NEW",
         ...buildUpdateExpression(
           cleanUpdatedItem,
-          uniquelyIdentifyingFieldName
+          uniquelyIdentifyingFieldName,
+          updateConfig
         )
       });
       const { Attributes } = await this.dynamoDBClient.send(command);
@@ -6092,7 +6117,7 @@ var InMemoryDataItemDBDriver = class {
    * @param updatedItem Partial update payload for the item.
    * @returns True when the item was updated.
    */
-  updateItem = async (uniqueIdentifier, updatedItem) => {
+  updateItem = async (uniqueIdentifier, updatedItem, updateConfig) => {
     const { uniquelyIdentifyingFieldName } = this.config;
     if (typeof uniqueIdentifier === "undefined") {
       throw {
@@ -6110,6 +6135,17 @@ var InMemoryDataItemDBDriver = class {
     };
     for (const [key, value] of Object.entries(cleanUpdatedItem)) {
       if (typeof value !== "undefined") {
+        const operator = updateConfig?.fieldOperators?.[key];
+        if (operator === TypeInfoORMUpdateOperators.NUMBER.INCREMENT) {
+          const currentValue = nextItem[key];
+          nextItem[key] = (typeof currentValue === "number" ? currentValue : 0) + value;
+          continue;
+        }
+        if (operator === TypeInfoORMUpdateOperators.NUMBER.DECREMENT) {
+          const currentValue = nextItem[key];
+          nextItem[key] = (typeof currentValue === "number" ? currentValue : 0) - value;
+          continue;
+        }
         nextItem[key] = value;
       }
     }
@@ -7528,8 +7564,24 @@ var TypeInfoORMService = class {
    * @returns Resolved full-text index field names.
    */
   resolveFullTextIndexFields = (typeName, override) => {
-    if (override) {
-      return [override];
+    if (typeof override === "string") {
+      return this.resolveFullTextIndexFields(typeName, [override]);
+    }
+    if (Array.isArray(override)) {
+      const seen2 = /* @__PURE__ */ new Set();
+      const fields2 = [];
+      for (const field of override) {
+        if (typeof field !== "string") {
+          continue;
+        }
+        const trimmed = field.trim();
+        if (!trimmed || seen2.has(trimmed)) {
+          continue;
+        }
+        seen2.add(trimmed);
+        fields2.push(trimmed);
+      }
+      return fields2;
     }
     const defaults = this.config.indexing?.fullText?.defaultIndexFieldByType?.[typeName];
     if (typeof defaults === "string") {
@@ -7833,6 +7885,10 @@ var TypeInfoORMService = class {
     }
     return fields;
   };
+  /**
+   * @returns Item snapshot normalized for indexing operations.
+   */
+  getIndexedItemSnapshot = (typeName, item) => this.getCleanItem(typeName, item, {});
   /**
    * @returns Mapped structured query.
    */
@@ -7952,6 +8008,132 @@ var TypeInfoORMService = class {
       });
     }
   }
+  /**
+   * Write the provided item snapshot into the configured indexes.
+   *
+   * Use this when data was created or modified outside `TypeInfoORMService`.
+   *
+   * @param typeName Type name for the indexed item.
+   * @param item Item snapshot to index.
+   * @param config Optional full-text field overrides.
+   * @returns Promise resolved when manual indexing completes.
+   */
+  indexItemIndexes = async (typeName, item, config = {}) => {
+    const indexedItem = this.getIndexedItemSnapshot(typeName, item);
+    await this.indexFullTextDocument(
+      typeName,
+      indexedItem,
+      config.fullTextIndexFields
+    );
+    await this.indexStructuredDocument(typeName, indexedItem);
+  };
+  /**
+   * Remove the provided item snapshot from the configured indexes.
+   *
+   * Use this when data was deleted outside `TypeInfoORMService`.
+   *
+   * @param typeName Type name for the indexed item.
+   * @param item Item snapshot to remove from the indexes.
+   * @param config Optional full-text field overrides.
+   * @returns Promise resolved when index cleanup completes.
+   */
+  removeItemIndexes = async (typeName, item, config = {}) => {
+    const indexedItem = this.getIndexedItemSnapshot(typeName, item);
+    await this.removeFullTextDocument(
+      typeName,
+      indexedItem,
+      config.fullTextIndexFields
+    );
+    await this.removeStructuredDocument(typeName, indexedItem);
+  };
+  /**
+   * Replace one indexed item snapshot with another.
+   *
+   * Use this when an existing stored item changed outside `TypeInfoORMService`
+   * or when a schema/config change requires removing old full-text fields and
+   * indexing a new field set.
+   *
+   * @param typeName Type name for the indexed item.
+   * @param previousItem Previous item snapshot to remove.
+   * @param nextItem Next item snapshot to index.
+   * @param config Optional previous/next full-text field overrides.
+   * @returns Promise resolved when replacement indexing completes.
+   */
+  replaceItemIndexes = async (typeName, previousItem, nextItem, config = {}) => {
+    const previousIndexedItem = this.getIndexedItemSnapshot(typeName, previousItem);
+    const nextIndexedItem = this.getIndexedItemSnapshot(typeName, nextItem);
+    await this.removeFullTextDocument(
+      typeName,
+      previousIndexedItem,
+      config.previousFullTextIndexFields
+    );
+    await this.indexFullTextDocument(
+      typeName,
+      nextIndexedItem,
+      config.nextFullTextIndexFields
+    );
+    await this.indexStructuredDocument(typeName, nextIndexedItem);
+  };
+  /**
+   * Reindex the current stored item using the configured driver.
+   *
+   * When no previous snapshot is supplied, the current stored item is used for
+   * both removal and indexing to refresh existing postings without duplication.
+   * Supply `previousItem` when an out-of-band update changed indexed field
+   * values, otherwise old full-text tokens cannot be removed safely.
+   *
+   * @param typeName Type name to reindex.
+   * @param primaryFieldValue Primary field value for the stored item.
+   * @param config Optional previous snapshot and full-text field overrides.
+   * @returns True when reindexing completed.
+   */
+  reindexStoredItem = async (typeName, primaryFieldValue, config = {}) => {
+    const driver = this.getDriverInternal(typeName);
+    const currentItem = await driver.readItem(primaryFieldValue);
+    const previousItem = config.previousItem ?? currentItem;
+    await this.replaceItemIndexes(typeName, previousItem, currentItem, {
+      previousFullTextIndexFields: config.previousFullTextIndexFields,
+      nextFullTextIndexFields: config.nextFullTextIndexFields
+    });
+    return true;
+  };
+  /**
+   * Reindex all currently stored items for a type.
+   *
+   * This is intended for maintenance passes after out-of-band writes or
+   * schema/index configuration changes. Deleted items still require explicit
+   * cleanup via {@link removeItemIndexes}, because full-text token removal
+   * needs a prior snapshot of indexed field values. For out-of-band updates
+   * that changed indexed values, provide `previousItemsByPrimaryField`.
+   *
+   * @param typeName Type name to reindex.
+   * @param config Paging, previous snapshots, and full-text field overrides.
+   * @returns Count of processed stored items.
+   */
+  reindexStoredType = async (typeName, config = {}) => {
+    const driver = this.getDriverInternal(typeName);
+    const primaryFieldName = String(this.getTypeInfo(typeName).primaryField);
+    const itemsPerPage = config.itemsPerPage ?? 100;
+    let processedCount = 0;
+    let cursor;
+    do {
+      const page = await driver.listItems({ itemsPerPage, cursor });
+      for (const item of page.items) {
+        const primaryFieldValue = item[primaryFieldName];
+        if (typeof primaryFieldValue === "undefined") {
+          continue;
+        }
+        const previousItem = config.previousItemsByPrimaryField?.[String(primaryFieldValue)] ?? item;
+        await this.replaceItemIndexes(typeName, previousItem, item, {
+          previousFullTextIndexFields: config.previousFullTextIndexFields,
+          nextFullTextIndexFields: config.nextFullTextIndexFields
+        });
+        processedCount += 1;
+      }
+      cursor = page.cursor;
+    } while (cursor);
+    return { processedCount };
+  };
   /**
    * @returns Promise resolved once indexing is complete.
    */
@@ -8063,6 +8245,40 @@ var TypeInfoORMService = class {
       throw validationResults;
     }
   };
+  /**
+   * Validate update operator config against the target TypeInfo fields.
+   */
+  validateUpdateConfig = (typeName, item, updateConfig) => {
+    const fieldOperators = updateConfig?.fieldOperators;
+    if (!fieldOperators) {
+      return;
+    }
+    const { fields = {}, primaryField } = this.getTypeInfo(typeName);
+    for (const [fieldName, operator] of Object.entries(fieldOperators)) {
+      const field = fields[fieldName];
+      const itemValue = item[fieldName];
+      const isNumberOperator = Object.values(
+        TypeInfoORMUpdateOperators.NUMBER
+      ).includes(
+        operator
+      );
+      if (!field || fieldName === primaryField || !isNumberOperator || field.array || field.type !== "number" || typeof itemValue !== "number") {
+        const validationResults = {
+          typeName,
+          valid: false,
+          error: getErrorDescriptor(
+            "INVALID_UPDATE_OPERATOR" /* INVALID_UPDATE_OPERATOR */
+          ),
+          errorMap: {
+            [fieldName]: [
+              getErrorDescriptor("INVALID_UPDATE_OPERATOR" /* INVALID_UPDATE_OPERATOR */)
+            ]
+          }
+        };
+        throw validationResults;
+      }
+    }
+  };
   /**
    * @returns Cleaned item with selected fields and DAC constraints applied.
    */
@@ -8475,8 +8691,7 @@ var TypeInfoORMService = class {
       ...cleanItem,
       [primaryField]: newIdentifier
     };
-    await this.indexFullTextDocument(typeName, indexedItem);
-    await this.indexStructuredDocument(typeName, indexedItem);
+    await this.indexItemIndexes(typeName, indexedItem);
     return newIdentifier;
   };
   /**
@@ -8537,10 +8752,12 @@ var TypeInfoORMService = class {
    * The `item` **must always** contain its **primary field value**.
    * @param typeName Type name to update.
    * @param item Item payload to update.
+   * @param updateConfig Optional per-field operator config.
    * @returns True when the update succeeded.
    * */
-  update = async (typeName, item, context) => {
+  update = async (typeName, item, updateConfig, context) => {
     this.validate(typeName, item, "UPDATE" /* UPDATE */, true);
+    this.validateUpdateConfig(typeName, item, updateConfig);
     const { primaryField } = this.getTypeInfo(typeName);
     const primaryFieldValue = typeof item === "object" && item !== null ? item[primaryField] : void 0;
     if (typeof primaryFieldValue === "undefined") {
@@ -8616,15 +8833,17 @@ var TypeInfoORMService = class {
             throw error;
           }
         }
-        const result = await driver.updateItem(primaryFieldValue, cleanItem);
+        const result = await driver.updateItem(
+          primaryFieldValue,
+          cleanItem,
+          updateConfig
+        );
         const updatedItem = await driver.readItem(primaryFieldValue);
         if (existingItem) {
-          await this.removeFullTextDocument(typeName, existingItem);
-          await this.indexFullTextDocument(typeName, updatedItem);
+          await this.replaceItemIndexes(typeName, existingItem, updatedItem);
         } else {
-          await this.indexFullTextDocument(typeName, updatedItem);
+          await this.indexItemIndexes(typeName, updatedItem);
         }
-        await this.indexStructuredDocument(typeName, updatedItem);
         return result;
       }
     }
@@ -8661,8 +8880,7 @@ var TypeInfoORMService = class {
         fromTypeName: typeName,
         fromTypePrimaryFieldValue: primaryFieldValue
       });
-      await this.removeFullTextDocument(typeName, existingItem);
-      await this.removeStructuredDocument(typeName, existingItem);
+      await this.removeItemIndexes(typeName, existingItem);
       return result;
     }
   };
@@ -8897,6 +9115,100 @@ var TypeInfoORMService = class {
   };
 };
 
+// src/api/ORM/getTypeInfoORMIndexingConfigFromTypeInfoMap.ts
+var dedupeFieldNames = (fieldNames) => {
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = [];
+  for (const fieldName of fieldNames) {
+    if (typeof fieldName !== "string") {
+      continue;
+    }
+    const trimmed = fieldName.trim();
+    if (!trimmed || seen.has(trimmed)) {
+      continue;
+    }
+    seen.add(trimmed);
+    deduped.push(trimmed);
+  }
+  return deduped;
+};
+var normalizeFieldMap = (fieldMap) => {
+  const normalized = {};
+  if (!fieldMap) {
+    return normalized;
+  }
+  for (const [typeName, configuredFieldNames] of Object.entries(fieldMap)) {
+    const values = Array.isArray(configuredFieldNames) ? configuredFieldNames : [configuredFieldNames];
+    const deduped = dedupeFieldNames(values);
+    if (deduped.length > 0) {
+      normalized[typeName] = deduped;
+    }
+  }
+  return normalized;
+};
+var mergeFieldMaps = (existing, generated) => {
+  const merged = { ...existing };
+  for (const [typeName, generatedFieldNames] of Object.entries(generated)) {
+    merged[typeName] = dedupeFieldNames([
+      ...existing[typeName] ?? [],
+      ...generatedFieldNames
+    ]);
+  }
+  return merged;
+};
+var hasIndexedFields = (fieldMap) => Object.keys(fieldMap).length > 0;
+var getTypeInfoORMIndexingConfigFromTypeInfoMap = (typeInfoMap, baseConfig = {}) => {
+  const generatedFullText = {};
+  const generatedStructured = {};
+  for (const [typeName, typeInfo] of Object.entries(typeInfoMap)) {
+    const fields = typeInfo.fields ?? {};
+    for (const [fieldName, field] of Object.entries(fields)) {
+      const indexed = field.tags?.indexed;
+      if (indexed?.fullText) {
+        generatedFullText[typeName] = [
+          ...generatedFullText[typeName] ?? [],
+          fieldName
+        ];
+      }
+      if (indexed?.structured) {
+        generatedStructured[typeName] = [
+          ...generatedStructured[typeName] ?? [],
+          fieldName
+        ];
+      }
+    }
+  }
+  if (hasIndexedFields(generatedFullText) && !baseConfig.fullText?.backend) {
+    throw new Error(
+      "Cannot generate fullText indexing config from tags without fullText.backend."
+    );
+  }
+  if (hasIndexedFields(generatedStructured) && !baseConfig.structured?.reader) {
+    throw new Error(
+      "Cannot generate structured indexing config from tags without structured.reader."
+    );
+  }
+  const mergedFullTextByType = mergeFieldMaps(
+    normalizeFieldMap(baseConfig.fullText?.defaultIndexFieldByType),
+    generatedFullText
+  );
+  const mergedStructuredByType = mergeFieldMaps(
+    normalizeFieldMap(baseConfig.structured?.indexedFieldsByType),
+    generatedStructured
+  );
+  return {
+    ...baseConfig,
+    fullText: baseConfig.fullText ? {
+      ...baseConfig.fullText,
+      ...hasIndexedFields(mergedFullTextByType) ? { defaultIndexFieldByType: mergedFullTextByType } : {}
+    } : void 0,
+    structured: baseConfig.structured ? {
+      ...baseConfig.structured,
+      ...hasIndexedFields(mergedStructuredByType) ? { indexedFieldsByType: mergedStructuredByType } : {}
+    } : void 0
+  };
+};
+
 // src/api/Router/Auth.ts
 var getRouteIsAuthorized = (authInfo, authConfig) => {
   const { userId, roles = [] } = authInfo;
@@ -9175,7 +9487,7 @@ var TYPE_INFO_ORM_API_PATH_METHOD_NAME_MAP = {
   delete: "delete",
   list: "list"
 };
-var getTypeInfoORMRouteMap = (config, dacConfig, getAccessingRoleId, authConfig) => {
+var getTypeInfoORMRouteMap = (config, dacConfig, getAccessingRoleId, authConfig, routeMapConfig) => {
   if (dacConfig && !getAccessingRoleId) {
     throw {
       message: "MISSING_ACCESSING_ROLE_GETTER" /* MISSING_ACCESSING_ROLE_GETTER */
@@ -9194,6 +9506,7 @@ var getTypeInfoORMRouteMap = (config, dacConfig, getAccessingRoleId, authConfig)
   const defaultAuthConfig = authConfig ?? {
     anyAuthorized: true
   };
+  const allowUpdateFieldOperators = routeMapConfig?.allowUpdateFieldOperators ?? true;
   const resolveContext = (eventData) => getContextFromEventData(eventData, dacConfig, getAccessingRoleId);
   const createRoute = (path, handlerFactory) => ({
     path,
@@ -9214,10 +9527,18 @@ var getTypeInfoORMRouteMap = (config, dacConfig, getAccessingRoleId, authConfig)
   };
   const updateHandlerFactory = (eventData) => {
     if (!dacConfig) {
-      return orm.update;
+      if (allowUpdateFieldOperators) {
+        return orm.update;
+      }
+      return ((typeName, item) => orm.update(typeName, item, void 0));
     }
     const context = resolveContext(eventData);
-    return ((typeName, item) => orm.update(typeName, item, context));
+    return ((typeName, item, updateConfig) => orm.update(
+      typeName,
+      item,
+      allowUpdateFieldOperators ? updateConfig : void 0,
+      context
+    ));
   };
   const deleteHandlerFactory = (eventData) => {
     if (!dacConfig) {
@@ -9302,4 +9623,4 @@ var getContextFromEventData = (eventData, dacConfig, getAccessingRoleId) => {
   return { accessingRoleId };
 };
 
-export { AWS, DACConstraintType, DATA_ITEM_DB_DRIVER_ERRORS, DynamoDBDataItemDBDriver, DynamoDBSupportedDataItemDBDriverEntry, ExactIndex, FullTextDdbBackend, FullTextDdbWriter, FullTextMemoryBackend, InMemoryDataItemDBDriver, InMemoryFileItemDBDriver, InMemoryFileSupportedDataItemDBDriverEntry, InMemoryItemRelationshipDBDriver, InMemorySupportedDataItemDBDriverEntry, IndexingRelationshipDriver, LossyIndex, RelationalDdbBackend, RelationalInMemoryBackend, S3FileItemDBDriver, S3SupportedFileItemDBDriverEntry, SEARCH_CAPS, SEARCH_DEFAULTS, SUPPORTED_TYPE_INFO_ORM_DB_DRIVERS, StructuredDdbBackend, StructuredDdbReader, StructuredDdbWriter, StructuredInMemoryBackend, StructuredInMemoryIndex, SupportedTypeInfoORMDBDriverNames, TYPE_INFO_ORM_API_PATH_METHOD_NAME_MAP, TYPE_INFO_ORM_ROUTE_MAP_ERRORS, TypeInfoORMService, WILDCARD_SIGNIFIER_PROTOTYPE, addRouteMapToRouteMap, addRouteToRouteMap, addRoutesToRouteMap, batchWriteWithRetry, buildExactDdbItem, buildExactDdbKey, buildExactS3Key, buildLossyDdbKey, buildLossyS3Key, buildRelationEdgeDdbItem, buildRelationEdgeDdbKey, buildStructuredDocFieldsItem, buildStructuredRangeItem, buildStructuredRangeKey, buildStructuredTermItem, buildStructuredTermKey, cleanRelationshipItem, createAwsSdkV3DynamoClient, createRelationEdgesDdbDependencies, createSearchTrace, decodeExactCursor, decodeLossyCursor, decodeRelationalCursor, decodeStructuredCursor, docTokenPositionsSchema, docTokensSchema, encodeDocKey, encodeDocMirrorKey, encodeDocTokenPositionSortKey, encodeDocTokenSortKey, encodeExactCursor, encodeLossyCursor, encodeRelationEdgePartitionKey, encodeRelationalCursor, encodeStructuredCursor, encodeTokenDocSortKey, encodeTokenKey, exactDdbSchema, exactPostingsSchema, fullTextDocMirrorSchema, fullTextKeyPrefixes, fullTextTokenStatsSchema, getDACPathsMatch, getDACRoleHasAccessToDataItem, getDataItemDACResourcePath, getDataItemFieldValueDACResourcePath, getDriverMethodWithModifiedError, getFlattenedDACConstraints, getFullORMDACRole, getItemRelationshipDACResourcePath, getItemRelationshipOriginDACConstraint, getItemRelationshipOriginDACResourcePath, getItemRelationshipOriginDACRole, getItemTypeDACConstraint, getItemTypeDACResourcePath, getItemTypeDACRole, getORMDACResourcePath, getResourceAccessByDACRole, getTypeInfoORMRouteMap, getValueIsWildcardSignifier, handleCloudFunctionEvent, handler, indexDocument, loadExactPositions, loadLossyIndex, lossyDdbSchema, lossyPostingsSchema, mergeDACAccessResults, mergeDACDataItemResourceAccessResultMaps, qualifyIndexField, relHandler, relationEdgesSchema, removeDocument, replaceFullTextDocument, resolveSearchLimits, searchExact, searchLossy, searchStructured, serializeStructuredValue, setIndexBackend, setRelationalHandlerDependencies, setStructuredHandlerDependencies, storeExactPositions, storeLossyIndex, structuredDocFieldsSchema, structuredHandler, structuredRangeIndexSchema, structuredTermIndexSchema, tokenize, tokenizeLossyTrigrams };
+export { AWS, DACConstraintType, DATA_ITEM_DB_DRIVER_ERRORS, DynamoDBDataItemDBDriver, DynamoDBSupportedDataItemDBDriverEntry, ExactIndex, FullTextDdbBackend, FullTextDdbWriter, FullTextMemoryBackend, InMemoryDataItemDBDriver, InMemoryFileItemDBDriver, InMemoryFileSupportedDataItemDBDriverEntry, InMemoryItemRelationshipDBDriver, InMemorySupportedDataItemDBDriverEntry, IndexingRelationshipDriver, LossyIndex, RelationalDdbBackend, RelationalInMemoryBackend, S3FileItemDBDriver, S3SupportedFileItemDBDriverEntry, SEARCH_CAPS, SEARCH_DEFAULTS, SUPPORTED_TYPE_INFO_ORM_DB_DRIVERS, StructuredDdbBackend, StructuredDdbReader, StructuredDdbWriter, StructuredInMemoryBackend, StructuredInMemoryIndex, SupportedTypeInfoORMDBDriverNames, TYPE_INFO_ORM_API_PATH_METHOD_NAME_MAP, TYPE_INFO_ORM_ROUTE_MAP_ERRORS, TypeInfoORMService, WILDCARD_SIGNIFIER_PROTOTYPE, addRouteMapToRouteMap, addRouteToRouteMap, addRoutesToRouteMap, batchWriteWithRetry, buildExactDdbItem, buildExactDdbKey, buildExactS3Key, buildLossyDdbKey, buildLossyS3Key, buildRelationEdgeDdbItem, buildRelationEdgeDdbKey, buildStructuredDocFieldsItem, buildStructuredRangeItem, buildStructuredRangeKey, buildStructuredTermItem, buildStructuredTermKey, cleanRelationshipItem, createAwsSdkV3DynamoClient, createRelationEdgesDdbDependencies, createSearchTrace, decodeExactCursor, decodeLossyCursor, decodeRelationalCursor, decodeStructuredCursor, docTokenPositionsSchema, docTokensSchema, encodeDocKey, encodeDocMirrorKey, encodeDocTokenPositionSortKey, encodeDocTokenSortKey, encodeExactCursor, encodeLossyCursor, encodeRelationEdgePartitionKey, encodeRelationalCursor, encodeStructuredCursor, encodeTokenDocSortKey, encodeTokenKey, exactDdbSchema, exactPostingsSchema, fullTextDocMirrorSchema, fullTextKeyPrefixes, fullTextTokenStatsSchema, getDACPathsMatch, getDACRoleHasAccessToDataItem, getDataItemDACResourcePath, getDataItemFieldValueDACResourcePath, getDriverMethodWithModifiedError, getFlattenedDACConstraints, getFullORMDACRole, getItemRelationshipDACResourcePath, getItemRelationshipOriginDACConstraint, getItemRelationshipOriginDACResourcePath, getItemRelationshipOriginDACRole, getItemTypeDACConstraint, getItemTypeDACResourcePath, getItemTypeDACRole, getORMDACResourcePath, getResourceAccessByDACRole, getTypeInfoORMIndexingConfigFromTypeInfoMap, getTypeInfoORMRouteMap, getValueIsWildcardSignifier, handleCloudFunctionEvent, handler, indexDocument, loadExactPositions, loadLossyIndex, lossyDdbSchema, lossyPostingsSchema, mergeDACAccessResults, mergeDACDataItemResourceAccessResultMaps, qualifyIndexField, relHandler, relationEdgesSchema, removeDocument, replaceFullTextDocument, resolveSearchLimits, searchExact, searchLossy, searchStructured, serializeStructuredValue, setIndexBackend, setRelationalHandlerDependencies, setStructuredHandlerDependencies, storeExactPositions, storeLossyIndex, structuredDocFieldsSchema, structuredHandler, structuredRangeIndexSchema, structuredTermIndexSchema, tokenize, tokenizeLossyTrigrams };

package/app/index.js

@@ -1,7 +1,7 @@
 export { createEasyLayout, getEasyLayoutTemplateDetails, getPascalCaseAreaName } from '../chunk-CMH6L5QQ.js';
 export { computeTrackPixels } from '../chunk-TJFTWPXQ.js';
 export { AutoForm, AutoFormView, Route, RouteContext, RouteContextConsumer, RouteContextProvider, RouteProvider, buildHistoryPath, buildQueryString, buildRoutePath, canUseBrowserHistory, computeAreaBounds, createAutoField, createBrowserRouteAdapter, createFormRenderer, createHistoryBackHandler, createManualRouteAdapter, createMemoryHistory, createNativeRouteAdapter, createRouteAdapterFromHistory, createUniversalAdapter, defaultTranslateValidationErrorCode, getFieldKind, parseHistoryPath, parseTemplate, resolveSuite, useFormEngine, useRouteContext, validateAreas, wrapRouteAdapterWithPathResolver } from '../chunk-44BMFTKD.js';
-import '../chunk-7AMEFPPP.js';
+import '../chunk-RUNXRISF.js';
 import '../chunk-YCTVEW2I.js';
 import { mergeStringPaths, PATH_DELIMITER } from '../chunk-WNFRDIBW.js';
 import '../chunk-I2KLQ2HA.js';
@@ -473,12 +473,14 @@ var TypeInfoORMClient = class {
    *
    * @param typeName - TypeInfo type name.
    * @param item - Updated item payload.
+   * @param updateConfig - Optional per-field operator config.
    * @returns Whether the update succeeded.
    */
-  update = async (typeName, item) => {
+  update = async (typeName, item, updateConfig) => {
     return await this.makeRequest("update" /* UPDATE */, [
       typeName,
-      item
+      item,
+      updateConfig
     ]);
   };
   /**

package/app/utils/TypeInfoORMClient.d.ts

@@ -4,7 +4,7 @@
  * Client wrapper around the TypeInfoORM API RouteMap. Uses ServiceConfig to
  * route requests to the server-side TypeInfoORM routes.
  */
-import { DeleteRelationshipResults, TypeInfoORMClientAPI, TypeInfoORMAPIRoutePaths } from "../../common/TypeInfoORM";
+import { DeleteRelationshipResults, TypeInfoORMClientAPI, TypeInfoORMAPIRoutePaths, TypeInfoORMUpdateConfig } from "../../common/TypeInfoORM";
 import { ServiceConfig } from "./Service";
 import { TypeInfoDataItem } from "../../common/TypeParsing/TypeInfo";
 import { ListItemsConfig, ListItemsResults, ListRelationshipsConfig } from "../../common/SearchTypes";
@@ -51,9 +51,10 @@ export declare class TypeInfoORMClient implements TypeInfoORMClientAPI {
      *
      * @param typeName - TypeInfo type name.
      * @param item - Updated item payload.
+     * @param updateConfig - Optional per-field operator config.
      * @returns Whether the update succeeded.
      */
-    update: (typeName: string, item: TypeInfoDataItem) => Promise<boolean>;
+    update: (typeName: string, item: TypeInfoDataItem, updateConfig?: TypeInfoORMUpdateConfig) => Promise<boolean>;
     /**
      * Delete an item by its primary field value.
      *

package/{chunk-7AMEFPPP.js → chunk-RUNXRISF.js}

@@ -54,6 +54,7 @@ var TypeInfoORMServiceError = /* @__PURE__ */ ((TypeInfoORMServiceError2) => {
   TypeInfoORMServiceError2["TYPE_INFO_MISSING_PRIMARY_FIELD"] = "TYPE_INFO_MISSING_PRIMARY_FIELD";
   TypeInfoORMServiceError2["INVALID_RELATIONSHIP"] = "INVALID_RELATIONSHIP";
   TypeInfoORMServiceError2["INVALID_OPERATION"] = "INVALID_OPERATION";
+  TypeInfoORMServiceError2["INVALID_UPDATE_OPERATOR"] = "INVALID_UPDATE_OPERATOR";
   TypeInfoORMServiceError2["MISSING_ACCESSING_ROLE"] = "MISSING_ACCESSING_ROLE";
   TypeInfoORMServiceError2["INDEXING_UNSUPPORTED_CRITERIA"] = "INDEXING_UNSUPPORTED_CRITERIA";
   TypeInfoORMServiceError2["INDEXING_UNSUPPORTED_COMBINATION"] = "INDEXING_UNSUPPORTED_COMBINATION";
@@ -74,5 +75,11 @@ var TypeInfoORMAPIRoutePaths = /* @__PURE__ */ ((TypeInfoORMAPIRoutePaths2) => {
   TypeInfoORMAPIRoutePaths2["LIST_RELATED_ITEMS"] = "list-related-items";
   return TypeInfoORMAPIRoutePaths2;
 })(TypeInfoORMAPIRoutePaths || {});
+var TypeInfoORMUpdateOperators = {
+  NUMBER: {
+    INCREMENT: "INCREMENT",
+    DECREMENT: "DECREMENT"
+  }
+};
 
-export { ComparisonOperators, ITEM_RELATIONSHIP_DAC_RESOURCE_NAME, LogicalOperators, OperationGroup, RelationshipOperation, TypeInfoORMAPIRoutePaths, TypeInfoORMServiceError };
+export { ComparisonOperators, ITEM_RELATIONSHIP_DAC_RESOURCE_NAME, LogicalOperators, OperationGroup, RelationshipOperation, TypeInfoORMAPIRoutePaths, TypeInfoORMServiceError, TypeInfoORMUpdateOperators };

package/common/TypeInfoORM/Types.d.ts

@@ -91,6 +91,10 @@ export declare enum TypeInfoORMServiceError {
      * Operation is not supported.
      * */
     INVALID_OPERATION = "INVALID_OPERATION",
+    /**
+     * Update operator config is invalid.
+     * */
+    INVALID_UPDATE_OPERATOR = "INVALID_UPDATE_OPERATOR",
     /**
      * Accessing role is missing when DAC is required.
      * */
@@ -181,6 +185,32 @@ export type TypeInfoORMContext = {
      */
     accessingRoleId: string;
 };
+/**
+ * Supported numeric field update operators.
+ */
+export declare const TypeInfoORMUpdateOperators: {
+    readonly NUMBER: {
+        readonly INCREMENT: "INCREMENT";
+        readonly DECREMENT: "DECREMENT";
+    };
+};
+/**
+ * Supported numeric field update operator values.
+ */
+export type TypeInfoORMNumberFieldUpdateOperator = (typeof TypeInfoORMUpdateOperators.NUMBER)[keyof typeof TypeInfoORMUpdateOperators.NUMBER];
+/**
+ * Supported field update operator values.
+ */
+export type TypeInfoORMFieldUpdateOperator = TypeInfoORMNumberFieldUpdateOperator;
+/**
+ * Optional config for TypeInfo ORM update calls.
+ */
+export type TypeInfoORMUpdateConfig = {
+    /**
+     * Optional per-field operator map applied during update.
+     */
+    fieldOperators?: Record<string, TypeInfoORMFieldUpdateOperator>;
+};
 /**
  * Server-side TypeInfoORM API contract.
  *
@@ -239,9 +269,10 @@ export type TypeInfoORMAPI = {
      *
      * @param typeName - Type name to update.
      * @param item - Updated item payload.
+     * @param updateConfig - Optional per-field operator config.
      * @returns Whether the update succeeded.
      */
-    update: (typeName: string, item: TypeInfoDataItem, context?: TypeInfoORMContext) => Promise<boolean>;
+    update: (typeName: string, item: TypeInfoDataItem, updateConfig?: TypeInfoORMUpdateConfig, context?: TypeInfoORMContext) => Promise<boolean>;
     /**
      * Delete an item by primary field value.
      *
@@ -319,9 +350,10 @@ export type TypeInfoORMClientAPI = {
      *
      * @param typeName - Type name to update.
      * @param item - Updated item payload.
+     * @param updateConfig - Optional per-field operator config.
      * @returns Whether the update succeeded.
      */
-    update: (typeName: string, item: TypeInfoDataItem) => Promise<boolean>;
+    update: (typeName: string, item: TypeInfoDataItem, updateConfig?: TypeInfoORMUpdateConfig) => Promise<boolean>;
     /**
      * Delete an item by primary field value.
      *

package/common/TypeParsing/TypeInfo.d.ts

@@ -132,6 +132,19 @@ export type SupportedFieldTags = Partial<{
          */
         emptyArrayIsValid: boolean;
     }>;
+    /**
+     * Indexing behavior flags used to derive ORM indexing configuration.
+     * */
+    indexed: Partial<{
+        /**
+         * Whether this field should be added to the type's default full-text index fields.
+         * */
+        fullText: boolean;
+        /**
+         * Whether this field should be added to the type's structured indexed field list.
+         * */
+        structured: boolean;
+    }>;
 }>;
 /**
  * The set of acceptable literal value types.

package/common/index.js

@@ -1,4 +1,4 @@
-export { ComparisonOperators, ITEM_RELATIONSHIP_DAC_RESOURCE_NAME, LogicalOperators, OperationGroup, RelationshipOperation, TypeInfoORMAPIRoutePaths, TypeInfoORMServiceError } from '../chunk-7AMEFPPP.js';
+export { ComparisonOperators, ITEM_RELATIONSHIP_DAC_RESOURCE_NAME, LogicalOperators, OperationGroup, RelationshipOperation, TypeInfoORMAPIRoutePaths, TypeInfoORMServiceError, TypeInfoORMUpdateOperators } from '../chunk-RUNXRISF.js';
 export { DENIED_TYPE_OPERATIONS, ERROR_MESSAGE_CONSTANTS, INVALID_CUSTOM_TYPE, PRIMITIVE_ERROR_MESSAGE_CONSTANTS, RelationshipValidationType, TYPE_KEYWORD_ERROR_MESSAGE_CONSTANTS, TYPE_KEYWORD_VALIDATORS, TypeOperation, getArrayItemErrorMap, getErrorDescriptor, getErrorDescriptors, getNoErrorDescriptor, getValidityValue, hasValue, isArrayErrorDescriptorCollection, validateArrayOfTypeInfoFieldValues, validateCustomType, validateKeywordType, validateTypeInfoDataItem, validateTypeInfoFieldOperationAllowed, validateTypeInfoFieldValue, validateTypeInfoValue, validateTypeOperationAllowed, validateValueMatchesPattern } from '../chunk-YCTVEW2I.js';
 import '../chunk-WNFRDIBW.js';
 import '../chunk-I2KLQ2HA.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@resistdesign/voltra",
-  "version": "3.0.0-alpha.43",
+  "version": "3.0.0-alpha.45",
   "description": "With our powers combined!",
   "homepage": "https://voltra.app",
   "repository": "git@github.com:resistdesign/voltra.git",