import { GroupMember, AddUserToGroupResponse, UserGroup } from './proto-build/compiled';
import IChaynsLogger from './utils/logger/IChaynsLogger';
import { TFixedGroupMember } from './types/TFixedGroupMember';
import { TFixedUserGroup } from './types/TFixedUserGroup';
type UacServiceClientBaseOptions = {
    baseUrl?: string;
    logger?: IChaynsLogger;
    getDefaultSiteId?: () => string;
};
type UacServiceClientOptionsWithSiteId = {
    getDefaultSiteId: () => string;
};
type UacServiceClientBrowserOptions = UacServiceClientBaseOptions & {
    getToken: () => Promise<string>;
    getDefaultPersonId: () => string;
    getLanguage: () => string | undefined;
};
type UacServiceClientServerOptions = UacServiceClientBaseOptions & {
    getApiToken: (roles: string[]) => Promise<string>;
    getDefaultPersonId?: never;
};
type UacServiceClientOptions = UacServiceClientBrowserOptions | UacServiceClientServerOptions;
type RemoveSiteId<T extends UacServiceClientOptions, O extends {
    siteId: string;
}> = (T extends UacServiceClientOptionsWithSiteId ? (Omit<O, 'siteId'> & {
    siteId?: string;
}) : O);
type RemovePersonId<T extends UacServiceClientOptions, O extends {
    personId: string;
}> = (T extends UacServiceClientBrowserOptions ? Omit<O, 'personId'> : O);
declare class UacServiceClient<T extends UacServiceClientOptions> {
    private getToken;
    private getDefaultSiteId;
    private logger;
    private baseUrl;
    private getApiToken;
    private getDefaultPersonId;
    private getLanguage;
    private testBaseUrlPromise;
    private isInNode;
    constructor({ getDefaultSiteId, logger, baseUrl, getDefaultPersonId, ...rest }: T);
    private getTokenForFetch;
    private logFetch;
    /**
     * Get all uac groups of a site
     * @param siteId
     * @param countUsers
     * @param countInvitations
     * @param withMeta
     */
    getUserGroups({ siteId, countUsers, countInvitations, withMeta }: RemoveSiteId<T, {
        siteId: string;
        countUsers?: boolean;
        countInvitations?: boolean;
        withMeta?: boolean;
    }>): Promise<TFixedUserGroup[] | UserGroup[]>;
    /**
     * Get a uac group by id
     * @param groupId
     * @param siteId
     * @param countUsers
     * @param countInvitations
     */
    getUserGroup({ groupId, siteId, countUsers, countInvitations }: RemoveSiteId<T, {
        groupId: number;
        siteId: string;
        countInvitations?: boolean;
        countUsers?: boolean;
    }>): Promise<UserGroup>;
    /**
     * Get the members of a uac group
     * @param groupId
     * @param siteId
     * @param skip
     * @param take
     */
    getGroupMembers({ groupId, siteId, skip, take, sortByDate }: RemoveSiteId<T, {
        groupId: number;
        siteId: string;
        skip?: number;
        take?: number;
        sortByDate?: boolean;
    }>): Promise<TFixedGroupMember[]>;
    /**
     * Get a single group membership
     * @param personId
     * @param siteId
     * @param groupId
     */
    getMembership({ personId, siteId, groupId }: RemoveSiteId<T, {
        personId: string;
        siteId: string;
        groupId: number;
    }>): Promise<{
        creationTime: string | undefined;
        expirationTime: string | undefined;
        personId: string;
        firstname: string;
        lastname: string;
        userGroupId: number;
        creationUser?: (IPerson | null);
        siteId: string;
        subscriptionId: (number | Long);
        membercardUid: string;
    }>;
    /**
     * Get all pending invitations for a group
     * @param siteId
     * @param groupId
     */
    getGroupInvitations({ siteId, groupId }: RemoveSiteId<T, {
        siteId: string;
        groupId: number;
    }>): Promise<import("./proto-build/compiled").IGroupInvitation[]>;
    /**
     * Get all groups for a user
     * @param options
     */
    getGroupsForUser(options: RemovePersonId<T, RemoveSiteId<T, {
        siteId: string;
        personId: string;
    }>>): Promise<IUserGroup[]>;
    /**
     * Check if the current user is a member of the given uac group
     * @param groupId
     * @param siteId
     * @param personId
     */
    isUserInGroup({ groupId, siteId, personId }: RemoveSiteId<T, {
        groupId: number;
        siteId: string;
        personId: string;
    }>): Promise<{
        inGroup: boolean;
    }>;
    /**
     * Get all sites where the current user is in the given uac group
     * @param options
     */
    getMembershipSites(options: RemovePersonId<T, {
        groupId: number;
        personId: string;
    }>): Promise<ISiteInfo[]>;
    /**
     * Search for members of all site groups
     * @param siteId
     * @param searchTerm
     * @param userGroupIds - optional list of usergroup ids to search in
     * @param skip - optional amount of results that should be skipped
     * @param take - optional amount of results that should be returned
     */
    searchMembers({ siteId, searchTerm, userGroupIds, skip, take }: RemoveSiteId<T, {
        siteId: string;
        searchTerm: string;
        userGroupIds?: number[];
        skip?: number;
        take?: number;
    }>): Promise<TFixedGroupMember[]>;
    /**
     * Get all groups where a user has a pending invite
     * @param siteId
     * @param personId
     */
    getInvitedGroups({ siteId, personId }: RemoveSiteId<T, {
        siteId: string;
        personId: string;
    }>): Promise<IUserGroup[]>;
    /**
     * Create a new user group
     * @param siteId
     * @param showName
     * @param description
     * @param pageId
     * @param parentGroupId
     * @param isWorkspace
     * @param users
     * @param icon
     */
    createUserGroup({ siteId, showName, description, pageId, parentGroupId, isWorkspace, users, icon, workspacePageId }: RemoveSiteId<T, {
        siteId: string;
        showName: string;
        description?: string;
        pageId?: number;
        parentGroupId?: number;
        isWorkspace?: boolean;
        users?: string[];
        icon: string;
        workspacePageId?: number;
    }>): Promise<UserGroup>;
    /**
     * Copy a user group and its members
     * @param groupId
     * @param siteId
     */
    copyUserGroup({ groupId, siteId }: RemoveSiteId<T, {
        groupId: number;
        siteId: string;
    }>): Promise<UserGroup>;
    /**
     * Add a user to a uac group
     * @param personId
     * @param groupId
     * @param siteId
     * @param expirationTime
     * @param force
     * @param ignoreConflict
     */
    addUserToGroup({ personId, groupId, siteId, expirationTime, force, ignoreConflict }: RemoveSiteId<T, {
        personId: string;
        groupId: number;
        siteId: string;
        expirationTime: string;
        force: boolean;
        ignoreConflict: boolean;
    }>): Promise<{
        success: boolean;
    }>;
    /**
     * Add multiple users to a uac group
     * @param groupId
     * @param siteId
     * @param members
     */
    addUsersToGroup({ groupId, siteId, members }: RemoveSiteId<T, {
        groupId: number;
        siteId: string;
        members: GroupMember[];
    }>): Promise<AddUserToGroupResponse>;
    /**
     * Update a uac group
     * @param groupId
     * @param siteId
     * @param values
     */
    updateUserGroup({ groupId, siteId, values }: RemoveSiteId<T, {
        groupId: number;
        siteId: string;
        values: {
            showName: string;
            description: string;
            pageId: number;
            parentGroupId: number;
            enableMembercard: boolean;
            memberLimit: number;
            icon: string;
            workspacePageId: number;
        };
    }>): Promise<UserGroup>;
    /**
     * Update the expiration time of a membership
     * @param personId
     * @param groupId
     * @param siteId
     * @param expirationTime
     */
    updateMembership({ personId, groupId, siteId, expirationTime }: RemoveSiteId<T, {
        personId: string;
        groupId: number;
        siteId: string;
        expirationTime: string;
    }>): Promise<{
        creationTime: string | undefined;
        expirationTime: string | undefined;
        personId: string;
        firstname: string;
        lastname: string;
        userGroupId: number;
        creationUser?: (IPerson | null);
        siteId: string;
        subscriptionId: (number | Long);
        membercardUid: string;
    }>;
    /**
     * Delete a usergroup
     * @param groupId
     * @param siteId
     */
    deleteUserGroup({ groupId, siteId }: RemoveSiteId<T, {
        groupId: number;
        siteId: string;
    }>): Promise<null>;
    /**
     * Remove a user from an uac group
     * @param personId
     * @param groupId
     * @param siteId
     * @param ignoreConflict
     * @param force whether to force remove user from known users even if still in any paid uac group
     * @param forceRemoveLocationUserWhenManager whether to force remove user as a location user when he is a manager
     */
    removeUserFromGroup({ personId, groupId, siteId, ignoreConflict, force, forceRemoveLocationUserWhenManager, }: RemoveSiteId<T, {
        groupId: number;
        siteId: string;
        personId: string;
        ignoreConflict: boolean;
        force?: boolean;
        forceRemoveLocationUserWhenManager?: boolean;
    }>): Promise<{
        success: boolean;
        expirationTime: string | undefined;
    }>;
    /**
     * Gets the personId either from the provided options or from the client-settings
     * @param options
     * @private
     */
    private getPersonId;
}
export { UacServiceClient };