import { AmityCommunityMemberStatusFilter } from '~/communityRepository/constants';
export declare const CommunityPostSettings: Readonly<{
    ONLY_ADMIN_CAN_POST: "ONLY_ADMIN_CAN_POST";
    ADMIN_REVIEW_POST_REQUIRED: "ADMIN_REVIEW_POST_REQUIRED";
    ANYONE_CAN_POST: "ANYONE_CAN_POST";
}>;
export declare const CommunityPostSettingMaps: Readonly<{
    ONLY_ADMIN_CAN_POST: {
        needApprovalOnPostCreation: boolean;
        onlyAdminCanPost: boolean;
    };
    ADMIN_REVIEW_POST_REQUIRED: {
        needApprovalOnPostCreation: boolean;
        onlyAdminCanPost: boolean;
    };
    ANYONE_CAN_POST: {
        needApprovalOnPostCreation: boolean;
        onlyAdminCanPost: boolean;
    };
}>;
export declare const DefaultCommunityPostSetting = "ONLY_ADMIN_CAN_POST";
export declare enum AmityCommunityType {
    Default = "default",
    Event = "event"
}
declare global {
    namespace Amity {
        const enum CommunitySortByEnum {
            FirstCreated = "firstCreated",
            LastCreated = "lastCreated",
            DisplayName = "displayName"
        }
        type CommunitySortBy = `${Amity.CommunitySortByEnum}`;
        const enum SearchCommunitySortByEnum {
            FirstCreated = "firstCreated",
            LastCreated = "lastCreated",
            DisplayName = "displayName"
        }
        type SearchCommunitySortBy = `${Amity.SearchCommunitySortByEnum}`;
        const enum CommunityMemberSortByEnum {
            FirstCreated = "firstCreated",
            LastCreated = "lastCreated"
        }
        type CommunityMemberSortBy = `${Amity.CommunityMemberSortByEnum}`;
        const enum SearchCommunityMemberSortByEnum {
            FirstCreated = "firstCreated",
            LastCreated = "lastCreated",
            DisplayName = "displayName"
        }
        type SearchCommunityMemberSortBy = `${Amity.SearchCommunityMemberSortByEnum}`;
        type CommunityActionType = 'onCreate' | 'onUpdate' | 'onDelete' | 'onJoin' | 'onLeft' | 'onMemberCountChanged';
        type CommunityMemberActionType = 'onJoin' | 'onLeft' | 'onBan' | 'onUnban' | 'onMemberCountChanged';
        type CommunityType = AmityCommunityType;
        type CommunityMetaData = Record<string, any>;
        type RawCommunity = {
            communityId: string;
            displayName: string;
            avatarFileId?: File<'image'>['fileId'];
            description?: string;
            channelId: Amity.Channel['channelId'];
            userId: Amity.InternalUser['userId'];
            isOfficial?: boolean;
            isPublic?: boolean;
            isJoined?: boolean;
            onlyAdminCanPost?: boolean;
            needApprovalOnPostCreation?: boolean;
            postsCount: number;
            membersCount: number;
            categoryIds: Amity.InternalCategory['categoryId'][];
            hasFlaggedComment: boolean;
            hasFlaggedPost: boolean;
            allowCommentInStory?: boolean;
            isDiscoverable?: boolean;
            requiresJoinApproval?: boolean;
            eventId?: Amity.Event['eventId'];
            type: Amity.CommunityType;
        } & Amity.Taggable & Amity.Metadata<Amity.DiscussionCommunityMetadata | CommunityMetaData> & Amity.Timestamps & Amity.SoftDelete & Amity.Subscribable;
        type InternalCommunity = Omit<Amity.RawCommunity, 'onlyAdminCanPost' | 'needApprovalOnPostCreation'> & Amity.CommunityStorySettings & {
            postSetting?: ValueOf<typeof CommunityPostSettings>;
        };
        type Community = Amity.InternalCommunity & Amity.CommunityLinkedObject;
        type DiscussionCommunityMetadata = {
            isEventCommunity: boolean;
            eventType: Amity.EventType;
            eventStartTime: string;
            eventEndTime?: string;
        };
        type QueryCommunities = {
            membership?: 'all' | 'member' | 'notMember';
            categoryId?: Amity.InternalCategory['categoryId'];
            includeDeleted?: boolean;
            tags?: Amity.Taggable['tags'];
            sortBy?: Amity.CommunitySortBy | Amity.CommunitySortByEnum;
            page?: string;
            limit?: number;
            includeDiscoverablePrivateCommunity?: boolean;
        };
        type QueryJoinCommunity = {
            communityId: string;
            status: Amity.JoinRequestStatus;
            sortBy?: Amity.CommunitySortBy | Amity.CommunitySortByEnum;
            options?: {
                limit?: number;
                token?: string;
            };
        };
        type SearchQueryCommunities = {
            displayName?: string;
            membership?: 'all' | 'member' | 'notMember';
            categoryId?: Amity.InternalCategory['categoryId'];
            includeDeleted?: boolean;
            tags?: Amity.Taggable['tags'];
            sortBy?: Amity.SearchCommunitySortBy | Amity.SearchCommunitySortByEnum;
            page?: string;
            limit?: number;
            includeDiscoverablePrivateCommunity?: boolean;
        };
        type QueryJoinRequest = {
            communityId: string;
            status: Amity.JoinRequestStatus;
            targetType: 'community';
            type: Amity.JoinRequestType;
            sortBy?: Amity.CommunitySortBy | Amity.CommunitySortByEnum;
            options?: {
                limit?: number;
                token?: string;
            };
            page?: string;
        };
        type QueryJoinRequestList = {
            communityIds: string[];
            sortBy?: Amity.CommunitySortBy | Amity.CommunitySortByEnum;
            options?: {
                limit?: number;
                token?: string;
            };
            page?: string;
        };
        type CommunityLiveCollection = Amity.LiveCollectionParams<Omit<QueryCommunities, 'page'>>;
        type RecommendedCommunityLiveCollection = Amity.LiveCollectionParams<{
            limit?: number;
            includeDiscoverablePrivateCommunity?: boolean;
        }>;
        type TrendingCommunityLiveCollection = Amity.LiveCollectionParams<{
            limit?: number;
            includeDiscoverablePrivateCommunity?: boolean;
        }>;
        type JoinRequestLiveCollection = Amity.LiveCollectionParams<QueryJoinRequest>;
        type JoinRequestListLiveCollection = Amity.LiveCollectionParams<QueryJoinRequestList>;
        type SearchCommunityLiveCollection = Amity.LiveCollectionParams<Omit<SearchQueryCommunities, 'page'>>;
        type CommunityLiveCollectionCache = Amity.LiveCollectionCache<Amity.Community['communityId'], Pick<QueryCommunities, 'page'>>;
        type RecommendedCommunityLiveCollectionCache = Amity.CommunityLiveCollectionCache;
        type TrendingCommunityLiveCollectionCache = Amity.CommunityLiveCollectionCache;
        type SearchCommunityLiveCollectionCache = Amity.LiveCollectionCache<Amity.Community['communityId'], Pick<SearchQueryCommunities, 'page'>>;
        type JoinRequestLiveCollectionCache = Amity.LiveCollectionCache<Amity.JoinRequest['joinRequestId'], Pick<QueryJoinRequest, 'page'>>;
        type JoinRequestListLiveCollectionCache = Amity.LiveCollectionCache<Amity.JoinRequest['joinRequestId'], Pick<QueryJoinRequestList, 'page'>>;
        type QueryCommunityMembers = {
            communityId: string;
            memberships?: ('banned' | 'member')[];
            roles?: string[];
            sortBy?: Amity.CommunityMemberSortByEnum | Amity.CommunityMemberSortBy;
            page?: string;
            limit?: number;
            includeDeleted?: boolean;
        };
        type QuerySearchCommunityMembers = {
            communityId: string;
            memberships?: ('banned' | 'member')[];
            roles?: string[];
            sortBy?: Amity.SearchCommunityMemberSortByEnum | Amity.SearchCommunityMemberSortBy;
            search?: Amity.InternalUser['displayName'] | Amity.InternalUser['userId'];
            page?: string;
            limit?: number;
            includeDeleted?: boolean;
        };
        type CommunityMemberLiveCollection = Amity.LiveCollectionParams<Omit<QueryCommunityMembers, 'page'>>;
        type SearchCommunityMemberLiveCollection = Amity.LiveCollectionParams<Omit<QuerySearchCommunityMembers, 'page'>>;
        type CommunityMemberLiveCollectionCache = Amity.LiveCollectionCache<Amity.Membership<'community'>['userId'], Pick<QueryCommunityMembers, 'page'>>;
        type SearchCommunityMemberLiveCollectionCache = Amity.LiveCollectionCache<Amity.Community['communityId'], Pick<QuerySearchCommunityMembers, 'page'>>;
        type QuerySemanticSearchCommunity = {
            query: string;
            categoryIds?: string[];
            filter?: AmityCommunityMemberStatusFilter;
            options?: {
                limit?: number;
                token?: string;
            };
            tags?: string[];
            includeDiscoverablePrivateCommunity?: boolean;
        };
        type SemanticSearchCommunityLiveCollection = Amity.LiveCollectionParams<Omit<QuerySemanticSearchCommunity, 'page' | 'filter' | 'options'>> & {
            communityMembershipStatus?: AmityCommunityMemberStatusFilter;
        };
        type SemanticSearchCommunityLiveCollectionCache = Amity.LiveCollectionCache<Amity.Community['communityId'], // communityId:score
        QuerySemanticSearchCommunity>;
        type CommunityLinkedObject = {
            categories: Amity.Category[];
            avatar?: Amity.File<'image'>;
            createInvitations: (userIds: string[]) => Promise<void>;
            getMemberInvitations: (params: Pick<Amity.InvitationLiveCollection, 'limit' | 'sortBy' | 'statuses'>, callback: Amity.LiveCollectionCallback<Amity.Invitation>) => Amity.Unsubscriber;
            getInvitation: () => Promise<Amity.Invitation | undefined>;
            join: () => Promise<Amity.JoinResult>;
            getJoinRequests: (params: QueryJoinRequest, callback: Amity.LiveCollectionCallback<Amity.JoinRequest>) => Amity.Unsubscriber;
            getMyJoinRequest: () => Promise<Amity.JoinRequest | undefined>;
        };
    }
}
//# sourceMappingURL=community.d.ts.map