@safercity/sdk-react 0.1.2 → 0.2.0

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { ProxyModeConfig, DirectModeConfig, CookieModeConfig, SaferCityClientOptions, SaferCityClient, AuthMode, ApiResponse, SaferCityApiError, ServerSentEvent } from '@safercity/sdk';
+import { ProxyModeConfig, DirectModeConfig, CookieModeConfig, SaferCityClientOptions, SaferCityClient, AuthMode, ApiResponse, SaferCityApiError, PanicInformationRecord, ServerSentEvent } from '@safercity/sdk';
 export * from '@safercity/sdk';
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import { ReactNode } from 'react';
@@ -46,11 +46,13 @@ interface ProxyModeProviderProps extends BaseProviderProps, ProxyModeConfig {
  * Props for direct mode
  */
 interface DirectModeProviderProps extends BaseProviderProps, DirectModeConfig {
+    userId?: string;
 }
 /**
  * Props for cookie mode
  */
 interface CookieModeProviderProps extends BaseProviderProps, CookieModeConfig {
+    userId?: string;
 }
 /**
  * Legacy props (for backward compatibility)
@@ -127,20 +129,34 @@ declare const saferCityKeys: {
     auth: () => readonly ["safercity", "auth"];
     authWhoami: () => readonly ["safercity", "auth", "whoami"];
     users: () => readonly ["safercity", "users"];
-    usersList: (filters?: Record<string, unknown>) => readonly ["safercity", "users", "list", Record<string, unknown> | undefined];
     usersDetail: (userId: string) => readonly ["safercity", "users", "detail", string];
     panics: () => readonly ["safercity", "panics"];
     panicsList: (filters?: Record<string, unknown>) => readonly ["safercity", "panics", "list", Record<string, unknown> | undefined];
     panicsDetail: (panicId: string) => readonly ["safercity", "panics", "detail", string];
+    panicTypes: (userId: string) => readonly ["safercity", "panics", "types", string];
+    panicInformation: () => readonly ["safercity", "panicInformation"];
+    panicInformationDetail: (id: string) => readonly ["safercity", "panicInformation", "detail", string];
+    panicInformationByUser: (userId: string) => readonly ["safercity", "panicInformation", "byUser", string];
+    panicEligibility: (userId: string) => readonly ["safercity", "panicInformation", "eligibility", string];
     subscriptions: () => readonly ["safercity", "subscriptions"];
     subscriptionsList: (filters?: Record<string, unknown>) => readonly ["safercity", "subscriptions", "list", Record<string, unknown> | undefined];
     subscriptionsTypes: () => readonly ["safercity", "subscriptions", "types"];
     subscriptionsStats: () => readonly ["safercity", "subscriptions", "stats"];
     locationSafety: (lat: number, lng: number) => readonly ["safercity", "location-safety", number, number];
+    banner: (body: {
+        latitude: number;
+        longitude: number;
+        radius?: number;
+    }) => readonly ["safercity", "banner", {
+        latitude: number;
+        longitude: number;
+        radius?: number;
+    }];
     crimes: () => readonly ["safercity", "crimes"];
     crimesList: (filters?: Record<string, unknown>) => readonly ["safercity", "crimes", "list", Record<string, unknown> | undefined];
     crimesCategories: () => readonly ["safercity", "crimes", "categories"];
     crimesTypes: () => readonly ["safercity", "crimes", "types"];
+    crimeCategoriesWithTypes: () => readonly ["safercity", "crimes", "categoriesWithTypes"];
 };
 declare function useHealthCheck(options?: Omit<UseQueryOptions<ApiResponse<{
     status: string;
@@ -160,29 +176,6 @@ declare function useWhoAmI(options?: Omit<UseQueryOptions<ApiResponse<{
     scopes: string[];
     sessionId: string;
 }>, SaferCityApiError>;
-declare function useUsers(filters?: {
-    limit?: number;
-    cursor?: string;
-    status?: string;
-}, options?: Omit<UseQueryOptions<ApiResponse<{
-    users: Array<{
-        id: string;
-        email?: string;
-        phone?: string;
-        status: string;
-    }>;
-    hasNext: boolean;
-    cursor?: string;
-}>, SaferCityApiError>, 'queryKey' | 'queryFn'>): _tanstack_react_query.UseQueryResult<ApiResponse<{
-    users: Array<{
-        id: string;
-        email?: string;
-        phone?: string;
-        status: string;
-    }>;
-    hasNext: boolean;
-    cursor?: string;
-}>, SaferCityApiError>;
 declare function useUser(userId: string, options?: Omit<UseQueryOptions<ApiResponse<{
     id: string;
     email?: string;
@@ -244,35 +237,6 @@ declare function useUpdateUser(options?: UseMutationOptions<ApiResponse<{
         metadata?: Record<string, unknown>;
     };
 }, unknown>;
-declare function useDeleteUser(options?: UseMutationOptions<ApiResponse<{
-    success: boolean;
-}>, SaferCityApiError, string>): _tanstack_react_query.UseMutationResult<ApiResponse<{
-    success: boolean;
-}>, SaferCityApiError, string, unknown>;
-declare function usePanics(filters?: {
-    userId?: string;
-    status?: string;
-    limit?: number;
-    cursor?: string;
-}, options?: Omit<UseQueryOptions<ApiResponse<{
-    panics: Array<{
-        id: string;
-        userId: string;
-        status: string;
-        createdAt: string;
-    }>;
-    hasNext: boolean;
-    cursor?: string;
-}>, SaferCityApiError>, 'queryKey' | 'queryFn'>): _tanstack_react_query.UseQueryResult<ApiResponse<{
-    panics: Array<{
-        id: string;
-        userId: string;
-        status: string;
-        createdAt: string;
-    }>;
-    hasNext: boolean;
-    cursor?: string;
-}>, SaferCityApiError>;
 declare function usePanic(panicId: string, query?: {
     userId?: string;
 }, options?: Omit<UseQueryOptions<ApiResponse<{
@@ -361,6 +325,137 @@ declare function useCancelPanic(options?: UseMutationOptions<ApiResponse<{
         reason?: string;
     };
 }, unknown>;
+declare function usePanicTypes(userId: string, options?: Omit<UseQueryOptions<ApiResponse<{
+    types: Array<{
+        id: string;
+        name: string;
+        description?: string;
+    }>;
+}>, SaferCityApiError>, 'queryKey' | 'queryFn'>): _tanstack_react_query.UseQueryResult<ApiResponse<{
+    types: Array<{
+        id: string;
+        name: string;
+        description?: string;
+    }>;
+}>, SaferCityApiError>;
+declare function usePanicInformation(id: string, options?: Omit<UseQueryOptions<ApiResponse<{
+    success: boolean;
+    data: PanicInformationRecord;
+}>, SaferCityApiError>, 'queryKey' | 'queryFn'>): _tanstack_react_query.UseQueryResult<ApiResponse<{
+    success: boolean;
+    data: PanicInformationRecord;
+}>, SaferCityApiError>;
+declare function usePanicInformationByUser(userId: string, options?: Omit<UseQueryOptions<ApiResponse<{
+    success: boolean;
+    data: PanicInformationRecord;
+}>, SaferCityApiError>, 'queryKey' | 'queryFn'>): _tanstack_react_query.UseQueryResult<ApiResponse<{
+    success: boolean;
+    data: PanicInformationRecord;
+}>, SaferCityApiError>;
+declare function usePanicEligibility(userId: string, options?: Omit<UseQueryOptions<ApiResponse<{
+    success: boolean;
+    data: {
+        eligible: boolean;
+        subscriptionActive: boolean;
+        profileComplete: boolean;
+        reasons: string[];
+        panicInformation: PanicInformationRecord | null;
+        subscriptionDetails: {
+            usedSeats: number;
+            userHasActiveSubscription: boolean;
+        } | null;
+    };
+}>, SaferCityApiError>, 'queryKey' | 'queryFn'>): _tanstack_react_query.UseQueryResult<ApiResponse<{
+    success: boolean;
+    data: {
+        eligible: boolean;
+        subscriptionActive: boolean;
+        profileComplete: boolean;
+        reasons: string[];
+        panicInformation: PanicInformationRecord | null;
+        subscriptionDetails: {
+            usedSeats: number;
+            userHasActiveSubscription: boolean;
+        } | null;
+    };
+}>, SaferCityApiError>;
+declare function useCreatePanicInformation(options?: UseMutationOptions<ApiResponse<{
+    success: boolean;
+    data: PanicInformationRecord;
+    message: string;
+}>, SaferCityApiError, {
+    userId: string;
+    phoneNumber: string;
+    firstName: string;
+    lastName: string;
+    idNumber: string;
+    duressCode?: string;
+    emergencyContacts?: Array<{
+        name: string;
+        phoneNumber: string;
+        relationship?: string;
+    }>;
+}>): _tanstack_react_query.UseMutationResult<ApiResponse<{
+    success: boolean;
+    data: PanicInformationRecord;
+    message: string;
+}>, SaferCityApiError, {
+    userId: string;
+    phoneNumber: string;
+    firstName: string;
+    lastName: string;
+    idNumber: string;
+    duressCode?: string;
+    emergencyContacts?: Array<{
+        name: string;
+        phoneNumber: string;
+        relationship?: string;
+    }>;
+}, unknown>;
+declare function useUpdatePanicInformation(options?: UseMutationOptions<ApiResponse<{
+    success: boolean;
+    data: PanicInformationRecord;
+    message: string;
+}>, SaferCityApiError, {
+    id: string;
+    data: {
+        phoneNumber?: string;
+        firstName?: string;
+        lastName?: string;
+        idNumber?: string;
+        duressCode?: string;
+        emergencyContacts?: Array<{
+            name: string;
+            phoneNumber: string;
+            relationship?: string;
+        }>;
+    };
+}>): _tanstack_react_query.UseMutationResult<ApiResponse<{
+    success: boolean;
+    data: PanicInformationRecord;
+    message: string;
+}>, SaferCityApiError, {
+    id: string;
+    data: {
+        phoneNumber?: string;
+        firstName?: string;
+        lastName?: string;
+        idNumber?: string;
+        duressCode?: string;
+        emergencyContacts?: Array<{
+            name: string;
+            phoneNumber: string;
+            relationship?: string;
+        }>;
+    };
+}, unknown>;
+declare function useDeletePanicInformation(options?: UseMutationOptions<ApiResponse<{
+    success: boolean;
+    message: string;
+}>, SaferCityApiError, string>): _tanstack_react_query.UseMutationResult<ApiResponse<{
+    success: boolean;
+    message: string;
+}>, SaferCityApiError, string, unknown>;
 declare function useSubscriptionTypes(options?: Omit<UseQueryOptions<ApiResponse<{
     types: Array<{
         id: string;
@@ -395,15 +490,6 @@ declare function useSubscriptions(filters?: {
         status: string;
     }>;
 }>, SaferCityApiError>;
-declare function useSubscriptionStats(options?: Omit<UseQueryOptions<ApiResponse<{
-    total: number;
-    active: number;
-    byType: Record<string, number>;
-}>, SaferCityApiError>, 'queryKey' | 'queryFn'>): _tanstack_react_query.UseQueryResult<ApiResponse<{
-    total: number;
-    active: number;
-    byType: Record<string, number>;
-}>, SaferCityApiError>;
 declare function useCreateSubscription(options?: UseMutationOptions<ApiResponse<{
     id: string;
     userId: string;
@@ -423,6 +509,38 @@ declare function useCreateSubscription(options?: UseMutationOptions<ApiResponse<
     subscriptionTypeId: string;
     status?: string;
 }, unknown>;
+declare function useSubscribeUser(options?: UseMutationOptions<ApiResponse<{
+    id: string;
+    userId: string;
+    subscriptionTypeId: string;
+    status: string;
+}>, SaferCityApiError, {
+    userId: string;
+    subscriptionTypeId: string;
+}>): _tanstack_react_query.UseMutationResult<ApiResponse<{
+    id: string;
+    userId: string;
+    subscriptionTypeId: string;
+    status: string;
+}>, SaferCityApiError, {
+    userId: string;
+    subscriptionTypeId: string;
+}, unknown>;
+declare function useBulkTriggerNotifications(options?: UseMutationOptions<ApiResponse<{
+    transactionIds: string[];
+    status: string;
+}>, SaferCityApiError, {
+    userIds: string[];
+    workflowId: string;
+    payload?: Record<string, unknown>;
+}>): _tanstack_react_query.UseMutationResult<ApiResponse<{
+    transactionIds: string[];
+    status: string;
+}>, SaferCityApiError, {
+    userIds: string[];
+    workflowId: string;
+    payload?: Record<string, unknown>;
+}, unknown>;
 declare function useLocationSafety(latitude: number, longitude: number, radius?: number, options?: Omit<UseQueryOptions<ApiResponse<{
     safetyScore: number;
     riskLevel: string;
@@ -438,6 +556,31 @@ declare function useLocationSafety(latitude: number, longitude: number, radius?:
         impact: number;
     }>;
 }>, SaferCityApiError>;
+declare function useBanner(body: {
+    latitude: number;
+    longitude: number;
+    radius?: number;
+}, options?: Omit<UseQueryOptions<ApiResponse<{
+    success: boolean;
+    data: {
+        totalCrimes: number;
+        categories: Array<{
+            name: string;
+            count: number;
+        }>;
+        period: string;
+    };
+}>, SaferCityApiError>, 'queryKey' | 'queryFn'>): _tanstack_react_query.UseQueryResult<ApiResponse<{
+    success: boolean;
+    data: {
+        totalCrimes: number;
+        categories: Array<{
+            name: string;
+            count: number;
+        }>;
+        period: string;
+    };
+}>, SaferCityApiError>;
 declare function useCrimes(filters?: {
     latitude?: number;
     longitude?: number;
@@ -487,6 +630,25 @@ declare function useCrimeTypes(options?: Omit<UseQueryOptions<ApiResponse<{
         categoryId: string;
     }>;
 }>, SaferCityApiError>;
+declare function useCrimeCategoriesWithTypes(options?: Omit<UseQueryOptions<ApiResponse<{
+    categories: Array<{
+        id: string;
+        name: string;
+        types: Array<{
+            id: string;
+            name: string;
+        }>;
+    }>;
+}>, SaferCityApiError>, 'queryKey' | 'queryFn'>): _tanstack_react_query.UseQueryResult<ApiResponse<{
+    categories: Array<{
+        id: string;
+        name: string;
+        types: Array<{
+            id: string;
+            name: string;
+        }>;
+    }>;
+}>, SaferCityApiError>;
 
 /**
  * State for streaming hooks
@@ -619,4 +781,4 @@ declare function useStream<T = ServerSentEvent>(createStream: () => AsyncIterabl
     error: Error | null;
 };
 
-export { type CookieModeProviderProps, type DirectModeProviderProps, type ProxyModeProviderProps, SaferCityProvider, type SaferCityProviderProps, type SessionState, type StreamState, type UseStreamOptions, saferCityKeys, useAuthMode, useCancelPanic, useCreatePanic, useCreateSubscription, useCreateUser, useCrimeCategories, useCrimeTypes, useCrimes, useDeleteUser, useHealthCheck, useLocationSafety, usePanic, usePanicStream, usePanics, useSaferCity, useSaferCityClient, useSession, useSessionManager, useStream, useSubscriptionStats, useSubscriptionTypes, useSubscriptions, useUpdatePanicLocation, useUpdateUser, useUser, useUsers, useWhoAmI };
+export { type CookieModeProviderProps, type DirectModeProviderProps, type ProxyModeProviderProps, SaferCityProvider, type SaferCityProviderProps, type SessionState, type StreamState, type UseStreamOptions, saferCityKeys, useAuthMode, useBanner, useBulkTriggerNotifications, useCancelPanic, useCreatePanic, useCreatePanicInformation, useCreateSubscription, useCreateUser, useCrimeCategories, useCrimeCategoriesWithTypes, useCrimeTypes, useCrimes, useDeletePanicInformation, useHealthCheck, useLocationSafety, usePanic, usePanicEligibility, usePanicInformation, usePanicInformationByUser, usePanicStream, usePanicTypes, useSaferCity, useSaferCityClient, useSession, useSessionManager, useStream, useSubscribeUser, useSubscriptionTypes, useSubscriptions, useUpdatePanicInformation, useUpdatePanicLocation, useUpdateUser, useUser, useWhoAmI };

package/dist/index.js

@@ -48,13 +48,15 @@ function SaferCityProvider(props) {
     if (isDirectMode(props)) {
       return createSaferCityClient({
         baseUrl: props.baseUrl,
-        tenantId: props.tenantId
+        tenantId: props.tenantId,
+        userId: props.userId
       });
     }
     if (isCookieMode(props)) {
       return createSaferCityClient({
         baseUrl: props.baseUrl,
         tenantId: props.tenantId,
+        userId: props.userId,
         headers: {
           // Note: cookies are sent automatically with fetch credentials: 'include'
         }
@@ -91,6 +93,7 @@ function SaferCityProvider(props) {
         if (!isMounted) return;
         if (response.ok) {
           const data = await response.json();
+          client.setUserId(data.userId);
           setSession({
             isAuthenticated: data.authenticated,
             isLoading: false,
@@ -117,7 +120,7 @@ function SaferCityProvider(props) {
     return () => {
       isMounted = false;
     };
-  }, [mode, props]);
+  }, [mode, props, client]);
   const createSession = useCallback(async (token, tenantId) => {
     if (mode !== "cookie" || !isCookieMode(props)) {
       throw new Error("createSession is only available in cookie mode");
@@ -252,12 +255,17 @@ var saferCityKeys = {
   authWhoami: () => [...saferCityKeys.auth(), "whoami"],
   // Users
   users: () => [...saferCityKeys.all, "users"],
-  usersList: (filters) => [...saferCityKeys.users(), "list", filters],
   usersDetail: (userId) => [...saferCityKeys.users(), "detail", userId],
   // Panics
   panics: () => [...saferCityKeys.all, "panics"],
   panicsList: (filters) => [...saferCityKeys.panics(), "list", filters],
   panicsDetail: (panicId) => [...saferCityKeys.panics(), "detail", panicId],
+  panicTypes: (userId) => [...saferCityKeys.panics(), "types", userId],
+  // Panic Information
+  panicInformation: () => [...saferCityKeys.all, "panicInformation"],
+  panicInformationDetail: (id) => [...saferCityKeys.panicInformation(), "detail", id],
+  panicInformationByUser: (userId) => [...saferCityKeys.panicInformation(), "byUser", userId],
+  panicEligibility: (userId) => [...saferCityKeys.panicInformation(), "eligibility", userId],
   // Subscriptions
   subscriptions: () => [...saferCityKeys.all, "subscriptions"],
   subscriptionsList: (filters) => [...saferCityKeys.subscriptions(), "list", filters],
@@ -265,11 +273,14 @@ var saferCityKeys = {
   subscriptionsStats: () => [...saferCityKeys.subscriptions(), "stats"],
   // Location Safety
   locationSafety: (lat, lng) => [...saferCityKeys.all, "location-safety", lat, lng],
+  // Banner
+  banner: (body) => [...saferCityKeys.all, "banner", body],
   // Crimes
   crimes: () => [...saferCityKeys.all, "crimes"],
   crimesList: (filters) => [...saferCityKeys.crimes(), "list", filters],
   crimesCategories: () => [...saferCityKeys.crimes(), "categories"],
-  crimesTypes: () => [...saferCityKeys.crimes(), "types"]
+  crimesTypes: () => [...saferCityKeys.crimes(), "types"],
+  crimeCategoriesWithTypes: () => [...saferCityKeys.crimes(), "categoriesWithTypes"]
 };
 function useHealthCheck(options) {
   const client = useSaferCityClient();
@@ -287,14 +298,6 @@ function useWhoAmI(options) {
     ...options
   });
 }
-function useUsers(filters, options) {
-  const client = useSaferCityClient();
-  return useQuery({
-    queryKey: saferCityKeys.usersList(filters),
-    queryFn: () => client.users.list(filters),
-    ...options
-  });
-}
 function useUser(userId, options) {
   const client = useSaferCityClient();
   return useQuery({
@@ -322,30 +325,10 @@ function useUpdateUser(options) {
     mutationFn: ({ userId, data }) => client.users.update(userId, data),
     onSuccess: (_, { userId }) => {
       queryClient.invalidateQueries({ queryKey: saferCityKeys.usersDetail(userId) });
-      queryClient.invalidateQueries({ queryKey: saferCityKeys.usersList() });
     },
     ...options
   });
 }
-function useDeleteUser(options) {
-  const client = useSaferCityClient();
-  const queryClient = useQueryClient();
-  return useMutation({
-    mutationFn: (userId) => client.users.delete(userId),
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: saferCityKeys.users() });
-    },
-    ...options
-  });
-}
-function usePanics(filters, options) {
-  const client = useSaferCityClient();
-  return useQuery({
-    queryKey: saferCityKeys.panicsList(filters),
-    queryFn: () => client.panics.list(filters),
-    ...options
-  });
-}
 function usePanic(panicId, query, options) {
   const client = useSaferCityClient();
   return useQuery({
@@ -389,6 +372,77 @@ function useCancelPanic(options) {
     ...options
   });
 }
+function usePanicTypes(userId, options) {
+  const client = useSaferCityClient();
+  return useQuery({
+    queryKey: saferCityKeys.panicTypes(userId),
+    queryFn: () => client.panics.types(userId),
+    enabled: !!userId,
+    staleTime: 1e3 * 60 * 10,
+    // 10 minutes - types don't change often
+    ...options
+  });
+}
+function usePanicInformation(id, options) {
+  const client = useSaferCityClient();
+  return useQuery({
+    queryKey: saferCityKeys.panicInformationDetail(id),
+    queryFn: () => client.panicInformation.get(id),
+    enabled: !!id,
+    ...options
+  });
+}
+function usePanicInformationByUser(userId, options) {
+  const client = useSaferCityClient();
+  return useQuery({
+    queryKey: saferCityKeys.panicInformationByUser(userId),
+    queryFn: () => client.panicInformation.getByUser(userId),
+    enabled: !!userId,
+    ...options
+  });
+}
+function usePanicEligibility(userId, options) {
+  const client = useSaferCityClient();
+  return useQuery({
+    queryKey: saferCityKeys.panicEligibility(userId),
+    queryFn: () => client.panicInformation.validateEligibility(userId),
+    enabled: !!userId,
+    ...options
+  });
+}
+function useCreatePanicInformation(options) {
+  const client = useSaferCityClient();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (data) => client.panicInformation.create(data),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: saferCityKeys.panicInformation() });
+    },
+    ...options
+  });
+}
+function useUpdatePanicInformation(options) {
+  const client = useSaferCityClient();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: ({ id, data }) => client.panicInformation.update(id, data),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: saferCityKeys.panicInformation() });
+    },
+    ...options
+  });
+}
+function useDeletePanicInformation(options) {
+  const client = useSaferCityClient();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (id) => client.panicInformation.delete(id),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: saferCityKeys.panicInformation() });
+    },
+    ...options
+  });
+}
 function useSubscriptionTypes(options) {
   const client = useSaferCityClient();
   return useQuery({
@@ -407,25 +461,35 @@ function useSubscriptions(filters, options) {
     ...options
   });
 }
-function useSubscriptionStats(options) {
+function useCreateSubscription(options) {
   const client = useSaferCityClient();
-  return useQuery({
-    queryKey: saferCityKeys.subscriptionsStats(),
-    queryFn: () => client.subscriptions.stats(),
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (data) => client.subscriptions.create(data),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: saferCityKeys.subscriptions() });
+    },
     ...options
   });
 }
-function useCreateSubscription(options) {
+function useSubscribeUser(options) {
   const client = useSaferCityClient();
   const queryClient = useQueryClient();
   return useMutation({
-    mutationFn: (data) => client.subscriptions.create(data),
+    mutationFn: (body) => client.subscriptions.subscribeUser(body),
     onSuccess: () => {
       queryClient.invalidateQueries({ queryKey: saferCityKeys.subscriptions() });
     },
     ...options
   });
 }
+function useBulkTriggerNotifications(options) {
+  const client = useSaferCityClient();
+  return useMutation({
+    mutationFn: (body) => client.notifications.bulkTrigger(body),
+    ...options
+  });
+}
 function useLocationSafety(latitude, longitude, radius, options) {
   const client = useSaferCityClient();
   return useQuery({
@@ -437,6 +501,17 @@ function useLocationSafety(latitude, longitude, radius, options) {
     ...options
   });
 }
+function useBanner(body, options) {
+  const client = useSaferCityClient();
+  return useQuery({
+    queryKey: saferCityKeys.banner(body),
+    queryFn: () => client.banner.get(body),
+    enabled: body.latitude !== void 0 && body.longitude !== void 0,
+    staleTime: 1e3 * 60 * 5,
+    // 5 minutes - location-based, changes moderately
+    ...options
+  });
+}
 function useCrimes(filters, options) {
   const client = useSaferCityClient();
   return useQuery({
@@ -465,6 +540,16 @@ function useCrimeTypes(options) {
     ...options
   });
 }
+function useCrimeCategoriesWithTypes(options) {
+  const client = useSaferCityClient();
+  return useQuery({
+    queryKey: saferCityKeys.crimeCategoriesWithTypes(),
+    queryFn: () => client.crimes.categoriesWithTypes(),
+    staleTime: 1e3 * 60 * 30,
+    // 30 minutes - categories rarely change
+    ...options
+  });
+}
 function usePanicStream(panicId, options = {}) {
   const client = useSaferCityClient();
   const {
@@ -659,6 +744,6 @@ function useStream(createStream, options = {}) {
   };
 }
 
-export { SaferCityProvider, saferCityKeys, useAuthMode, useCancelPanic, useCreatePanic, useCreateSubscription, useCreateUser, useCrimeCategories, useCrimeTypes, useCrimes, useDeleteUser, useHealthCheck, useLocationSafety, usePanic, usePanicStream, usePanics, useSaferCity, useSaferCityClient, useSession, useSessionManager, useStream, useSubscriptionStats, useSubscriptionTypes, useSubscriptions, useUpdatePanicLocation, useUpdateUser, useUser, useUsers, useWhoAmI };
+export { SaferCityProvider, saferCityKeys, useAuthMode, useBanner, useBulkTriggerNotifications, useCancelPanic, useCreatePanic, useCreatePanicInformation, useCreateSubscription, useCreateUser, useCrimeCategories, useCrimeCategoriesWithTypes, useCrimeTypes, useCrimes, useDeletePanicInformation, useHealthCheck, useLocationSafety, usePanic, usePanicEligibility, usePanicInformation, usePanicInformationByUser, usePanicStream, usePanicTypes, useSaferCity, useSaferCityClient, useSession, useSessionManager, useStream, useSubscribeUser, useSubscriptionTypes, useSubscriptions, useUpdatePanicInformation, useUpdatePanicLocation, useUpdateUser, useUser, useWhoAmI };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map