import { Organization, OrganizationSettings } from '@frank-auth/client';
import { AuthError, CreateOrganizationParams, InviteMemberParams, OrganizationInvitation, OrganizationMembership, UpdateOrganizationParams } from '../provider/types';
export interface UseOrganizationReturn {
    organization: Organization | null;
    organizations: Organization[];
    activeOrganization: Organization | null;
    memberships: OrganizationMembership[];
    invitations: OrganizationInvitation[];
    isLoaded: boolean;
    isLoading: boolean;
    error: AuthError | null;
    createOrganization: (params: CreateOrganizationParams) => Promise<Organization>;
    updateOrganization: (organizationId: string, params: UpdateOrganizationParams) => Promise<Organization>;
    deleteOrganization: (organizationId: string) => Promise<void>;
    switchOrganization: (organizationId: string) => Promise<void>;
    inviteMember: (params: InviteMemberParams) => Promise<void>;
    removeMember: (memberId: string) => Promise<void>;
    updateMemberRole: (memberId: string, role: string) => Promise<void>;
    getMembers: () => Promise<OrganizationMember[]>;
    acceptInvitation: (invitationId: string) => Promise<void>;
    declineInvitation: (invitationId: string) => Promise<void>;
    cancelInvitation: (invitationId: string) => Promise<void>;
    resendInvitation: (invitationId: string) => Promise<void>;
    updateSettings: (settings: Partial<OrganizationSettings>) => Promise<OrganizationSettings>;
    organizationId: string | null;
    organizationName: string | null;
    organizationSlug: string | null;
    isOwner: boolean;
    isAdmin: boolean;
    isMember: boolean;
    memberCount: number;
    pendingInvitations: number;
    hasOrganizations: boolean;
    canCreateOrganization: boolean;
    canSwitchOrganization: boolean;
}
export interface OrganizationMember {
    id: string;
    userId: string;
    organizationId: string;
    role: string;
    status: "active" | "invited" | "suspended";
    joinedAt: Date;
    invitedBy?: string;
    user: {
        id: string;
        firstName?: string;
        lastName?: string;
        email: string;
        profileImageUrl?: string;
    };
}
/**
 * Organization management hook providing access to all organization functionality
 *
 * @example Basic organization management
 * ```tsx
 * import { useOrganization } from '@frank-auth/react';
 *
 * function OrganizationManager() {
 *   const {
 *     organization,
 *     organizations,
 *     switchOrganization,
 *     createOrganization,
 *     isOwner,
 *     memberCount
 *   } = useOrganization();
 *
 *   return (
 *     <div>
 *       <h2>{organization?.name}</h2>
 *       <p>Members: {memberCount}</p>
 *
 *       {organizations.length > 1 && (
 *         <select onChange={(e) => switchOrganization(e.target.value)}>
 *           {organizations.map((org) => (
 *             <option key={org.id} value={org.id}>
 *               {org.name}
 *             </option>
 *           ))}
 *         </select>
 *       )}
 *
 *       {isOwner && (
 *         <button onClick={() => createOrganization({
 *           name: 'New Organization',
 *           slug: 'new-org'
 *         })}>
 *           Create Organization
 *         </button>
 *       )}
 *     </div>
 *   );
 * }
 * ```
 *
 * @example Member management
 * ```tsx
 * function MemberManager() {
 *   const {
 *     getMembers,
 *     inviteMember,
 *     removeMember,
 *     isAdmin
 *   } = useOrganization();
 *   const [members, setMembers] = useState([]);
 *
 *   useEffect(() => {
 *     getMembers().then(setMembers);
 *   }, [getMembers]);
 *
 *   if (!isAdmin) return <div>Access denied</div>;
 *
 *   return (
 *     <div>
 *       <h3>Members</h3>
 *       {members.map((member) => (
 *         <div key={member.id}>
 *           <span>{member.user.email} ({member.role})</span>
 *           <button onClick={() => removeMember(member.id)}>
 *             Remove
 *           </button>
 *         </div>
 *       ))}
 *       <button onClick={() => inviteMember({
 *         emailAddress: 'new@example.com',
 *         role: 'member'
 *       })}>
 *         Invite Member
 *       </button>
 *     </div>
 *   );
 * }
 * ```
 */
export declare function useOrganization(): UseOrganizationReturn;
/**
 * Hook for organization membership and role information
 */
export declare function useOrganizationMembership(): {
    organization: Organization | null;
    membership: OrganizationMembership | null | undefined;
    role: string | null;
    isOwner: boolean;
    isAdmin: boolean;
    isMember: boolean;
    memberCount: number;
    joinedAt: Date | null;
    status: "active" | "suspended" | "invited" | null;
};
/**
 * Hook for organization invitations management
 */
export declare function useOrganizationInvitations(): {
    invitations: OrganizationInvitation[];
    pendingInvitations: OrganizationInvitation[];
    expiredInvitations: OrganizationInvitation[];
    acceptInvitation: (invitationId: string) => Promise<void>;
    declineInvitation: (invitationId: string) => Promise<void>;
    cancelInvitation: ((invitationId: string) => Promise<void>) | undefined;
    resendInvitation: ((invitationId: string) => Promise<void>) | undefined;
    inviteMember: ((params: InviteMemberParams) => Promise<void>) | undefined;
    canManageInvitations: boolean;
    isLoading: boolean;
    error: AuthError | null;
};
/**
 * Hook for organization switching
 */
export declare function useOrganizationSwitcher(): {
    organizations: Organization[];
    activeOrganization: Organization | null;
    switchOrganization: (organizationId: string) => Promise<void>;
    canSwitchOrganization: boolean;
    isLoading: boolean;
    hasMultipleOrganizations: boolean;
};
//# sourceMappingURL=use-organization.d.ts.map