@growsober/sdk 1.0.0

package/dist/api/types.d.ts

@@ -0,0 +1,464 @@
+/**
+ * Type extraction utilities for OpenAPI-generated types
+ *
+ * This file provides type-safe helpers to extract request/response types
+ * from the @growsober/types package.
+ */
+import type { paths, components } from '@growsober/types';
+/**
+ * Extract request body type for a given endpoint and method
+ */
+export type RequestBody<Path extends keyof paths, Method extends keyof paths[Path]> = paths[Path][Method] extends {
+    requestBody: {
+        content: {
+            'application/json': infer T;
+        };
+    };
+} ? T : never;
+/**
+ * Extract response type for a given endpoint, method, and status code
+ */
+export type ResponseBody<Path extends keyof paths, Method extends keyof paths[Path], Status extends number = 200> = paths[Path][Method] extends {
+    responses: {
+        [K in Status]: {
+            content: {
+                'application/json': infer T;
+            };
+        };
+    };
+} ? T : never;
+/**
+ * Extract query parameters type for a given endpoint and method
+ */
+export type QueryParams<Path extends keyof paths, Method extends keyof paths[Path]> = paths[Path][Method] extends {
+    parameters: {
+        query?: infer Q;
+    };
+} ? Q : Record<string, never>;
+/**
+ * Extract path parameters type for a given endpoint and method
+ */
+export type PathParams<Path extends keyof paths, Method extends keyof paths[Path]> = paths[Path][Method] extends {
+    parameters: {
+        path: infer P;
+    };
+} ? P : Record<string, never>;
+export type RegisterRequest = components['schemas']['RegisterDto'];
+export type AuthResponse = components['schemas']['AuthResponseDto'];
+export type LoginRequest = components['schemas']['LoginDto'];
+export type RefreshTokenRequest = components['schemas']['RefreshTokenDto'];
+export type TokenResponse = components['schemas']['TokenResponseDto'];
+export type FirebaseAuthRequest = components['schemas']['FirebaseAuthDto'];
+export type UserResponse = components['schemas']['UserResponseDto'];
+export type UserPublicResponse = components['schemas']['UserPublicResponseDto'];
+export type CreateUserRequest = components['schemas']['CreateUserDto'];
+export type UpdateUserRequest = components['schemas']['UpdateUserDto'];
+export type HubResponse = components['schemas']['HubResponseDto'];
+export type CreateHubRequest = components['schemas']['CreateHubDto'];
+export type UpdateHubRequest = components['schemas']['UpdateHubDto'];
+export interface HubMemberResponse {
+    id: string;
+    hubId: string;
+    userId: string;
+    role: 'MEMBER' | 'MODERATOR' | 'ADMIN' | 'OWNER';
+    status: 'PENDING' | 'APPROVED' | 'REJECTED';
+    joinedAt: string;
+    user?: UserPublicResponse;
+}
+export type EventResponse = components['schemas']['EventResponseDto'];
+export type CreateEventRequest = components['schemas']['CreateEventDto'];
+export type UpdateEventRequest = components['schemas']['UpdateEventDto'];
+export type BookingResponse = components['schemas']['BookingResponseDto'];
+export type CreateBookingRequest = components['schemas']['CreateBookingDto'];
+export type LibraryContentResponse = components['schemas']['LibraryContentResponseDto'];
+export type LibraryContentDetailResponse = components['schemas']['LibraryContentDetailResponseDto'];
+export type LibraryProgressResponse = components['schemas']['LibraryProgressResponseDto'];
+export type BusinessResponse = components['schemas']['BusinessResponseDto'];
+export type OfferResponse = components['schemas']['OfferResponseDto'];
+export type RedeemOfferRequest = components['schemas']['RedeemOfferDto'];
+export type SubscriptionResponse = components['schemas']['SubscriptionResponseDto'];
+export type CreateCheckoutRequest = components['schemas']['CreateCheckoutDto'];
+export type NotificationResponse = components['schemas']['NotificationResponseDto'];
+export type RegisterDeviceTokenRequest = components['schemas']['RegisterDeviceDto'];
+export interface DailyCheckInResponse {
+    id: string;
+    userId: string;
+    date: string;
+    mood: number | null;
+    energy: number | null;
+    stayedSober: boolean | null;
+    triggers: string[];
+    copingUsed: string[];
+    notes: string | null;
+    gratitude: string[];
+    createdAt: string;
+    updatedAt: string;
+}
+export interface CreateCheckInRequest {
+    date: string;
+    mood?: number;
+    energy?: number;
+    stayedSober?: boolean;
+    triggers?: string[];
+    copingUsed?: string[];
+    notes?: string;
+    gratitude?: string[];
+}
+export interface UpdateCheckInRequest {
+    mood?: number;
+    energy?: number;
+    stayedSober?: boolean;
+    triggers?: string[];
+    copingUsed?: string[];
+    notes?: string;
+    gratitude?: string[];
+}
+export interface CheckInStreakResponse {
+    currentStreak: number;
+    longestStreak: number;
+    totalCheckIns: number;
+}
+export interface MoodLogResponse {
+    id: string;
+    userId: string;
+    mood: number;
+    notes?: string;
+    triggers?: string[];
+    createdAt: string;
+}
+export interface CreateMoodLogRequest {
+    mood: number;
+    notes?: string;
+    triggers?: string[];
+}
+export interface WinResponse {
+    id: string;
+    userId: string;
+    title: string;
+    description?: string;
+    category: string;
+    imageUrl?: string;
+    createdAt: string;
+}
+export interface CreateWinRequest {
+    title: string;
+    description?: string;
+    category: string;
+    imageUrl?: string;
+}
+export interface HabitResponse {
+    id: string;
+    userId: string;
+    name: string;
+    description?: string;
+    icon?: string;
+    color?: string;
+    frequency: string;
+    targetDays: number[];
+    targetCount: number;
+    currentStreak: number;
+    longestStreak: number;
+    totalCompletions: number;
+    isActive: boolean;
+    isPaused: boolean;
+    reminderTime?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface CreateHabitRequest {
+    name: string;
+    description?: string;
+    icon?: string;
+    color?: string;
+    frequency: string;
+    targetDays?: number[];
+    targetCount?: number;
+    reminderTime?: string;
+}
+export interface UpdateHabitRequest {
+    name?: string;
+    description?: string;
+    icon?: string;
+    color?: string;
+    frequency?: string;
+    targetDays?: number[];
+    targetCount?: number;
+    isActive?: boolean;
+    isPaused?: boolean;
+    reminderTime?: string;
+}
+export interface ReflectionResponse {
+    id: string;
+    userId: string;
+    prompt: string;
+    content: string;
+    mood?: number;
+    createdAt: string;
+}
+export interface CreateReflectionRequest {
+    prompt: string;
+    content: string;
+    mood?: number;
+}
+export interface UserStreakResponse {
+    id: string;
+    userId: string;
+    type: string;
+    currentStreak: number;
+    longestStreak: number;
+    totalCheckIns: number;
+    lastActivityDate: string;
+}
+export interface BadgeResponse {
+    id: string;
+    appId: string;
+    name: string;
+    description?: string;
+    iconUrl?: string;
+    type: string;
+    threshold?: number;
+    isSecret: boolean;
+    isActive: boolean;
+    sortOrder: number;
+    createdAt: string;
+}
+export interface UserBadgeResponse {
+    id: string;
+    userId: string;
+    badgeId: string;
+    awardedAt: string;
+    badge?: BadgeResponse;
+}
+export interface MapUserResponse {
+    id: string;
+    name: string;
+    avatar?: string;
+    locationLat: number;
+    locationLong: number;
+}
+export interface MapHubResponse {
+    id: string;
+    name: string;
+    slug: string;
+    locationLat: number;
+    locationLong: number;
+    memberCount: number;
+}
+export interface MapEventResponse {
+    id: string;
+    title: string;
+    slug: string;
+    locationLat: number;
+    locationLong: number;
+    startDate: string;
+    attendeeCount: number;
+}
+export interface MapBusinessResponse {
+    id: string;
+    name: string;
+    slug?: string;
+    locationLat: number;
+    locationLong: number;
+    type: string;
+    hasAfDrinks: boolean;
+}
+export type AmbassadorStatus = 'PENDING' | 'ACTIVE' | 'INACTIVE' | 'ALUMNI';
+export interface AmbassadorResponse {
+    id: string;
+    userId: string;
+    hubId: string | null;
+    title: string | null;
+    bio: string | null;
+    status: AmbassadorStatus;
+    isVerified: boolean;
+    isFoundingAmbassador: boolean;
+    eventsHosted: number;
+    membersRecruited: number;
+    rewardPoints: number;
+    createdAt: string;
+    approvedAt: string | null;
+    user?: {
+        id: string;
+        name: string | null;
+        profileImage: string | null;
+    };
+    hub?: {
+        id: string;
+        name: string;
+        slug: string;
+        city?: string;
+        whatsappGroupUrl?: string;
+    } | null;
+}
+export interface AmbassadorLeaderboardResponse {
+    id: string;
+    userId: string;
+    userName: string | null;
+    profileImage: string | null;
+    hubName: string | null;
+    eventsHosted: number;
+    membersRecruited: number;
+    rewardPoints: number;
+    isFoundingAmbassador: boolean;
+    rank: number;
+}
+export interface ApplyAmbassadorRequest {
+    hubId?: string;
+    motivation: string;
+    bio?: string;
+}
+export interface UpdateAmbassadorRequest {
+    hubId?: string;
+    title?: string;
+    bio?: string;
+    status?: AmbassadorStatus;
+    isVerified?: boolean;
+    isFoundingAmbassador?: boolean;
+}
+export type Grow90Status = 'ACTIVE' | 'COMPLETED' | 'PAUSED' | 'ABANDONED';
+export interface Grow90EnrollmentResponse {
+    id: string;
+    userId: string;
+    startDate: string;
+    targetEndDate: string;
+    actualEndDate: string | null;
+    currentDay: number;
+    completedDays: number;
+    missedDays: number;
+    status: Grow90Status;
+    completedAt: string | null;
+    dailyReminderTime: string;
+    weeklyCallDay: string | null;
+    createdAt: string;
+    progressPercentage: number;
+    daysRemaining: number;
+}
+export interface Grow90ProgressResponse {
+    id: string;
+    dayNumber: number;
+    date: string;
+    isCompleted: boolean;
+    completedAt: string | null;
+    morningCheckIn: boolean;
+    eveningCheckIn: boolean;
+    contentViewed: boolean;
+    journalEntry: string | null;
+    gratitudeList: string[];
+    morningMood: number | null;
+    eveningMood: number | null;
+    createdAt: string;
+}
+export interface Grow90TodayResponse {
+    progress: Grow90ProgressResponse | null;
+    dayNumber: number;
+    dailyContent: {
+        title: string;
+        message: string;
+        tip: string;
+        affirmation: string;
+        morningMessage?: string;
+        eveningReflection?: string;
+        journalPrompt?: string;
+        theme?: string;
+    };
+    tasks: {
+        morningCheckIn: boolean;
+        eveningCheckIn: boolean;
+        contentViewed: boolean;
+        journalEntry: boolean;
+        gratitude: boolean;
+    };
+}
+export interface Grow90StatsResponse {
+    completedDays: number;
+    currentStreak: number;
+    longestStreak: number;
+    averageMood: number | null;
+    completionRate: number;
+    journalEntriesCount: number;
+}
+export interface EnrollGrow90Request {
+    dailyReminderTime?: string;
+    weeklyCallDay?: string;
+    stripePaymentId?: string;
+}
+export interface UpdateGrow90ProgressRequest {
+    morningCheckIn?: boolean;
+    eveningCheckIn?: boolean;
+    contentViewed?: boolean;
+    journalEntry?: string;
+    gratitudeList?: string[];
+    morningMood?: number;
+    eveningMood?: number;
+}
+export interface UpdateGrow90SettingsRequest {
+    dailyReminderTime?: string;
+    weeklyCallDay?: string;
+}
+export type EventMessageType = 'TEXT' | 'IMAGE' | 'SYSTEM' | 'ANNOUNCEMENT';
+export type ChatMemberRole = 'MEMBER' | 'MODERATOR' | 'HOST';
+export interface EventChatResponse {
+    id: string;
+    eventId: string;
+    messageCount: number;
+    memberCount: number;
+    isActive: boolean;
+    isLocked: boolean;
+    lastMessageAt?: string;
+    createdAt: string;
+    eventTitle?: string;
+    eventStartDate?: string;
+}
+export interface ChatMemberResponse {
+    id: string;
+    chatId: string;
+    userId: string;
+    role: ChatMemberRole;
+    nickname?: string;
+    isMuted: boolean;
+    lastReadAt?: string;
+    joinedAt: string;
+    userName?: string;
+    userImage?: string;
+}
+export interface MessageResponse {
+    id: string;
+    chatId: string;
+    userId: string;
+    content: string;
+    messageType: EventMessageType;
+    imageUrl?: string;
+    replyToId?: string;
+    isEdited: boolean;
+    isDeleted: boolean;
+    createdAt: string;
+    updatedAt?: string;
+    userName?: string;
+    userImage?: string;
+    replyToContent?: string;
+    replyToUserName?: string;
+}
+export interface PaginatedMessagesResponse {
+    messages: MessageResponse[];
+    total: number;
+    hasMore: boolean;
+    nextCursor?: string;
+}
+export interface SendMessageRequest {
+    content: string;
+    messageType?: EventMessageType;
+    imageUrl?: string;
+    replyToId?: string;
+}
+export interface UpdateMessageRequest {
+    content: string;
+}
+export interface UpdateChatSettingsRequest {
+    isLocked?: boolean;
+    isActive?: boolean;
+}
+export interface UpdateMemberSettingsRequest {
+    isMuted?: boolean;
+    nickname?: string;
+}
+export type { paths, components };

package/dist/api/types.js

@@ -0,0 +1,9 @@
+"use strict";
+/**
+ * Type extraction utilities for OpenAPI-generated types
+ *
+ * This file provides type-safe helpers to extract request/response types
+ * from the @growsober/types package.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/api/types.ts"],"names":[],"mappings":";AAAA;;;;;GAKG","sourcesContent":["/**\n * Type extraction utilities for OpenAPI-generated types\n *\n * This file provides type-safe helpers to extract request/response types\n * from the @growsober/types package.\n */\n\nimport type { paths, components } from '@growsober/types';\n\n// ============================================================================\n// TYPE EXTRACTION HELPERS\n// ============================================================================\n\n/**\n * Extract request body type for a given endpoint and method\n */\nexport type RequestBody<\n  Path extends keyof paths,\n  Method extends keyof paths[Path]\n> = paths[Path][Method] extends { requestBody: { content: { 'application/json': infer T } } }\n  ? T\n  : never;\n\n/**\n * Extract response type for a given endpoint, method, and status code\n */\nexport type ResponseBody<\n  Path extends keyof paths,\n  Method extends keyof paths[Path],\n  Status extends number = 200\n> = paths[Path][Method] extends { responses: { [K in Status]: { content: { 'application/json': infer T } } } }\n  ? T\n  : never;\n\n/**\n * Extract query parameters type for a given endpoint and method\n */\nexport type QueryParams<\n  Path extends keyof paths,\n  Method extends keyof paths[Path]\n> = paths[Path][Method] extends { parameters: { query?: infer Q } }\n  ? Q\n  : Record<string, never>;\n\n/**\n * Extract path parameters type for a given endpoint and method\n */\nexport type PathParams<\n  Path extends keyof paths,\n  Method extends keyof paths[Path]\n> = paths[Path][Method] extends { parameters: { path: infer P } }\n  ? P\n  : Record<string, never>;\n\n// ============================================================================\n// AUTH TYPES\n// ============================================================================\n\nexport type RegisterRequest = components['schemas']['RegisterDto'];\nexport type AuthResponse = components['schemas']['AuthResponseDto'];\nexport type LoginRequest = components['schemas']['LoginDto'];\nexport type RefreshTokenRequest = components['schemas']['RefreshTokenDto'];\nexport type TokenResponse = components['schemas']['TokenResponseDto'];\nexport type FirebaseAuthRequest = components['schemas']['FirebaseAuthDto'];\n\n// ============================================================================\n// USER TYPES\n// ============================================================================\n\nexport type UserResponse = components['schemas']['UserResponseDto'];\nexport type UserPublicResponse = components['schemas']['UserPublicResponseDto'];\nexport type CreateUserRequest = components['schemas']['CreateUserDto'];\nexport type UpdateUserRequest = components['schemas']['UpdateUserDto'];\n\n// ============================================================================\n// HUB TYPES\n// ============================================================================\n\nexport type HubResponse = components['schemas']['HubResponseDto'];\nexport type CreateHubRequest = components['schemas']['CreateHubDto'];\nexport type UpdateHubRequest = components['schemas']['UpdateHubDto'];\n\n// HubMemberResponse - will be available when hub membership endpoints are fully implemented\n// For now, define inline type based on API response structure\nexport interface HubMemberResponse {\n  id: string;\n  hubId: string;\n  userId: string;\n  role: 'MEMBER' | 'MODERATOR' | 'ADMIN' | 'OWNER';\n  status: 'PENDING' | 'APPROVED' | 'REJECTED';\n  joinedAt: string;\n  user?: UserPublicResponse;\n}\n\n// ============================================================================\n// EVENT TYPES\n// ============================================================================\n\nexport type EventResponse = components['schemas']['EventResponseDto'];\nexport type CreateEventRequest = components['schemas']['CreateEventDto'];\nexport type UpdateEventRequest = components['schemas']['UpdateEventDto'];\n\n// ============================================================================\n// BOOKING TYPES\n// ============================================================================\n\nexport type BookingResponse = components['schemas']['BookingResponseDto'];\nexport type CreateBookingRequest = components['schemas']['CreateBookingDto'];\n\n// ============================================================================\n// LIBRARY TYPES\n// ============================================================================\n\nexport type LibraryContentResponse = components['schemas']['LibraryContentResponseDto'];\nexport type LibraryContentDetailResponse = components['schemas']['LibraryContentDetailResponseDto'];\nexport type LibraryProgressResponse = components['schemas']['LibraryProgressResponseDto'];\n\n// ============================================================================\n// BUSINESS & OFFER TYPES\n// ============================================================================\n\nexport type BusinessResponse = components['schemas']['BusinessResponseDto'];\nexport type OfferResponse = components['schemas']['OfferResponseDto'];\nexport type RedeemOfferRequest = components['schemas']['RedeemOfferDto'];\n\n// ============================================================================\n// SUBSCRIPTION TYPES\n// ============================================================================\n\nexport type SubscriptionResponse = components['schemas']['SubscriptionResponseDto'];\nexport type CreateCheckoutRequest = components['schemas']['CreateCheckoutDto'];\n\n// ============================================================================\n// NOTIFICATION TYPES\n// ============================================================================\n\nexport type NotificationResponse = components['schemas']['NotificationResponseDto'];\n\n// ============================================================================\n// DEVICE TOKEN TYPES\n// ============================================================================\n\nexport type RegisterDeviceTokenRequest = components['schemas']['RegisterDeviceDto'];\n\n// ============================================================================\n// SUPPORT TYPES (Placeholder - will be generated when support module is registered)\n// ============================================================================\n\n// These types will be generated from OpenAPI once the support module endpoints\n// are registered in the API. For now, we define placeholder interfaces.\n\nexport interface DailyCheckInResponse {\n  id: string;\n  userId: string;\n  date: string;\n  mood: number | null;\n  energy: number | null;\n  stayedSober: boolean | null;\n  triggers: string[];\n  copingUsed: string[];\n  notes: string | null;\n  gratitude: string[];\n  createdAt: string;\n  updatedAt: string;\n}\n\nexport interface CreateCheckInRequest {\n  date: string;\n  mood?: number;\n  energy?: number;\n  stayedSober?: boolean;\n  triggers?: string[];\n  copingUsed?: string[];\n  notes?: string;\n  gratitude?: string[];\n}\n\nexport interface UpdateCheckInRequest {\n  mood?: number;\n  energy?: number;\n  stayedSober?: boolean;\n  triggers?: string[];\n  copingUsed?: string[];\n  notes?: string;\n  gratitude?: string[];\n}\n\nexport interface CheckInStreakResponse {\n  currentStreak: number;\n  longestStreak: number;\n  totalCheckIns: number;\n}\n\nexport interface MoodLogResponse {\n  id: string;\n  userId: string;\n  mood: number;\n  notes?: string;\n  triggers?: string[];\n  createdAt: string;\n}\n\nexport interface CreateMoodLogRequest {\n  mood: number;\n  notes?: string;\n  triggers?: string[];\n}\n\nexport interface WinResponse {\n  id: string;\n  userId: string;\n  title: string;\n  description?: string;\n  category: string;\n  imageUrl?: string;\n  createdAt: string;\n}\n\nexport interface CreateWinRequest {\n  title: string;\n  description?: string;\n  category: string;\n  imageUrl?: string;\n}\n\nexport interface HabitResponse {\n  id: string;\n  userId: string;\n  name: string;\n  description?: string;\n  icon?: string;\n  color?: string;\n  frequency: string;\n  targetDays: number[];\n  targetCount: number;\n  currentStreak: number;\n  longestStreak: number;\n  totalCompletions: number;\n  isActive: boolean;\n  isPaused: boolean;\n  reminderTime?: string;\n  createdAt: string;\n  updatedAt: string;\n}\n\nexport interface CreateHabitRequest {\n  name: string;\n  description?: string;\n  icon?: string;\n  color?: string;\n  frequency: string;\n  targetDays?: number[];\n  targetCount?: number;\n  reminderTime?: string;\n}\n\nexport interface UpdateHabitRequest {\n  name?: string;\n  description?: string;\n  icon?: string;\n  color?: string;\n  frequency?: string;\n  targetDays?: number[];\n  targetCount?: number;\n  isActive?: boolean;\n  isPaused?: boolean;\n  reminderTime?: string;\n}\n\nexport interface ReflectionResponse {\n  id: string;\n  userId: string;\n  prompt: string;\n  content: string;\n  mood?: number;\n  createdAt: string;\n}\n\nexport interface CreateReflectionRequest {\n  prompt: string;\n  content: string;\n  mood?: number;\n}\n\nexport interface UserStreakResponse {\n  id: string;\n  userId: string;\n  type: string;\n  currentStreak: number;\n  longestStreak: number;\n  totalCheckIns: number;\n  lastActivityDate: string;\n}\n\n// ============================================================================\n// GAMIFICATION TYPES (Placeholder - will be generated when gamification module is registered)\n// ============================================================================\n\nexport interface BadgeResponse {\n  id: string;\n  appId: string;\n  name: string;\n  description?: string;\n  iconUrl?: string;\n  type: string;\n  threshold?: number;\n  isSecret: boolean;\n  isActive: boolean;\n  sortOrder: number;\n  createdAt: string;\n}\n\nexport interface UserBadgeResponse {\n  id: string;\n  userId: string;\n  badgeId: string;\n  awardedAt: string;\n  badge?: BadgeResponse;\n}\n\n// ============================================================================\n// MAP TYPES (Placeholder - will be generated when map module is registered)\n// ============================================================================\n\nexport interface MapUserResponse {\n  id: string;\n  name: string;\n  avatar?: string;\n  locationLat: number;\n  locationLong: number;\n}\n\nexport interface MapHubResponse {\n  id: string;\n  name: string;\n  slug: string;\n  locationLat: number;\n  locationLong: number;\n  memberCount: number;\n}\n\nexport interface MapEventResponse {\n  id: string;\n  title: string;\n  slug: string;\n  locationLat: number;\n  locationLong: number;\n  startDate: string;\n  attendeeCount: number;\n}\n\nexport interface MapBusinessResponse {\n  id: string;\n  name: string;\n  slug?: string;\n  locationLat: number;\n  locationLong: number;\n  type: string;\n  hasAfDrinks: boolean;\n}\n\n// ============================================================================\n// AMBASSADOR TYPES\n// ============================================================================\n\nexport type AmbassadorStatus = 'PENDING' | 'ACTIVE' | 'INACTIVE' | 'ALUMNI';\n\nexport interface AmbassadorResponse {\n  id: string;\n  userId: string;\n  hubId: string | null;\n  title: string | null;\n  bio: string | null;\n  status: AmbassadorStatus;\n  isVerified: boolean;\n  isFoundingAmbassador: boolean;\n  eventsHosted: number;\n  membersRecruited: number;\n  rewardPoints: number;\n  createdAt: string;\n  approvedAt: string | null;\n  user?: {\n    id: string;\n    name: string | null;\n    profileImage: string | null;\n  };\n  hub?: {\n    id: string;\n    name: string;\n    slug: string;\n    city?: string;\n    whatsappGroupUrl?: string;\n  } | null;\n}\n\nexport interface AmbassadorLeaderboardResponse {\n  id: string;\n  userId: string;\n  userName: string | null;\n  profileImage: string | null;\n  hubName: string | null;\n  eventsHosted: number;\n  membersRecruited: number;\n  rewardPoints: number;\n  isFoundingAmbassador: boolean;\n  rank: number;\n}\n\nexport interface ApplyAmbassadorRequest {\n  hubId?: string;\n  motivation: string;\n  bio?: string;\n}\n\nexport interface UpdateAmbassadorRequest {\n  hubId?: string;\n  title?: string;\n  bio?: string;\n  status?: AmbassadorStatus;\n  isVerified?: boolean;\n  isFoundingAmbassador?: boolean;\n}\n\n// ============================================================================\n// GROW90 TYPES\n// ============================================================================\n\nexport type Grow90Status = 'ACTIVE' | 'COMPLETED' | 'PAUSED' | 'ABANDONED';\n\nexport interface Grow90EnrollmentResponse {\n  id: string;\n  userId: string;\n  startDate: string;\n  targetEndDate: string;\n  actualEndDate: string | null;\n  currentDay: number;\n  completedDays: number;\n  missedDays: number;\n  status: Grow90Status;\n  completedAt: string | null;\n  dailyReminderTime: string;\n  weeklyCallDay: string | null;\n  createdAt: string;\n  progressPercentage: number;\n  daysRemaining: number;\n}\n\nexport interface Grow90ProgressResponse {\n  id: string;\n  dayNumber: number;\n  date: string;\n  isCompleted: boolean;\n  completedAt: string | null;\n  morningCheckIn: boolean;\n  eveningCheckIn: boolean;\n  contentViewed: boolean;\n  journalEntry: string | null;\n  gratitudeList: string[];\n  morningMood: number | null;\n  eveningMood: number | null;\n  createdAt: string;\n}\n\nexport interface Grow90TodayResponse {\n  progress: Grow90ProgressResponse | null;\n  dayNumber: number;\n  dailyContent: {\n    title: string;\n    message: string;\n    tip: string;\n    affirmation: string;\n    morningMessage?: string;\n    eveningReflection?: string;\n    journalPrompt?: string;\n    theme?: string;\n  };\n  tasks: {\n    morningCheckIn: boolean;\n    eveningCheckIn: boolean;\n    contentViewed: boolean;\n    journalEntry: boolean;\n    gratitude: boolean;\n  };\n}\n\nexport interface Grow90StatsResponse {\n  completedDays: number;\n  currentStreak: number;\n  longestStreak: number;\n  averageMood: number | null;\n  completionRate: number;\n  journalEntriesCount: number;\n}\n\nexport interface EnrollGrow90Request {\n  dailyReminderTime?: string;\n  weeklyCallDay?: string;\n  stripePaymentId?: string;\n}\n\nexport interface UpdateGrow90ProgressRequest {\n  morningCheckIn?: boolean;\n  eveningCheckIn?: boolean;\n  contentViewed?: boolean;\n  journalEntry?: string;\n  gratitudeList?: string[];\n  morningMood?: number;\n  eveningMood?: number;\n}\n\nexport interface UpdateGrow90SettingsRequest {\n  dailyReminderTime?: string;\n  weeklyCallDay?: string;\n}\n\n// ============================================================================\n// EVENT CHAT TYPES\n// ============================================================================\n\nexport type EventMessageType = 'TEXT' | 'IMAGE' | 'SYSTEM' | 'ANNOUNCEMENT';\nexport type ChatMemberRole = 'MEMBER' | 'MODERATOR' | 'HOST';\n\nexport interface EventChatResponse {\n  id: string;\n  eventId: string;\n  messageCount: number;\n  memberCount: number;\n  isActive: boolean;\n  isLocked: boolean;\n  lastMessageAt?: string;\n  createdAt: string;\n  eventTitle?: string;\n  eventStartDate?: string;\n}\n\nexport interface ChatMemberResponse {\n  id: string;\n  chatId: string;\n  userId: string;\n  role: ChatMemberRole;\n  nickname?: string;\n  isMuted: boolean;\n  lastReadAt?: string;\n  joinedAt: string;\n  userName?: string;\n  userImage?: string;\n}\n\nexport interface MessageResponse {\n  id: string;\n  chatId: string;\n  userId: string;\n  content: string;\n  messageType: EventMessageType;\n  imageUrl?: string;\n  replyToId?: string;\n  isEdited: boolean;\n  isDeleted: boolean;\n  createdAt: string;\n  updatedAt?: string;\n  userName?: string;\n  userImage?: string;\n  replyToContent?: string;\n  replyToUserName?: string;\n}\n\nexport interface PaginatedMessagesResponse {\n  messages: MessageResponse[];\n  total: number;\n  hasMore: boolean;\n  nextCursor?: string;\n}\n\nexport interface SendMessageRequest {\n  content: string;\n  messageType?: EventMessageType;\n  imageUrl?: string;\n  replyToId?: string;\n}\n\nexport interface UpdateMessageRequest {\n  content: string;\n}\n\nexport interface UpdateChatSettingsRequest {\n  isLocked?: boolean;\n  isActive?: boolean;\n}\n\nexport interface UpdateMemberSettingsRequest {\n  isMuted?: boolean;\n  nickname?: string;\n}\n\n// Re-export paths and components for advanced usage\nexport type { paths, components };\n"]}

package/dist/hooks/useAuth.d.ts

@@ -0,0 +1,5 @@
+export declare function useSendOtp(): import("@tanstack/react-query").UseMutationResult<{
+    message: string;
+}, Error, any, unknown>;
+export declare function useVerifyOtp(): import("@tanstack/react-query").UseMutationResult<any, Error, any, unknown>;
+export declare function useRefreshToken(): import("@tanstack/react-query").UseMutationResult<any, Error, string, unknown>;

package/dist/hooks/useAuth.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSendOtp = useSendOtp;
+exports.useVerifyOtp = useVerifyOtp;
+exports.useRefreshToken = useRefreshToken;
+const react_query_1 = require("@tanstack/react-query");
+const client_1 = require("../api/client");
+function useSendOtp() {
+    return (0, react_query_1.useMutation)({
+        mutationFn: async (data) => {
+            const client = (0, client_1.getApiClient)();
+            const response = await client.post('/auth/send-otp', data);
+            return response.data;
+        },
+    });
+}
+function useVerifyOtp() {
+    const queryClient = (0, react_query_1.useQueryClient)();
+    return (0, react_query_1.useMutation)({
+        mutationFn: async (data) => {
+            const client = (0, client_1.getApiClient)();
+            const response = await client.post('/auth/verify-otp', data);
+            return response.data;
+        },
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: ['user', 'me'] });
+        },
+    });
+}
+function useRefreshToken() {
+    return (0, react_query_1.useMutation)({
+        mutationFn: async (refreshToken) => {
+            const client = (0, client_1.getApiClient)();
+            const response = await client.post('/auth/refresh', { refreshToken });
+            return response.data;
+        },
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/hooks/useUser.d.ts

@@ -0,0 +1,43 @@
+export declare function useCurrentUser(): import("@tanstack/react-query").UseQueryResult<any, Error>;
+export declare function useUpdateUser(): import("@tanstack/react-query").UseMutationResult<any, Error, {
+    email?: string;
+    phone?: string;
+    name?: string;
+    bio?: string;
+    profileImage?: string;
+    city?: string;
+    cityId?: string;
+    locationLat?: number;
+    locationLong?: number;
+    showOnMap?: boolean;
+    locationRadius?: number;
+    customFields?: Record<string, never>;
+    notifyEmail?: boolean;
+    notifyPush?: boolean;
+    notifyWhatsApp?: boolean;
+    instagramUrl?: string;
+    linkedinUrl?: string;
+    websiteUrl?: string;
+    onboardingComplete?: boolean;
+}, unknown>;
+export declare function useCompleteOnboarding(): import("@tanstack/react-query").UseMutationResult<any, Error, {
+    email?: string;
+    phone?: string;
+    name?: string;
+    bio?: string;
+    profileImage?: string;
+    city?: string;
+    cityId?: string;
+    locationLat?: number;
+    locationLong?: number;
+    showOnMap?: boolean;
+    locationRadius?: number;
+    customFields?: Record<string, never>;
+    notifyEmail?: boolean;
+    notifyPush?: boolean;
+    notifyWhatsApp?: boolean;
+    instagramUrl?: string;
+    linkedinUrl?: string;
+    websiteUrl?: string;
+    onboardingComplete?: boolean;
+}, unknown>;

package/dist/hooks/useUser.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useCurrentUser = useCurrentUser;
+exports.useUpdateUser = useUpdateUser;
+exports.useCompleteOnboarding = useCompleteOnboarding;
+const react_query_1 = require("@tanstack/react-query");
+const client_1 = require("../api/client");
+function useCurrentUser() {
+    return (0, react_query_1.useQuery)({
+        queryKey: ['user', 'me'],
+        queryFn: async () => {
+            const client = (0, client_1.getApiClient)();
+            const response = await client.get('/users/me');
+            return response.data;
+        },
+    });
+}
+function useUpdateUser() {
+    const queryClient = (0, react_query_1.useQueryClient)();
+    return (0, react_query_1.useMutation)({
+        mutationFn: async (data) => {
+            const client = (0, client_1.getApiClient)();
+            const response = await client.put('/users/me', data);
+            return response.data;
+        },
+        onSuccess: (updatedUser) => {
+            queryClient.setQueryData(['user', 'me'], updatedUser);
+        },
+    });
+}
+function useCompleteOnboarding() {
+    const queryClient = (0, react_query_1.useQueryClient)();
+    return (0, react_query_1.useMutation)({
+        mutationFn: async (data) => {
+            const client = (0, client_1.getApiClient)();
+            const response = await client.put('/users/me/complete-onboarding', data);
+            return response.data;
+        },
+        onSuccess: (updatedUser) => {
+            queryClient.setQueryData(['user', 'me'], updatedUser);
+        },
+    });
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXNlVXNlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9ob29rcy91c2VVc2VyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBT0Esd0NBU0M7QUFFRCxzQ0FhQztBQUVELHNEQWFDO0FBOUNELHVEQUE4RTtBQUM5RSwwQ0FBNkM7QUFNN0MsU0FBZ0IsY0FBYztJQUM1QixPQUFPLElBQUEsc0JBQVEsRUFBQztRQUNkLFFBQVEsRUFBRSxDQUFDLE1BQU0sRUFBRSxJQUFJLENBQUM7UUFDeEIsT0FBTyxFQUFFLEtBQUssSUFBbUIsRUFBRTtZQUNqQyxNQUFNLE1BQU0sR0FBRyxJQUFBLHFCQUFZLEdBQUUsQ0FBQztZQUM5QixNQUFNLFFBQVEsR0FBRyxNQUFNLE1BQU0sQ0FBQyxHQUFHLENBQUMsV0FBVyxDQUFDLENBQUM7WUFDL0MsT0FBTyxRQUFRLENBQUMsSUFBSSxDQUFDO1FBQ3ZCLENBQUM7S0FDRixDQUFDLENBQUM7QUFDTCxDQUFDO0FBRUQsU0FBZ0IsYUFBYTtJQUMzQixNQUFNLFdBQVcsR0FBRyxJQUFBLDRCQUFjLEdBQUUsQ0FBQztJQUVyQyxPQUFPLElBQUEseUJBQVcsRUFBQztRQUNqQixVQUFVLEVBQUUsS0FBSyxFQUFFLElBQW1CLEVBQWlCLEVBQUU7WUFDdkQsTUFBTSxNQUFNLEdBQUcsSUFBQSxxQkFBWSxHQUFFLENBQUM7WUFDOUIsTUFBTSxRQUFRLEdBQUcsTUFBTSxNQUFNLENBQUMsR0FBRyxDQUFDLFdBQVcsRUFBRSxJQUFJLENBQUMsQ0FBQztZQUNyRCxPQUFPLFFBQVEsQ0FBQyxJQUFJLENBQUM7UUFDdkIsQ0FBQztRQUNELFNBQVMsRUFBRSxDQUFDLFdBQVcsRUFBRSxFQUFFO1lBQ3pCLFdBQVcsQ0FBQyxZQUFZLENBQUMsQ0FBQyxNQUFNLEVBQUUsSUFBSSxDQUFDLEVBQUUsV0FBVyxDQUFDLENBQUM7UUFDeEQsQ0FBQztLQUNGLENBQUMsQ0FBQztBQUNMLENBQUM7QUFFRCxTQUFnQixxQkFBcUI7SUFDbkMsTUFBTSxXQUFXLEdBQUcsSUFBQSw0QkFBYyxHQUFFLENBQUM7SUFFckMsT0FBTyxJQUFBLHlCQUFXLEVBQUM7UUFDakIsVUFBVSxFQUFFLEtBQUssRUFBRSxJQUFtQixFQUFpQixFQUFFO1lBQ3ZELE1BQU0sTUFBTSxHQUFHLElBQUEscUJBQVksR0FBRSxDQUFDO1lBQzlCLE1BQU0sUUFBUSxHQUFHLE1BQU0sTUFBTSxDQUFDLEdBQUcsQ0FBQywrQkFBK0IsRUFBRSxJQUFJLENBQUMsQ0FBQztZQUN6RSxPQUFPLFFBQVEsQ0FBQyxJQUFJLENBQUM7UUFDdkIsQ0FBQztRQUNELFNBQVMsRUFBRSxDQUFDLFdBQVcsRUFBRSxFQUFFO1lBQ3pCLFdBQVcsQ0FBQyxZQUFZLENBQUMsQ0FBQyxNQUFNLEVBQUUsSUFBSSxDQUFDLEVBQUUsV0FBVyxDQUFDLENBQUM7UUFDeEQsQ0FBQztLQUNGLENBQUMsQ0FBQztBQUNMLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyB1c2VRdWVyeSwgdXNlTXV0YXRpb24sIHVzZVF1ZXJ5Q2xpZW50IH0gZnJvbSAnQHRhbnN0YWNrL3JlYWN0LXF1ZXJ5JztcbmltcG9ydCB7IGdldEFwaUNsaWVudCB9IGZyb20gJy4uL2FwaS9jbGllbnQnO1xuaW1wb3J0IHR5cGUgeyBjb21wb25lbnRzIH0gZnJvbSAnQGdyb3dzb2Jlci90eXBlcyc7XG5cbnR5cGUgVXNlciA9IGNvbXBvbmVudHNbJ3NjaGVtYXMnXVsnVXNlciddO1xudHlwZSBVcGRhdGVVc2VyRHRvID0gY29tcG9uZW50c1snc2NoZW1hcyddWydVcGRhdGVVc2VyRHRvJ107XG5cbmV4cG9ydCBmdW5jdGlvbiB1c2VDdXJyZW50VXNlcigpIHtcbiAgcmV0dXJuIHVzZVF1ZXJ5KHtcbiAgICBxdWVyeUtleTogWyd1c2VyJywgJ21lJ10sXG4gICAgcXVlcnlGbjogYXN5bmMgKCk6IFByb21pc2U8VXNlcj4gPT4ge1xuICAgICAgY29uc3QgY2xpZW50ID0gZ2V0QXBpQ2xpZW50KCk7XG4gICAgICBjb25zdCByZXNwb25zZSA9IGF3YWl0IGNsaWVudC5nZXQoJy91c2Vycy9tZScpO1xuICAgICAgcmV0dXJuIHJlc3BvbnNlLmRhdGE7XG4gICAgfSxcbiAgfSk7XG59XG5cbmV4cG9ydCBmdW5jdGlvbiB1c2VVcGRhdGVVc2VyKCkge1xuICBjb25zdCBxdWVyeUNsaWVudCA9IHVzZVF1ZXJ5Q2xpZW50KCk7XG5cbiAgcmV0dXJuIHVzZU11dGF0aW9uKHtcbiAgICBtdXRhdGlvbkZuOiBhc3luYyAoZGF0YTogVXBkYXRlVXNlckR0byk6IFByb21pc2U8VXNlcj4gPT4ge1xuICAgICAgY29uc3QgY2xpZW50ID0gZ2V0QXBpQ2xpZW50KCk7XG4gICAgICBjb25zdCByZXNwb25zZSA9IGF3YWl0IGNsaWVudC5wdXQoJy91c2Vycy9tZScsIGRhdGEpO1xuICAgICAgcmV0dXJuIHJlc3BvbnNlLmRhdGE7XG4gICAgfSxcbiAgICBvblN1Y2Nlc3M6ICh1cGRhdGVkVXNlcikgPT4ge1xuICAgICAgcXVlcnlDbGllbnQuc2V0UXVlcnlEYXRhKFsndXNlcicsICdtZSddLCB1cGRhdGVkVXNlcik7XG4gICAgfSxcbiAgfSk7XG59XG5cbmV4cG9ydCBmdW5jdGlvbiB1c2VDb21wbGV0ZU9uYm9hcmRpbmcoKSB7XG4gIGNvbnN0IHF1ZXJ5Q2xpZW50ID0gdXNlUXVlcnlDbGllbnQoKTtcblxuICByZXR1cm4gdXNlTXV0YXRpb24oe1xuICAgIG11dGF0aW9uRm46IGFzeW5jIChkYXRhOiBVcGRhdGVVc2VyRHRvKTogUHJvbWlzZTxVc2VyPiA9PiB7XG4gICAgICBjb25zdCBjbGllbnQgPSBnZXRBcGlDbGllbnQoKTtcbiAgICAgIGNvbnN0IHJlc3BvbnNlID0gYXdhaXQgY2xpZW50LnB1dCgnL3VzZXJzL21lL2NvbXBsZXRlLW9uYm9hcmRpbmcnLCBkYXRhKTtcbiAgICAgIHJldHVybiByZXNwb25zZS5kYXRhO1xuICAgIH0sXG4gICAgb25TdWNjZXNzOiAodXBkYXRlZFVzZXIpID0+IHtcbiAgICAgIHF1ZXJ5Q2xpZW50LnNldFF1ZXJ5RGF0YShbJ3VzZXInLCAnbWUnXSwgdXBkYXRlZFVzZXIpO1xuICAgIH0sXG4gIH0pO1xufVxuIl19