@softtynet/zca-js 2.2.8 → 2.2.10

package/dist/apis/auth/updateActiveStatus.js

@@ -0,0 +1,27 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory } from "../../utils.js";
+export const updateActiveStatusFactory = apiFactory()((api, ctx, utils) => {
+    const pingURL = utils.makeURL(`${api.zpwServiceMap.profile[0]}/api/social/profile/ping`);
+    const deactiveURL = utils.makeURL(`${api.zpwServiceMap.profile[0]}/api/social/profile/deactive`);
+    /**
+     * Update active status?
+     *
+     * @param active
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function updateActiveStatus(active) {
+        const params = {
+            status: active ? 1 : 0,
+            imei: ctx.imei,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt params");
+        const targetURL = active ? pingURL : deactiveURL;
+        const response = await utils.request(utils.makeURL(targetURL, { params: encryptedParams }), {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/auth/updateLang.d.ts

@@ -0,0 +1,6 @@
+export declare enum UpdateLangAvailableLanguages {
+    VI = "VI",
+    EN = "EN"
+}
+export type UpdateLangResponse = "";
+export declare const updateLangFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => (language?: UpdateLangAvailableLanguages) => Promise<"">;

package/dist/apis/auth/updateLang.js

@@ -0,0 +1,30 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory } from "../../utils.js";
+export var UpdateLangAvailableLanguages;
+(function (UpdateLangAvailableLanguages) {
+    UpdateLangAvailableLanguages["VI"] = "VI";
+    UpdateLangAvailableLanguages["EN"] = "EN";
+})(UpdateLangAvailableLanguages || (UpdateLangAvailableLanguages = {}));
+export const updateLangFactory = apiFactory()((api, _, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.profile[0]}/api/social/profile/updatelang`);
+    /**
+     * Update language?
+     *
+     * @param language language to update (VI, EN)
+     *
+     * @note Calling this API alone will not update the user's language.
+     * @throws {ZaloApiError}
+     */
+    return async function updateLang(language = UpdateLangAvailableLanguages.VI) {
+        const params = {
+            language: language,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/board/addPollOptions.d.ts

@@ -0,0 +1,14 @@
+import type { PollOptions } from "../../models/index.js";
+export type AddPollOptionsOption = {
+    voted: boolean;
+    content: string;
+};
+export type AddPollOptionsPayload = {
+    pollId: number;
+    options: AddPollOptionsOption[];
+    votedOptionIds: number[];
+};
+export type AddPollOptionsResponse = {
+    options: PollOptions[];
+};
+export declare const addPollOptionsFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => (payload: AddPollOptionsPayload) => Promise<AddPollOptionsResponse>;

package/dist/apis/board/addPollOptions.js

@@ -0,0 +1,26 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory } from "../../utils.js";
+export const addPollOptionsFactory = apiFactory()((api, _ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/poll/option/add`);
+    /**
+     * Add new option to poll
+     *
+     * @param payload
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function addPollOptions(payload) {
+        const params = {
+            poll_id: payload.pollId,
+            new_options: JSON.stringify(payload.options),
+            voted_option_ids: payload.votedOptionIds,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/board/createNote.d.ts

@@ -0,0 +1,7 @@
+import type { NoteDetail } from "../../models/index.js";
+export type CreateNoteOptions = {
+    title: string;
+    pinAct?: boolean;
+};
+export type CreateNoteResponse = NoteDetail;
+export declare const createNoteFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => (options: CreateNoteOptions, groupId: string) => Promise<NoteDetail>;

package/dist/apis/board/createNote.js

@@ -0,0 +1,47 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory } from "../../utils.js";
+export const createNoteFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group_board[0]}/api/board/topic/createv2`);
+    /**
+     * Create a note in a group
+     *
+     * @param options note options
+     * @param options.title note title
+     * @param options.pinAct pin action (pin note)
+     * @param groupId group id
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function createNote(options, groupId) {
+        const params = {
+            grid: groupId,
+            type: 0,
+            color: -16777216,
+            emoji: "",
+            startTime: -1,
+            duration: -1,
+            params: JSON.stringify({
+                title: options.title,
+            }),
+            repeat: 0,
+            src: 1,
+            imei: ctx.imei,
+            pinAct: options.pinAct ? 1 : 0,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(serviceURL, {
+            method: "POST",
+            body: new URLSearchParams({
+                params: encryptedParams,
+            }),
+        });
+        return utils.resolve(response, (result) => {
+            if (typeof result.data.params === "string") {
+                result.data.params = JSON.parse(result.data.params);
+            }
+            return result.data;
+        });
+    };
+});

package/dist/apis/board/createPoll.d.ts

@@ -0,0 +1,36 @@
+import type { PollDetail } from "../../models/index.js";
+/**
+ * Options for creating a poll.
+ */
+export type CreatePollOptions = {
+    /**
+     * Question for the poll.
+     */
+    question: string;
+    /**
+     * List of options for the poll.
+     */
+    options: string[];
+    /**
+     * Poll expiration time in milliseconds (0 = no expiration).
+     */
+    expiredTime?: number;
+    /**
+     * Allows multiple choices in the poll.
+     */
+    allowMultiChoices?: boolean;
+    /**
+     * Allows members to add new options to the poll.
+     */
+    allowAddNewOption?: boolean;
+    /**
+     * Hides voting results until the user has voted.
+     */
+    hideVotePreview?: boolean;
+    /**
+     * Hides poll voters (anonymous poll).
+     */
+    isAnonymous?: boolean;
+};
+export type CreatePollResponse = PollDetail;
+export declare const createPollFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => (options: CreatePollOptions, groupId: string) => Promise<PollDetail>;

package/dist/apis/board/createPoll.js

@@ -0,0 +1,39 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory } from "../../utils.js";
+export const createPollFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group[0]}/api/poll/create`);
+    /**
+     * Create a poll in a group.
+     *
+     * @param options Poll options
+     * @param groupId Group ID to create poll from
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function createPoll(options, groupId) {
+        const params = {
+            group_id: groupId,
+            question: options.question,
+            options: options.options,
+            expired_time: options.expiredTime ?? 0,
+            pinAct: false,
+            allow_multi_choices: !!options.allowMultiChoices,
+            allow_add_new_option: !!options.allowAddNewOption,
+            is_hide_vote_preview: !!options.hideVotePreview,
+            is_anonymous: !!options.isAnonymous,
+            poll_type: 0,
+            src: 1,
+            imei: ctx.imei,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(serviceURL, {
+            method: "POST",
+            body: new URLSearchParams({
+                params: encryptedParams,
+            }),
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/board/createReminder.d.ts

@@ -0,0 +1,12 @@
+import type { ReminderGroup, ReminderUser } from "../../models/index.js";
+import { ReminderRepeatMode, ThreadType } from "../../models/index.js";
+export type CreateReminderOptions = {
+    title: string;
+    emoji?: string;
+    startTime?: number;
+    repeat?: ReminderRepeatMode;
+};
+export type CreateReminderUser = ReminderUser;
+export type CreateReminderGroup = Omit<ReminderGroup, "responseMem">;
+export type CreateReminderResponse = CreateReminderUser | CreateReminderGroup;
+export declare const createReminderFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => (options: CreateReminderOptions, threadId: string, type?: ThreadType) => Promise<CreateReminderResponse>;

package/dist/apis/board/createReminder.js

@@ -0,0 +1,62 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { ReminderRepeatMode, ThreadType } from "../../models/index.js";
+import { apiFactory } from "../../utils.js";
+export const createReminderFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = {
+        [ThreadType.User]: utils.makeURL(`${api.zpwServiceMap.group_board[0]}/api/board/oneone/create`),
+        [ThreadType.Group]: utils.makeURL(`${api.zpwServiceMap.group_board[0]}/api/board/topic/createv2`),
+    };
+    /**
+     * Create a reminder in a group
+     *
+     * @param options reminder options
+     * @param threadId Group ID to create note from
+     * @param type Thread type (User or Group)
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function createReminder(options, threadId, type = ThreadType.User) {
+        const params = type === ThreadType.User
+            ? {
+                objectData: JSON.stringify({
+                    toUid: threadId,
+                    type: 0,
+                    color: -16245706,
+                    emoji: options.emoji ?? "⏰",
+                    startTime: options.startTime ?? Date.now(),
+                    duration: -1,
+                    params: { title: options.title },
+                    needPin: false,
+                    repeat: options.repeat ?? ReminderRepeatMode.None,
+                    creatorUid: ctx.uid, // Note: for some reason, you can put any valid UID here instead of your own and it still works, atleast for mobile
+                    src: 1,
+                }),
+                imei: ctx.imei,
+            }
+            : {
+                grid: threadId,
+                type: 0,
+                color: -16245706,
+                emoji: options.emoji ?? "⏰",
+                startTime: options.startTime ?? Date.now(),
+                duration: -1,
+                params: JSON.stringify({
+                    title: options.title,
+                }),
+                repeat: options.repeat ?? ReminderRepeatMode.None,
+                src: 1,
+                imei: ctx.imei,
+                pinAct: 0,
+            };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(serviceURL[type], {
+            method: "POST",
+            body: new URLSearchParams({
+                params: encryptedParams,
+            }),
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/board/editNote.d.ts

@@ -0,0 +1,17 @@
+import type { NoteDetail } from "../../models/index.js";
+export type EditNoteOptions = {
+    /**
+     * New note title
+     */
+    title: string;
+    /**
+     * Topic ID to edit note from
+     */
+    topicId: string;
+    /**
+     * Should the note be pinned?
+     */
+    pinAct?: boolean;
+};
+export type EditNoteResponse = NoteDetail;
+export declare const editNoteFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => (options: EditNoteOptions, groupId: string) => Promise<NoteDetail>;

package/dist/apis/board/editNote.js

@@ -0,0 +1,46 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory } from "../../utils.js";
+export const editNoteFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group_board[0]}/api/board/topic/updatev2`);
+    /**
+     * Edit an existing note in a group
+     *
+     * @param options Options for editing the note
+     * @param groupId Group ID to create note from
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function editNote(options, groupId) {
+        const params = {
+            grid: groupId,
+            type: 0,
+            color: -16777216,
+            emoji: "",
+            startTime: -1,
+            duration: -1,
+            params: JSON.stringify({
+                title: options.title,
+            }),
+            topicId: options.topicId,
+            repeat: 0,
+            imei: ctx.imei,
+            pinAct: options.pinAct ? 1 : 2,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(serviceURL, {
+            method: "POST",
+            body: new URLSearchParams({
+                params: encryptedParams,
+            }),
+        });
+        return utils.resolve(response, (result) => {
+            const data = result.data;
+            if (typeof data.params == "string") {
+                data.params = JSON.parse(data.params);
+            }
+            return data;
+        });
+    };
+});

package/dist/apis/board/editReminder.d.ts

@@ -0,0 +1,13 @@
+import type { ReminderRepeatMode, ReminderGroup, ReminderUser } from "../../models/index.js";
+import { ThreadType } from "../../models/index.js";
+export type EditReminderOptions = {
+    title: string;
+    topicId: string;
+    emoji?: string;
+    startTime?: number;
+    repeat?: ReminderRepeatMode;
+};
+export type EditReminderUser = ReminderUser;
+export type EditReminderGroup = Omit<ReminderGroup, "responseMem">;
+export type EditReminderResponse = EditReminderUser | EditReminderGroup;
+export declare const editReminderFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => (options: EditReminderOptions, threadId: string, type?: ThreadType) => Promise<EditReminderResponse>;

package/dist/apis/board/editReminder.js

@@ -0,0 +1,60 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { ThreadType } from "../../models/index.js";
+import { apiFactory } from "../../utils.js";
+export const editReminderFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = {
+        [ThreadType.User]: utils.makeURL(`${api.zpwServiceMap.group_board[0]}/api/board/oneone/update`),
+        [ThreadType.Group]: utils.makeURL(`${api.zpwServiceMap.group_board[0]}/api/board/topic/updatev2`),
+    };
+    /**
+     * Edit an existing reminder
+     *
+     * @param options Reminder parameters
+     * @param threadId Thread ID
+     * @param type Thread type (User/Group)
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function editReminder(options, threadId, type = ThreadType.User) {
+        const requestParams = type === ThreadType.User
+            ? {
+                objectData: JSON.stringify({
+                    toUid: threadId,
+                    type: 0,
+                    color: -16777216,
+                    emoji: options.emoji ?? "",
+                    startTime: options.startTime ?? Date.now(),
+                    duration: -1,
+                    params: { title: options.title },
+                    needPin: false,
+                    reminderId: options.topicId,
+                    repeat: options.repeat ?? 0,
+                }),
+            }
+            : {
+                grid: threadId,
+                type: 0,
+                color: -16777216,
+                emoji: options.emoji ?? "",
+                startTime: options.startTime ?? Date.now(),
+                duration: -1,
+                params: JSON.stringify({
+                    title: options.title,
+                }),
+                topicId: options.topicId,
+                repeat: options.repeat ?? 0,
+                imei: ctx.imei,
+                pinAct: 2,
+            };
+        const encryptedParams = utils.encodeAES(JSON.stringify(requestParams));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(serviceURL[type], {
+            method: "POST",
+            body: new URLSearchParams({
+                params: encryptedParams,
+            }),
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/board/getListBoard.d.ts

@@ -0,0 +1,21 @@
+import type { NoteDetail, PinnedMessageDetail, PollDetail } from "../../models/index.js";
+import { BoardType } from "../../models/index.js";
+export type ListBoardOptions = {
+    /**
+     * Page number (default: 1)
+     */
+    page?: number;
+    /**
+     * Number of items to retrieve (default: 20)
+     */
+    count?: number;
+};
+export type BoardItem = {
+    boardType: BoardType;
+    data: PollDetail | NoteDetail | PinnedMessageDetail;
+};
+export type GetListBoardResponse = {
+    items: BoardItem[];
+    count: number;
+};
+export declare const getListBoardFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => (options: ListBoardOptions, groupId: string) => Promise<GetListBoardResponse>;

package/dist/apis/board/getListBoard.js

@@ -0,0 +1,44 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { BoardType } from "../../models/index.js";
+import { apiFactory } from "../../utils.js";
+export const getListBoardFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group_board[0]}/api/board/list`);
+    /**
+     * Get list board items in a group
+     *
+     * @param options - The options for the request
+     * @param groupId - The ID of the group
+     *
+     * @throws {ZaloApiError}
+     *
+     */
+    return async function getListBoard(options, groupId) {
+        const requestParams = {
+            group_id: groupId,
+            board_type: 0,
+            page: options.page ?? 1,
+            count: options.count ?? 20,
+            last_id: 0,
+            last_type: 0,
+            imei: ctx.imei,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(requestParams));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(utils.makeURL(serviceURL, { params: encryptedParams }), {
+            method: "GET",
+        });
+        return utils.resolve(response, (result) => {
+            const data = result.data;
+            data.items.forEach((item) => {
+                if (item.boardType != BoardType.Poll) {
+                    const detailData = item.data;
+                    if (typeof detailData.params === "string") {
+                        detailData.params = JSON.parse(detailData.params);
+                    }
+                }
+            });
+            return data;
+        });
+    };
+});

package/dist/apis/board/getListPinTopics.d.ts

@@ -0,0 +1,5 @@
+export type GetListPinTopicsResponse = {
+    items: unknown[];
+    version: number;
+};
+export declare const getListPinTopicsFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => (groupId: string, boardVersion?: number) => Promise<GetListPinTopicsResponse>;

package/dist/apis/board/getListPinTopics.js

@@ -0,0 +1,28 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { apiFactory } from "../../utils.js";
+export const getListPinTopicsFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = utils.makeURL(`${api.zpwServiceMap.group_board[0]}/api/board/pin/list`);
+    /**
+     * Lấy danh sách chủ đề / tin nhắn đã ghim trong bảng tin nhóm (command 12001)
+     *
+     * @param groupId ID nhóm
+     * @param boardVersion Phiên bản bảng ghim hiện tại (mặc định `0`)
+     * @throws {ZaloApiError}
+     */
+    return async function getListPinTopics(groupId, boardVersion = 0) {
+        const params = {
+            groupId,
+            boardVersion,
+            imei: ctx.imei,
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(params));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(utils.makeURL(serviceURL, {
+            params: encryptedParams,
+        }), {
+            method: "GET",
+        });
+        return utils.resolve(response);
+    };
+});

package/dist/apis/board/getListReminder.d.ts

@@ -0,0 +1,28 @@
+import type { ReminderGroup, ReminderUser } from "../../models/index.js";
+import { ThreadType } from "../../models/index.js";
+export type ListReminderOptions = {
+    /**
+     * Page number (default: 1)
+     */
+    page?: number;
+    /**
+     * Number of items to retrieve (default: 20)
+     */
+    count?: number;
+};
+export type ReminderListUser = ReminderUser;
+export type ReminderListGroup = ReminderGroup & {
+    groupId: string;
+    eventType: number;
+    responseMem: {
+        rejectMember: number;
+        myResp: number;
+        acceptMember: number;
+    };
+    repeatInfo: {
+        list_ts: unknown[];
+    };
+    repeatData: unknown[];
+};
+export type GetListReminderResponse = (ReminderListUser & ReminderListGroup)[];
+export declare const getListReminderFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => (options: ListReminderOptions, threadId: string, type?: ThreadType) => Promise<GetListReminderResponse>;

package/dist/apis/board/getListReminder.js

@@ -0,0 +1,49 @@
+import { ZaloApiError } from "../../Errors/ZaloApiError.js";
+import { ThreadType } from "../../models/index.js";
+import { apiFactory } from "../../utils.js";
+export const getListReminderFactory = apiFactory()((api, ctx, utils) => {
+    const serviceURL = {
+        [ThreadType.User]: utils.makeURL(`${api.zpwServiceMap.group_board[0]}/api/board/oneone/list`),
+        [ThreadType.Group]: utils.makeURL(`${api.zpwServiceMap.group_board[0]}/api/board/listReminder`),
+    };
+    /**
+     * Get list reminder
+     *
+     * @param options - The options for the request
+     * @param threadId - The ID of the thread
+     * @param type - The type of the thread (User or Group)
+     *
+     * @throws {ZaloApiError}
+     */
+    return async function getListReminder(options, threadId, type = ThreadType.User) {
+        const requestParams = {
+            objectData: JSON.stringify(type === ThreadType.User
+                ? {
+                    uid: threadId,
+                    board_type: 1,
+                    page: options.page ?? 1,
+                    count: options.count ?? 20,
+                    last_id: 0,
+                    last_type: 0,
+                }
+                : {
+                    group_id: threadId,
+                    board_type: 1,
+                    page: options.page ?? 1,
+                    count: options.count ?? 20,
+                    last_id: 0,
+                    last_type: 0,
+                }),
+            ...(type === ThreadType.Group && { imei: ctx.imei }),
+        };
+        const encryptedParams = utils.encodeAES(JSON.stringify(requestParams));
+        if (!encryptedParams)
+            throw new ZaloApiError("Failed to encrypt params");
+        const response = await utils.request(utils.makeURL(serviceURL[type], { params: encryptedParams }), {
+            method: "GET",
+        });
+        return utils.resolve(response, (result) => {
+            return JSON.parse(result.data);
+        });
+    };
+});

package/dist/apis/board/getPollDetail.d.ts

@@ -0,0 +1,3 @@
+import type { PollDetail } from "../../models/index.js";
+export type PollDetailResponse = PollDetail;
+export declare const getPollDetailFactory: (ctx: import("../../context.js").ContextBase, api: import("../../apis.js").API) => (pollId: number) => Promise<PollDetail>;