import React, { PropsWithChildren } from 'react';
import { GetPendingInvitationsParams, GetMembershipsParams, GetDomainsParams, GetMembershipRequestParams, GetMembersParams, GetInvitationsParams, OrganizationDomainResource, OrganizationMembershipRequestResource, OrganizationMembershipResource, OrganizationInvitationResource, OrganizationResource, GetUserOrganizationMembershipParams, GetUserOrganizationInvitationsParams, GetUserOrganizationSuggestionsParams, UserOrganizationInvitationResource, OrganizationSuggestionResource, CreateOrganizationParams, SetActive, LoadedClerk, UserResource, ClientResource, ActiveSessionResource } from '@clerk/types';

declare function assertContextExists(contextVal: unknown, msgOrCtx: string | React.Context<any>): asserts contextVal;
type Options = {
    assertCtxFn?: (v: unknown, msg: string) => void;
};
type ContextOf<T> = React.Context<{
    value: T;
} | undefined>;
type UseCtxFn<T> = () => T;
/**
 * Creates and returns a Context and two hooks that return the context value.
 * The Context type is derived from the type passed in by the user.
 * The first hook returned guarantees that the context exists so the returned value is always CtxValue
 * The second hook makes no guarantees, so the returned value can be CtxValue | undefined
 */
declare const createContextAndHook: <CtxVal>(displayName: string, options?: Options) => [ContextOf<CtxVal>, UseCtxFn<CtxVal>, UseCtxFn<CtxVal | Partial<CtxVal>>];

type ValueOrSetter<T = unknown> = (size: T | ((_size: T) => T)) => void;
type PaginatedResources<T = unknown> = {
    data: T[];
    count: number;
    isLoading: boolean;
    isFetching: boolean;
    isError: boolean;
    page: number;
    pageCount: number;
    fetchPage: ValueOrSetter<number>;
    fetchPrevious: () => void;
    fetchNext: () => void;
    hasNextPage: boolean;
    hasPreviousPage: boolean;
};
type PaginatedResourcesWithDefault<T> = {
    [K in keyof PaginatedResources<T>]: PaginatedResources<T>[K] extends boolean ? false : PaginatedResources<T>[K] | undefined;
};

type UseOrganizationParams = {
    /**
     * @deprecated Use `invitations` instead
     */
    invitationList?: GetPendingInvitationsParams;
    /**
     * @deprecated Use `memberships` instead
     */
    membershipList?: GetMembershipsParams;
    domains?: true | (GetDomainsParams & {
        infinite?: boolean;
        keepPreviousData?: boolean;
    });
    membershipRequests?: true | (GetMembershipRequestParams & {
        infinite?: boolean;
        keepPreviousData?: boolean;
    });
    memberships?: true | (GetMembersParams & {
        infinite?: boolean;
        keepPreviousData?: boolean;
    });
    invitations?: true | (GetInvitationsParams & {
        infinite?: boolean;
        keepPreviousData?: boolean;
    });
};
type UseOrganizationReturn = {
    isLoaded: false;
    organization: undefined;
    /**
     * @deprecated Use `invitations` instead
     */
    invitationList: undefined;
    /**
     * @deprecated Use `memberships` instead
     */
    membershipList: undefined;
    membership: undefined;
    domains: PaginatedResourcesWithDefault<OrganizationDomainResource>;
    membershipRequests: PaginatedResourcesWithDefault<OrganizationMembershipRequestResource>;
    memberships: PaginatedResourcesWithDefault<OrganizationMembershipResource>;
    invitations: PaginatedResourcesWithDefault<OrganizationInvitationResource>;
} | {
    isLoaded: true;
    organization: OrganizationResource;
    /**
     * @deprecated Use `invitations` instead
     */
    invitationList: undefined;
    /**
     * @deprecated Use `memberships` instead
     */
    membershipList: undefined;
    membership: undefined;
    domains: PaginatedResourcesWithDefault<OrganizationDomainResource>;
    membershipRequests: PaginatedResourcesWithDefault<OrganizationMembershipRequestResource>;
    memberships: PaginatedResourcesWithDefault<OrganizationMembershipResource>;
    invitations: PaginatedResourcesWithDefault<OrganizationInvitationResource>;
} | {
    isLoaded: boolean;
    organization: OrganizationResource | null;
    /**
     * @deprecated Use `invitations` instead
     */
    invitationList: OrganizationInvitationResource[] | null | undefined;
    /**
     * @deprecated Use `memberships` instead
     */
    membershipList: OrganizationMembershipResource[] | null | undefined;
    membership: OrganizationMembershipResource | null | undefined;
    domains: PaginatedResources<OrganizationDomainResource> | null;
    membershipRequests: PaginatedResources<OrganizationMembershipRequestResource> | null;
    memberships: PaginatedResources<OrganizationMembershipResource> | null;
    invitations: PaginatedResources<OrganizationInvitationResource> | null;
};
type UseOrganization = (params?: UseOrganizationParams) => UseOrganizationReturn;
declare const useOrganization: UseOrganization;

type UseOrganizationListParams = {
    userMemberships?: true | (GetUserOrganizationMembershipParams & {
        infinite?: boolean;
        keepPreviousData?: boolean;
    });
    userInvitations?: true | (GetUserOrganizationInvitationsParams & {
        infinite?: boolean;
        keepPreviousData?: boolean;
    });
    userSuggestions?: true | (GetUserOrganizationSuggestionsParams & {
        infinite?: boolean;
        keepPreviousData?: boolean;
    });
};
type OrganizationList = ReturnType<typeof createOrganizationList>;
type UseOrganizationListReturn = {
    isLoaded: false;
    /**
     * @deprecated Use userMemberships instead
     */
    organizationList: undefined;
    createOrganization: undefined;
    setActive: undefined;
    userMemberships: PaginatedResourcesWithDefault<OrganizationMembershipResource>;
    userInvitations: PaginatedResourcesWithDefault<UserOrganizationInvitationResource>;
    userSuggestions: PaginatedResourcesWithDefault<OrganizationSuggestionResource>;
} | {
    isLoaded: boolean;
    /**
     * @deprecated Use userMemberships instead
     */
    organizationList: OrganizationList;
    createOrganization: (params: CreateOrganizationParams) => Promise<OrganizationResource>;
    setActive: SetActive;
    userMemberships: PaginatedResources<OrganizationMembershipResource>;
    userInvitations: PaginatedResources<UserOrganizationInvitationResource>;
    userSuggestions: PaginatedResources<OrganizationSuggestionResource>;
};
type UseOrganizationList = (params?: UseOrganizationListParams) => UseOrganizationListReturn;
declare const useOrganizationList: UseOrganizationList;
declare function createOrganizationList(organizationMemberships: OrganizationMembershipResource[]): {
    membership: OrganizationMembershipResource;
    organization: OrganizationResource;
}[];

type UseOrganizationsReturn = {
    isLoaded: false;
    /**
     * @deprecated Use `createOrganization` from `useOrganizationList`
     * Example: `const {createOrganization} = useOrganizationList()`
     */
    createOrganization: undefined;
    /**
     * @deprecated Use `memberships` from `useOrganization`
     * Example: `const {memberships} = useOrganization()`
     */
    getOrganizationMemberships: undefined;
    /**
     * @deprecated Use `getOrganization` from `useClerk`
     * Example: `const {getOrganization} = useClerk()`
     */
    getOrganization: undefined;
} | {
    isLoaded: true;
    /**
     * @deprecated Use `createOrganization` from `useOrganizationList`
     * Example: `const {createOrganization} = useOrganizationList()`
     */
    createOrganization: (params: CreateOrganizationParams) => Promise<OrganizationResource>;
    /**
     * @deprecated Use `memberships` from `useOrganization`
     * Example: `const {memberships} = useOrganization()`
     */
    getOrganizationMemberships: () => Promise<OrganizationMembershipResource[]>;
    /**
     * @deprecated Use `getOrganization` from `useClerk`
     * Example: `const {getOrganization} = useClerk()`
     */
    getOrganization: (organizationId: string) => Promise<OrganizationResource | undefined>;
};
type UseOrganizations = () => UseOrganizationsReturn;
/**
 * @deprecated Use useOrganizationList, useOrganization, or useClerk instead
 */
declare const useOrganizations: UseOrganizations;

declare const useSafeLayoutEffect: typeof React.useLayoutEffect;

declare const ClerkInstanceContext: React.Context<{
    value: LoadedClerk;
} | undefined>;
declare const useClerkInstanceContext: () => LoadedClerk;
declare const UserContext: React.Context<{
    value: UserResource | null | undefined;
} | undefined>;
declare const useUserContext: () => UserResource | null | undefined;
declare const ClientContext: React.Context<{
    value: ClientResource | null | undefined;
} | undefined>;
declare const useClientContext: () => ClientResource | null | undefined;
declare const SessionContext: React.Context<{
    value: ActiveSessionResource | null | undefined;
} | undefined>;
declare const useSessionContext: () => ActiveSessionResource | null | undefined;
type OrganizationContextProps = {
    organization: OrganizationResource | null | undefined;
    /**
     * @deprecated This property will be dropped in the next major release.
     * This property is only used in another deprecated part: `invitationList` from useOrganization
     */
    lastOrganizationInvitation: OrganizationInvitationResource | null | undefined;
    /**
     * @deprecated This property will be dropped in the next major release.
     * This property is only used in another deprecated part: `membershipList` from useOrganization
     */
    lastOrganizationMember: OrganizationMembershipResource | null | undefined;
};
declare const useOrganizationContext: () => {
    organization: OrganizationResource | null | undefined;
    lastOrganizationInvitation: OrganizationInvitationResource | null | undefined;
    lastOrganizationMember: OrganizationMembershipResource | null | undefined;
};
declare const OrganizationProvider: ({ children, organization, lastOrganizationMember, lastOrganizationInvitation, swrConfig, }: PropsWithChildren<OrganizationContextProps & {
    swrConfig?: any;
}>) => React.JSX.Element;
/**
 * @deprecated use OrganizationProvider instead
 */
declare const OrganizationContext: (args_0: PropsWithChildren<OrganizationContextProps & {
    swrConfig?: any;
}>) => React.JSX.Element;

export { ClerkInstanceContext, ClientContext, OrganizationContext, OrganizationProvider, SessionContext, UserContext, assertContextExists, createContextAndHook, useClerkInstanceContext, useClientContext, useOrganization, useOrganizationContext, useOrganizationList, useOrganizations, useSafeLayoutEffect, useSessionContext, useUserContext };