@nextsparkjs/core 0.1.0-beta.75 → 0.1.0-beta.77

package/dist/hooks/useLastAuthMethod.d.ts

@@ -0,0 +1,7 @@
+export declare function useLastAuthMethod(): {
+    lastMethod: import("../types/auth").AuthProviderWithNull;
+    saveAuthMethod: (method: "email" | "google") => void;
+    clearAuthMethod: () => void;
+    isReady: boolean;
+};
+//# sourceMappingURL=useLastAuthMethod.d.ts.map

package/dist/hooks/useLastAuthMethod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLastAuthMethod.d.ts","sourceRoot":"","sources":["../../src/hooks/useLastAuthMethod.ts"],"names":[],"mappings":"AAOA,wBAAgB,iBAAiB;;6BAuBa,OAAO,GAAG,QAAQ;;;EA2B/D"}

package/dist/hooks/useLocale.d.ts

@@ -0,0 +1,8 @@
+import { type SupportedLocale } from '../lib/config';
+export declare function useLocale(): {
+    locale: any;
+    changeLanguage: (newLocale: SupportedLocale) => Promise<void>;
+    isChanging: boolean;
+    supportedLocales: any;
+};
+//# sourceMappingURL=useLocale.d.ts.map

package/dist/hooks/useLocale.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLocale.d.ts","sourceRoot":"","sources":["../../src/hooks/useLocale.ts"],"names":[],"mappings":"AAMA,OAAO,EAAe,KAAK,eAAe,EAAE,MAAM,eAAe,CAAA;AAEjE,wBAAgB,SAAS;;gCAO8B,eAAe;;;EAoCrE"}

package/dist/hooks/useMembership.d.ts

@@ -0,0 +1,64 @@
+import type { QuotaInfo } from '../lib/billing/types';
+/**
+ * Unified hook providing subscription, features, limits, and canDo() method
+ *
+ * This hook integrates RBAC permissions (from TeamContext), feature access (from Plan),
+ * and quota enforcement (from Limits) into a single DX-friendly interface.
+ *
+ * FIX2: Refactored to avoid React hooks violations:
+ * - hasFeature() now uses cached features from context (no hook calls)
+ * - getQuota() returns sync cached data
+ * - Added getQuotaAsync() for full quota info with current usage
+ *
+ * @example
+ * ```tsx
+ * const membership = useMembership()
+ *
+ * // Check subscription info
+ * console.log(membership.plan.name) // 'Pro'
+ * console.log(membership.subscription.status) // 'active'
+ *
+ * // Check feature access (sync, cached)
+ * if (membership.hasFeature('advanced_analytics')) {
+ *   // Show analytics
+ * }
+ *
+ * // Check quota limits (sync, cached)
+ * const projectsLimit = membership.getQuota('projects')
+ * console.log(projectsLimit.max, projectsLimit.resetPeriod)
+ *
+ * // Get full quota info with current usage (async)
+ * const projectsQuota = await membership.getQuotaAsync('projects')
+ * console.log(projectsQuota.current, projectsQuota.max)
+ *
+ * // Unified permission check (Permission + Feature + Quota)
+ * const canCreateProject = await membership.canDo('projects.create')
+ * if (canCreateProject.allowed) {
+ *   // Create project
+ * } else {
+ *   toast.error(canCreateProject.reason)
+ * }
+ * ```
+ */
+export declare function useMembership(): {
+    plan: import("../lib/billing/types").Plan;
+    subscription: import("../lib/billing/types").SubscriptionWithPlan;
+    status: import("../lib/billing/types").SubscriptionStatus;
+    isTrialing: boolean;
+    isActive: boolean;
+    isPastDue: boolean;
+    isCanceled: boolean;
+    isLoading: boolean;
+    hasFeature: (featureSlug: string) => boolean;
+    getQuota: (limitSlug: string) => {
+        max: number;
+        resetPeriod: string;
+    } | null;
+    getQuotaAsync: (limitSlug: string) => Promise<QuotaInfo | null>;
+    canDo: (action: string) => Promise<{
+        allowed: boolean;
+        reason?: string;
+    }>;
+    refetch: () => void;
+};
+//# sourceMappingURL=useMembership.d.ts.map

package/dist/hooks/useMembership.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useMembership.d.ts","sourceRoot":"","sources":["../../src/hooks/useMembership.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAA;AAErD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,wBAAgB,aAAa;;;;;;;;;8BAeC,MAAM,KAAG,OAAO;0BAOpB,MAAM,KAAG;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI;+BAYzC,MAAM,KAAG,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC;oBAmB7C,MAAM,KAAG,OAAO,CAAC;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;;EAmChF"}

package/dist/hooks/useNotifications.d.ts

@@ -0,0 +1,18 @@
+export interface Notification {
+    id: string;
+    title: string;
+    message: string;
+    type: 'info' | 'success' | 'warning' | 'error';
+    timestamp: Date;
+    isRead: boolean;
+    actionUrl?: string;
+}
+export declare function useNotifications(): {
+    notifications: Notification[];
+    unreadCount: number;
+    markAsRead: (notificationId: string) => void;
+    markAllAsRead: () => void;
+    deleteNotification: (notificationId: string) => void;
+    addNotification: (notification: Omit<Notification, "id" | "timestamp">) => void;
+};
+//# sourceMappingURL=useNotifications.d.ts.map

package/dist/hooks/useNotifications.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useNotifications.d.ts","sourceRoot":"","sources":["../../src/hooks/useNotifications.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,YAAY;IAC3B,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,EAAE,MAAM,CAAA;IACb,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS,GAAG,OAAO,CAAA;IAC9C,SAAS,EAAE,IAAI,CAAA;IACf,MAAM,EAAE,OAAO,CAAA;IACf,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AA0DD,wBAAgB,gBAAgB;;;iCAGM,MAAM;;yCAgBE,MAAM;oCAMX,IAAI,CAAC,YAAY,EAAE,IAAI,GAAG,WAAW,CAAC;EAsB9E"}

package/dist/hooks/useOrigin.d.ts

@@ -0,0 +1,2 @@
+export declare function useOrigin(): string;
+//# sourceMappingURL=useOrigin.d.ts.map

package/dist/hooks/useOrigin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useOrigin.d.ts","sourceRoot":"","sources":["../../src/hooks/useOrigin.ts"],"names":[],"mappings":"AAIA,wBAAgB,SAAS,WAyBxB"}

package/dist/hooks/usePatternUsages.d.ts

@@ -0,0 +1,273 @@
+/**
+ * Options for the usePatternUsages hook
+ */
+export interface UsePatternUsagesOptions {
+    /** Filter by entity type (e.g., 'pages', 'posts') */
+    entityType?: string;
+    /** Number of results per page (default: 50) */
+    limit?: number;
+    /** Current page number (default: 1) */
+    page?: number;
+    /** Whether the query is enabled (default: true) */
+    enabled?: boolean;
+    /** Stale time in ms (default: 5 minutes) */
+    staleTime?: number;
+}
+/**
+ * Single usage record with entity info
+ */
+export interface PatternUsage {
+    id: string;
+    patternId: string;
+    entityType: string;
+    entityId: string;
+    teamId: string;
+    createdAt: string;
+    entityTitle?: string;
+    entityName?: string;
+    entityFirstName?: string;
+    entityLastName?: string;
+    entityEmail?: string;
+    entitySlug?: string;
+    entityStatus?: string;
+    entityUpdatedAt?: string;
+}
+/**
+ * Usage count by entity type
+ */
+export interface PatternUsageCount {
+    entityType: string;
+    count: number;
+}
+/**
+ * Result of the usePatternUsages query
+ */
+export interface PatternUsagesResult {
+    usages: PatternUsage[];
+    counts: PatternUsageCount[];
+    total: number;
+    page: number;
+    totalPages: number;
+}
+/**
+ * React Query hook to fetch pattern usages
+ *
+ * @param patternId - The ID of the pattern to get usages for
+ * @param options - Query options (entityType filter, pagination, etc.)
+ * @returns Query result with usages, counts, and pagination info
+ *
+ * @example
+ * ```tsx
+ * const { usages, counts, total, isLoading, error } = usePatternUsages(patternId, {
+ *   entityType: 'pages',
+ *   limit: 20,
+ *   page: 1,
+ * })
+ * ```
+ */
+export declare function usePatternUsages(patternId: string, options?: UsePatternUsagesOptions): {
+    usages: PatternUsage[];
+    counts: PatternUsageCount[];
+    total: number;
+    page: number;
+    totalPages: number;
+    data: PatternUsagesResult;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: true;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<PatternUsagesResult, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    promise: Promise<PatternUsagesResult>;
+} | {
+    usages: PatternUsage[];
+    counts: PatternUsageCount[];
+    total: number;
+    page: number;
+    totalPages: number;
+    data: PatternUsagesResult;
+    error: null;
+    isError: false;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: false;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<PatternUsagesResult, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    promise: Promise<PatternUsagesResult>;
+} | {
+    usages: PatternUsage[];
+    counts: PatternUsageCount[];
+    total: number;
+    page: number;
+    totalPages: number;
+    data: undefined;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: true;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<PatternUsagesResult, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    promise: Promise<PatternUsagesResult>;
+} | {
+    usages: PatternUsage[];
+    counts: PatternUsageCount[];
+    total: number;
+    page: number;
+    totalPages: number;
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoading: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<PatternUsagesResult, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    promise: Promise<PatternUsagesResult>;
+} | {
+    usages: PatternUsage[];
+    counts: PatternUsageCount[];
+    total: number;
+    page: number;
+    totalPages: number;
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isLoading: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<PatternUsagesResult, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    promise: Promise<PatternUsagesResult>;
+} | {
+    usages: PatternUsage[];
+    counts: PatternUsageCount[];
+    total: number;
+    page: number;
+    totalPages: number;
+    data: PatternUsagesResult;
+    isError: false;
+    error: null;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: true;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<PatternUsagesResult, Error>>;
+    fetchStatus: import("@tanstack/react-query").FetchStatus;
+    promise: Promise<PatternUsagesResult>;
+};
+/**
+ * Hook to get just the usage count for a pattern
+ * Useful for displaying usage count in lists without full usage details
+ *
+ * @param patternId - The ID of the pattern
+ * @param options - Query options
+ * @returns Query result with total usage count
+ */
+export declare function usePatternUsageCount(patternId: string, options?: {
+    enabled?: boolean;
+    staleTime?: number;
+}): import("@tanstack/react-query").UseQueryResult<number, Error>;
+//# sourceMappingURL=usePatternUsages.d.ts.map

package/dist/hooks/usePatternUsages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"usePatternUsages.d.ts","sourceRoot":"","sources":["../../src/hooks/usePatternUsages.ts"],"names":[],"mappings":"AAMA;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC,qDAAqD;IACrD,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,+CAA+C;IAC/C,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,uCAAuC;IACvC,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,mDAAmD;IACnD,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,4CAA4C;IAC5C,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,EAAE,EAAE,MAAM,CAAA;IACV,SAAS,EAAE,MAAM,CAAA;IACjB,UAAU,EAAE,MAAM,CAAA;IAClB,QAAQ,EAAE,MAAM,CAAA;IAChB,MAAM,EAAE,MAAM,CAAA;IACd,SAAS,EAAE,MAAM,CAAA;IACjB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,eAAe,CAAC,EAAE,MAAM,CAAA;CACzB;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,UAAU,EAAE,MAAM,CAAA;IAClB,KAAK,EAAE,MAAM,CAAA;CACd;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,YAAY,EAAE,CAAA;IACtB,MAAM,EAAE,iBAAiB,EAAE,CAAA;IAC3B,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,MAAM,CAAA;IACZ,UAAU,EAAE,MAAM,CAAA;CACnB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,gBAAgB,CAC9B,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE,uBAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4EtC;AAED;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAClC,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE;IAAE,OAAO,CAAC,EAAE,OAAO,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAO,iEA8BxD"}

package/dist/hooks/usePrefetch.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Hook to prefetch settings page data on hover
+ *
+ * @example
+ * ```tsx
+ * function SettingsSidebar() {
+ *   const { prefetchProfile, prefetchTeams } = usePrefetchSettings()
+ *
+ *   return (
+ *     <nav>
+ *       <Link href="/dashboard/settings/profile" onMouseEnter={prefetchProfile}>
+ *         Profile
+ *       </Link>
+ *       <Link href="/dashboard/settings/teams" onMouseEnter={prefetchTeams}>
+ *         Teams
+ *       </Link>
+ *     </nav>
+ *   )
+ * }
+ * ```
+ */
+export declare function usePrefetchSettings(): {
+    prefetchProfile: () => void;
+    prefetchTeams: () => void;
+};
+/**
+ * Generic prefetch hook for any entity list
+ *
+ * @example
+ * ```tsx
+ * function EntityNav() {
+ *   const prefetchProducts = usePrefetchEntity('products')
+ *
+ *   return (
+ *     <Link href="/dashboard/products" onMouseEnter={prefetchProducts}>
+ *       Products
+ *     </Link>
+ *   )
+ * }
+ * ```
+ */
+export declare function usePrefetchEntity(entitySlug: string): () => void;
+//# sourceMappingURL=usePrefetch.d.ts.map

package/dist/hooks/usePrefetch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"usePrefetch.d.ts","sourceRoot":"","sources":["../../src/hooks/usePrefetch.ts"],"names":[],"mappings":"AAyBA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,mBAAmB;;;EAuBlC;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,MAAM,cAgBnD"}

package/dist/hooks/useQuickCreateEntities.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Hook for Quick Create entities
+ * Gets entities from client registry (populated by server component)
+ * Filters by user permissions
+ */
+import type { EntityConfig } from '../lib/entities/types';
+export declare function useQuickCreateEntities(): {
+    entities: EntityConfig[];
+    isLoading: boolean;
+    error: string;
+    hasEntities: boolean;
+};
+//# sourceMappingURL=useQuickCreateEntities.d.ts.map

package/dist/hooks/useQuickCreateEntities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useQuickCreateEntities.d.ts","sourceRoot":"","sources":["../../src/hooks/useQuickCreateEntities.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAKH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAA;AAEzD,wBAAgB,sBAAsB;;;;;EAkDrC"}

package/dist/hooks/useQuota.d.ts

@@ -0,0 +1,26 @@
+import { QuotaInfo } from '../lib/billing/types';
+/**
+ * Hook to check quota usage for a specific limit
+ *
+ * @param limitSlug - The slug of the limit to check (e.g., 'projects', 'team_members')
+ * @returns QuotaInfo - Current usage, max limit, and whether action is allowed
+ *
+ * @example
+ * ```tsx
+ * const projectsQuota = useQuota('projects')
+ * if (!projectsQuota.allowed) {
+ *   toast.error('Project limit reached. Please upgrade your plan.')
+ * }
+ * ```
+ */
+export declare function useQuota(limitSlug: string): {
+    isLoading: boolean;
+    error: Error | null;
+    refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<QuotaInfo, Error>>;
+    allowed: boolean;
+    current: number;
+    max: number;
+    remaining: number;
+    percentUsed: number;
+};
+//# sourceMappingURL=useQuota.d.ts.map

package/dist/hooks/useQuota.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useQuota.d.ts","sourceRoot":"","sources":["../../src/hooks/useQuota.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAA;AAEhD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,QAAQ,CAAC,SAAS,EAAE,MAAM;;WA+BtB,KAAK,GAAG,IAAI;;;;;;;EAG/B"}

package/dist/hooks/useSearch.d.ts

@@ -0,0 +1,23 @@
+import type { SearchResultType } from '@nextsparkjs/registries/entity-types';
+export interface SearchResult {
+    id: string;
+    title: string;
+    description?: string;
+    type: SearchResultType;
+    url: string;
+    category?: string;
+    priority?: 'low' | 'medium' | 'high';
+    completed?: boolean;
+    entityType?: string;
+    status?: string;
+}
+export declare function useSearch(): {
+    query: string;
+    setQuery: import("react").Dispatch<import("react").SetStateAction<string>>;
+    results: SearchResult[];
+    isSearching: boolean;
+    clearSearch: () => void;
+    hasResults: boolean;
+    isEmpty: boolean;
+};
+//# sourceMappingURL=useSearch.d.ts.map

package/dist/hooks/useSearch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSearch.d.ts","sourceRoot":"","sources":["../../src/hooks/useSearch.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sCAAsC,CAAA;AAG5E,MAAM,WAAW,YAAY;IAC3B,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,EAAE,MAAM,CAAA;IACb,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,IAAI,EAAE,gBAAgB,CAAA;IACtB,GAAG,EAAE,MAAM,CAAA;IACX,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,QAAQ,CAAC,EAAE,KAAK,GAAG,QAAQ,GAAG,MAAM,CAAA;IACpC,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB;AAwFD,wBAAgB,SAAS;;;;;;;;EAsIxB"}

package/dist/hooks/useSidebarState.d.ts

@@ -0,0 +1,7 @@
+export declare function useSidebarState(): {
+    isCollapsed: boolean;
+    toggleSidebar: () => void;
+    setIsCollapsed: (newState: boolean) => Promise<void>;
+    isLoading: boolean;
+};
+//# sourceMappingURL=useSidebarState.d.ts.map

package/dist/hooks/useSidebarState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSidebarState.d.ts","sourceRoot":"","sources":["../../src/hooks/useSidebarState.ts"],"names":[],"mappings":"AAKA,wBAAgB,eAAe;;;+BAkB2B,OAAO;;EA+BhE"}

package/dist/hooks/useSubscription.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Hook to access subscription data
+ *
+ * @example
+ * ```tsx
+ * const { plan, status, isActive } = useSubscription()
+ * ```
+ */
+export declare function useSubscription(): import("..").SubscriptionContextValue;
+//# sourceMappingURL=useSubscription.d.ts.map

package/dist/hooks/useSubscription.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSubscription.d.ts","sourceRoot":"","sources":["../../src/hooks/useSubscription.ts"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,wBAAgB,eAAe,0CAE9B"}

package/dist/hooks/useTeam.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Hook to get current team information
+ */
+export declare function useTeam(): {
+    team: import("./teams").Team;
+    teamId: string;
+    canCurrentUserCreateTeam: boolean;
+    isLoading: boolean;
+};
+//# sourceMappingURL=useTeam.d.ts.map

package/dist/hooks/useTeam.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTeam.d.ts","sourceRoot":"","sources":["../../src/hooks/useTeam.ts"],"names":[],"mappings":"AAIA;;GAEG;AACH,wBAAgB,OAAO;;;;;EAStB"}

package/dist/hooks/useTeamInvitations.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Hook to manage team invitations
+ */
+export declare function useTeamInvitations(): {
+    invitations: any;
+    isLoading: boolean;
+    acceptInvitation: import("@tanstack/react-query").UseMutateFunction<any, Error, string, unknown>;
+    acceptInvitationAsync: import("@tanstack/react-query").UseMutateAsyncFunction<any, Error, string, unknown>;
+    isAccepting: boolean;
+    declineInvitation: import("@tanstack/react-query").UseMutateFunction<any, Error, string, unknown>;
+    declineInvitationAsync: import("@tanstack/react-query").UseMutateAsyncFunction<any, Error, string, unknown>;
+    isDeclining: boolean;
+};
+//# sourceMappingURL=useTeamInvitations.d.ts.map

package/dist/hooks/useTeamInvitations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTeamInvitations.d.ts","sourceRoot":"","sources":["../../src/hooks/useTeamInvitations.ts"],"names":[],"mappings":"AAIA;;GAEG;AACH,wBAAgB,kBAAkB;;;;;;;;;EA6DjC"}

package/dist/hooks/useTeamMembers.d.ts

@@ -0,0 +1,29 @@
+import { InviteMemberRequest, UpdateMemberRoleRequest } from '../lib/teams/types';
+interface UseTeamMembersOptions {
+    /**
+     * Optional teamId to use instead of context teamId.
+     * Useful when viewing a team detail page where the teamId comes from URL.
+     */
+    teamId?: string;
+}
+/**
+ * Hook to manage team members
+ *
+ * @param options - Optional configuration including teamId override
+ */
+export declare function useTeamMembers(options?: UseTeamMembersOptions): {
+    members: any;
+    isLoading: boolean;
+    inviteMember: import("@tanstack/react-query").UseMutateFunction<any, Error, InviteMemberRequest, unknown>;
+    inviteMemberAsync: import("@tanstack/react-query").UseMutateAsyncFunction<any, Error, InviteMemberRequest, unknown>;
+    isInviting: boolean;
+    updateMemberRole: import("@tanstack/react-query").UseMutateFunction<any, Error, {
+        memberId: string;
+        role: UpdateMemberRoleRequest["role"];
+    }, unknown>;
+    isUpdatingRole: boolean;
+    removeMember: import("@tanstack/react-query").UseMutateFunction<any, Error, string, unknown>;
+    isRemovingMember: boolean;
+};
+export {};
+//# sourceMappingURL=useTeamMembers.d.ts.map

package/dist/hooks/useTeamMembers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTeamMembers.d.ts","sourceRoot":"","sources":["../../src/hooks/useTeamMembers.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,mBAAmB,EAAE,uBAAuB,EAAE,MAAM,oBAAoB,CAAA;AAEjF,UAAU,qBAAqB;IAC7B;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,OAAO,CAAC,EAAE,qBAAqB;;;;;;;kBAqDP,MAAM;cAAQ,uBAAuB,CAAC,MAAM,CAAC;;;;;EAwCnG"}

package/dist/hooks/useTeamUpdate.d.ts

@@ -0,0 +1,26 @@
+interface TeamUpdatePayload {
+    name?: string;
+    description?: string | null;
+}
+interface TeamUpdateResponse {
+    success: boolean;
+    data?: {
+        id: string;
+        name: string;
+        description: string | null;
+        slug: string;
+        avatarUrl: string | null;
+        ownerId: string;
+        createdAt: string;
+        updatedAt: string;
+    };
+    error?: string;
+    code?: string;
+}
+/**
+ * Hook for updating team name and description (owner only)
+ * Uses TanStack Query mutation with cache invalidation
+ */
+export declare function useTeamUpdate(teamId: string): import("@tanstack/react-query").UseMutationResult<TeamUpdateResponse, Error, TeamUpdatePayload, unknown>;
+export {};
+//# sourceMappingURL=useTeamUpdate.d.ts.map

package/dist/hooks/useTeamUpdate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTeamUpdate.d.ts","sourceRoot":"","sources":["../../src/hooks/useTeamUpdate.ts"],"names":[],"mappings":"AAKA,UAAU,iBAAiB;IACzB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAC5B;AAED,UAAU,kBAAkB;IAC1B,OAAO,EAAE,OAAO,CAAA;IAChB,IAAI,CAAC,EAAE;QACL,EAAE,EAAE,MAAM,CAAA;QACV,IAAI,EAAE,MAAM,CAAA;QACZ,WAAW,EAAE,MAAM,GAAG,IAAI,CAAA;QAC1B,IAAI,EAAE,MAAM,CAAA;QACZ,SAAS,EAAE,MAAM,GAAG,IAAI,CAAA;QACxB,OAAO,EAAE,MAAM,CAAA;QACf,SAAS,EAAE,MAAM,CAAA;QACjB,SAAS,EAAE,MAAM,CAAA;KAClB,CAAA;IACD,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,IAAI,CAAC,EAAE,MAAM,CAAA;CACd;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,4GA8B3C"}