export declare const PostContentType: Readonly<{
    TEXT: "text";
    IMAGE: "image";
    FILE: "file";
    VIDEO: "video";
    LIVESTREAM: "liveStream";
    POLL: "poll";
    CLIP: "clip";
    AUDIO: "audio";
    ROOM: "room";
}>;
export declare const PostStructureType: Readonly<{
    TEXT: "text";
    IMAGE: "image";
    VIDEO: "video";
    FILE: "file";
    AUDIO: "audio";
    MIXED: "mixed";
}>;
declare global {
    namespace Amity {
        type PostTargetType = Amity.Feed['targetType'] | 'content' | 'all';
        type PostContentType = ValueOf<typeof PostContentType> | string;
        type MixedMediaPostContentType = Exclude<ValueOf<typeof PostContentType>, 'text' | 'poll' | 'liveStream' | 'clip'>;
        type PostActionType = 'onFetch' | 'onCreate' | 'onUpdate' | 'onDelete' | 'onApproved' | 'onDeclined' | 'onFlagged' | 'onUnflagged' | 'onReactionAdded' | 'onReactionRemoved';
        type PostStructureType = ValueOf<typeof PostStructureType>;
        type RawPost<T extends PostContentType = any> = {
            postId: string;
            postedUserId: Amity.RawUser['userId'];
            parentId: Amity.RawPost['postId'];
            parentPostId: Amity.RawPost['postId'];
            targetType: PostTargetType;
            targetId: string;
            feedId: Amity.Feed['feedId'];
            children: Amity.RawPost['postId'][];
            comments: Amity.InternalComment['commentId'][];
            commentsCount: number;
            hasFlaggedChildren: false;
            hasFlaggedComment: false;
            editedAt: Amity.timestamp;
            metadata?: Record<string, any>;
            flagCount: number;
            hashFlag: {
                bits: number;
                hashes: number;
                hash: string;
            } | null;
            tags?: string[];
            createdAt: Amity.timestamp;
            updatedAt?: Amity.timestamp;
            isDeleted?: boolean;
            path: string;
            impression: number;
            reach: number;
            reactionsCount: number;
            reactions: Record<string, number>;
            myReactions?: string[];
            hashtags?: string[];
            structureType: Amity.PostStructureType;
            eventId?: string;
            links?: Amity.Link[];
            productTags?: Amity.RawProductTag[];
            pinnedProductId?: string;
        } & Amity.Content<T> & Amity.Mentionable<'user'>;
        type InternalPost<T extends PostContentType = any> = RawPost<T> & {
            feedType?: 'reviewing' | 'published';
            /**
             * Locally computed comment count (includes all comments and replies).
             * Initialized from server value, updated by PostCommentCountEngine.
             */
            localCommentCount: number;
        };
        type PostLinkObject = {
            childrenPosts: Amity.Post[];
            latestComments: (Amity.Comment | null)[];
            creator: Amity.User | undefined;
            analytics: {
                markAsViewed: () => void;
                markAsMeaningfullyViewed: (feedRenderPosition?: number) => void;
            };
            productTags: (Amity.TextProductTag | Amity.MediaProductTag)[];
            targetCommunity?: Amity.Community;
            getImageInfo: () => Amity.File<'image'> | undefined;
            getVideoInfo: () => Amity.File<'video'> | undefined;
            getVideoThumbnailInfo: () => Amity.File<'image'> | undefined;
            getFileInfo: () => Amity.File<'file'> | undefined;
            getPollInfo: () => Amity.Poll | undefined;
            getLivestreamInfo: () => Amity.Stream | undefined;
            getClipInfo: () => Amity.File<'clip'> | undefined;
            getAudioInfo: () => Amity.File<'audio'> | undefined;
            getRoomInfo: () => Amity.Room | undefined;
        };
        type Post<T extends PostContentType = any> = Omit<Amity.InternalPost<T>, 'productTags'> & Amity.PostLinkObject;
        type ClipDisplayMode = 'fill' | 'fit';
        type QueryPosts = {
            targetId: string;
            targetType: Amity.InternalPost['targetType'];
            sortBy?: 'lastCreated' | 'firstCreated';
            dataTypes?: Exclude<Amity.PostContentType, 'text'>[];
            includeDeleted?: boolean;
            hasFlag?: boolean;
            feedType?: 'reviewing' | 'published';
            tags?: Amity.Taggable['tags'];
            matchingOnlyParentPost?: boolean;
            page?: string;
            limit?: number;
            includeMixedStructure?: boolean;
            untilAt?: Amity.timestamp;
            excludeBlockUserPosts?: boolean;
        };
        type QueryPostsWithHashtags = {
            dataTypes?: Exclude<Amity.PostContentType, 'text'>[];
            targetType: Amity.InternalPost['targetType'];
            hashtags: string[];
            matchingOnlyParentPost?: boolean;
            page?: string;
            limit?: number;
            includeMixedStructure?: boolean;
        };
        type PostLiveCollection = Amity.LiveCollectionParams<Omit<QueryPosts, 'sortBy' | 'page'> & {
            sortBy?: 'lastCreated' | 'firstCreated';
        }>;
        type SearchPostWithHashtagLiveCollection = Amity.LiveCollectionParams<Omit<QueryPostsWithHashtags, 'page'> & {
            sortBy?: 'lastCreated' | 'firstCreated';
        }>;
        type PostLiveCollectionCache = Amity.LiveCollectionCache<Amity.InternalPost['postId'], Pick<QueryPosts, 'page'>>;
        type QuerySemanticSearchPosts = {
            query: string;
            targetId?: string;
            targetType?: Amity.InternalPost['targetType'];
            dataTypes?: string[];
            matchingOnlyParentPost?: boolean;
            limit?: number;
            includeMixedStructure?: boolean;
        };
        type SemanticSearchPostLiveCollection = Amity.LiveCollectionParams<Omit<QuerySemanticSearchPosts, 'page'>>;
        type SemanticSearchPostLiveCollectionCache = Amity.LiveCollectionCache<Amity.InternalPost['postId'], // postId:score
        QuerySemanticSearchPosts>;
        type QueryLiveRoomPosts = {
            limit?: number;
        };
        type LiveRoomPostLiveCollection = Amity.LiveCollectionParams<QueryLiveRoomPosts>;
        type LiveRoomPostLiveCollectionCache = Amity.LiveCollectionCache<Amity.InternalPost['postId'], Pick<QueryLiveRoomPosts, 'limit'>>;
        type QueryCommunityLiveRoomPosts = {
            communityIds: string[];
        };
        type CommunityLiveRoomPostLiveCollection = Amity.LiveCollectionParams<QueryCommunityLiveRoomPosts>;
        type CommunityLiveRoomPostLiveCollectionCache = Amity.LiveCollectionCache<Amity.InternalPost['postId'], QueryCommunityLiveRoomPosts>;
        type Link = {
            index?: number;
            length?: number;
            url: string;
            renderPreview: boolean;
            domain?: string;
            title?: string;
            imageUrl?: string;
        };
    }
}
//# sourceMappingURL=post.d.ts.map