import { HttpClient, NonNullablePaths, EventDefinition, MaybeContext, BuildRESTFunction, BuildEventDefinition } from '@wix/sdk-types';
import { Badge, UpdateBadge, ListBadgesOptions, ListBadgesResponse, AssignBadgeResponse, ListMembersByBadgeOptions, ListMembersResponse, ListMembersBadgeIdsResponse, GetMemberCountsPerBadgeResponse, UpdateBadgesDisplayOrderResponse, BadgeAssignedEnvelope, BadgeUnassignedEnvelope, BadgeCreatedEnvelope, BadgeDeletedEnvelope, BadgeUpdatedEnvelope } from './index.typings.js';
export { ActionEvent, AssignBadgeRequest, AssignBadgesRequest, AssignBadgesResponse, BadgeAssigned, BadgeMemberCount, BadgeUnassigned, BaseEventMetadata, CountBadgesRequest, CountBadgesResponse, CreateBadgeRequest, CreateBadgeResponse, CursorPaging, CursorPagingMetadata, Cursors, DeleteBadgeRequest, DeleteBadgeResponse, DomainEvent, DomainEventBodyOneOf, EntityCreatedEvent, EntityDeletedEvent, EntityUpdatedEvent, EventMetadata, GetBadgeRequest, GetBadgeResponse, GetMemberCountsPerBadgeRequest, IdentificationData, IdentificationDataIdOneOf, ListBadgesRequest, ListMembersBadgeIdsRequest, ListMembersRequest, ListMembersWithBadgesRequest, ListMembersWithBadgesResponse, MemberBadgeIds, MessageEnvelope, Paging, PagingMetadata, QueryBadgesRequest, QueryBadgesResponse, RestoreInfo, SortOrder, Sorting, UnassignBadgeRequest, UnassignBadgeResponse, UpdateBadgeRequest, UpdateBadgeResponse, UpdateBadgesDisplayOrderRequest, WebhookIdentityType } from './index.typings.js';

type BadgeNonNullablePaths = `_id`;
declare function createBadge$1(httpClient: HttpClient): CreateBadgeSignature;
interface CreateBadgeSignature {
    /**
     * Creates a badge.
     *
     * New badges do not have any badge permissions by default. Wix users can set badge permissions from the [Badges page in the dashboard](https://support.wix.com/en/article/site-members-creating-and-managing-member-badges?tabs=Dashboard-0#managing-member-badges).
     *
     * If `backgroundColor` or `textColor` are not specified, they default to `"#796EFF"` (purple) and `"#FFFFFF"` (white) respectively.
     * @param - Badge to create.
     * @returns Created badge.
     */
    (badge: NonNullablePaths<Badge, `backgroundColor` | `textColor` | `title`>): Promise<NonNullablePaths<Badge, BadgeNonNullablePaths>>;
}
declare function updateBadge$1(httpClient: HttpClient): UpdateBadgeSignature;
interface UpdateBadgeSignature {
    /**
     * Updates a badge.
     *
     * Note that the badge `slug` is based on the badge `title`. If you update the `title`, the `slug` updates accordingly.
     * @param - Badge ID.
     * @returns Updated badge.
     */
    (_id: string, badge: UpdateBadge): Promise<NonNullablePaths<Badge, BadgeNonNullablePaths>>;
}
declare function listBadges$1(httpClient: HttpClient): ListBadgesSignature;
interface ListBadgesSignature {
    /**
     * Retrieves up to 1,000 badges, given the requested paging.
     *
     * Default `paging.limit` is `100` and `paging.offset` is `0`.
     *
     * This method is not universal and only runs on the backend.
     */
    (options?: ListBadgesOptions): Promise<NonNullablePaths<ListBadgesResponse, {
        [P in BadgeNonNullablePaths]: `badges.${number}.${P}`;
    }[BadgeNonNullablePaths]>>;
}
declare function getBadge$1(httpClient: HttpClient): GetBadgeSignature;
interface GetBadgeSignature {
    /**
     * Retrieves a badge.
     *
     * This method is not universal and only runs on the backend.
     * @param - Badge ID.
     * @returns Badge.
     */
    (_id: string): Promise<NonNullablePaths<Badge, BadgeNonNullablePaths>>;
}
declare function deleteBadge$1(httpClient: HttpClient): DeleteBadgeSignature;
interface DeleteBadgeSignature {
    /**
     * Deletes a badge.
     * @param - Badge ID.
     */
    (_id: string): Promise<void>;
}
declare function assignBadge$1(httpClient: HttpClient): AssignBadgeSignature;
interface AssignBadgeSignature {
    /**
     * Assigns a badge to site members.
     *
     * Members inherit the badge's permissions when they receive the badge.
     * Badge permissions are added to previous member permissions, they don't replace the existing permissions.
     * @param - Badge ID.
     * @param - Member IDs to assign to the badge.
     */
    (_id: string, memberIds: string[]): Promise<NonNullablePaths<AssignBadgeResponse, `memberIds`>>;
}
declare function unassignBadge$1(httpClient: HttpClient): UnassignBadgeSignature;
interface UnassignBadgeSignature {
    /**
     * Removes an assigned badge from multiple site members.
     *
     * The members lose the badge's permissions when the badge is removed.
     * @param - Badge ID.
     * @param - List of members to remove.
     */
    (_id: string, memberIds: string[]): Promise<void>;
}
declare function listMembersByBadge$1(httpClient: HttpClient): ListMembersByBadgeSignature;
interface ListMembersByBadgeSignature {
    /**
     * Retrieves up to 1,000 site members assigned to a badge.
     *
     * Default `paging.limit` is `100` and `paging.offset` is `0`.
     *
     * This method is not universal and only runs on the backend.
     * @param - Badge ID.
     */
    (_id: string, options?: ListMembersByBadgeOptions): Promise<NonNullablePaths<ListMembersResponse, `memberIds`>>;
}
declare function listBadgesPerMember$1(httpClient: HttpClient): ListBadgesPerMemberSignature;
interface ListBadgesPerMemberSignature {
    /**
     * Retrieves badges assigned to specified members.
     *
     * Members are typically associated with a contact, each having a distinct `memberId` and `contactId`. When passing the ID as a parameter, avoid presuming the IDs are identical since they represent separate entities.
     *
     * This method is not universal and only runs on the backend.
     * @param - Member IDs to retrieve badges for.
     */
    (memberIds: string[]): Promise<NonNullablePaths<ListMembersBadgeIdsResponse, `memberBadgeIds` | `memberBadgeIds.${number}.memberId`>>;
}
declare function getMemberCountsPerBadge$1(httpClient: HttpClient): GetMemberCountsPerBadgeSignature;
interface GetMemberCountsPerBadgeSignature {
    /**
     * Retrieves a member count per badge.
     *
     * This method is not universal function and only runs on the backend.
     */
    (): Promise<NonNullablePaths<GetMemberCountsPerBadgeResponse, `badgeMemberCounts` | `badgeMemberCounts.${number}.badgeId` | `badgeMemberCounts.${number}.memberCount`>>;
}
declare function updateBadgesDisplayOrder$1(httpClient: HttpClient): UpdateBadgesDisplayOrderSignature;
interface UpdateBadgesDisplayOrderSignature {
    /**
     * Updates the display order of badges.
     *
     * This method is not universal function and only runs on the backend
     * @param - Badge IDs in the order to display.
     */
    (badgeIds: string[]): Promise<NonNullablePaths<UpdateBadgesDisplayOrderResponse, {
        [P in BadgeNonNullablePaths]: `badges.${number}.${P}`;
    }[BadgeNonNullablePaths]>>;
}
declare const onBadgeAssigned$1: EventDefinition<BadgeAssignedEnvelope, "wix.badges.v3.badge_badge_assigned">;
declare const onBadgeUnassigned$1: EventDefinition<BadgeUnassignedEnvelope, "wix.badges.v3.badge_badge_unassigned">;
declare const onBadgeCreated$1: EventDefinition<BadgeCreatedEnvelope, "wix.badges.v3.badge_created">;
declare const onBadgeDeleted$1: EventDefinition<BadgeDeletedEnvelope, "wix.badges.v3.badge_deleted">;
declare const onBadgeUpdated$1: EventDefinition<BadgeUpdatedEnvelope, "wix.badges.v3.badge_updated">;

declare const createBadge: MaybeContext<BuildRESTFunction<typeof createBadge$1> & typeof createBadge$1>;
declare const updateBadge: MaybeContext<BuildRESTFunction<typeof updateBadge$1> & typeof updateBadge$1>;
declare const listBadges: MaybeContext<BuildRESTFunction<typeof listBadges$1> & typeof listBadges$1>;
declare const getBadge: MaybeContext<BuildRESTFunction<typeof getBadge$1> & typeof getBadge$1>;
declare const deleteBadge: MaybeContext<BuildRESTFunction<typeof deleteBadge$1> & typeof deleteBadge$1>;
declare const assignBadge: MaybeContext<BuildRESTFunction<typeof assignBadge$1> & typeof assignBadge$1>;
declare const unassignBadge: MaybeContext<BuildRESTFunction<typeof unassignBadge$1> & typeof unassignBadge$1>;
declare const listMembersByBadge: MaybeContext<BuildRESTFunction<typeof listMembersByBadge$1> & typeof listMembersByBadge$1>;
declare const listBadgesPerMember: MaybeContext<BuildRESTFunction<typeof listBadgesPerMember$1> & typeof listBadgesPerMember$1>;
declare const getMemberCountsPerBadge: MaybeContext<BuildRESTFunction<typeof getMemberCountsPerBadge$1> & typeof getMemberCountsPerBadge$1>;
declare const updateBadgesDisplayOrder: MaybeContext<BuildRESTFunction<typeof updateBadgesDisplayOrder$1> & typeof updateBadgesDisplayOrder$1>;
/**
 * Triggered when a member receives a badge.
 */
declare const onBadgeAssigned: BuildEventDefinition<typeof onBadgeAssigned$1>;
/**
 * Triggered when a member's badge is removed.
 */
declare const onBadgeUnassigned: BuildEventDefinition<typeof onBadgeUnassigned$1>;
/**
 * Triggered when a badge is created.
 */
declare const onBadgeCreated: BuildEventDefinition<typeof onBadgeCreated$1>;
/**
 * Triggered when a badge is deleted.
 */
declare const onBadgeDeleted: BuildEventDefinition<typeof onBadgeDeleted$1>;
/**
 * Triggered when a badge is updated.
 */
declare const onBadgeUpdated: BuildEventDefinition<typeof onBadgeUpdated$1>;

export { AssignBadgeResponse, Badge, BadgeAssignedEnvelope, BadgeCreatedEnvelope, BadgeDeletedEnvelope, BadgeUnassignedEnvelope, BadgeUpdatedEnvelope, GetMemberCountsPerBadgeResponse, ListBadgesOptions, ListBadgesResponse, ListMembersBadgeIdsResponse, ListMembersByBadgeOptions, ListMembersResponse, UpdateBadge, UpdateBadgesDisplayOrderResponse, assignBadge, createBadge, deleteBadge, getBadge, getMemberCountsPerBadge, listBadges, listBadgesPerMember, listMembersByBadge, onBadgeAssigned, onBadgeCreated, onBadgeDeleted, onBadgeUnassigned, onBadgeUpdated, unassignBadge, updateBadge, updateBadgesDisplayOrder };