@sendbird/cli 0.0.0-stage → 0.4.0

package/dist/pro-api-catalog.js

@@ -0,0 +1,619 @@
+import { pushBody, pushRecord, callsPushListSchema } from "./calls-catalog.js";
+/** Dashboard-backed Pro operations. All traffic uses Gate OAuth and App-Id. */
+import { z } from "zod";
+const text = z.string().min(1), optional = z.string().optional(), bool = z.boolean().optional();
+const object = z.object({}).passthrough(), empty = z.object({}).strict();
+const page = {
+    limit: z.number().int().min(1).max(100).default(20),
+    token: optional,
+};
+const settings = "app/core/api/settings.ts", chatSettings = "app/chat/api/settings.ts", announcements = "app/chat/api/announcements.ts";
+const keywordSettings = z
+    .object({
+    type: z.number().int().min(0).max(3).optional(),
+    keywords: z.string().optional(),
+    regex_filters: z
+        .array(z.object({ regex: text }).strict())
+        .max(100)
+        .optional(),
+    regex_filters_case_sensitive: bool,
+    should_check_global: bool,
+})
+    .strict();
+const likelihood = z.number().int().min(0).max(5).optional();
+const image = z
+    .object({
+    type: z.number().int().min(0).max(2).optional(),
+    soft_block: bool,
+    check_urls: bool,
+    limits: z
+        .object({
+        adult: likelihood,
+        spoof: likelihood,
+        medical: likelihood,
+        violence: likelihood,
+        racy: likelihood,
+    })
+        .strict()
+        .optional(),
+})
+    .strict();
+const channelSettings = {
+    profanity_filter: keywordSettings.optional(),
+    image_moderation: image.optional(),
+    display_past_message: bool,
+    max_message_length: z
+        .union([
+        z.literal(-1),
+        z.literal(50),
+        z.literal(100),
+        z.literal(200),
+        z.literal(500),
+        z.literal(1000),
+        z.literal(5000),
+    ])
+        .optional(),
+    // -1 delegates to the service's system limit; it is not unlimited.
+    user_messages_per_channel: z.number().int().min(-1).optional(),
+    user_messages_per_channel_duration: z.number().int().nonnegative().optional(),
+    allow_links: bool,
+};
+const definitions = [];
+function add(name, method, path, source, body, response = object, params, query, extra = {}) {
+    definitions.push({
+        name,
+        description: name,
+        method,
+        path,
+        scope: "app",
+        requiresOrg: method !== "GET",
+        source: [
+            source.startsWith("announcement:")
+                ? announcements
+                : source.startsWith("chat:")
+                    ? chatSettings
+                    : settings,
+            source.replace(/^(announcement|chat):/, ""),
+        ],
+        body,
+        response,
+        params,
+        query,
+        ...(method !== "GET" ? { danger: true } : {}),
+        ...extra,
+    });
+}
+add("chat settings get", "GET", "/platform/v3/applications/settings_global", "fetchSettingsGlobal");
+add("chat settings update", "PUT", "/platform/v3/applications/settings_global", "updateSettingsGlobal", z.object(channelSettings).strict(), object, undefined, undefined, {
+    description: "Update global moderation and channel defaults; read and preserve current settings first",
+    example: { display_past_message: true },
+});
+add("chat settings custom list", "GET", "/platform/v3/applications/settings_by_channel_custom_type", "fetchSettingsForCustomChannelTypes", undefined, z.object({
+    channel_custom_type_settings: z.array(object),
+    next: z.string().nullable(),
+}), undefined, z.object(page));
+add("chat settings custom get", "GET", "/platform/v3/applications/settings_by_channel_custom_type/{custom_type}", "fetchSettingsForCustomChannelType", undefined, object, z.object({ custom_type: text }));
+add("chat settings custom create", "POST", "/platform/v3/applications/settings_by_channel_custom_type", "createSettingsForCustomChannelType", z.object({ custom_type: text, ...channelSettings }).strict());
+add("chat settings custom update", "PUT", "/platform/v3/applications/settings_by_channel_custom_type/{custom_type}", "updateSettingsForCustomChannelType", z.object(channelSettings).strict(), object, z.object({ custom_type: text }), undefined, { example: { display_past_message: true } });
+for (const scope of ["global", "custom"]) {
+    const path = scope === "global"
+        ? "/platform/v3/applications/settings_global/profanity_keyword"
+        : "/platform/v3/applications/settings_by_channel_custom_type/{custom_type}/profanity_keyword";
+    const stem = scope === "global" ? "Default" : "CustomType";
+    for (const [verb, method, source] of [
+        ["list", "GET", `fetch${stem}ProfanityKeywords`],
+        ["add", "PATCH", `add${stem}ProfanityKeyword`],
+        ["delete", "DELETE", `delete${stem}ProfanityKeyword`],
+    ])
+        add(`chat moderation keywords ${scope} ${verb}`, method, path + (verb === "list" ? "" : "/{keyword}"), `chat:${source}`, method === "PATCH" ? empty : undefined, object, z.object({
+            ...(scope === "custom" ? { custom_type: text } : {}),
+            ...(verb !== "list" ? { keyword: text } : {}),
+        }));
+}
+add("chat webhook get", "GET", "/platform/v3/applications/settings/webhook", "getWebhooksInformation", undefined, z.object({ webhook: object }), undefined, undefined, { description: "Read Chat webhook settings with the callback URL masked" });
+add("chat webhook categories", "GET", "/platform/v3/applications/settings/webhook", "getWebhooksAllCategories", undefined, object, undefined, z.object({ display_all_webhook_categories: z.literal(true).default(true) }));
+add("chat webhook update", "PUT", "/platform/v3/applications/settings/webhook", "updateWebhookInformation", z
+    .object({
+    enabled: z.boolean(),
+    url: z.union([z.literal(""), z.url()]),
+    enabled_events: z.array(text).max(100).optional(),
+    include_members: z.boolean(),
+    include_unread_count: z.boolean(),
+    events_to_include_channel_metadata: z.array(text).max(100).optional(),
+})
+    .strict(), z.object({ webhook: object }), undefined, undefined, {
+    description: "Update Chat event webhook; URL is accepted only in a private body file",
+    privateFields: ["url"],
+});
+const dimension = z.enum(["daily", "monthly"]);
+add("chat analytics metric get", "GET", "/platform/v3/statistics/metric", "fetchStatistics", undefined, z
+    .object({
+    values: z.array(z.unknown()),
+    next: z.string().nullable().optional(),
+})
+    .passthrough(), undefined, z
+    .object({
+    metric_type: z.enum([
+        "created_users",
+        "deactivated_users",
+        "deleted_users",
+        "created_channels",
+        "active_channels",
+        "messages",
+        "messages_per_user",
+        "message_viewers",
+        "message_senders",
+    ]),
+    time_dimension: dimension,
+    start_year: z.number().int().min(2000).max(2100),
+    end_year: z.number().int().min(2000).max(2100),
+    start_month: z.number().int().min(1).max(12),
+    end_month: z.number().int().min(1).max(12),
+    start_day: z.number().int().min(1).max(31).optional(),
+    end_day: z.number().int().min(1).max(31).optional(),
+    segments: optional,
+    token: optional,
+})
+    .strict(), {
+    source: ["app/chat/api/analytics.ts", "fetchStatistics"],
+    description: "Read one bounded analytics metric page; follow next with --token, not a data export",
+});
+const announcementMessage = z
+    .object({
+    type: z.enum(["MESG", "ADMM"]),
+    user_id: text.nullable(),
+    content: text,
+    custom_type: optional,
+    data: optional,
+})
+    .strict();
+const creation = {
+    message: announcementMessage,
+    target_at: z.enum([
+        "target_channels",
+        "target_users_included_channels",
+        "target_users_only_channels",
+    ]),
+    target_list: z.array(text).min(1).max(100),
+    target_channel_type: z
+        .enum(["non_distinct", "distinct", "all"])
+        .default("all"),
+    create_channel: z.boolean().default(false),
+    enable_push: z.boolean().default(false),
+    scheduled_at: z.number().int().nonnegative(),
+    announcement_group: optional,
+};
+const announcementId = z.object({ id: text });
+add("chat announcement create", "POST", "/platform/v3/announcements", "announcement:createAnnouncement", z.object(creation).strict(), object, undefined, undefined, {
+    description: "Send or schedule a bounded announcement to explicit targets; requires --yes",
+    example: {
+        message: { type: "MESG", user_id: "SENDER_ID", content: "Announcement" },
+        target_at: "target_channels",
+        target_list: ["CHANNEL_URL"],
+        scheduled_at: 1893456000,
+    },
+});
+add("chat announcement list", "GET", "/platform/v3/announcements", "announcement:fetchAnnouncements", undefined, z.object({
+    announcements: z.array(object),
+    next: z.string().nullable().optional(),
+}), undefined, z.object({
+    ...page,
+    status: z
+        .enum([
+        "scheduled",
+        "ready",
+        "running",
+        "canceled",
+        "stopped",
+        "paused",
+        "completed",
+        "incompleted",
+        "on-hold",
+    ])
+        .optional(),
+}));
+add("chat announcement get", "GET", "/platform/v3/announcements/{id}", "announcement:fetchAnnouncement", undefined, object, announcementId);
+add("chat announcement update", "PUT", "/platform/v3/announcements/{id}", "announcement:updateAnnouncement", z
+    .object({
+    message: announcementMessage.optional(),
+    enable_push: bool,
+    scheduled_at: z.number().int().nonnegative().optional(),
+    end_at: z.number().int().nonnegative().nullable().optional(),
+    cease_at: z
+        .string()
+        .regex(/^([01]\d|2[0-3])[0-5]\d$/)
+        .nullable()
+        .optional(),
+    resume_at: z
+        .string()
+        .regex(/^([01]\d|2[0-3])[0-5]\d$/)
+        .nullable()
+        .optional(),
+    announcement_group: optional,
+})
+    .strict(), object, announcementId, undefined, {
+    example: { enable_push: false },
+    description: "Update announcement fields; legacy version differences may be rejected by the server",
+});
+add("chat announcement action", "PUT", "/platform/v3/announcements/{id}", "announcement:updateAnnouncement", z.object({ action: z.enum(["cancel", "pause", "resume", "stop"]) }).strict(), object, announcementId, undefined, {
+    description: "Pause, resume, cancel or stop a current-version announcement; never retry an uncertain action",
+});
+add("chat announcement groups list", "GET", "/platform/v3/announcement_group", "announcement:fetchAnnouncementGroups", undefined, z.object({
+    announcement_groups: z.array(z.string()),
+    next: z.string().nullable(),
+}), undefined, z.object(page));
+add("chat announcement open-status", "GET", "/platform/v3/announcement_open_status/{id}", "announcement:getAnnouncementOpenStatus", undefined, z.object({ open_status: z.array(object), next: z.string().nullable() }), announcementId, z.object(page));
+add("chat announcement open-rate", "GET", "/platform/v3/announcement_open_rate/{id}", "announcement:fetchAnnouncementOpenRate", undefined, z.object({ event_id: text }).passthrough(), announcementId);
+add("chat push settings update", "PUT", "/platform/v3/applications/push/settings", "updatePushSettings", z.object({ always_push: bool, include_channel_unread_count: bool }).strict(), object, undefined, undefined, { example: { always_push: false } });
+const template = z.union([
+    z.string(),
+    z.object({ title: z.string(), body: z.string() }).strict(),
+]);
+add("chat push template set", "POST", "/platform/v3/applications/push/message_templates/{template_name}", "updatePushMessageTemplates", z
+    .object({
+    template: z
+        .object({ MESG: template, FILE: template, ADMM: template })
+        .strict(),
+})
+    .strict(), z.object({ push_message_templates: z.array(object) }), z.object({ template_name: z.enum(["default", "alternative"]) }));
+add("chat push test send", "POST", "/platform/dapi/push/test", "chat:postPushTest", z
+    .object({
+    channel_url: text,
+    user_id: text,
+    device_token: text,
+    message: text,
+    provider_id: text,
+    use_fcm_v1_api: bool,
+})
+    .strict(), z.object({ channel_url: text, msg_id: z.number().int(), msg_ts: z.number() }), undefined, undefined, {
+    privateFields: ["device_token"],
+    description: "Submit a real Chat Push test to an authorized device; acceptance does not prove receipt",
+});
+add("chat push test get", "GET", "/platform/dapi/push/test", "chat:getPushTestResult", undefined, z.object({
+    push_logged: z.boolean(),
+    push_results: z.array(object).optional(),
+    msg_ts: z.number().optional(),
+}), undefined, z.object({
+    channel_url: text,
+    msg_id: z.number().int().positive(),
+    provider_id: text,
+}));
+add("app ip-allowlist get", "GET", "/platform/v3/applications/settings/ip_whitelist", "getIPWhitelist", undefined, z.object({ ip_whitelist_addresses: z.array(z.string()) }));
+add("app partition set", "PUT", "/platform/dapi/settings/open_channels_dynamic_partitioning/", "updateOpenChannelDynamicPartitioningOption", z
+    .object({
+    option_type: z.enum([
+        "single_subchannel",
+        "multiple_subchannels",
+        "custom",
+    ]),
+})
+    .strict(), object, undefined, undefined, {
+    description: "Change Open-channel partitioning mode; needs an authorized app and readback",
+});
+for (const [action, method, symbol] of [
+    ["list", "GET", "fetchPushConfiguration"],
+    ["create", "POST", "createPushConfiguration"],
+    ["update", "PUT", "updatePushConfiguration"],
+    ["delete", "DELETE", "deletePushConfiguration"],
+]) {
+    add(`chat push ${action}`, method, "/platform/v3/applications/push/{push_type}" +
+        (["update", "delete"].includes(action) ? "/{id}" : ""), symbol, ["create", "update"].includes(action) ? pushBody : undefined, action === "list" || action === "create"
+        ? callsPushListSchema
+        : action === "update"
+            ? z.object({
+                push_configurations: z.union([z.string(), z.array(pushRecord)]),
+            })
+            : z.object({}).nullable(), z.object({
+        push_type: z.enum(["apns", "fcm", "huawei"]),
+        ...(["update", "delete"].includes(action) ? { id: text } : {}),
+    }), action === "list"
+        ? z.object({ ...page, paginated: z.literal(true).default(true) })
+        : undefined, {
+        description: `${action} Chat push provider credentials; separate from Calls VoIP providers`,
+        privateFields: ["apns_cert_password", "huawei_app_secret"],
+    });
+}
+add("app delete", "DELETE", "/platform/v3/applications", "deleteApplication", undefined, object, z.object({ confirm_app_name: text }), undefined, {
+    description: "Delete the selected application and its data; exact app name and --yes are required",
+});
+for (const [action, method, source] of [
+    ["add", "PUT", "putIPWhitelist"],
+    ["remove", "DELETE", "deleteIPWhitelist"],
+])
+    add(`app ip-allowlist ${action}`, method, "/platform/v3/applications/settings/ip_whitelist", source, z
+        .object({ ip_whitelist_addresses: z.array(text).min(1).max(100) })
+        .strict(), z.object({ ip_whitelist_addresses: z.array(z.string()) }), z.object({ confirm_app_name: text, confirm_source_ip: text }), undefined, {
+        description: `${action} IP/CIDR entries; confirm the current source IP and exact application name first`,
+    });
+const organizationSource = "app/common/api/organizations.ts";
+const ssoResponse = z.object({
+    uid: text,
+    sso_entity_id: z.string().nullable().optional(),
+    sso_idp_url: z.string().nullable().optional(),
+    sso_idp_cert: z.string().nullable().optional(),
+    sso_enforcing: z.boolean().optional(),
+    sso_jit_provisioning: z.boolean().optional(),
+});
+add("org sso get", "GET", "/dashboard_api/organizations/{orgId}/", "fetchOrganization", undefined, ssoResponse, undefined, undefined, {
+    scope: "org",
+    source: [organizationSource, "fetchOrganization"],
+    description: "Read the authenticated organization's SAML configuration; public certificate is masked",
+});
+add("org sso set", "POST", "/dashboard_api/organizations/{orgId}/sso_profile/", "updateSamlConfiguration", z
+    .object({
+    entity_id: text,
+    idp_url: z.url(),
+    idp_cert: text,
+    sso_enforcing: z.boolean(),
+    jit_provisioning: z.boolean(),
+    sso_default_role: text,
+    slug_name: text.optional(),
+})
+    .strict(), ssoResponse, z.object({ confirm_org_name: text, login_tested: z.boolean().optional() }), undefined, {
+    scope: "org",
+    source: [organizationSource, "updateSamlConfiguration"],
+    privateFields: ["idp_cert", "idp_url"],
+    description: "Configure SAML with explicit organization confirmation; enforcement requires --login-tested true",
+});
+add("org sso delete", "DELETE", "/dashboard_api/organizations/{orgId}/sso_profile/", "deleteSamlConfiguration", undefined, ssoResponse, z.object({ confirm_org_name: text }), undefined, {
+    scope: "org",
+    source: [organizationSource, "deleteSamlConfiguration"],
+    description: "Remove SAML configuration; confirm the organization and --yes. Review member login recovery first",
+});
+const modSource = "app/chat/api/channelModeration.ts";
+const modParams = { type: z.enum(["open", "group", "supergroup"]), id: text };
+const modBody = z
+    .object({
+    user_id: text,
+    seconds: z
+        .number()
+        .int()
+        .min(-1)
+        .max(31536000)
+        .refine((n) => n !== 0),
+    description: z.string().max(4000).default(""),
+})
+    .strict();
+for (const [noun, wire, listSymbol, addSymbol, removeSymbol, getSymbol] of [
+    [
+        "banned",
+        "ban",
+        "fetchChannelBannedUsers",
+        "banUser",
+        "unbanUser",
+        "getBanDetail",
+    ],
+    [
+        "muted",
+        "mute",
+        "fetchChannelMutedUsers",
+        "muteUser",
+        "unmuteUser",
+        "getMuteDetail",
+    ],
+]) {
+    const path = `/platform/v3/{kind}/{id}/${wire}`;
+    add(`chat moderation channel ${noun} list`, "GET", path, listSymbol, undefined, z.object({
+        [`${noun}_list`]: z.array(object),
+        next: z.string().nullable().optional(),
+    }), z.object(modParams), z.object(page), {
+        source: [modSource, listSymbol],
+        description: `List ${noun} users with Dashboard moderation permission; no SDK user token required`,
+    });
+    add(`chat moderation channel ${wire}`, "POST", path, addSymbol, modBody, object, z.object(modParams), undefined, {
+        source: [modSource, addSymbol],
+        description: `${wire} one user with an explicit duration in seconds (-1 means indefinite)`,
+    });
+    add(`chat moderation channel un${wire}`, "DELETE", path + "/{user_id}", removeSymbol, undefined, z.object({}).nullable(), z.object({ ...modParams, user_id: text }), undefined, { source: [modSource, removeSymbol] });
+    add(`chat moderation channel ${noun} get`, "GET", path + "/{user_id}", getSymbol, undefined, object, z.object({ ...modParams, user_id: text }), undefined, {
+        source: [modSource, getSymbol],
+        description: `Read one ${wire} record; a missing record does not establish other restrictions`,
+    });
+}
+add("chat moderation channel freeze", "PUT", "/platform/v3/{kind}/{id}/freeze", "freezeChannel", z.object({ freeze: z.boolean() }).strict(), z.object({ channel_url: text }).passthrough(), z.object(modParams), undefined, {
+    source: [modSource, "freezeChannel"],
+    description: "Freeze or unfreeze a channel under Dashboard moderation permission",
+});
+add("chat moderation channel operators add", "POST", "/platform/v3/{kind}/{id}/operators", "updateOperators", z.object({ operator_ids: z.array(text).min(1).max(100) }).strict(), object, z.object(modParams), undefined, {
+    source: [modSource, "updateOperators"],
+    description: "Register channel operators using the Dashboard endpoint; review current operators first",
+});
+add("chat moderation message search", "GET", "/platform/dapi/messages/", "searchMessages", undefined, z.object({
+    messages: z.array(object),
+    page: z.number().int(),
+    last: z.number().int(),
+    total: z.number().int(),
+}), undefined, z
+    .object({
+    keyword: text,
+    channel_url: z.string().optional(),
+    user_id: z.string().optional(),
+    start_timestamp: z.number().int().nonnegative(),
+    end_timestamp: z.number().int().nonnegative(),
+    exclude_removed: z.boolean().default(true),
+    page: z.number().int().min(1).max(100).default(1),
+    limit: z.number().int().min(1).max(100).default(20),
+})
+    .strict(), {
+    source: ["app/chat/api/messages.ts", "searchMessages"],
+    description: "Search app messages with Dashboard messageSearch permission, separate from SDK member-visible search",
+});
+add("chat push enabled get", "GET", "/dashboard/applications/{appId}/get_detail/", "fetchApplicationGetDetail", undefined, z
+    .object({ app_id: text, push_enabled: z.boolean().optional() })
+    .passthrough(), undefined, undefined, {
+    source: ["app/core/api/application.ts", "fetchApplicationGetDetail"],
+    description: "Read the shared Push switch used by Chat and Calls",
+});
+add("chat push enabled set", "PUT", "/platform/dapi/applications/detail/", "togglePushEnabled", z.object({ push_enabled: z.boolean() }).strict(), z.object({
+    application: z
+        .object({ app_id: text, push_enabled: z.boolean() })
+        .passthrough(),
+}), z.object({ confirm_shared_push: z.literal(true) }), undefined, {
+    description: "Change the shared Chat/Calls Push switch; requires --confirm-shared-push true and --yes",
+});
+add("app partition get", "GET", "/dashboard/applications/{appId}/get_detail/", "fetchApplicationGetDetail", undefined, z.object({ app_id: text, attrs: object.optional() }), undefined, undefined, {
+    source: ["app/core/api/application.ts", "fetchApplicationGetDetail"],
+    description: "Read Open-channel partitioning defaults and participant limits; snapshots do not prove scale",
+});
+for (const d of definitions) {
+    if (d.name === "chat webhook update")
+        d.example = { url: "https://example.com/chat-webhook" };
+    if (d.name === "chat analytics metric get")
+        d.exampleQuery = {
+            start_year: 2026,
+            end_year: 2026,
+            start_month: 10,
+            end_month: 10,
+            start_day: 1,
+            end_day: 14,
+            time_dimension: "daily",
+        };
+    if (d.name === "chat moderation message search")
+        d.exampleQuery = {
+            start_timestamp: 1790812800000,
+            end_timestamp: 1790899200000,
+        };
+    if (/^chat push (create|update)$/.test(d.name))
+        d.example = {
+            format: "p8",
+            environment: "development",
+            apns_bundle_id: "com.example.chat",
+            apns_key_id: "KEY_ID",
+            apns_team_id: "TEAM_ID",
+        };
+    if (/^app ip-allowlist (add|remove)$/.test(d.name)) {
+        d.example = { ip_whitelist_addresses: ["203.0.113.0/24"] };
+        d.exampleParams = {
+            confirm_source_ip: "203.0.113.1",
+            confirm_app_name: "APP_NAME",
+        };
+    }
+    if (d.name === "org sso set")
+        d.example = {
+            entity_id: "IDP_ENTITY_ID",
+            idp_url: "https://idp.example.com/saml",
+            idp_cert: "PUBLIC_IDP_CERT_PEM",
+            sso_enforcing: false,
+            jit_provisioning: false,
+            sso_default_role: "MEMBER_ROLE_NAME",
+        };
+    if (/^chat moderation channel (ban|mute)$/.test(d.name))
+        d.example = { seconds: 60, description: "Authorized test" };
+}
+const settingsResponse = z
+    .object({
+    profanity_filter: z.object({ type: z.number().int() }).passthrough(),
+})
+    .passthrough();
+const announcementResponse = z
+    .object({ unique_id: optional, event_id: optional, status: optional })
+    .passthrough()
+    .refine((v) => Boolean(v.unique_id || v.event_id), "Missing announcement identity");
+export const proApiDefinitions = definitions.map((d) => {
+    let response = d.response;
+    if (d.name === "chat settings get" || d.name === "chat settings update")
+        response = settingsResponse;
+    if ([
+        "chat settings custom get",
+        "chat settings custom create",
+        "chat settings custom update",
+    ].includes(d.name))
+        response = z.object({ custom_type: text }).passthrough();
+    if (d.name.startsWith("chat moderation keywords "))
+        response = z.object({ profanity_filter: object });
+    if (d.name === "chat webhook get" || d.name === "chat webhook update")
+        response = z.object({
+            webhook: z
+                .object({
+                enabled: z.boolean(),
+                url: z.string(),
+                enabled_events: z.array(z.string()).optional(),
+            })
+                .passthrough(),
+        });
+    if ([
+        "chat announcement create",
+        "chat announcement get",
+        "chat announcement update",
+        "chat announcement action",
+    ].includes(d.name))
+        response = announcementResponse;
+    if (d.name === "chat announcement list")
+        response = z.object({
+            announcements: z.array(announcementResponse),
+            next: z.string().nullable().optional(),
+        });
+    if (d.name === "chat push test get")
+        response = z.discriminatedUnion("push_logged", [
+            z.object({ push_logged: z.literal(false), msg_ts: z.number() }),
+            z.object({ push_logged: z.literal(true), push_results: z.array(object) }),
+        ]);
+    const words = d.name.split(" "), verb = words.at(-1), subject = words.slice(0, -1).join(" ");
+    const description = d.description === d.name
+        ? `${verb[0].toUpperCase() + verb.slice(1)} ${subject} using the authenticated Dashboard role`
+        : d.description;
+    if (d.name.startsWith("chat push enabled "))
+        return {
+            ...d,
+            response,
+            resultSchema: z.object({
+                app_id: text,
+                push_enabled: z.boolean().nullable(),
+                shared_with_calls: z.literal(true),
+            }),
+            description,
+        };
+    if (d.name === "app partition get")
+        return {
+            ...d,
+            response,
+            resultSchema: z.object({
+                app_id: text,
+                dynamic_partitioning_enabled: z.boolean().nullable(),
+                max_participants_per_subchannel: z.number().nullable(),
+                max_total_participants: z.number().nullable(),
+            }),
+            description,
+        };
+    const resultSchema = d.name === "chat push test get"
+        ? z.discriminatedUnion("push_logged", [
+            z.object({
+                push_logged: z.literal(false),
+                msg_ts: z.number(),
+                delivery_verified: z.literal(false),
+            }),
+            z.object({
+                push_logged: z.literal(true),
+                delivery_verified: z.literal(false),
+                push_results: z.array(z.object({
+                    result_code: z.number(),
+                    push_type: z.string(),
+                    ts: z.number(),
+                    device_token_count: z.number().int().nonnegative(),
+                })),
+            }),
+        ])
+        : d.name === "chat push test send"
+            ? z.object({
+                channel_url: text,
+                msg_id: z.number(),
+                msg_ts: z.number(),
+                delivery_verified: z.literal(false),
+            })
+            : d.name === "chat push update"
+                ? z.union([
+                    z.object({ push_configurations: z.array(pushRecord) }),
+                    z.object({
+                        acknowledged: z.literal(true),
+                        metadata_available: z.literal(false),
+                    }),
+                ])
+                : undefined;
+    return {
+        ...d,
+        response,
+        description,
+        ...(resultSchema ? { resultSchema } : {}),
+    };
+});
+//# sourceMappingURL=pro-api-catalog.js.map