@ram_28/kf-ai-sdk 1.0.11 → 1.0.13

package/sdk/base-types.ts

@@ -0,0 +1,45 @@
+// ============================================================
+// BASE TYPES MODULE - Field Type Exports
+// @ram_28/kf-ai-sdk/types
+// ============================================================
+
+export type {
+  // ID and String fields
+  IdFieldType,
+  StringFieldType,
+  TextAreaFieldType,
+
+  // Numeric fields
+  NumberFieldType,
+  LongFieldType,
+
+  // Boolean field
+  BooleanFieldType,
+
+  // Date/Time fields
+  DateFieldType,
+  DateTimeFieldType,
+
+  // Complex fields
+  CurrencyFieldType,
+  CurrencyValueType,
+  JSONFieldType,
+  ReferenceFieldType,
+
+  // JSON types
+  JSONValueType,
+  JSONObjectType,
+  JSONArrayType,
+
+  // Select/Lookup fields
+  SelectFieldType,
+  LookupFieldType,
+
+  // Container types
+  ArrayFieldType,
+  ObjectFieldType,
+  OptionalFieldType,
+
+  // Utility types
+  ExtractFieldTypeType,
+} from './types/base-fields';

package/sdk/components/hooks/index.ts

@@ -1,35 +1,35 @@
 // Table hook
 export { useTable } from "./useTable";
 export type {
-  UseTableOptions,
-  UseTableReturn,
-  ColumnDefinition,
+  UseTableOptionsType,
+  UseTableReturnType,
+  ColumnDefinitionType,
 } from "./useTable";
 
 // Form hook
 export { useForm } from "./useForm";
 export type {
   // Core types
-  UseFormOptions,
-  UseFormReturn,
-  FormOperation,
-  FormMode,
+  UseFormOptionsType,
+  UseFormReturnType,
+  FormOperationType,
+  FormModeType,
 
   // Form field configuration
-  FormFieldConfig,
-  FormSchemaConfig,
-  FormFieldType,
-  SelectOption,
-  FieldPermission,
+  FormFieldConfigType,
+  FormSchemaConfigType,
+  FormFieldTypeType,
+  SelectOptionType,
+  FieldPermissionType,
 
   // Result types
-  FieldValidationResult,
-  SubmissionResult,
+  FieldValidationResultType,
+  SubmissionResultType,
 
   // BDO Schema types (advanced)
-  BDOSchema,
-  BDOFieldDefinition,
-  SchemaValidationRule,
+  BDOSchemaType,
+  BDOFieldDefinitionType,
+  SchemaValidationRuleType,
 } from "./useForm";
 
 // Error utilities
@@ -43,11 +43,11 @@ export {
 // Kanban hook
 export { useKanban } from "./useKanban";
 export type {
-  UseKanbanOptions,
-  UseKanbanReturn,
-  KanbanCard,
-  KanbanColumn,
-  ColumnDefinition as KanbanColumnDefinition,
+  UseKanbanOptionsType,
+  UseKanbanReturnType,
+  KanbanCardType,
+  KanbanColumnType,
+  ColumnConfigType,
 } from "./useKanban";
 
 // Filter hook

package/sdk/components/hooks/useFilter/index.ts

@@ -1,25 +1,19 @@
 // Main hook export
 export { useFilter } from "./useFilter";
 
-// Type exports (new names)
+// Type exports
 export type {
-  Condition,
-  ConditionGroup,
-  ConditionGroupOperator,
-  Filter,
-  FilterRHSType,
-  UseFilterOptions,
-  UseFilterReturn,
-  // Legacy type exports
-  FilterCondition,
-  FilterOperator,
+  ConditionType,
+  ConditionGroupType,
+  ConditionGroupOperatorType,
+  FilterType,
+  FilterRHSTypeType,
+  UseFilterOptionsType,
+  UseFilterReturnType,
 } from "./types";
 
 // Type guard exports
 export {
   isCondition,
   isConditionGroup,
-  // Legacy type guard exports
-  isFilterCondition,
-  isFilterLogical,
 } from "./types";

package/sdk/components/hooks/useFilter/types.ts

@@ -1,24 +1,18 @@
 import type {
-  Condition,
-  ConditionGroup,
-  ConditionGroupOperator,
-  Filter,
-  FilterRHSType,
-  // Legacy types for backwards compatibility
-  FilterCondition,
-  FilterOperator,
+  ConditionType,
+  ConditionGroupType,
+  ConditionGroupOperatorType,
+  FilterType,
+  FilterRHSTypeType,
 } from "../../../types/common";
 
 // Re-export from common types for convenience
 export type {
-  Condition,
-  ConditionGroup,
-  ConditionGroupOperator,
-  Filter,
-  FilterRHSType,
-  // Legacy re-exports
-  FilterCondition,
-  FilterOperator,
+  ConditionType,
+  ConditionGroupType,
+  ConditionGroupOperatorType,
+  FilterType,
+  FilterRHSTypeType,
 };
 
 // ============================================================
@@ -29,8 +23,8 @@ export type {
  * Type guard to check if an item is a ConditionGroup (has nested Condition array)
  */
 export const isConditionGroup = (
-  item: Condition | ConditionGroup
-): item is ConditionGroup => {
+  item: ConditionType | ConditionGroupType
+): item is ConditionGroupType => {
   return "Condition" in item;
 };
 
@@ -38,25 +32,11 @@ export const isConditionGroup = (
  * Type guard to check if an item is a leaf Condition (has LHSField)
  */
 export const isCondition = (
-  item: Condition | ConditionGroup
-): item is Condition => {
+  item: ConditionType | ConditionGroupType
+): item is ConditionType => {
   return "LHSField" in item;
 };
 
-// ============================================================
-// LEGACY TYPE GUARDS (for backwards compatibility)
-// ============================================================
-
-/**
- * @deprecated Use `isConditionGroup` instead
- */
-export const isFilterLogical = isConditionGroup;
-
-/**
- * @deprecated Use `isCondition` instead
- */
-export const isFilterCondition = isCondition;
-
 // ============================================================
 // HOOK-SPECIFIC TYPE DEFINITIONS
 // ============================================================
@@ -64,29 +44,29 @@ export const isFilterCondition = isCondition;
 /**
  * Hook options (minimal configuration)
  */
-export interface UseFilterOptions {
+export interface UseFilterOptionsType {
   /** Initial filter conditions */
-  initialConditions?: Array<Condition | ConditionGroup>;
+  initialConditions?: Array<ConditionType | ConditionGroupType>;
   /** Initial operator for combining conditions (defaults to "And") */
-  initialOperator?: ConditionGroupOperator;
+  initialOperator?: ConditionGroupOperatorType;
 }
 
 /**
  * Hook return interface with nested filter support
  */
-export interface UseFilterReturn {
+export interface UseFilterReturnType {
   // ============================================================
   // STATE (read-only)
   // ============================================================
 
   /** Current operator for combining root-level conditions ("And" | "Or" | "Not") */
-  operator: ConditionGroupOperator;
+  operator: ConditionGroupOperatorType;
 
   /** Current filter items (with id populated) */
-  items: Array<Condition | ConditionGroup>;
+  items: Array<ConditionType | ConditionGroupType>;
 
   /** Ready-to-use API payload (id stripped, undefined if no conditions) */
-  payload: Filter | undefined;
+  payload: FilterType | undefined;
 
   /** Whether any conditions exist */
   hasConditions: boolean;
@@ -99,27 +79,27 @@ export interface UseFilterReturn {
    * Add a leaf condition at root level
    * @returns The id of the created condition
    */
-  add: (condition: Omit<Condition, "id">) => string;
+  add: (condition: Omit<ConditionType, "id">) => string;
 
   /**
    * Add a condition group at root level
    * @returns The id of the created group
    */
-  addGroup: (operator: ConditionGroupOperator) => string;
+  addGroup: (operator: ConditionGroupOperatorType) => string;
 
   /**
    * Add a leaf condition to a specific parent group
    * @param parentId - The id of the parent ConditionGroup
    * @returns The id of the created condition
    */
-  addTo: (parentId: string, condition: Omit<Condition, "id">) => string;
+  addTo: (parentId: string, condition: Omit<ConditionType, "id">) => string;
 
   /**
    * Add a condition group to a specific parent group
    * @param parentId - The id of the parent ConditionGroup
    * @returns The id of the created group
    */
-  addGroupTo: (parentId: string, operator: ConditionGroupOperator) => string;
+  addGroupTo: (parentId: string, operator: ConditionGroupOperatorType) => string;
 
   // ============================================================
   // UPDATE OPERATIONS
@@ -130,14 +110,14 @@ export interface UseFilterReturn {
    * @param id - The id of the condition to update
    * @param updates - Partial updates to apply
    */
-  update: (id: string, updates: Partial<Omit<Condition, "id">>) => void;
+  update: (id: string, updates: Partial<Omit<ConditionType, "id">>) => void;
 
   /**
    * Update a condition group's operator by id
    * @param id - The id of the group to update
    * @param operator - The new operator
    */
-  updateOperator: (id: string, operator: ConditionGroupOperator) => void;
+  updateOperator: (id: string, operator: ConditionGroupOperatorType) => void;
 
   // ============================================================
   // REMOVE & ACCESS
@@ -154,7 +134,7 @@ export interface UseFilterReturn {
    * @param id - The id to look up
    * @returns The item or undefined if not found
    */
-  get: (id: string) => Condition | ConditionGroup | undefined;
+  get: (id: string) => ConditionType | ConditionGroupType | undefined;
 
   // ============================================================
   // UTILITY
@@ -164,14 +144,5 @@ export interface UseFilterReturn {
   clear: () => void;
 
   /** Set the root operator for combining conditions */
-  setOperator: (op: ConditionGroupOperator) => void;
-
-  // ============================================================
-  // LEGACY API (for backwards compatibility)
-  // ============================================================
-
-  /**
-   * @deprecated Use `items` instead
-   */
-  conditions: Array<Condition | ConditionGroup>;
+  setOperator: (op: ConditionGroupOperatorType) => void;
 }

package/sdk/components/hooks/useFilter/useFilter.ts

@@ -1,11 +1,11 @@
 import { useState, useCallback, useMemo } from "react";
 import type {
-  Condition,
-  ConditionGroup,
-  ConditionGroupOperator,
-  Filter,
+  ConditionType,
+  ConditionGroupType,
+  ConditionGroupOperatorType,
+  FilterType,
 } from "../../../types/common";
-import type { UseFilterOptions, UseFilterReturn } from "./types";
+import type { UseFilterOptionsType, UseFilterReturnType } from "./types";
 import { isConditionGroup } from "./types";
 
 // ============================================================
@@ -24,7 +24,7 @@ const generateId = (): string => {
 /**
  * Ensure an item has an id
  */
-const ensureId = <T extends Condition | ConditionGroup>(item: T): T => {
+const ensureId = <T extends ConditionType | ConditionGroupType>(item: T): T => {
   if (!item.id) {
     return { ...item, id: generateId() };
   }
@@ -35,8 +35,8 @@ const ensureId = <T extends Condition | ConditionGroup>(item: T): T => {
  * Deep clone and ensure all items have ids
  */
 const cloneWithIds = (
-  items: Array<Condition | ConditionGroup>
-): Array<Condition | ConditionGroup> => {
+  items: Array<ConditionType | ConditionGroupType>
+): Array<ConditionType | ConditionGroupType> => {
   return items.map((item) => {
     const withId = ensureId(item);
     if (isConditionGroup(withId)) {
@@ -53,18 +53,18 @@ const cloneWithIds = (
  * Strip id fields from items for API payload
  */
 const stripIds = (
-  items: Array<Condition | ConditionGroup>
-): Array<Condition | ConditionGroup> => {
+  items: Array<ConditionType | ConditionGroupType>
+): Array<ConditionType | ConditionGroupType> => {
   return items.map((item) => {
     if (isConditionGroup(item)) {
       const { id, ...rest } = item;
       return {
         ...rest,
         Condition: stripIds(item.Condition),
-      } as ConditionGroup;
+      } as ConditionGroupType;
     }
     const { id, ...rest } = item;
-    return rest as Condition;
+    return rest as ConditionType;
   });
 };
 
@@ -72,9 +72,9 @@ const stripIds = (
  * Find an item by id in a tree structure
  */
 const findById = (
-  items: Array<Condition | ConditionGroup>,
+  items: Array<ConditionType | ConditionGroupType>,
   id: string
-): Condition | ConditionGroup | undefined => {
+): ConditionType | ConditionGroupType | undefined => {
   for (const item of items) {
     if (item.id === id) {
       return item;
@@ -91,10 +91,10 @@ const findById = (
  * Find a parent group by child id
  */
 const findParentById = (
-  items: Array<Condition | ConditionGroup>,
+  items: Array<ConditionType | ConditionGroupType>,
   childId: string,
-  parent: ConditionGroup | null = null
-): ConditionGroup | null => {
+  parent: ConditionGroupType | null = null
+): ConditionGroupType | null => {
   for (const item of items) {
     if (item.id === childId) {
       return parent;
@@ -111,10 +111,10 @@ const findParentById = (
  * Update an item in the tree by id
  */
 const updateInTree = (
-  items: Array<Condition | ConditionGroup>,
+  items: Array<ConditionType | ConditionGroupType>,
   id: string,
-  updater: (item: Condition | ConditionGroup) => Condition | ConditionGroup
-): Array<Condition | ConditionGroup> => {
+  updater: (item: ConditionType | ConditionGroupType) => ConditionType | ConditionGroupType
+): Array<ConditionType | ConditionGroupType> => {
   return items.map((item) => {
     if (item.id === id) {
       return updater(item);
@@ -133,9 +133,9 @@ const updateInTree = (
  * Remove an item from the tree by id
  */
 const removeFromTree = (
-  items: Array<Condition | ConditionGroup>,
+  items: Array<ConditionType | ConditionGroupType>,
   id: string
-): Array<Condition | ConditionGroup> => {
+): Array<ConditionType | ConditionGroupType> => {
   return items
     .filter((item) => item.id !== id)
     .map((item) => {
@@ -153,10 +153,10 @@ const removeFromTree = (
  * Add an item to a specific parent in the tree
  */
 const addToParent = (
-  items: Array<Condition | ConditionGroup>,
+  items: Array<ConditionType | ConditionGroupType>,
   parentId: string,
-  newItem: Condition | ConditionGroup
-): Array<Condition | ConditionGroup> => {
+  newItem: ConditionType | ConditionGroupType
+): Array<ConditionType | ConditionGroupType> => {
   return items.map((item) => {
     if (item.id === parentId && isConditionGroup(item)) {
       return {
@@ -178,18 +178,18 @@ const addToParent = (
 // USE FILTER HOOK - Nested Filter Support
 // ============================================================
 
-export function useFilter(options: UseFilterOptions = {}): UseFilterReturn {
+export function useFilter(options: UseFilterOptionsType = {}): UseFilterReturnType {
   // Initialize items with ids
-  const [items, setItems] = useState<Array<Condition | ConditionGroup>>(() =>
+  const [items, setItems] = useState<Array<ConditionType | ConditionGroupType>>(() =>
     cloneWithIds(options.initialConditions || [])
   );
 
-  const [operator, setOperatorState] = useState<ConditionGroupOperator>(
+  const [operator, setOperatorState] = useState<ConditionGroupOperatorType>(
     options.initialOperator || "And"
   );
 
   // Build payload for API (strip ids)
-  const payload = useMemo((): Filter | undefined => {
+  const payload = useMemo((): FilterType | undefined => {
     if (items.length === 0) return undefined;
     return {
       Operator: operator,
@@ -203,16 +203,16 @@ export function useFilter(options: UseFilterOptions = {}): UseFilterReturn {
   // ADD OPERATIONS
   // ============================================================
 
-  const add = useCallback((condition: Omit<Condition, "id">): string => {
+  const add = useCallback((condition: Omit<ConditionType, "id">): string => {
     const id = generateId();
-    const newCondition: Condition = { ...condition, id };
+    const newCondition: ConditionType = { ...condition, id };
     setItems((prev) => [...prev, newCondition]);
     return id;
   }, []);
 
-  const addGroup = useCallback((groupOperator: ConditionGroupOperator): string => {
+  const addGroup = useCallback((groupOperator: ConditionGroupOperatorType): string => {
     const id = generateId();
-    const newGroup: ConditionGroup = {
+    const newGroup: ConditionGroupType = {
       id,
       Operator: groupOperator,
       Condition: [],
@@ -222,9 +222,9 @@ export function useFilter(options: UseFilterOptions = {}): UseFilterReturn {
   }, []);
 
   const addTo = useCallback(
-    (parentId: string, condition: Omit<Condition, "id">): string => {
+    (parentId: string, condition: Omit<ConditionType, "id">): string => {
       const id = generateId();
-      const newCondition: Condition = { ...condition, id };
+      const newCondition: ConditionType = { ...condition, id };
       setItems((prev) => addToParent(prev, parentId, newCondition));
       return id;
     },
@@ -232,9 +232,9 @@ export function useFilter(options: UseFilterOptions = {}): UseFilterReturn {
   );
 
   const addGroupTo = useCallback(
-    (parentId: string, groupOperator: ConditionGroupOperator): string => {
+    (parentId: string, groupOperator: ConditionGroupOperatorType): string => {
       const id = generateId();
-      const newGroup: ConditionGroup = {
+      const newGroup: ConditionGroupType = {
         id,
         Operator: groupOperator,
         Condition: [],
@@ -250,7 +250,7 @@ export function useFilter(options: UseFilterOptions = {}): UseFilterReturn {
   // ============================================================
 
   const update = useCallback(
-    (id: string, updates: Partial<Omit<Condition, "id">>): void => {
+    (id: string, updates: Partial<Omit<ConditionType, "id">>): void => {
       setItems((prev) =>
         updateInTree(prev, id, (item) => {
           if (!isConditionGroup(item)) {
@@ -264,7 +264,7 @@ export function useFilter(options: UseFilterOptions = {}): UseFilterReturn {
   );
 
   const updateOperator = useCallback(
-    (id: string, newOperator: ConditionGroupOperator): void => {
+    (id: string, newOperator: ConditionGroupOperatorType): void => {
       setItems((prev) =>
         updateInTree(prev, id, (item) => {
           if (isConditionGroup(item)) {
@@ -286,7 +286,7 @@ export function useFilter(options: UseFilterOptions = {}): UseFilterReturn {
   }, []);
 
   const get = useCallback(
-    (id: string): Condition | ConditionGroup | undefined => {
+    (id: string): ConditionType | ConditionGroupType | undefined => {
       return findById(items, id);
     },
     [items]
@@ -300,7 +300,7 @@ export function useFilter(options: UseFilterOptions = {}): UseFilterReturn {
     setItems([]);
   }, []);
 
-  const setOperator = useCallback((op: ConditionGroupOperator): void => {
+  const setOperator = useCallback((op: ConditionGroupOperatorType): void => {
     setOperatorState(op);
   }, []);
 
@@ -332,8 +332,5 @@ export function useFilter(options: UseFilterOptions = {}): UseFilterReturn {
     // Utility
     clear,
     setOperator,
-
-    // Legacy API
-    conditions: items,
   };
 }

package/sdk/components/hooks/useForm/apiClient.ts

@@ -4,7 +4,7 @@
 // Handles schema fetching and form submissions
 
 import { api, getBdoSchema } from "../../../api";
-import type { BDOSchema, FormOperation, SubmissionResult } from "./types";
+import type { BDOSchemaType, FormOperationType, SubmissionResultType } from "./types";
 
 // ============================================================
 // SCHEMA FETCHING
@@ -13,7 +13,7 @@ import type { BDOSchema, FormOperation, SubmissionResult } from "./types";
 /**
  * Fetch BDO schema from backend metadata endpoint
  */
-export async function fetchFormSchema(source: string): Promise<BDOSchema> {
+export async function fetchFormSchema(source: string): Promise<BDOSchemaType> {
   try {
     // Use the new metadata API client to fetch BDO schema
     const bdoResp = await getBdoSchema(source);
@@ -25,7 +25,7 @@ export async function fetchFormSchema(source: string): Promise<BDOSchema> {
     }
 
     // Return the full BDO schema - the form processor will extract what it needs
-    return bdoSchema as BDOSchema;
+    return bdoSchema as BDOSchemaType;
   } catch (error) {
     console.error(`Schema fetch error for ${source}:`, error);
     throw new Error(
@@ -40,7 +40,7 @@ export async function fetchFormSchema(source: string): Promise<BDOSchema> {
 export async function fetchFormSchemaWithRetry(
   source: string,
   maxRetries: number = 3
-): Promise<BDOSchema> {
+): Promise<BDOSchemaType> {
   let lastError: Error;
 
   for (let attempt = 1; attempt <= maxRetries; attempt++) {
@@ -88,10 +88,10 @@ export async function fetchRecord<T = any>(
  */
 export async function submitFormData<T = any>(
   source: string,
-  operation: FormOperation,
+  operation: FormOperationType,
   data: Partial<T>,
   recordId?: string
-): Promise<SubmissionResult> {
+): Promise<SubmissionResultType> {
   try {
     let result;
 
@@ -242,7 +242,7 @@ export function validateFormData<T>(
 export function cleanFormData<T>(
   data: Partial<T>,
   computedFields: string[],
-  operation: FormOperation = "create",
+  operation: FormOperationType = "create",
   originalData?: Partial<T>
 ): Partial<T> {
   const cleanedData: Partial<T> = {};
@@ -404,7 +404,7 @@ export function clearCache(keyPrefix?: string): void {
  */
 export async function fetchFormSchemaWithCache(
   source: string
-): Promise<BDOSchema> {
+): Promise<BDOSchemaType> {
   const cacheKey = `schema:${source}`;
   const cached = getCacheData(cacheKey);