lemma-sdk 0.2.32 → 0.2.34

package/dist/react/useFileSearch.js

@@ -0,0 +1,64 @@
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { normalizeError, resolvePodClient } from "./utils.js";
+export function useFileSearch({ client, podId, query = "", enabled = true, autoLoad = true, minQueryLength = 1, limit = 10, searchMethod, }) {
+    const [response, setResponse] = useState(null);
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const trimmedQuery = query.trim();
+    const reset = useCallback(() => {
+        setResponse(null);
+        setError(null);
+        setIsLoading(false);
+    }, []);
+    const search = useCallback(async (overrides = {}, signal) => {
+        const nextQuery = (overrides.query ?? trimmedQuery).trim();
+        if (!enabled || nextQuery.length < minQueryLength) {
+            reset();
+            return null;
+        }
+        setIsLoading(true);
+        setError(null);
+        try {
+            const scopedClient = resolvePodClient(client, podId);
+            const nextResponse = await scopedClient.files.search(nextQuery, {
+                limit: overrides.limit ?? limit,
+                searchMethod: overrides.searchMethod ?? searchMethod,
+            });
+            if (signal?.aborted)
+                return null;
+            setResponse(nextResponse);
+            return nextResponse;
+        }
+        catch (searchError) {
+            if (signal?.aborted)
+                return null;
+            setError(normalizeError(searchError, "Failed to search files."));
+            setResponse(null);
+            return null;
+        }
+        finally {
+            if (!signal?.aborted)
+                setIsLoading(false);
+        }
+    }, [client, enabled, limit, minQueryLength, podId, reset, searchMethod, trimmedQuery]);
+    useEffect(() => {
+        if (!enabled || !autoLoad)
+            return;
+        if (trimmedQuery.length < minQueryLength) {
+            reset();
+            return;
+        }
+        const controller = new AbortController();
+        void search({}, controller.signal);
+        return () => controller.abort();
+    }, [autoLoad, enabled, minQueryLength, reset, search, trimmedQuery]);
+    return useMemo(() => ({
+        response,
+        results: response?.results ?? [],
+        totalResults: response?.total_results ?? 0,
+        isLoading,
+        error,
+        search,
+        reset,
+    }), [error, isLoading, reset, response, search]);
+}

package/dist/react/useFileTree.d.ts

@@ -0,0 +1,21 @@
+import type { LemmaClient } from "../client.js";
+import type { DirectoryTreeNode, DirectoryTreeResponse } from "../types.js";
+export interface UseFileTreeOptions {
+    client: LemmaClient;
+    podId?: string;
+    enabled?: boolean;
+    autoLoad?: boolean;
+    rootPath?: string;
+    filesPerDirectory?: number;
+}
+export interface UseFileTreeResult {
+    tree: DirectoryTreeNode | null;
+    response: DirectoryTreeResponse | null;
+    isLoading: boolean;
+    error: Error | null;
+    refresh: (overrides?: {
+        rootPath?: string;
+        filesPerDirectory?: number;
+    }) => Promise<DirectoryTreeResponse | null>;
+}
+export declare function useFileTree({ client, podId, enabled, autoLoad, rootPath, filesPerDirectory, }: UseFileTreeOptions): UseFileTreeResult;

package/dist/react/useFileTree.js

@@ -0,0 +1,59 @@
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { normalizeError, resolvePodClient } from "./utils.js";
+export function useFileTree({ client, podId, enabled = true, autoLoad = true, rootPath = "/", filesPerDirectory = 3, }) {
+    const [response, setResponse] = useState(null);
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const refresh = useCallback(async (overrides = {}, signal) => {
+        if (!enabled) {
+            setResponse(null);
+            setError(null);
+            setIsLoading(false);
+            return null;
+        }
+        setIsLoading(true);
+        setError(null);
+        try {
+            const scopedClient = resolvePodClient(client, podId);
+            const nextResponse = await scopedClient.files.tree({
+                rootPath: overrides.rootPath ?? rootPath,
+                filesPerDirectory: overrides.filesPerDirectory ?? filesPerDirectory,
+            });
+            if (signal?.aborted)
+                return null;
+            setResponse(nextResponse);
+            return nextResponse;
+        }
+        catch (refreshError) {
+            if (signal?.aborted)
+                return null;
+            setError(normalizeError(refreshError, "Failed to load file tree."));
+            setResponse(null);
+            return null;
+        }
+        finally {
+            if (!signal?.aborted)
+                setIsLoading(false);
+        }
+    }, [client, enabled, filesPerDirectory, podId, rootPath]);
+    useEffect(() => {
+        if (!enabled) {
+            setResponse(null);
+            setError(null);
+            setIsLoading(false);
+            return;
+        }
+        if (!autoLoad)
+            return;
+        const controller = new AbortController();
+        void refresh({}, controller.signal);
+        return () => controller.abort();
+    }, [autoLoad, enabled, refresh]);
+    return useMemo(() => ({
+        tree: response?.tree ?? null,
+        response,
+        isLoading,
+        error,
+        refresh,
+    }), [error, isLoading, refresh, response]);
+}

package/dist/react/useFiles.d.ts

@@ -0,0 +1,29 @@
+import type { LemmaClient } from "../client.js";
+import type { FileResponse } from "../types.js";
+export interface UseFilesOptions {
+    client: LemmaClient;
+    podId?: string;
+    enabled?: boolean;
+    autoLoad?: boolean;
+    limit?: number;
+    pageToken?: string;
+    directoryPath?: string;
+    parentId?: string;
+}
+export interface UseFilesResult {
+    files: FileResponse[];
+    nextPageToken: string | null;
+    isLoading: boolean;
+    isLoadingMore: boolean;
+    error: Error | null;
+    refresh: (overrides?: {
+        limit?: number;
+        pageToken?: string;
+        directoryPath?: string;
+        parentId?: string;
+    }) => Promise<FileResponse[]>;
+    loadMore: (overrides?: {
+        limit?: number;
+    }) => Promise<FileResponse[]>;
+}
+export declare function useFiles({ client, podId, enabled, autoLoad, limit, pageToken, directoryPath, parentId, }: UseFilesOptions): UseFilesResult;

package/dist/react/useFiles.js

@@ -0,0 +1,90 @@
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { normalizeError, resolvePodClient } from "./utils.js";
+export function useFiles({ client, podId, enabled = true, autoLoad = true, limit = 100, pageToken, directoryPath = "/", parentId, }) {
+    const [files, setFiles] = useState([]);
+    const [nextPageToken, setNextPageToken] = useState(null);
+    const [isLoading, setIsLoading] = useState(false);
+    const [isLoadingMore, setIsLoadingMore] = useState(false);
+    const [error, setError] = useState(null);
+    const refresh = useCallback(async (overrides = {}, signal) => {
+        if (!enabled)
+            return [];
+        setIsLoading(true);
+        setError(null);
+        try {
+            const scopedClient = resolvePodClient(client, podId);
+            const response = await scopedClient.files.list({
+                limit: overrides.limit ?? limit,
+                pageToken: overrides.pageToken ?? pageToken,
+                directoryPath: overrides.directoryPath ?? directoryPath,
+                parentId: overrides.parentId ?? parentId,
+            });
+            if (signal?.aborted)
+                return [];
+            const nextFiles = response.items ?? [];
+            setFiles(nextFiles);
+            setNextPageToken(response.next_page_token ?? null);
+            return nextFiles;
+        }
+        catch (refreshError) {
+            if (signal?.aborted)
+                return [];
+            setError(normalizeError(refreshError, "Failed to load files."));
+            return [];
+        }
+        finally {
+            if (!signal?.aborted)
+                setIsLoading(false);
+        }
+    }, [client, directoryPath, enabled, limit, pageToken, parentId, podId]);
+    const loadMore = useCallback(async (overrides = {}) => {
+        if (!enabled || !nextPageToken || isLoading || isLoadingMore)
+            return [];
+        setIsLoadingMore(true);
+        setError(null);
+        try {
+            const scopedClient = resolvePodClient(client, podId);
+            const response = await scopedClient.files.list({
+                limit: overrides.limit ?? limit,
+                pageToken: nextPageToken,
+                directoryPath,
+                parentId,
+            });
+            const moreFiles = response.items ?? [];
+            setFiles((previous) => [...previous, ...moreFiles]);
+            setNextPageToken(response.next_page_token ?? null);
+            return moreFiles;
+        }
+        catch (loadError) {
+            setError(normalizeError(loadError, "Failed to load more files."));
+            return [];
+        }
+        finally {
+            setIsLoadingMore(false);
+        }
+    }, [client, directoryPath, enabled, isLoading, isLoadingMore, limit, nextPageToken, parentId, podId]);
+    useEffect(() => {
+        if (!enabled) {
+            setFiles([]);
+            setNextPageToken(null);
+            setError(null);
+            setIsLoading(false);
+            setIsLoadingMore(false);
+            return;
+        }
+        if (!autoLoad)
+            return;
+        const controller = new AbortController();
+        void refresh({}, controller.signal);
+        return () => controller.abort();
+    }, [autoLoad, enabled, refresh]);
+    return useMemo(() => ({
+        files,
+        nextPageToken,
+        isLoading,
+        isLoadingMore,
+        error,
+        refresh,
+        loadMore,
+    }), [error, files, isLoading, isLoadingMore, loadMore, nextPageToken, refresh]);
+}

package/dist/react/useRecords.js

@@ -72,7 +72,10 @@ export function useRecords({ client, podId, tableName, filters, sort, limit = 20
         trimmedTableName,
     ]);
     const loadMore = useCallback(async (overrides = {}) => {
-        if (!isEnabled || !nextPageToken || isLoading || isLoadingMore) {
+        const loadedCount = records.length;
+        const canLoadWithCursor = Boolean(nextPageToken);
+        const canLoadWithOffset = loadedCount < total;
+        if (!isEnabled || isLoading || isLoadingMore || (!canLoadWithCursor && !canLoadWithOffset)) {
             return [];
         }
         setIsLoadingMore(true);
@@ -83,15 +86,15 @@ export function useRecords({ client, podId, tableName, filters, sort, limit = 20
                 filters: stableFilters,
                 sort: stableSort,
                 limit: overrides.limit ?? limit,
-                pageToken: nextPageToken,
-                offset: overrides.offset,
+                pageToken: overrides.pageToken ?? nextPageToken ?? undefined,
+                offset: overrides.offset ?? (nextPageToken ? undefined : (offset ?? 0) + loadedCount),
                 sortBy: overrides.sortBy ?? sortBy,
                 order: overrides.order ?? order,
                 params: overrides.params ?? stableParams,
             });
             const moreRecords = (response.items ?? []);
             setRecords((previous) => [...previous, ...moreRecords]);
-            setTotal(response.total ?? records.length + moreRecords.length);
+            setTotal(response.total ?? loadedCount + moreRecords.length);
             setNextPageToken(response.next_page_token ?? null);
             return moreRecords;
         }
@@ -103,7 +106,7 @@ export function useRecords({ client, podId, tableName, filters, sort, limit = 20
         finally {
             setIsLoadingMore(false);
         }
-    }, [client, isEnabled, isLoading, isLoadingMore, limit, nextPageToken, offset, order, podId, records.length, sortBy, stableFilters, stableParams, stableSort, trimmedTableName]);
+    }, [client, isEnabled, isLoading, isLoadingMore, limit, nextPageToken, offset, order, podId, records.length, sortBy, stableFilters, stableParams, stableSort, total, trimmedTableName]);
     useEffect(() => {
         if (!isEnabled) {
             setRecords([]);

package/dist/react/useRemovePodMember.d.ts

@@ -0,0 +1,19 @@
+import type { LemmaClient } from "../client.js";
+export interface UseRemovePodMemberOptions {
+    client: LemmaClient;
+    podId?: string;
+    memberId?: string | null;
+    enabled?: boolean;
+    onSuccess?: (memberId: string) => void;
+    onError?: (error: unknown) => void;
+}
+export interface UseRemovePodMemberResult {
+    removedMemberId: string | null;
+    isSubmitting: boolean;
+    error: Error | null;
+    remove: (overrides?: {
+        memberId?: string | null;
+    }) => Promise<boolean>;
+    reset: () => void;
+}
+export declare function useRemovePodMember({ client, podId, memberId, enabled, onSuccess, onError, }: UseRemovePodMemberOptions): UseRemovePodMemberResult;

package/dist/react/useRemovePodMember.js

@@ -0,0 +1,50 @@
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { normalizeError, resolvePodId } from "./utils.js";
+export function useRemovePodMember({ client, podId, memberId = null, enabled = true, onSuccess, onError, }) {
+    const [removedMemberId, setRemovedMemberId] = useState(null);
+    const [isSubmitting, setIsSubmitting] = useState(false);
+    const [error, setError] = useState(null);
+    const onSuccessRef = useRef(onSuccess);
+    const onErrorRef = useRef(onError);
+    useEffect(() => { onSuccessRef.current = onSuccess; }, [onSuccess]);
+    useEffect(() => { onErrorRef.current = onError; }, [onError]);
+    const trimmedMemberId = typeof memberId === "string" ? memberId.trim() : "";
+    const remove = useCallback(async (overrides = {}) => {
+        const nextMemberId = typeof overrides.memberId === "string"
+            ? overrides.memberId.trim()
+            : trimmedMemberId;
+        if (!enabled || nextMemberId.length === 0) {
+            return false;
+        }
+        setIsSubmitting(true);
+        setError(null);
+        try {
+            const resolvedPodId = resolvePodId(client, podId);
+            await client.podMembers.remove(resolvedPodId, nextMemberId);
+            setRemovedMemberId(nextMemberId);
+            onSuccessRef.current?.(nextMemberId);
+            return true;
+        }
+        catch (mutationError) {
+            const normalized = normalizeError(mutationError, "Failed to remove pod member.");
+            setError(normalized);
+            onErrorRef.current?.(mutationError);
+            return false;
+        }
+        finally {
+            setIsSubmitting(false);
+        }
+    }, [client, enabled, podId, trimmedMemberId]);
+    const reset = useCallback(() => {
+        setRemovedMemberId(null);
+        setError(null);
+        setIsSubmitting(false);
+    }, []);
+    return useMemo(() => ({
+        removedMemberId,
+        isSubmitting,
+        error,
+        remove,
+        reset,
+    }), [error, isSubmitting, remove, removedMemberId, reset]);
+}

package/dist/react/useUpdatePodMemberRole.d.ts

@@ -0,0 +1,20 @@
+import type { LemmaClient } from "../client.js";
+import type { PodMember, PodRole } from "../types.js";
+export interface UseUpdatePodMemberRoleOptions {
+    client: LemmaClient;
+    podId?: string;
+    memberId?: string | null;
+    enabled?: boolean;
+    onSuccess?: (member: PodMember) => void;
+    onError?: (error: unknown) => void;
+}
+export interface UseUpdatePodMemberRoleResult {
+    updatedMember: PodMember | null;
+    isSubmitting: boolean;
+    error: Error | null;
+    updateRole: (role: PodRole, overrides?: {
+        memberId?: string | null;
+    }) => Promise<PodMember | null>;
+    reset: () => void;
+}
+export declare function useUpdatePodMemberRole({ client, podId, memberId, enabled, onSuccess, onError, }: UseUpdatePodMemberRoleOptions): UseUpdatePodMemberRoleResult;

package/dist/react/useUpdatePodMemberRole.js

@@ -0,0 +1,50 @@
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { normalizeError, resolvePodId } from "./utils.js";
+export function useUpdatePodMemberRole({ client, podId, memberId = null, enabled = true, onSuccess, onError, }) {
+    const [updatedMember, setUpdatedMember] = useState(null);
+    const [isSubmitting, setIsSubmitting] = useState(false);
+    const [error, setError] = useState(null);
+    const onSuccessRef = useRef(onSuccess);
+    const onErrorRef = useRef(onError);
+    useEffect(() => { onSuccessRef.current = onSuccess; }, [onSuccess]);
+    useEffect(() => { onErrorRef.current = onError; }, [onError]);
+    const trimmedMemberId = typeof memberId === "string" ? memberId.trim() : "";
+    const updateRole = useCallback(async (role, overrides = {}) => {
+        const nextMemberId = typeof overrides.memberId === "string"
+            ? overrides.memberId.trim()
+            : trimmedMemberId;
+        if (!enabled || nextMemberId.length === 0) {
+            return null;
+        }
+        setIsSubmitting(true);
+        setError(null);
+        try {
+            const resolvedPodId = resolvePodId(client, podId);
+            const nextMember = await client.podMembers.updateRole(resolvedPodId, nextMemberId, role);
+            setUpdatedMember(nextMember);
+            onSuccessRef.current?.(nextMember);
+            return nextMember;
+        }
+        catch (mutationError) {
+            const normalized = normalizeError(mutationError, "Failed to update pod member role.");
+            setError(normalized);
+            onErrorRef.current?.(mutationError);
+            return null;
+        }
+        finally {
+            setIsSubmitting(false);
+        }
+    }, [client, enabled, podId, trimmedMemberId]);
+    const reset = useCallback(() => {
+        setUpdatedMember(null);
+        setError(null);
+        setIsSubmitting(false);
+    }, []);
+    return useMemo(() => ({
+        updatedMember,
+        isSubmitting,
+        error,
+        updateRole,
+        reset,
+    }), [error, isSubmitting, reset, updateRole, updatedMember]);
+}

package/dist/react/useWorkflowStart.d.ts

@@ -1,5 +1,5 @@
 import type { LemmaClient } from "../client.js";
-import type { FlowRun, FlowStartType, Workflow, WorkflowRunInputs } from "../types.js";
+import type { FlowRun, Workflow, WorkflowStartType, WorkflowRunInputs } from "../types.js";
 import { type UseFlowSessionResult } from "./useFlowSession.js";
 export interface UseWorkflowStartOptions {
     client: LemmaClient;
@@ -15,7 +15,7 @@ export interface UseWorkflowStartOptions {
 }
 export interface UseWorkflowStartResult extends Omit<UseFlowSessionResult, "start" | "listHistory"> {
     workflow: Workflow | null;
-    startType: FlowStartType | "MANUAL";
+    startType: WorkflowStartType | "MANUAL";
     inputSchema: Record<string, unknown> | null;
     inputUiSchema: Record<string, unknown> | null;
     isLoadingWorkflow: boolean;

package/dist/record-display.d.ts

@@ -0,0 +1,20 @@
+import type { ColumnSchema } from "./types.js";
+export interface RecordDetailFieldGroupDefinition {
+    label: string;
+    fields: string[];
+}
+export declare function detectRecordTitleColumn(columns: ColumnSchema[]): ColumnSchema | undefined;
+export declare function detectRecordDescriptionColumn(columns: ColumnSchema[]): ColumnSchema | undefined;
+export declare function detectRecordStatusColumn(columns: ColumnSchema[]): ColumnSchema | undefined;
+export declare function isDefaultRecordDetailHiddenField(name: string): boolean;
+export declare function buildDefaultRecordDetailFieldGroups(columns: ColumnSchema[], options?: {
+    hiddenFields?: string[];
+    titleField?: string;
+    descriptionField?: string;
+    statusField?: string;
+    identifierField?: string;
+}): RecordDetailFieldGroupDefinition[];
+export declare function humanizeRecordFieldName(value: string): string;
+export declare function formatRecordPlainValue(value: unknown): string;
+export declare function formatRecordDisplayValue(value: unknown): string;
+export declare function formatRecordDateDisplayValue(value: unknown, options?: Intl.DateTimeFormatOptions): string;

package/dist/record-display.js

@@ -0,0 +1,78 @@
+export function detectRecordTitleColumn(columns) {
+    return columns.find((column) => !column.system && !column.auto && !column.computed && /title|name|subject|label/i.test(column.name));
+}
+export function detectRecordDescriptionColumn(columns) {
+    return columns.find((column) => !column.system
+        && !column.auto
+        && !column.computed
+        && column.type === "TEXT"
+        && /description|summary|body|content|notes|reason/i.test(column.name));
+}
+export function detectRecordStatusColumn(columns) {
+    return columns.find((column) => /status|state|stage/i.test(column.name));
+}
+export function isDefaultRecordDetailHiddenField(name) {
+    return name === "id" || name === "created_at" || name === "updated_at";
+}
+export function buildDefaultRecordDetailFieldGroups(columns, options = {}) {
+    const excluded = new Set([
+        ...(options.hiddenFields ?? []),
+        options.titleField,
+        options.descriptionField,
+        options.statusField,
+        options.identifierField,
+    ].filter((value) => Boolean(value)));
+    const displayable = columns.filter((column) => !column.system
+        && !column.auto
+        && !column.computed
+        && !isDefaultRecordDetailHiddenField(column.name)
+        && !excluded.has(column.name));
+    if (displayable.length === 0)
+        return [];
+    return [
+        {
+            label: "Details",
+            fields: displayable.map((column) => column.name),
+        },
+    ];
+}
+export function humanizeRecordFieldName(value) {
+    return value
+        .replace(/[_\.]/g, " ")
+        .replace(/\s+/g, " ")
+        .trim()
+        .replace(/\b\w/g, (match) => match.toUpperCase());
+}
+export function formatRecordPlainValue(value) {
+    if (value == null || value === "")
+        return "";
+    if (value instanceof Date)
+        return formatRecordDateDisplayValue(value);
+    if (typeof value === "boolean")
+        return value ? "Yes" : "No";
+    if (typeof value === "number")
+        return value.toLocaleString();
+    if (Array.isArray(value))
+        return value.map(formatRecordPlainValue).filter(Boolean).join(", ");
+    if (typeof value === "object")
+        return JSON.stringify(value);
+    return String(value);
+}
+export function formatRecordDisplayValue(value) {
+    return formatRecordPlainValue(value) || "Not set";
+}
+export function formatRecordDateDisplayValue(value, options) {
+    if (value == null || value === "")
+        return "Not set";
+    const date = value instanceof Date ? value : new Date(String(value));
+    if (Number.isNaN(date.getTime()))
+        return String(value);
+    return new Intl.DateTimeFormat(undefined, {
+        month: "short",
+        day: "numeric",
+        year: "numeric",
+        hour: "numeric",
+        minute: "2-digit",
+        ...options,
+    }).format(date);
+}

package/dist/record-form.d.ts

@@ -22,9 +22,13 @@ export interface BuildRecordPayloadResult {
     errors: Record<string, string>;
     isValid: boolean;
 }
+export declare const DEFAULT_RECORD_FORM_HIDDEN_FIELDS: readonly ["id", "created_at", "updated_at", "creator_user_id", "sort_order"];
 export declare function getRecordFieldKind(column: ColumnSchema): RecordSchemaFieldKind;
 export declare function buildRecordSchemaFields(table: Table): RecordSchemaField[];
 export declare function getEditableRecordFields(table: Table): RecordSchemaField[];
+export declare function orderRecordSchemaFields<T extends {
+    name: string;
+}>(fields: T[], fieldOrder?: string[]): T[];
 export declare function formatRecordValueForForm(column: ColumnSchema, value: unknown): unknown;
 export declare function buildRecordFormValues(table: Table, values?: Record<string, unknown>): Record<string, unknown>;
 export declare function buildRecordPayload(table: Table, values: Record<string, unknown>, options?: BuildRecordPayloadOptions): BuildRecordPayloadResult;

package/dist/record-form.js

@@ -1,5 +1,12 @@
 import { parseForeignKeyReference } from "./datastore-query.js";
 import { DatastoreDataType } from "./types.js";
+export const DEFAULT_RECORD_FORM_HIDDEN_FIELDS = [
+    "id",
+    "created_at",
+    "updated_at",
+    "creator_user_id",
+    "sort_order",
+];
 function sentenceCase(value) {
     return value
         .replace(/_/g, " ")
@@ -101,6 +108,15 @@ export function buildRecordSchemaFields(table) {
 export function getEditableRecordFields(table) {
     return buildRecordSchemaFields(table).filter((field) => !field.readOnly);
 }
+export function orderRecordSchemaFields(fields, fieldOrder) {
+    if (!fieldOrder?.length)
+        return fields;
+    const ordered = fieldOrder
+        .map((name) => fields.find((field) => field.name === name))
+        .filter((field) => field !== undefined);
+    const remaining = fields.filter((field) => !fieldOrder.includes(field.name));
+    return [...ordered, ...remaining];
+}
 export function formatRecordValueForForm(column, value) {
     const kind = getRecordFieldKind(column);
     if (value === null || typeof value === "undefined") {

package/dist/types.d.ts

@@ -1,4 +1,4 @@
-import type { AgentResponse, AssistantResponse, AvailableModels, ColumnSchema, ConversationMessageResponse, ConversationResponse, CreateAgentRequest, CreateAssistantRequest, CreateTaskRequest, DatastoreQueryResponse, FlowRunEntity, FlowResponse, FunctionRunResponse, IconUploadResponse, OrganizationInvitationResponse, OrganizationMemberResponse, OrganizationResponse, PodConfigResponse, PodJoinRequestCreateResponse, PodMemberResponse, PodResponse, TableResponse, TaskMessageResponse, TaskResponse, UpdateAgentRequest, UpdateAssistantRequest, UserResponse } from "./openapi_client/index.js";
+import type { AgentResponse, AssistantResponse, AvailableModels, ColumnSchema, ConversationMessageResponse, ConversationResponse, CreateAgentRequest, CreateAssistantRequest, CreateTaskRequest, DatastoreQueryResponse, DirectoryTreeNode, DirectoryTreeResponse, FileResponse, FileSearchResponse, FileSearchResultSchema, FlowRunEntity, FlowResponse, FunctionRunResponse, IconUploadResponse, OrganizationInvitationResponse, OrganizationMemberResponse, OrganizationResponse, PodConfigResponse, PodJoinRequestCreateResponse, PodMemberResponse, PodResponse, TableResponse, TaskMessageResponse, TaskResponse, UpdateAgentRequest, UpdateAssistantRequest, UserResponse } from "./openapi_client/index.js";
 /** Public ergonomic types. */
 export interface PageResult<T> {
     items: T[];
@@ -52,9 +52,16 @@ export type TaskMessage = TaskMessageResponse;
 export type FunctionRun = FunctionRunResponse;
 export type FlowRun = FlowRunEntity;
 export type Workflow = FlowResponse;
+export type WorkflowStart = Workflow["start"];
+export type WorkflowStartType = NonNullable<WorkflowStart>["type"];
 export type Table = TableResponse;
 export type TableColumn = ColumnSchema;
 export type DatastoreQueryResult = DatastoreQueryResponse;
+export type DatastoreFile = FileResponse;
+export type DatastoreFileSearchResponse = FileSearchResponse;
+export type DatastoreFileSearchResult = FileSearchResultSchema;
+export type DatastoreDirectoryTree = DirectoryTreeResponse;
+export type DatastoreDirectoryTreeNode = DirectoryTreeNode;
 export type Pod = PodResponse;
 export type PodConfig = PodConfigResponse;
 export type PodMember = PodMemberResponse;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lemma-sdk",
-  "version": "0.2.32",
+  "version": "0.2.34",
   "description": "Official TypeScript SDK for Lemma pod-scoped APIs",
   "type": "module",
   "main": "dist/index.js",
@@ -45,6 +45,7 @@
     "build:bundle": "tsc -p tsconfig.bundle.json && node ./scripts/build_browser_bundle.mjs",
     "clean": "node -e \"require('fs').rmSync('dist', { recursive: true, force: true, maxRetries: 10, retryDelay: 100 })\"",
     "registry:build": "shadcn build ./registry.json -o ./public/r",
+    "registry:check": "npm run registry:build && node ./scripts/check_registry_blocks.mjs",
     "prepublishOnly": "npm run build",
     "release:check": "npm run build && npm_config_cache=.npm-cache npm pack --dry-run"
   },

package/dist/openapi_client/models/EmailSurfaceConfigCreate.d.ts

@@ -1,5 +0,0 @@
-export type EmailSurfaceConfigCreate = {
-    account_id?: (string | null);
-    inbox_email?: (string | null);
-    type?: string;
-};