@axcode/axcloud-sdk 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,1473 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import React from 'react';
+import * as _tanstack_react_query from '@tanstack/react-query';
+import { QueryClient } from '@tanstack/react-query';
+import { useAuth0, User as User$1 } from '@auth0/auth0-react';
+
+/**
+ * AxCloud API Client
+ *
+ * Fetch wrapper with authentication header injection and error handling.
+ */
+interface ClientConfig {
+    baseUrl: string;
+    getAccessToken?: () => Promise<string | undefined>;
+    /** API key for public content endpoints */
+    apiKey?: string;
+    /** Default request timeout in milliseconds (default: 30000) */
+    timeout?: number;
+}
+interface RequestOptions extends Omit<RequestInit, 'body'> {
+    body?: unknown;
+    params?: Record<string, string | number | boolean | undefined>;
+    /** Request timeout in milliseconds (overrides client default) */
+    timeout?: number;
+}
+declare class AxCloudClient {
+    private baseUrl;
+    private getAccessToken?;
+    private apiKey?;
+    private defaultTimeout;
+    constructor(config: ClientConfig);
+    /**
+     * Update the access token getter (used when auth state changes)
+     */
+    setAccessTokenGetter(getter: () => Promise<string | undefined>): void;
+    /**
+     * Build URL with query parameters
+     */
+    private buildUrl;
+    /**
+     * Make an authenticated request
+     */
+    request<T>(path: string, options?: RequestOptions): Promise<T>;
+    /**
+     * GET request
+     */
+    get<T>(path: string, params?: Record<string, string | number | boolean | undefined>): Promise<T>;
+    /**
+     * POST request
+     */
+    post<T>(path: string, body?: unknown): Promise<T>;
+    /**
+     * PUT request
+     */
+    put<T>(path: string, body?: unknown): Promise<T>;
+    /**
+     * PATCH request
+     */
+    patch<T>(path: string, body?: unknown): Promise<T>;
+    /**
+     * DELETE request
+     */
+    delete<T>(path: string): Promise<T>;
+}
+/**
+ * Create a client instance associated with a key (typically the provider instance)
+ * This allows multiple AxCloudProviders to coexist without conflicts
+ */
+declare function createClient(config: ClientConfig, key?: object): AxCloudClient;
+/**
+ * Get a client instance by key
+ * @deprecated Use the client from useAxCloudContext() instead
+ */
+declare function getClient(key?: object): AxCloudClient;
+
+/**
+ * AxCloud SDK Error Types
+ */
+type AxCloudErrorCode = 'UNAUTHORIZED' | 'FORBIDDEN' | 'NOT_FOUND' | 'VALIDATION_ERROR' | 'NETWORK_ERROR' | 'TIMEOUT_ERROR' | 'SERVER_ERROR' | 'UNKNOWN_ERROR';
+declare class AxCloudError extends Error {
+    readonly code: AxCloudErrorCode;
+    readonly status: number;
+    readonly details?: Record<string, unknown>;
+    constructor(message: string, code: AxCloudErrorCode, status: number, details?: Record<string, unknown>);
+    static fromResponse(status: number, body?: unknown): AxCloudError;
+    static networkError(originalError?: Error): AxCloudError;
+    static timeoutError(timeoutMs: number): AxCloudError;
+}
+declare function isAxCloudError(error: unknown): error is AxCloudError;
+
+/**
+ * AxCloud SDK Types
+ *
+ * Note: In the future, these types should be auto-generated from the OpenAPI spec.
+ * For now, they are manually defined based on the AxCloud API.
+ */
+type AxCloudModule = 'content' | 'members' | 'sections' | 'training' | 'ai' | 'documents' | 'voting';
+type SystemRole = 'super_admin' | 'org_admin' | 'section_admin' | 'member' | 'viewer';
+type UserRole = SystemRole | 'superadmin' | 'admin' | 'editor';
+type BaseRole = 'org_admin' | 'section_admin' | 'member' | 'viewer';
+/**
+ * Custom role definition
+ */
+interface CustomRole {
+    role_id: string;
+    org_id: string;
+    name: string;
+    description?: string;
+    baseRole: BaseRole;
+    permissions?: string[];
+    deniedPermissions?: string[];
+    effectivePermissions?: string[];
+    color?: string;
+    icon?: string;
+    hierarchy: number;
+    isSystem: false;
+    isActive: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+interface Organization {
+    id: string;
+    name: string;
+    slug: string;
+    description?: string;
+    modules: AxCloudModule[];
+    settings?: OrganizationSettings;
+    createdAt: string;
+    updatedAt: string;
+}
+interface OrganizationSettings {
+    allowPublicSignup?: boolean;
+    requireEmailVerification?: boolean;
+    defaultUserRole?: UserRole;
+    theme?: {
+        primaryColor?: string;
+        logo?: string;
+    };
+}
+interface Section {
+    id: string;
+    organizationId: string;
+    name: string;
+    description?: string;
+    slug: string;
+    parentId?: string;
+    permissions?: SectionPermissions;
+    createdAt: string;
+    updatedAt: string;
+}
+interface SectionPermissions {
+    canViewMembers?: boolean;
+    canEditContent?: boolean;
+    canManageMembers?: boolean;
+}
+interface User {
+    id: string;
+    email: string;
+    name: string;
+    firstName?: string;
+    lastName?: string;
+    avatar?: string;
+    organizationId: string;
+    sectionId?: string;
+    role: UserRole;
+    customRole?: CustomRole;
+    permissions?: string[];
+    metadata?: Record<string, unknown>;
+    createdAt: string;
+    updatedAt: string;
+}
+/**
+ * Check if user has a specific permission
+ */
+declare function userHasPermission(user: User, permission: string): boolean;
+/**
+ * Check if user has any of the specified permissions
+ */
+declare function userHasAnyPermission(user: User, permissions: string[]): boolean;
+/**
+ * Check if user has all of the specified permissions
+ */
+declare function userHasAllPermissions(user: User, permissions: string[]): boolean;
+interface Membership {
+    userId: string;
+    organizationId: string;
+    sectionId?: string;
+    section?: Section;
+    role: UserRole;
+    status: 'active' | 'pending' | 'suspended' | 'expired';
+    joinedAt: string;
+    expiresAt?: string;
+    metadata?: Record<string, unknown>;
+}
+interface ContentItem {
+    id: string;
+    organizationId: string;
+    type: string;
+    title: string;
+    slug: string;
+    content: string;
+    excerpt?: string;
+    author?: {
+        id: string;
+        name: string;
+    };
+    status: 'draft' | 'published' | 'archived';
+    visibility: 'public' | 'members' | 'section';
+    sectionId?: string;
+    publishedAt?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+interface NewsItem extends ContentItem {
+    type: 'news';
+    featuredImage?: string;
+    category?: string;
+    tags?: string[];
+}
+interface Page extends ContentItem {
+    type: 'page';
+    template?: string;
+    order?: number;
+}
+interface PaginatedResponse<T> {
+    items: T[];
+    total: number;
+    page: number;
+    pageSize: number;
+    hasMore: boolean;
+}
+interface AxCloudConfig {
+    orgId: string;
+    apiUrl: string;
+    /** API stage - defaults to 'dev'. Use 'prod' for production. */
+    stage: string;
+    /** API key for public content endpoints (optional - required for public API access) */
+    apiKey?: string;
+    auth0: {
+        domain: string;
+        clientId: string;
+        redirectUri: string;
+        audience?: string;
+        /** Database connection name for password operations. Defaults to 'Username-Password-Authentication' */
+        connection?: string;
+    };
+}
+interface ContentQueryOptions {
+    page?: number;
+    pageSize?: number;
+    status?: 'draft' | 'published' | 'archived';
+    visibility?: 'public' | 'members' | 'section';
+    sectionId?: string;
+    search?: string;
+    sortBy?: string;
+    sortOrder?: 'asc' | 'desc';
+    /** Force public endpoint even when authenticated (for public pages) */
+    publicOnly?: boolean;
+}
+/**
+ * Organization branding information
+ */
+interface OrganizationBranding {
+    organizationId: string;
+    name: string;
+    branding: {
+        /** Signed URL for logo (expires in 1 hour) */
+        logoUrl: string | null;
+        /** Seconds until logoUrl expires */
+        logoExpiresIn: number | null;
+        /** Primary brand color (hex) */
+        primaryColor: string | null;
+        /** Secondary brand color (hex) */
+        secondaryColor: string | null;
+    };
+}
+/**
+ * Signed URL response for media assets
+ */
+interface SignedMediaUrl {
+    /** Signed S3 URL (expires in 1 hour) */
+    url: string;
+    /** Seconds until URL expires */
+    expiresIn: number;
+    /** S3 bucket name */
+    bucket: string;
+    /** S3 object key */
+    key: string;
+}
+/**
+ * Media list item
+ */
+interface MediaItem {
+    /** File key (filename) */
+    key: string;
+    /** File size in bytes */
+    size: number;
+    /** Last modified timestamp */
+    lastModified: string;
+}
+/**
+ * Media list response
+ */
+interface MediaListResponse {
+    items: MediaItem[];
+    count: number;
+    bucket: string;
+    prefix: string;
+}
+
+/**
+ * AxCloud Forms Module
+ *
+ * Public functions for form submissions.
+ * Requires organization API key for authentication.
+ * Used by public websites like airene.io, theremoters.io, etc.
+ */
+/**
+ * Form submission request
+ */
+interface FormSubmission {
+    /** Organization API key (required for authentication) */
+    apiKey: string;
+    /** Site domain (e.g., 'airene.io') */
+    site: string;
+    /** Form type: 'waitlist', 'contact', or 'membership' */
+    formType: 'waitlist' | 'contact' | 'membership';
+    /** Email address */
+    email: string;
+    /** Additional form data */
+    data?: Record<string, unknown>;
+}
+/**
+ * Form submission response
+ */
+interface FormSubmissionResponse {
+    /** Whether the submission was successful */
+    success: boolean;
+    /** User-friendly message */
+    message: string;
+    /** Unique submission ID */
+    submissionId: string;
+}
+/**
+ * Form submission stored in database
+ */
+interface FormSubmissionRecord {
+    submission_id: string;
+    org_id: string;
+    site: string;
+    form_type: 'waitlist' | 'contact' | 'membership';
+    status: 'pending' | 'approved' | 'rejected' | 'converted';
+    email: string;
+    data: Record<string, unknown>;
+    created_at: string;
+    updated_at: string;
+    reviewed_by?: string;
+    reviewed_at?: string;
+    notes?: string;
+    user_id?: string;
+}
+/**
+ * Form stats response from API
+ */
+interface FormStatsResponse {
+    stats: {
+        total: number;
+        byStatus: Record<string, number>;
+        byType: Record<string, number>;
+        bySite: Record<string, number>;
+        recent: {
+            today: number;
+            last7Days: number;
+            last30Days: number;
+        };
+    };
+    summary: {
+        pending: number;
+        approved: number;
+        rejected: number;
+        conversionRate: string;
+    };
+    period: {
+        days: number;
+        from: string;
+        to: string;
+    };
+}
+/**
+ * Paginated response for form submissions
+ */
+interface FormSubmissionsResponse {
+    items: FormSubmissionRecord[];
+    total: number;
+    cursor?: string;
+    hasMore: boolean;
+}
+/**
+ * Submit a form to AxCloud
+ *
+ * Requires organization API key for authentication.
+ *
+ * @param apiUrl - AxCloud Forms API base URL (e.g., 'https://api.axcloud.app/forms/dev')
+ * @param submission - Form submission data including API key
+ * @returns Submission response with ID
+ *
+ * @example
+ * ```tsx
+ * import { submitForm } from '@axcloud/sdk'
+ *
+ * const handleSubmit = async (email: string) => {
+ *   const result = await submitForm(
+ *     'https://api.axcloud.app/forms/dev',
+ *     {
+ *       apiKey: 'your-org-api-key',
+ *       site: 'airene.io',
+ *       formType: 'waitlist',
+ *       email,
+ *       data: { name: 'John Doe' }
+ *     }
+ *   )
+ *   console.log(result.message) // "Thanks! We'll notify you when we launch."
+ * }
+ * ```
+ */
+declare function submitForm(apiUrl: string, submission: FormSubmission): Promise<FormSubmissionResponse>;
+/**
+ * Create a form submission helper with pre-configured API URL, API key, and site
+ *
+ * @param config - Configuration with apiUrl, apiKey, and site
+ * @returns Object with submit functions
+ *
+ * @example
+ * ```tsx
+ * import { createFormHelper } from '@axcloud/sdk'
+ *
+ * const forms = createFormHelper({
+ *   apiUrl: 'https://api.axcloud.app/forms/dev',
+ *   apiKey: 'your-org-api-key',
+ *   site: 'airene.io'
+ * })
+ *
+ * // Now you can submit forms without repeating apiUrl, apiKey and site
+ * const result = await forms.submit('waitlist', 'user@example.com')
+ * ```
+ */
+declare function createFormHelper(config: {
+    apiUrl: string;
+    apiKey: string;
+    site: string;
+}): {
+    /**
+     * Submit a waitlist form
+     */
+    submitWaitlist: (email: string, data?: Record<string, unknown>) => Promise<FormSubmissionResponse>;
+    /**
+     * Submit a contact form
+     */
+    submitContact: (email: string, data: {
+        name?: string;
+        message: string;
+        [key: string]: unknown;
+    }) => Promise<FormSubmissionResponse>;
+    /**
+     * Submit a membership application
+     */
+    submitMembership: (email: string, data: {
+        firstName?: string;
+        lastName?: string;
+        phone?: string;
+        [key: string]: unknown;
+    }) => Promise<FormSubmissionResponse>;
+    /**
+     * Generic submit function
+     */
+    submit: (formType: "waitlist" | "contact" | "membership", email: string, data?: Record<string, unknown>) => Promise<FormSubmissionResponse>;
+};
+
+interface AxCloudProviderProps {
+    children: React.ReactNode;
+    orgId: string;
+    apiUrl: string;
+    /** API stage - defaults to 'dev'. Use 'prod' for production. */
+    stage?: string;
+    /** API key for public content endpoints */
+    apiKey?: string;
+    auth0: {
+        domain: string;
+        clientId: string;
+        redirectUri: string;
+        audience?: string;
+        /** Database connection name for password operations. Defaults to 'Username-Password-Authentication' */
+        connection?: string;
+    };
+    queryClient?: QueryClient;
+    /** Default request timeout in milliseconds (default: 30000) */
+    timeout?: number;
+}
+/**
+ * AxCloudProvider - Main provider for the SDK
+ *
+ * Combines Auth0Provider, QueryClientProvider, and AxCloud context.
+ *
+ * @example
+ * ```tsx
+ * <AxCloudProvider
+ *   orgId="spf"
+ *   apiUrl="https://api.axcloud.app"
+ *   apiKey="your-api-key"  // Required for public content access
+ *   auth0={{
+ *     domain: "auth.axcloud.app",
+ *     clientId: "xxx",
+ *     redirectUri: window.location.origin
+ *   }}
+ * >
+ *   <App />
+ * </AxCloudProvider>
+ * ```
+ */
+declare function AxCloudProvider({ children, orgId, apiUrl, stage, apiKey, auth0, queryClient, timeout, }: AxCloudProviderProps): react_jsx_runtime.JSX.Element;
+
+interface AxCloudContextValue {
+    config: AxCloudConfig;
+    client: AxCloudClient;
+    orgId: string;
+    /** API stage (e.g., 'dev', 'prod') */
+    stage: string;
+    /** Whether using public API mode (API key, no auth) */
+    isPublicMode: boolean;
+}
+declare function useAxCloudContext(): AxCloudContextValue;
+
+interface AuthUser {
+    id: string;
+    email: string;
+    name: string;
+    avatar?: string;
+}
+interface UseAuthReturn {
+    isAuthenticated: boolean;
+    isLoading: boolean;
+    error: Error | undefined;
+    user: AuthUser | null;
+    login: (options?: {
+        returnTo?: string;
+    }) => Promise<void>;
+    logout: (options?: {
+        returnTo?: string;
+    }) => Promise<void>;
+    getAccessToken: () => Promise<string | undefined>;
+    getAuth0Client: () => Auth0ClientState;
+    /** Request a password reset email for the current user or specified email */
+    requestPasswordReset: (email?: string) => Promise<{
+        success: boolean;
+        message: string;
+    }>;
+}
+interface Auth0ClientState {
+    loginWithRedirect: ReturnType<typeof useAuth0>['loginWithRedirect'];
+    logout: ReturnType<typeof useAuth0>['logout'];
+    getAccessTokenSilently: ReturnType<typeof useAuth0>['getAccessTokenSilently'];
+    getIdTokenClaims: ReturnType<typeof useAuth0>['getIdTokenClaims'];
+    user: User$1 | undefined;
+    isAuthenticated: boolean;
+    isLoading: boolean;
+    error: Error | undefined;
+}
+/**
+ * useAuth - Authentication hook with simplified API and escape hatch
+ *
+ * Provides easy login/logout methods while allowing access to the
+ * underlying Auth0 client for advanced use cases.
+ *
+ * @example
+ * ```tsx
+ * function Header() {
+ *   const { isAuthenticated, login, logout, user } = useAuth()
+ *
+ *   return isAuthenticated ? (
+ *     <button onClick={logout}>Log out</button>
+ *   ) : (
+ *     <button onClick={login}>Log in</button>
+ *   )
+ * }
+ * ```
+ *
+ * @example
+ * // Advanced: Get access token for manual API calls
+ * ```tsx
+ * function MyComponent() {
+ *   const { getAccessToken } = useAuth()
+ *
+ *   const fetchData = async () => {
+ *     const token = await getAccessToken()
+ *     // Use token for custom API calls
+ *   }
+ * }
+ * ```
+ */
+declare function useAuth(): UseAuthReturn;
+
+interface UserApiResponse extends User {
+    all_org_ids?: string[];
+    organization_memberships?: Record<string, {
+        role: string;
+        sections?: string[];
+    }>;
+    isSuperAdmin?: boolean;
+}
+/**
+ * useUser - Fetch the current authenticated user from AxCloud
+ *
+ * Returns the full user profile including organization membership,
+ * role, section, and permissions.
+ *
+ * Also validates that the user has access to the configured organization.
+ *
+ * @example
+ * ```tsx
+ * function Profile() {
+ *   const { user, isLoading, isError, hasOrgAccess } = useUser()
+ *
+ *   if (isLoading) return <Spinner />
+ *   if (!hasOrgAccess) return <AccessDenied />
+ *   if (!user) return <LoginPrompt />
+ *
+ *   return (
+ *     <div>
+ *       <h1>Welcome, {user.name}!</h1>
+ *       <p>Role: {user.role}</p>
+ *       <p>Organization: {user.organizationId}</p>
+ *     </div>
+ *   )
+ * }
+ * ```
+ */
+declare function useUser(): {
+    user: UserApiResponse | null;
+    isLoading: boolean;
+    isError: boolean;
+    error: Error | null;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<UserApiResponse, Error>>;
+    hasOrgAccess: boolean;
+    roleInOrg: string | null;
+    isAuthenticated: boolean;
+    role: UserRole | null;
+    organizationId: string | null;
+    sectionId: string | null;
+    permissions: string[];
+    isSuperAdmin: boolean;
+};
+
+/**
+ * Public organization response from /content/public/{orgId}/org
+ */
+interface PublicOrganization {
+    org_id: string;
+    name: string;
+    description?: string;
+    branding?: {
+        logo?: string;
+        primaryColor?: string;
+        secondaryColor?: string;
+    };
+    modules?: string[];
+    contact?: {
+        email?: string;
+        phone?: string;
+        website?: string;
+    };
+    social?: {
+        facebook?: string;
+        twitter?: string;
+        linkedin?: string;
+        instagram?: string;
+    };
+}
+/**
+ * useOrg - Fetch organization info and check module availability
+ *
+ * Automatically uses the appropriate endpoint:
+ * - With API key (public): `/content/public/{orgId}/org`
+ * - With JWT auth: `/{stage}/api/organizations/{orgId}`
+ *
+ * @example
+ * ```tsx
+ * function Dashboard() {
+ *   const { org, hasModule, isLoading } = useOrg()
+ *
+ *   if (isLoading) return <Spinner />
+ *
+ *   return (
+ *     <div>
+ *       <h1>{org.name}</h1>
+ *       {org.branding?.logo && <img src={org.branding.logo} alt={org.name} />}
+ *       {hasModule('training') && <TrainingSection />}
+ *       {hasModule('ai') && <AIChatWidget />}
+ *     </div>
+ *   )
+ * }
+ * ```
+ */
+declare function useOrg(): {
+    org: {
+        id: string;
+        org_id: string;
+        name: string;
+        description: string | undefined;
+        branding: {
+            primaryColor?: string;
+            logo?: string;
+        } | undefined;
+        modules: string[];
+        contact: {
+            email?: string;
+            phone?: string;
+            website?: string;
+        } | undefined;
+        social: {
+            facebook?: string;
+            twitter?: string;
+            linkedin?: string;
+            instagram?: string;
+        } | undefined;
+    } | null;
+    orgId: string;
+    isLoading: boolean;
+    isError: boolean;
+    error: Error | null;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<Organization | PublicOrganization, Error>>;
+    hasModule: (module: AxCloudModule) => boolean;
+    modules: string[];
+};
+
+/**
+ * useNews - Fetch news articles for the organization
+ *
+ * When authenticated (isPublicMode = false), fetches news visible to members
+ * including public, internal, and members-only content.
+ *
+ * When not authenticated (isPublicMode = true), fetches only public news.
+ *
+ * @example
+ * ```tsx
+ * function NewsPage() {
+ *   const { data: news, isLoading, isError, error } = useNews()
+ *
+ *   if (isLoading) return <Spinner />
+ *   if (isError) return <Error message={error.message} />
+ *
+ *   return (
+ *     <ul>
+ *       {news.map(item => (
+ *         <li key={item.id}>{item.title}</li>
+ *       ))}
+ *     </ul>
+ *   )
+ * }
+ * ```
+ *
+ * @example
+ * // With pagination
+ * ```tsx
+ * const { data, hasMore, fetchNextPage } = useNews({
+ *   pageSize: 10,
+ *   status: 'published'
+ * })
+ * ```
+ */
+declare function useNews(options?: ContentQueryOptions): {
+    data: NewsItem[];
+    total: number;
+    hasMore: boolean;
+    isLoading: boolean;
+    isError: boolean;
+    error: Error | null;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<PaginatedResponse<NewsItem>, Error>>;
+};
+
+/**
+ * useContent - Generic content fetching hook
+ *
+ * When authenticated (isPublicMode = false), fetches content visible to members
+ * including public, internal, and members-only content (for supported types).
+ *
+ * When not authenticated (isPublicMode = true), fetches only public content.
+ *
+ * @param contentType - The type of content to fetch (e.g., 'news', 'pages', 'events')
+ * @param options - Query options for filtering and pagination
+ *
+ * @example
+ * ```tsx
+ * // Fetch pages
+ * const { data: pages } = useContent('pages')
+ *
+ * // Fetch custom content type
+ * const { data: events } = useContent('events', {
+ *   status: 'published',
+ *   sortBy: 'startDate'
+ * })
+ * ```
+ */
+declare function useContent<T extends ContentItem = ContentItem>(contentType: string, options?: ContentQueryOptions): {
+    data: T[];
+    total: number;
+    hasMore: boolean;
+    isLoading: boolean;
+    isError: boolean;
+    error: Error | null;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<PaginatedResponse<T>, Error>>;
+};
+interface ContentItemOptions {
+    /** Force public endpoint even when authenticated */
+    publicOnly?: boolean;
+}
+/**
+ * useContentItem - Fetch a single content item by ID or slug
+ *
+ * When authenticated (isPublicMode = false), fetches from member endpoint
+ * which can return members-only content (for supported types).
+ *
+ * When not authenticated (isPublicMode = true), fetches only public content.
+ *
+ * @param contentType - The type of content (e.g., 'news', 'pages', 'events')
+ * @param idOrSlug - The content ID or slug
+ * @param options - Optional settings
+ *
+ * @example
+ * ```tsx
+ * // Fetch a page by slug
+ * const { data: page } = useContentItem('pages', 'about-us')
+ *
+ * // Force public endpoint
+ * const { data: page } = useContentItem('pages', 'about-us', { publicOnly: true })
+ * ```
+ */
+declare function useContentItem<T extends ContentItem = ContentItem>(contentType: string, idOrSlug: string, options?: ContentItemOptions): {
+    data: _tanstack_react_query.NoInfer<T> | null;
+    isLoading: boolean;
+    isError: boolean;
+    error: Error | null;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<_tanstack_react_query.NoInfer<T>, Error>>;
+};
+
+interface SectionWithMembers extends Section {
+    members?: User[];
+    memberCount?: number;
+}
+/**
+ * useMySection - Fetch the current user's section
+ *
+ * Returns the section the authenticated user belongs to,
+ * along with optional member list if the user has permission to view.
+ *
+ * @example
+ * ```tsx
+ * function MySectionPage() {
+ *   const { section, members, isLoading } = useMySection()
+ *
+ *   if (isLoading) return <Spinner />
+ *   if (!section) return <p>You are not assigned to a section</p>
+ *
+ *   return (
+ *     <div>
+ *       <h1>{section.name}</h1>
+ *       <p>{section.description}</p>
+ *       <h2>Members ({members.length})</h2>
+ *       <ul>
+ *         {members.map(m => <li key={m.id}>{m.name}</li>)}
+ *       </ul>
+ *     </div>
+ *   )
+ * }
+ * ```
+ */
+declare function useMySection(options?: {
+    includeMembers?: boolean;
+}): {
+    section: SectionWithMembers | null;
+    sectionId: string | null;
+    members: User[];
+    memberCount: number;
+    isLoading: boolean;
+    isError: boolean;
+    error: Error | null;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<SectionWithMembers, Error>>;
+    hasSection: boolean;
+    user: UserApiResponse | null;
+};
+/**
+ * useSections - Fetch all sections for the organization
+ *
+ * @example
+ * ```tsx
+ * const { sections } = useSections()
+ * ```
+ */
+declare function useSections(): {
+    sections: Section[];
+    isLoading: boolean;
+    isError: boolean;
+    error: Error | null;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<Section[], Error>>;
+};
+
+interface UseFormsOptions {
+    /** Filter by form type */
+    formType?: 'waitlist' | 'contact' | 'membership';
+    /** Filter by status */
+    status?: 'pending' | 'approved' | 'rejected' | 'converted';
+    /** Number of items per page (default 50, max 100) */
+    limit?: number;
+    /** Pagination cursor */
+    cursor?: string;
+}
+interface UseFormStatsOptions {
+    /** Number of days to include (default 30, max 365) */
+    days?: number;
+}
+/**
+ * useForms - Fetch form submissions for the organization (admin only)
+ *
+ * @example
+ * ```tsx
+ * function FormSubmissions() {
+ *   const { data, isLoading, hasMore, refetch } = useForms({
+ *     status: 'pending'
+ *   })
+ *
+ *   if (isLoading) return <Spinner />
+ *
+ *   return (
+ *     <ul>
+ *       {data.map(submission => (
+ *         <li key={submission.submission_id}>{submission.email}</li>
+ *       ))}
+ *     </ul>
+ *   )
+ * }
+ * ```
+ */
+declare function useForms(options?: UseFormsOptions): {
+    data: FormSubmissionRecord[];
+    total: number;
+    hasMore: boolean;
+    cursor: string | undefined;
+    isLoading: boolean;
+    isError: boolean;
+    error: Error | null;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<FormSubmissionsResponse, Error>>;
+};
+/**
+ * useFormStats - Fetch form submission statistics (admin only)
+ *
+ * @example
+ * ```tsx
+ * function FormDashboard() {
+ *   const { stats, summary, isLoading } = useFormStats({ days: 30 })
+ *
+ *   if (isLoading) return <Spinner />
+ *
+ *   return (
+ *     <div>
+ *       <p>Pending: {summary.pending}</p>
+ *       <p>Approved: {summary.approved}</p>
+ *       <p>Conversion Rate: {summary.conversionRate}</p>
+ *     </div>
+ *   )
+ * }
+ * ```
+ */
+declare function useFormStats(options?: UseFormStatsOptions): {
+    stats: {
+        total: number;
+        byStatus: Record<string, number>;
+        byType: Record<string, number>;
+        bySite: Record<string, number>;
+        recent: {
+            today: number;
+            last7Days: number;
+            last30Days: number;
+        };
+    } | undefined;
+    summary: {
+        pending: number;
+        approved: number;
+        rejected: number;
+        conversionRate: string;
+    } | undefined;
+    period: {
+        days: number;
+        from: string;
+        to: string;
+    } | undefined;
+    isLoading: boolean;
+    isError: boolean;
+    error: Error | null;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<FormStatsResponse, Error>>;
+};
+/**
+ * useUpdateFormSubmission - Mutation hook for updating submission status
+ *
+ * @example
+ * ```tsx
+ * function SubmissionRow({ submission }) {
+ *   const { mutate: updateSubmission, isLoading } = useUpdateFormSubmission()
+ *
+ *   const handleApprove = () => {
+ *     updateSubmission({
+ *       submissionId: submission.submission_id,
+ *       status: 'approved',
+ *       notes: 'Approved by admin'
+ *     })
+ *   }
+ *
+ *   return (
+ *     <button onClick={handleApprove} disabled={isLoading}>
+ *       Approve
+ *     </button>
+ *   )
+ * }
+ * ```
+ */
+declare function useUpdateFormSubmission(): _tanstack_react_query.UseMutationResult<{
+    success: boolean;
+    message: string;
+    submission: FormSubmissionRecord;
+    user_created?: boolean;
+    user_id?: string;
+}, Error, {
+    submissionId: string;
+    status: "approved" | "rejected";
+    notes?: string;
+}, unknown>;
+
+/**
+ * useLinkedAccounts Hook
+ *
+ * Manages linked social accounts (identities) for the current user.
+ * Supports Google, Microsoft, and Apple OAuth providers.
+ *
+ * Uses React-Query for caching, background refresh, and automatic refetch.
+ *
+ * @example
+ * ```tsx
+ * function AccountSettings() {
+ *   const {
+ *     identities,
+ *     availableProviders,
+ *     isLoading,
+ *     linkAccount,
+ *     unlinkAccount,
+ *     canUnlink
+ *   } = useLinkedAccounts()
+ *
+ *   return (
+ *     <div>
+ *       {identities.map(identity => (
+ *         <div key={identity.provider}>
+ *           {identity.provider_display_name}
+ *           {canUnlink && !identity.is_primary && (
+ *             <button onClick={() => unlinkAccount(identity.provider)}>
+ *               Disconnect
+ *             </button>
+ *           )}
+ *         </div>
+ *       ))}
+ *       {availableProviders.map(provider => (
+ *         <button key={provider.provider} onClick={() => linkAccount(provider.provider)}>
+ *           Connect {provider.display_name}
+ *         </button>
+ *       ))}
+ *     </div>
+ *   )
+ * }
+ * ```
+ */
+interface LinkedIdentity {
+    provider: string;
+    provider_display_name: string;
+    provider_icon: string;
+    user_id: string;
+    connection: string;
+    is_social: boolean;
+    is_primary: boolean;
+    profile_data?: {
+        email?: string;
+        name?: string;
+        picture?: string;
+    };
+}
+interface AvailableProvider {
+    provider: string;
+    display_name: string;
+    icon: string;
+}
+interface UseLinkedAccountsReturn {
+    /** List of linked identities/accounts */
+    identities: LinkedIdentity[];
+    /** List of providers available for linking */
+    availableProviders: AvailableProvider[];
+    /** Whether the user can unlink accounts (must have >1) */
+    canUnlink: boolean;
+    /** Loading state */
+    isLoading: boolean;
+    /** Error state */
+    error: Error | null;
+    /** Initiate linking a new account - redirects to OAuth flow */
+    linkAccount: (provider: 'google' | 'microsoft' | 'apple') => void;
+    /** Unlink an account */
+    unlinkAccount: (provider: string) => void;
+    /** Whether a link operation is in progress */
+    isLinking: boolean;
+    /** Whether an unlink operation is in progress */
+    isUnlinking: boolean;
+    /** Refresh the identities list */
+    refetch: () => Promise<unknown>;
+}
+/**
+ * useLinkedAccounts - Manage social login accounts
+ *
+ * Provides functionality to view, link, and unlink social accounts
+ * (Google, Microsoft, Apple) from the user's profile.
+ *
+ * Uses React-Query for caching and automatic state management.
+ */
+declare function useLinkedAccounts(): UseLinkedAccountsReturn;
+
+/**
+ * useBranding - Fetch organization branding (logo, colors)
+ *
+ * Returns branding information including a signed URL for the logo.
+ * The logo URL expires after 1 hour and will be refreshed automatically.
+ *
+ * @example
+ * ```tsx
+ * const { branding, logoUrl, isLoading } = useBranding()
+ *
+ * return (
+ *   <header>
+ *     {logoUrl && <img src={logoUrl} alt="Logo" />}
+ *     <h1 style={{ color: branding?.primaryColor }}>Welcome</h1>
+ *   </header>
+ * )
+ * ```
+ */
+declare function useBranding(): {
+    branding: {
+        logoUrl: string | null;
+        logoExpiresIn: number | null;
+        primaryColor: string | null;
+        secondaryColor: string | null;
+    } | null;
+    logoUrl: string | null;
+    organizationName: string | null;
+    isLoading: boolean;
+    isError: boolean;
+    error: Error | null;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<OrganizationBranding, Error>>;
+};
+/**
+ * useLogo - Fetch organization logo URL
+ *
+ * Returns a signed URL for the organization logo.
+ * Use this when you only need the logo, not full branding info.
+ *
+ * @example
+ * ```tsx
+ * const { logoUrl, isLoading } = useLogo()
+ *
+ * if (isLoading) return <Skeleton />
+ * return logoUrl ? <img src={logoUrl} alt="Logo" /> : <DefaultLogo />
+ * ```
+ */
+declare function useLogo(): {
+    logoUrl: string | null;
+    expiresIn: number | null;
+    isLoading: boolean;
+    isError: boolean;
+    error: Error | null;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<SignedMediaUrl, Error>>;
+};
+/**
+ * useAvatar - Fetch user avatar URL
+ *
+ * @param userId - The user ID to fetch avatar for
+ *
+ * @example
+ * ```tsx
+ * const { avatarUrl } = useAvatar(user.id)
+ * return <img src={avatarUrl || defaultAvatar} alt={user.name} />
+ * ```
+ */
+declare function useAvatar(userId: string): {
+    avatarUrl: string | null;
+    isLoading: boolean;
+    isError: boolean;
+    error: Error | null;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<SignedMediaUrl, Error>>;
+};
+/**
+ * useMediaList - List media files in organization's library
+ *
+ * @param type - Media type to list ('media', 'logos', 'avatars')
+ * @param limit - Maximum number of items to return (default: 50)
+ *
+ * @example
+ * ```tsx
+ * const { items, isLoading } = useMediaList('media', 20)
+ *
+ * return (
+ *   <div className="grid">
+ *     {items.map(item => (
+ *       <MediaThumbnail key={item.key} item={item} />
+ *     ))}
+ *   </div>
+ * )
+ * ```
+ */
+declare function useMediaList(type?: 'media' | 'logos' | 'avatars', limit?: number): {
+    items: MediaItem[];
+    count: number;
+    isLoading: boolean;
+    isError: boolean;
+    error: Error | null;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<MediaListResponse, Error>>;
+};
+/**
+ * useMedia - Fetch a specific media file by ID
+ *
+ * @param mediaId - The media ID (filename including extension)
+ *
+ * @example
+ * ```tsx
+ * const { mediaUrl } = useMedia('hero-image.jpg')
+ * return <img src={mediaUrl} alt="Hero" />
+ * ```
+ */
+declare function useMedia(mediaId: string): {
+    mediaUrl: string | null;
+    expiresIn: number | null;
+    isLoading: boolean;
+    isError: boolean;
+    error: Error | null;
+    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<SignedMediaUrl, Error>>;
+};
+
+interface LoginButtonProps {
+    /**
+     * Button text when not authenticated
+     */
+    children?: React.ReactNode;
+    /**
+     * URL to return to after login
+     */
+    returnTo?: string;
+    /**
+     * Additional CSS class names
+     */
+    className?: string;
+    /**
+     * Inline styles
+     */
+    style?: React.CSSProperties;
+}
+/**
+ * LoginButton - Trigger Auth0 Universal Login
+ *
+ * @example
+ * ```tsx
+ * <LoginButton>Sign In</LoginButton>
+ *
+ * // With custom return URL
+ * <LoginButton returnTo="/dashboard">Sign In</LoginButton>
+ *
+ * // With styling
+ * <LoginButton className="btn btn-primary">Sign In</LoginButton>
+ * ```
+ */
+declare function LoginButton({ children, returnTo, className, style, }: LoginButtonProps): react_jsx_runtime.JSX.Element;
+interface LogoutButtonProps {
+    /**
+     * Button text
+     */
+    children?: React.ReactNode;
+    /**
+     * URL to return to after logout
+     */
+    returnTo?: string;
+    /**
+     * Additional CSS class names
+     */
+    className?: string;
+    /**
+     * Inline styles
+     */
+    style?: React.CSSProperties;
+}
+/**
+ * LogoutButton - Trigger logout
+ *
+ * @example
+ * ```tsx
+ * <LogoutButton>Sign Out</LogoutButton>
+ * ```
+ */
+declare function LogoutButton({ children, returnTo, className, style, }: LogoutButtonProps): react_jsx_runtime.JSX.Element;
+
+interface ProtectedRouteProps {
+    /**
+     * Content to render when authenticated
+     */
+    children: React.ReactNode;
+    /**
+     * Required role(s) to access this route
+     */
+    roles?: UserRole | UserRole[];
+    /**
+     * Component to render while loading
+     */
+    loadingComponent?: React.ReactNode;
+    /**
+     * Component to render when not authenticated
+     */
+    unauthenticatedComponent?: React.ReactNode;
+    /**
+     * Component to render when authenticated but lacking required role
+     */
+    unauthorizedComponent?: React.ReactNode;
+    /**
+     * Whether to automatically redirect to login when not authenticated
+     * @default false
+     */
+    redirectToLogin?: boolean;
+    /**
+     * Return URL after login (only used with redirectToLogin)
+     */
+    returnTo?: string;
+}
+/**
+ * ProtectedRoute - Require authentication to view content
+ *
+ * @example
+ * ```tsx
+ * // Basic usage
+ * <ProtectedRoute>
+ *   <MemberContent />
+ * </ProtectedRoute>
+ *
+ * // With role requirement
+ * <ProtectedRoute roles="admin">
+ *   <AdminDashboard />
+ * </ProtectedRoute>
+ *
+ * // With multiple allowed roles
+ * <ProtectedRoute roles={['admin', 'editor']}>
+ *   <ContentEditor />
+ * </ProtectedRoute>
+ *
+ * // With custom fallbacks
+ * <ProtectedRoute
+ *   loadingComponent={<Spinner />}
+ *   unauthenticatedComponent={<LoginPrompt />}
+ *   unauthorizedComponent={<AccessDenied />}
+ * >
+ *   <ProtectedContent />
+ * </ProtectedRoute>
+ *
+ * // Auto-redirect to login
+ * <ProtectedRoute redirectToLogin>
+ *   <MemberArea />
+ * </ProtectedRoute>
+ * ```
+ */
+declare function ProtectedRoute({ children, roles, loadingComponent, unauthenticatedComponent, unauthorizedComponent, redirectToLogin, returnTo, }: ProtectedRouteProps): react_jsx_runtime.JSX.Element;
+
+interface ModuleGateProps {
+    /**
+     * Required module(s) to render children
+     */
+    module: AxCloudModule | AxCloudModule[];
+    /**
+     * Content to render when module is enabled
+     */
+    children: React.ReactNode;
+    /**
+     * Content to render when module is NOT enabled
+     */
+    fallback?: React.ReactNode;
+    /**
+     * Whether ALL modules are required (true) or ANY module (false)
+     * @default false (any)
+     */
+    requireAll?: boolean;
+}
+/**
+ * ModuleGate - Conditionally render based on organization modules
+ *
+ * Only renders children if the organization has the required module(s) enabled.
+ *
+ * @example
+ * ```tsx
+ * // Single module
+ * <ModuleGate module="training">
+ *   <TrainingSection />
+ * </ModuleGate>
+ *
+ * // With fallback
+ * <ModuleGate module="ai" fallback={<UpgradePrompt />}>
+ *   <AIChatWidget />
+ * </ModuleGate>
+ *
+ * // Multiple modules (any)
+ * <ModuleGate module={['training', 'documents']}>
+ *   <LearningCenter />
+ * </ModuleGate>
+ *
+ * // Multiple modules (all required)
+ * <ModuleGate module={['training', 'ai']} requireAll>
+ *   <AITrainingAssistant />
+ * </ModuleGate>
+ * ```
+ */
+declare function ModuleGate({ module, children, fallback, requireAll, }: ModuleGateProps): react_jsx_runtime.JSX.Element | null;
+/**
+ * useModuleAccess - Hook for programmatic module checks
+ *
+ * @example
+ * ```tsx
+ * function Dashboard() {
+ *   const { hasModule, modules } = useModuleAccess()
+ *
+ *   return (
+ *     <nav>
+ *       <Link to="/news">News</Link>
+ *       {hasModule('training') && <Link to="/training">Training</Link>}
+ *       {hasModule('ai') && <Link to="/chat">AI Chat</Link>}
+ *     </nav>
+ *   )
+ * }
+ * ```
+ */
+declare function useModuleAccess(): {
+    hasModule: (module: AxCloudModule) => boolean;
+    modules: string[];
+    isLoading: boolean;
+};
+
+interface LinkedAccountsListProps {
+    /** Which providers to show (default: all available) */
+    providers?: ('google' | 'microsoft' | 'apple')[];
+    /** Show connect buttons for unlinked providers */
+    showConnectButtons?: boolean;
+    /** Custom class name for the container */
+    className?: string;
+    /** Callback when an account is successfully unlinked */
+    onUnlink?: (provider: string) => void;
+    /** Callback when link flow is initiated */
+    onLinkInitiated?: (provider: string) => void;
+    /** Custom render for identity items */
+    renderIdentity?: (identity: LinkedIdentity, onUnlink: () => void) => React.ReactNode;
+    /** Custom render for available provider items */
+    renderAvailableProvider?: (provider: AvailableProvider, onLink: () => void) => React.ReactNode;
+}
+/**
+ * LinkedAccountsList - Ready-to-use component for managing linked accounts
+ *
+ * Uses CSS classes for styling. Import the CSS file for default styles:
+ * import '@axcode/axcloud-sdk/styles/linked-accounts.css'
+ */
+declare function LinkedAccountsList({ providers, showConnectButtons, className, onUnlink, onLinkInitiated, renderIdentity, renderAvailableProvider, }: LinkedAccountsListProps): react_jsx_runtime.JSX.Element;
+
+export { type AvailableProvider, AxCloudClient, type AxCloudConfig, AxCloudError, type AxCloudErrorCode, type AxCloudModule, AxCloudProvider, type BaseRole, type ContentItem, type ContentQueryOptions, type CustomRole, type FormStatsResponse, type FormSubmission, type FormSubmissionRecord, type FormSubmissionResponse, type FormSubmissionsResponse, LinkedAccountsList, type LinkedAccountsListProps, type LinkedIdentity, LoginButton, LogoutButton, type MediaItem, type MediaListResponse, type Membership, ModuleGate, type NewsItem, type Organization, type OrganizationBranding, type OrganizationSettings, type Page, type PaginatedResponse, ProtectedRoute, type Section, type SectionPermissions, type SignedMediaUrl, type SystemRole, type UseLinkedAccountsReturn, type User, type UserRole, createClient, createFormHelper, getClient, isAxCloudError, submitForm, useAuth, useAvatar, useAxCloudContext, useBranding, useContent, useContentItem, useFormStats, useForms, useLinkedAccounts, useLogo, useMedia, useMediaList, useModuleAccess, useMySection, useNews, useOrg, useSections, useUpdateFormSubmission, useUser, userHasAllPermissions, userHasAnyPermission, userHasPermission };