@pol-studios/db 1.0.33 → 1.0.35

package/dist/UserMetadataContext-QLIv-mfF.d.ts

@@ -0,0 +1,171 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as react from 'react';
+import { ReactNode } from 'react';
+import { User } from '@supabase/supabase-js';
+import { D as Database } from './useSupabase-DSZNeXnF.js';
+
+type ProfileStatus = "active" | "archived" | "suspended";
+interface SimpleProfile {
+    id: string;
+    email?: string | null;
+    firstName?: string | null;
+    lastName?: string | null;
+    fullName?: string | null;
+    status?: ProfileStatus | null;
+    profilePath?: string | null;
+    [key: string]: unknown;
+}
+interface SimpleUserAccess {
+    id: string;
+    userId: string;
+    accessKey: string;
+}
+interface SimpleAuthContextValue {
+    /** Supabase user (from auth session) */
+    user: User | null;
+    /** Profile from PowerSync (local SQLite) */
+    profile: SimpleProfile | null;
+    /** Access keys from PowerSync (local SQLite) */
+    accessKeys: string[];
+    /** Whether auth data is loading */
+    isLoading: boolean;
+    /** Whether profile is archived */
+    isArchived: boolean;
+    /** Whether profile is suspended */
+    isSuspended: boolean;
+    /** Profile status */
+    profileStatus: ProfileStatus | undefined;
+    /**
+     * Check if user has access to a resource.
+     * Supports wildcards: *:*:*, project:*:read, project:123:*
+     *
+     * @example
+     * hasAccess("admin") // exact match
+     * hasAccess("project:123:read") // check specific resource
+     */
+    hasAccess: (accessKey: string) => boolean;
+    /** Sign out the user */
+    signOut: () => Promise<void>;
+}
+/**
+ * Maps permission action strings to numeric levels for comparison.
+ * Higher numbers grant more access.
+ */
+declare function getPermissionLevel(action: string): number;
+/**
+ * Check if a user has at least the required permission level for a resource.
+ * Checks all matching access keys and returns true if any grants sufficient access.
+ *
+ * @param accessKeys - User's access keys
+ * @param resourceType - e.g., "project", "client", "database"
+ * @param resourceId - The ID of the resource
+ * @param requiredAction - e.g., "read", "edit", "admin"
+ */
+declare function hasResourceAccess(accessKeys: string[], resourceType: string, resourceId: string, requiredAction: string): boolean;
+interface SimpleAuthProviderProps {
+    children: ReactNode;
+    /** Supabase user from auth session */
+    user: User | null;
+    /** Profile from PowerSync query */
+    profile: SimpleProfile | null;
+    /** User access records from PowerSync query */
+    userAccess: SimpleUserAccess[] | null;
+    /** Whether the data is loading */
+    isLoading?: boolean;
+    /** Sign out function */
+    onSignOut: () => Promise<void>;
+}
+declare function SimpleAuthProvider({ children, user, profile, userAccess, isLoading, onSignOut, }: SimpleAuthProviderProps): react_jsx_runtime.JSX.Element;
+/**
+ * Hook to access auth state and hasAccess function.
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const { user, profile, hasAccess, isLoading } = useSimpleAuth();
+ *
+ *   if (isLoading) return <Loading />;
+ *   if (!user) return <Login />;
+ *
+ *   // Check simple access
+ *   if (hasAccess("admin")) {
+ *     return <AdminPanel />;
+ *   }
+ *
+ *   // Check resource access
+ *   if (hasAccess("project:123:edit")) {
+ *     return <Editor />;
+ *   }
+ *
+ *   return <ReadOnlyView />;
+ * }
+ * ```
+ */
+declare function useSimpleAuth(): SimpleAuthContextValue;
+/**
+ * Hook that requires authentication.
+ * Throws if user is not authenticated.
+ *
+ * @example
+ * ```tsx
+ * function ProtectedComponent() {
+ *   const { user, hasAccess } = useRequireAuth();
+ *   // user is guaranteed to be non-null here
+ * }
+ * ```
+ */
+declare function useRequireAuth(): SimpleAuthContextValue & {
+    user: User;
+};
+/**
+ * Hook to check resource-level access with permission levels.
+ *
+ * @example
+ * ```tsx
+ * function ProjectEditor({ projectId }: { projectId: string }) {
+ *   const canEdit = useResourceAccess("project", projectId, "edit");
+ *   const canDelete = useResourceAccess("project", projectId, "admin");
+ *
+ *   return (
+ *     <div>
+ *       <button disabled={!canEdit}>Edit</button>
+ *       <button disabled={!canDelete}>Delete</button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useResourceAccess(resourceType: string, resourceId: string | number | undefined, requiredAction: string): boolean;
+declare function useCanView(resourceType: string, resourceId: string | number | undefined): boolean;
+declare function useCanEdit(resourceType: string, resourceId: string | number | undefined): boolean;
+declare function useCanDelete(resourceType: string, resourceId: string | number | undefined): boolean;
+declare function useCanShare(resourceType: string, resourceId: string | number | undefined): boolean;
+
+type UserMetadataRow = Database["core"]["Tables"]["UserMetadata"]["Row"];
+type UserMetadataInsert = Database["core"]["Tables"]["UserMetadata"]["Insert"];
+type UserMetadataUpdate = Database["core"]["Tables"]["UserMetadata"]["Update"];
+interface UserMetadataContextType {
+    metadata: Record<string, string>;
+    isLoading: boolean;
+    error: Error | null;
+    setMetadata: (key: string, value: string) => Promise<void>;
+    getMetadata: (key: string) => string | undefined;
+    removeMetadata: (key: string) => Promise<void>;
+    refreshMetadata: () => Promise<void>;
+}
+declare const userMetadataContext: react.Context<UserMetadataContextType>;
+declare function UserMetadataProvider({ children }: {
+    children: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+declare function useUserMetadata(): UserMetadataContextType;
+declare function useUserMetadataValue(key: string): string | undefined;
+declare function useSetUserMetadata(): {
+    setMetadata: (key: string, value: string) => Promise<void>;
+    removeMetadata: (key: string) => Promise<void>;
+};
+declare function useUserMetadataState<T>(key: string, defaultValue: T, options?: {
+    serialize?: (value: T) => string;
+    deserialize?: (value: string) => T;
+}): [T, (value: T) => Promise<void>, boolean];
+
+export { type ProfileStatus as P, SimpleAuthProvider as S, type UserMetadataContextType as U, useRequireAuth as a, useResourceAccess as b, useCanView as c, useCanEdit as d, useCanDelete as e, useCanShare as f, getPermissionLevel as g, hasResourceAccess as h, type SimpleAuthProviderProps as i, type SimpleAuthContextValue as j, type SimpleProfile as k, type SimpleUserAccess as l, useSetUserMetadata as m, useUserMetadata as n, useUserMetadataState as o, useUserMetadataValue as p, userMetadataContext as q, type UserMetadataInsert as r, UserMetadataProvider as s, type UserMetadataRow as t, useSimpleAuth as u, type UserMetadataUpdate as v };

package/dist/auth/context.d.ts

@@ -1,13 +1,61 @@
-export { P as Profile, a as ProfileStatus, S as SetupAuthContext, b as SetupAuthContextProviderProps, s as setupAuthContext } from '../setupAuthContext-B76nbIP6.js';
+export { j as SimpleAuthContextValue, S as SimpleAuthProvider, i as SimpleAuthProviderProps, k as SimpleProfile, P as SimpleProfileStatus, l as SimpleUserAccess, U as UserMetadataContextType, r as UserMetadataInsert, s as UserMetadataProvider, t as UserMetadataRow, v as UserMetadataUpdate, g as getPermissionLevel, h as hasResourceAccess, a as useRequireAuth, b as useResourceAccess, m as useSetUserMetadata, u as useSimpleAuth, e as useSimpleCanDelete, d as useSimpleCanEdit, f as useSimpleCanShare, c as useSimpleCanView, n as useUserMetadata, o as useUserMetadataState, p as useUserMetadataValue, q as userMetadataContext } from '../UserMetadataContext-QLIv-mfF.js';
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import * as react from 'react';
 import { ReactNode } from 'react';
+import { User } from '@supabase/supabase-js';
+export { P as Profile, a as ProfileStatus, S as SetupAuthContext, b as SetupAuthContextProviderProps, s as setupAuthContext } from '../setupAuthContext-B76nbIP6.js';
 import { d as EntityType, b as EntityPermissionCheck, a as EntityAction } from '../EntityPermissions-DwFt4tUd.js';
-export { U as UserMetadataContextType, e as UserMetadataInsert, f as UserMetadataProvider, g as UserMetadataRow, h as UserMetadataUpdate, u as useSetUserMetadata, a as useUserMetadata, b as useUserMetadataState, c as useUserMetadataValue, d as userMetadataContext } from '../UserMetadataContext-yLZQu24J.js';
-import '@supabase/supabase-js';
 import '../useSupabase-DSZNeXnF.js';
 import '@supabase/supabase-js/dist/module/lib/types.js';
 
+interface PowerSyncDB {
+    getAll: <T>(sql: string, params?: any[]) => Promise<T[]>;
+    getOptional: <T>(sql: string, params?: any[]) => Promise<T | null>;
+    watch: (sql: string, params: any[], options: {
+        onResult: (result: any) => void;
+    }, abortOptions?: {
+        signal: AbortSignal;
+    }) => void;
+}
+interface SupabaseClient {
+    auth: {
+        getUser: () => Promise<{
+            data: {
+                user: User | null;
+            };
+            error: any;
+        }>;
+        getSession: () => Promise<{
+            data: {
+                session: {
+                    user: User;
+                } | null;
+            };
+            error: any;
+        }>;
+        signOut: () => Promise<{
+            error: any;
+        }>;
+        onAuthStateChange: (callback: (event: string, session: any) => void) => {
+            data: {
+                subscription: {
+                    unsubscribe: () => void;
+                };
+            };
+        };
+    };
+}
+interface OfflineAuthProviderProps {
+    children: ReactNode;
+    /** PowerSync database instance */
+    db: PowerSyncDB | null;
+    /** Supabase client for auth */
+    supabase: SupabaseClient;
+    /** Whether PowerSync is ready */
+    isDbReady?: boolean;
+}
+declare function OfflineAuthProvider({ children, db, supabase, isDbReady, }: OfflineAuthProviderProps): react_jsx_runtime.JSX.Element;
+
 interface AuthProviderProps {
     children: ReactNode;
     /**
@@ -45,4 +93,4 @@ declare function PermissionProvider({ children }: {
 }): react_jsx_runtime.JSX.Element;
 declare function usePermissions(): PermissionContextValue;
 
-export { AuthProvider, type AuthProviderProps, type EntityPermissionContextValue, type PermissionContextValue, PermissionProvider, entityPermissionContext, permissionContext, usePermissions };
+export { AuthProvider, type AuthProviderProps, type EntityPermissionContextValue, OfflineAuthProvider, type OfflineAuthProviderProps, type PermissionContextValue, PermissionProvider, entityPermissionContext, permissionContext, usePermissions };

package/dist/auth/context.js

@@ -1,3 +1,16 @@
+import {
+  OfflineAuthProvider,
+  SimpleAuthProvider,
+  getPermissionLevel,
+  hasResourceAccess,
+  useCanDelete,
+  useCanEdit,
+  useCanShare,
+  useCanView,
+  useRequireAuth,
+  useResourceAccess,
+  useSimpleAuth
+} from "../chunk-5HJLTYRA.js";
 import {
   AuthProvider,
   PermissionProvider,
@@ -11,7 +24,8 @@ import {
   useUserMetadataState,
   useUserMetadataValue,
   userMetadataContext
-} from "../chunk-E6JL3RUF.js";
+} from "../chunk-YQUNORJD.js";
+import "../chunk-UBHORKBS.js";
 import "../chunk-J4ZVCXZ4.js";
 import "../chunk-YUX6RGLZ.js";
 import "../chunk-AKIRHA4Q.js";
@@ -19,13 +33,24 @@ import "../chunk-DMVUEJG2.js";
 import "../chunk-7D4SUZUM.js";
 export {
   AuthProvider,
+  OfflineAuthProvider,
   PermissionProvider,
+  SimpleAuthProvider,
   UserMetadataProvider,
   entityPermissionContext,
+  getPermissionLevel,
+  hasResourceAccess,
   permissionContext,
   setupAuthContext,
   usePermissions,
+  useRequireAuth,
+  useResourceAccess,
   useSetUserMetadata,
+  useSimpleAuth,
+  useCanDelete as useSimpleCanDelete,
+  useCanEdit as useSimpleCanEdit,
+  useCanShare as useSimpleCanShare,
+  useCanView as useSimpleCanView,
   useUserMetadata,
   useUserMetadataState,
   useUserMetadataValue,

package/dist/auth/hooks.d.ts

@@ -1,12 +1,116 @@
 import { User } from '@supabase/supabase-js';
+import { k as SimpleProfile, l as SimpleUserAccess } from '../UserMetadataContext-QLIv-mfF.js';
+export { m as useSetUserMetadata, n as useUserMetadata, o as useUserMetadataState, p as useUserMetadataValue } from '../UserMetadataContext-QLIv-mfF.js';
 import { S as SetupAuthContext, E as EffectivePermission } from '../setupAuthContext-B76nbIP6.js';
 import { d as EntityType, a as EntityAction, b as EntityPermissionCheck } from '../EntityPermissions-DwFt4tUd.js';
-export { u as useSetUserMetadata, a as useUserMetadata, b as useUserMetadataState, c as useUserMetadataValue } from '../UserMetadataContext-yLZQu24J.js';
-import 'react';
 import 'react/jsx-runtime';
+import 'react';
 import '../useSupabase-DSZNeXnF.js';
 import '@supabase/supabase-js/dist/module/lib/types.js';
 
+/**
+ * useOfflineAuth - Hook for offline-first authentication
+ *
+ * Reads Profile and UserAccess from PowerSync (local SQLite).
+ * Works 100% offline once data is synced.
+ *
+ * Usage:
+ * ```tsx
+ * import { SimpleAuthProvider } from "@pol-studios/db";
+ * import { useOfflineAuth } from "@pol-studios/db";
+ *
+ * function AuthWrapper({ children }) {
+ *   const authData = useOfflineAuth();
+ *
+ *   return (
+ *     <SimpleAuthProvider {...authData}>
+ *       {children}
+ *     </SimpleAuthProvider>
+ *   );
+ * }
+ * ```
+ */
+
+interface OfflineAuthData {
+    /** Supabase user from auth session */
+    user: User | null;
+    /** Profile from PowerSync */
+    profile: SimpleProfile | null;
+    /** User access records from PowerSync */
+    userAccess: SimpleUserAccess[] | null;
+    /** Whether auth data is loading */
+    isLoading: boolean;
+    /** Sign out function */
+    onSignOut: () => Promise<void>;
+}
+interface UseOfflineAuthOptions {
+    /** Supabase client for auth operations */
+    supabase: {
+        auth: {
+            getUser: () => Promise<{
+                data: {
+                    user: User | null;
+                };
+                error: any;
+            }>;
+            signOut: () => Promise<{
+                error: any;
+            }>;
+            onAuthStateChange: (callback: (event: string, session: any) => void) => {
+                data: {
+                    subscription: {
+                        unsubscribe: () => void;
+                    };
+                };
+            };
+        };
+    };
+    /** PowerSync database for local queries */
+    db: {
+        getAll: <T>(sql: string, params?: any[]) => Promise<T[]>;
+        getOptional: <T>(sql: string, params?: any[]) => Promise<T | null>;
+    } | null;
+    /** Whether PowerSync is ready */
+    isDbReady?: boolean;
+}
+/**
+ * Query keys for React Query integration
+ */
+declare const offlineAuthQueryKeys: {
+    profile: (userId: string | undefined) => readonly ["profile", string];
+    userAccess: (userId: string | undefined) => readonly ["userAccess", string];
+};
+/**
+ * Query functions for React Query integration.
+ * Use these with useQuery from @tanstack/react-query.
+ *
+ * @example
+ * ```tsx
+ * import { useQuery } from "@tanstack/react-query";
+ * import { offlineAuthQueries, offlineAuthQueryKeys } from "@pol-studios/db";
+ *
+ * function useProfile(db, userId) {
+ *   return useQuery({
+ *     queryKey: offlineAuthQueryKeys.profile(userId),
+ *     queryFn: () => offlineAuthQueries.fetchProfile(db, userId),
+ *     enabled: !!userId && !!db,
+ *   });
+ * }
+ * ```
+ */
+declare const offlineAuthQueries: {
+    fetchProfile(db: {
+        getOptional: <T>(sql: string, params?: any[]) => Promise<T | null>;
+    }, userId: string): Promise<SimpleProfile | null>;
+    fetchUserAccess(db: {
+        getAll: <T>(sql: string, params?: any[]) => Promise<T[]>;
+    }, userId: string): Promise<SimpleUserAccess[]>;
+};
+/**
+ * Extract access keys from UserAccess records.
+ */
+declare function extractAccessKeys(userAccess: SimpleUserAccess[] | null): string[];
+
 /**
  * Hook for authenticated users only.
  * Throws an error if the user is not authenticated.
@@ -310,4 +414,4 @@ declare function useInvalidatePermission(): (entityType: EntityType, entityId: n
  */
 declare function usePermissionLoading(): boolean;
 
-export { EntityAction, EntityPermissionCheck, EntityType, type EntityWithPermission, useAuth, useCanCreate, useCanDelete, useCanEdit, useCanShare, useCanView, useInvalidatePermission, usePermission, usePermissionCheck, usePermissionLoading, usePermissionsBatch, useSetupAuth };
+export { EntityAction, EntityPermissionCheck, EntityType, type EntityWithPermission, type OfflineAuthData, type UseOfflineAuthOptions, extractAccessKeys, offlineAuthQueries, offlineAuthQueryKeys, useAuth, useCanCreate, useCanDelete, useCanEdit, useCanShare, useCanView, useInvalidatePermission, usePermission, usePermissionCheck, usePermissionLoading, usePermissionsBatch, useSetupAuth };

package/dist/auth/hooks.js

@@ -1,4 +1,7 @@
 import {
+  extractAccessKeys,
+  offlineAuthQueries,
+  offlineAuthQueryKeys,
   useAuth,
   useCanCreate,
   useCanDelete,
@@ -11,19 +14,23 @@ import {
   usePermissionLoading,
   usePermissionsBatch,
   useSetupAuth
-} from "../chunk-PNC6CG5U.js";
+} from "../chunk-7NFMEDJW.js";
 import {
   useSetUserMetadata,
   useUserMetadata,
   useUserMetadataState,
   useUserMetadataValue
-} from "../chunk-E6JL3RUF.js";
+} from "../chunk-YQUNORJD.js";
+import "../chunk-UBHORKBS.js";
 import "../chunk-J4ZVCXZ4.js";
 import "../chunk-YUX6RGLZ.js";
 import "../chunk-AKIRHA4Q.js";
 import "../chunk-DMVUEJG2.js";
 import "../chunk-7D4SUZUM.js";
 export {
+  extractAccessKeys,
+  offlineAuthQueries,
+  offlineAuthQueryKeys,
   useAuth,
   useCanCreate,
   useCanDelete,

package/dist/auth/index.d.ts

@@ -1,11 +1,11 @@
-export { EntityWithPermission, useAuth, useCanCreate, useCanDelete, useCanEdit, useCanShare, useCanView, useInvalidatePermission, usePermission, usePermissionCheck, usePermissionLoading, usePermissionsBatch, useSetupAuth } from './hooks.js';
+export { j as SimpleAuthContextValue, S as SimpleAuthProvider, i as SimpleAuthProviderProps, k as SimpleProfile, P as SimpleProfileStatus, l as SimpleUserAccess, U as UserMetadataContextType, r as UserMetadataInsert, s as UserMetadataProvider, t as UserMetadataRow, v as UserMetadataUpdate, g as getPermissionLevel, h as hasResourceAccess, a as useRequireAuth, b as useResourceAccess, m as useSetUserMetadata, u as useSimpleAuth, e as useSimpleCanDelete, d as useSimpleCanEdit, f as useSimpleCanShare, c as useSimpleCanView, n as useUserMetadata, o as useUserMetadataState, p as useUserMetadataValue, q as userMetadataContext } from '../UserMetadataContext-QLIv-mfF.js';
+export { EntityWithPermission, OfflineAuthData, UseOfflineAuthOptions, extractAccessKeys, offlineAuthQueries, offlineAuthQueryKeys, useAuth, useCanCreate, useCanDelete, useCanEdit, useCanShare, useCanView, useInvalidatePermission, usePermission, usePermissionCheck, usePermissionLoading, usePermissionsBatch, useSetupAuth } from './hooks.js';
+export { AuthProvider, AuthProviderProps, EntityPermissionContextValue, OfflineAuthProvider, OfflineAuthProviderProps, PermissionContextValue, PermissionProvider, entityPermissionContext, permissionContext, usePermissions } from './context.js';
 export { P as Profile, a as ProfileStatus, S as SetupAuthContext, b as SetupAuthContextProviderProps, s as setupAuthContext } from '../setupAuthContext-B76nbIP6.js';
-export { AuthProvider, AuthProviderProps, EntityPermissionContextValue, PermissionContextValue, PermissionProvider, entityPermissionContext, permissionContext, usePermissions } from './context.js';
-export { U as UserMetadataContextType, e as UserMetadataInsert, f as UserMetadataProvider, g as UserMetadataRow, h as UserMetadataUpdate, u as useSetUserMetadata, a as useUserMetadata, b as useUserMetadataState, c as useUserMetadataValue, d as userMetadataContext } from '../UserMetadataContext-yLZQu24J.js';
 export { hasAccess, hasAllAccess, hasAllEntityAccess, hasAnyAccess, hasAnyEntityAccess, hasEntityAccess, isEntityAccessDenied, isPermissionLoaded } from './guards.js';
 export { E as EntityAccessRecord, a as EntityAction, b as EntityPermissionCheck, c as EntityPermissionLevel, d as EntityType, P as PermissionEffect } from '../EntityPermissions-DwFt4tUd.js';
-import '@supabase/supabase-js';
-import 'react';
 import 'react/jsx-runtime';
+import 'react';
+import '@supabase/supabase-js';
 import '../useSupabase-DSZNeXnF.js';
 import '@supabase/supabase-js/dist/module/lib/types.js';

package/dist/auth/index.js

@@ -1,18 +1,34 @@
-import "../chunk-NSIAAYW3.js";
+import "../chunk-6KN7KLEG.js";
 import {
-  useAuth,
-  useCanCreate,
+  OfflineAuthProvider,
+  SimpleAuthProvider,
+  getPermissionLevel,
+  hasResourceAccess,
   useCanDelete,
   useCanEdit,
   useCanShare,
   useCanView,
+  useRequireAuth,
+  useResourceAccess,
+  useSimpleAuth
+} from "../chunk-5HJLTYRA.js";
+import {
+  extractAccessKeys,
+  offlineAuthQueries,
+  offlineAuthQueryKeys,
+  useAuth,
+  useCanCreate,
+  useCanDelete as useCanDelete2,
+  useCanEdit as useCanEdit2,
+  useCanShare as useCanShare2,
+  useCanView as useCanView2,
   useInvalidatePermission,
   usePermission,
   usePermissionCheck,
   usePermissionLoading,
   usePermissionsBatch,
   useSetupAuth
-} from "../chunk-PNC6CG5U.js";
+} from "../chunk-7NFMEDJW.js";
 import {
   AuthProvider,
   PermissionProvider,
@@ -26,7 +42,8 @@ import {
   useUserMetadataState,
   useUserMetadataValue,
   userMetadataContext
-} from "../chunk-E6JL3RUF.js";
+} from "../chunk-YQUNORJD.js";
+import "../chunk-UBHORKBS.js";
 import {
   hasAccess,
   hasAllAccess,
@@ -44,33 +61,47 @@ import "../chunk-DMVUEJG2.js";
 import "../chunk-7D4SUZUM.js";
 export {
   AuthProvider,
+  OfflineAuthProvider,
   PermissionProvider,
+  SimpleAuthProvider,
   UserMetadataProvider,
   entityPermissionContext,
+  extractAccessKeys,
+  getPermissionLevel,
   hasAccess,
   hasAllAccess,
   hasAllEntityAccess,
   hasAnyAccess,
   hasAnyEntityAccess,
   hasEntityAccess,
+  hasResourceAccess,
   isEntityAccessDenied,
   isPermissionLoaded,
+  offlineAuthQueries,
+  offlineAuthQueryKeys,
   permissionContext,
   setupAuthContext,
   useAuth,
   useCanCreate,
-  useCanDelete,
-  useCanEdit,
-  useCanShare,
-  useCanView,
+  useCanDelete2 as useCanDelete,
+  useCanEdit2 as useCanEdit,
+  useCanShare2 as useCanShare,
+  useCanView2 as useCanView,
   useInvalidatePermission,
   usePermission,
   usePermissionCheck,
   usePermissionLoading,
   usePermissions,
   usePermissionsBatch,
+  useRequireAuth,
+  useResourceAccess,
   useSetUserMetadata,
   useSetupAuth,
+  useSimpleAuth,
+  useCanDelete as useSimpleCanDelete,
+  useCanEdit as useSimpleCanEdit,
+  useCanShare as useSimpleCanShare,
+  useCanView as useSimpleCanView,
   useUserMetadata,
   useUserMetadataState,
   useUserMetadataValue,