@sendbird/cli 0.0.0-stage → 0.4.0

package/dist/catalog.js

@@ -0,0 +1,784 @@
+import { callsTrialFollowupSchema } from "./calls-credits.js";
+import { proApiDefinitions } from "./pro-api-catalog.js";
+import { z } from "zod";
+import { featureDefinitions } from "./features.js";
+import { callsDefinitions } from "./calls-catalog.js";
+import { billingHandoffSchema, billingVerificationSchema, } from "./billing-plan.js";
+const text = z.string().min(1);
+const optional = z.string().optional();
+const bool = z.boolean().optional();
+const metadata = z.record(z.string().min(1).max(128), z.string().max(190));
+const page = {
+    limit: z.number().int().min(1).max(100).default(20),
+    token: optional,
+};
+const id = { id: text };
+const type = z.enum(["open", "group", "supergroup"]);
+const channel = { id: text, type };
+const user = "app/core/api/users.ts";
+const channels = "app/chat/api/channels.ts";
+const application = "app/core/api/application.ts";
+const settings = "app/core/api/settings.ts";
+const auth = "app/common/api/authentication.ts";
+const org = "app/common/api/organizations.ts";
+const usage = "app/common/api/usage.ts";
+const billing = "app/common/api/billing.ts";
+const object = z.object({}).passthrough();
+const userResponse = z.object({ user_id: z.string() }).passthrough();
+const channelResponse = z.object({ channel_url: z.string() }).passthrough();
+export const verifySchema = z
+    .object({
+    user: object.optional(),
+    organization: object.optional(),
+    organizations: z.array(object).optional(),
+    role: object.optional(),
+})
+    .passthrough()
+    .refine((v) => v.user || v.organization || v.organizations, "Missing identity");
+const defs = [...featureDefinitions, ...proApiDefinitions];
+function add(d) {
+    defs.push(d);
+}
+add({
+    name: "org list",
+    description: "List organizations accessible to the current session",
+    method: "GET",
+    path: "/dashboard/auth/verify2/",
+    response: verifySchema,
+    source: [auth, "verifyAuth"],
+});
+add({
+    name: "org get",
+    description: "Get an organization",
+    method: "GET",
+    path: "/dashboard_api/organizations/{orgId}/",
+    scope: "org",
+    response: z.object({ uid: text }).passthrough(),
+    source: [org, "fetchOrganization"],
+});
+add({
+    name: "org create",
+    description: "Create an organization",
+    method: "POST",
+    path: "/dashboard_api/organizations/",
+    body: z
+        .object({ organization_name: z.string().trim().min(1), contact: optional })
+        .strict(),
+    response: z
+        .object({
+        organizations: z.array(z.object({ uid: text }).passthrough()).min(1),
+    })
+        .passthrough(),
+    source: [org, "createOrganization"],
+    example: { organization_name: "Chat demo" },
+});
+add({
+    name: "app list",
+    description: "List accessible applications (offset pagination)",
+    method: "GET",
+    path: "/dashboard/applications/",
+    query: z.object({
+        limit: page.limit,
+        offset: z.number().int().min(0).default(0),
+        app_name_or_app_id: optional,
+    }),
+    response: z
+        .object({
+        results: z.array(z.object({ app_id: text }).passthrough()),
+        next: z.string().nullable().optional(),
+        skipped_unavailable_applications: z
+            .number()
+            .int()
+            .nonnegative()
+            .optional(),
+        filter_note: z.string().optional(),
+    })
+        .passthrough(),
+    source: ["app/common/api/applications.ts", "fetchApplications"],
+});
+add({
+    name: "app get",
+    description: "Get application detail and authentication policy",
+    method: "GET",
+    path: "/dashboard/applications/{appId}/get_detail/",
+    scope: "app",
+    response: z
+        .object({
+        app_id: text,
+        guest_user_policy: z.number().optional(),
+        current_premium_features: z
+            .unknown()
+            .optional()
+            .describe("Dashboard plan snapshot. super_group_channel, reactions and poll are reported flags, not runtime authorization checks. False does not prove runtime denial, true does not prove runtime success, and missing values are unknown. Use doctor to inspect plan, activation and prerequisites separately."),
+    })
+        .passthrough(),
+    source: [application, "fetchApplicationGetDetail"],
+});
+add({
+    name: "app create",
+    description: "Create an application with optional Calls registration in an organization",
+    method: "POST",
+    path: "/dashboard/applications/",
+    scope: "org",
+    body: z
+        .object({
+        app_name: text,
+        region: text.optional(),
+        is_calls_enabled: z.boolean().default(false),
+        is_delight_region: z.boolean().default(false),
+    })
+        .strict(),
+    response: z.object({ application: object }).passthrough(),
+    resultSchema: z
+        .object({
+        application: object,
+        calls_trial: callsTrialFollowupSchema.optional(),
+    })
+        .passthrough(),
+    source: [application, "createApplication"],
+    defaults: {
+        is_desk_enabled: false,
+    },
+    example: { app_name: "Chat demo", region: "YOUR_REGION" },
+});
+add({
+    name: "app rename",
+    description: "Rename the selected application",
+    method: "PUT",
+    path: "/platform/dapi/settings/change_app_name/",
+    scope: "app",
+    body: z.object({ app_name: text }).strict(),
+    response: object,
+    source: [settings, "changeAppName"],
+});
+add({
+    name: "app auth-policy get",
+    description: "Read current guest/access-token policy from app detail",
+    method: "GET",
+    path: "/dashboard/applications/{appId}/get_detail/",
+    scope: "app",
+    response: z
+        .object({ app_id: text, guest_user_policy: z.number().optional() })
+        .passthrough(),
+    resultSchema: z
+        .object({
+        guest_user_policy: z.union([z.literal(0), z.literal(1), z.literal(2)]),
+    })
+        .strict(),
+    source: [application, "fetchApplicationGetDetail"],
+});
+add({
+    name: "app auth-policy set",
+    description: "Set the Dashboard guest_user_policy (0, 1 or 2)",
+    method: "PUT",
+    path: "/platform/dapi/settings/access_token_user_policy/",
+    scope: "app",
+    body: z
+        .object({
+        guest_user_policy: z.union([z.literal(0), z.literal(1), z.literal(2)]),
+    })
+        .strict(),
+    response: z
+        .object({
+        guest_user_policy: z.union([z.literal(0), z.literal(1), z.literal(2)]),
+    })
+        .passthrough(),
+    source: [settings, "updateAccessTokenUserPolicy"],
+    danger: true,
+});
+for (const name of ["list", "search"])
+    add({
+        name: `chat user ${name}`,
+        description: "List/search Chat users with bounded cursor pagination",
+        method: "GET",
+        path: "/platform/v3/users",
+        scope: "app",
+        query: z.object({
+            ...page,
+            user_ids: optional,
+            nickname: optional,
+            nickname_startswith: optional,
+            active_mode: z.enum(["all", "activated", "deactivated"]).optional(),
+        }),
+        response: z
+            .object({ users: z.array(userResponse), next: z.string().optional() })
+            .passthrough(),
+        source: [user, name === "list" ? "fetchUsers" : "searchUsers"],
+    });
+add({
+    name: "chat user get",
+    description: "Get a Chat user",
+    method: "GET",
+    path: "/platform/v3/users/{id}",
+    scope: "app",
+    params: z.object(id),
+    response: userResponse,
+    source: [user, "fetchUser"],
+});
+add({
+    name: "chat user create",
+    description: "Create a Chat user",
+    method: "POST",
+    path: "/platform/v3/users",
+    scope: "app",
+    multipart: true,
+    body: z
+        .object({
+        user_id: text,
+        nickname: text,
+        profile_url: z.string().default(""),
+        issue_access_token: bool,
+    })
+        .strict(),
+    response: userResponse,
+    source: [user, "createUser"],
+    example: { user_id: "alice", nickname: "Alice" },
+});
+add({
+    name: "chat user update",
+    description: "Update nickname or profile URL",
+    method: "PUT",
+    path: "/platform/v3/users/{id}",
+    scope: "app",
+    params: z.object(id),
+    multipart: true,
+    body: z.object({ nickname: optional, profile_url: optional }).strict(),
+    response: userResponse,
+    source: [user, "editUser"],
+});
+add({
+    name: "chat user delete",
+    description: "Delete a Chat user",
+    method: "DELETE",
+    path: "/platform/v3/users/{id}",
+    scope: "app",
+    params: z.object(id),
+    response: object.nullable(),
+    source: [user, "deleteUser"],
+    danger: true,
+});
+for (const action of ["activate", "deactivate"])
+    add({
+        name: `chat user ${action}`,
+        description: `${action} a Chat user`,
+        method: "PUT",
+        path: "/platform/dapi/users/{id}/moderations",
+        scope: "app",
+        params: z.object(id),
+        body: z
+            .object(action === "deactivate"
+            ? { leave_all_when_deactivated: z.boolean().default(false) }
+            : {})
+            .strict(),
+        defaults: { is_active: action === "activate" },
+        response: object,
+        source: [user, action === "activate" ? "reactivateUser" : "deactivateUser"],
+        danger: action === "deactivate",
+    });
+add({
+    name: "chat user token get",
+    description: "Read a user token into --secret-output",
+    method: "GET",
+    path: "/platform/v3/users/{id}",
+    scope: "app",
+    params: z.object(id),
+    query: z.object({ with_access_token: z.literal(true).default(true) }),
+    response: userResponse,
+    source: [user, "fetchUser"],
+    secret: true,
+});
+add({
+    name: "chat user token issue",
+    description: "Issue or replace a user access token",
+    method: "PUT",
+    path: "/platform/v3/users/{id}",
+    scope: "app",
+    params: z.object(id),
+    defaults: { issue_access_token: true },
+    multipart: true,
+    response: userResponse,
+    source: [user, "editUser"],
+    danger: true,
+    secret: true,
+});
+add({
+    name: "chat user metadata get",
+    description: "Get user metadata",
+    method: "GET",
+    path: "/platform/v3/users/{id}/metadata",
+    scope: "app",
+    params: z.object(id),
+    response: object,
+    source: [user, "fetchUserMetadata"],
+});
+add({
+    name: "chat user metadata set",
+    description: "Set user metadata",
+    method: "POST",
+    path: "/platform/v3/users/{id}/metadata",
+    scope: "app",
+    params: z.object(id),
+    body: z.object({ metadata }).strict(),
+    response: object,
+    source: [user, "postUserMetadata"],
+});
+add({
+    name: "chat user metadata delete",
+    description: "Delete all metadata of one user",
+    method: "DELETE",
+    path: "/platform/v3/users/{id}/metadata",
+    scope: "app",
+    params: z.object(id),
+    response: object.nullable(),
+    source: [user, "deleteUserMetadata"],
+    danger: true,
+});
+for (const action of ["list", "search"])
+    add({
+        name: `chat channel ${action}`,
+        description: "List/search Open, Group or Supergroup channels",
+        method: "GET",
+        path: "/platform/v3/{kind}",
+        scope: "app",
+        params: z.object({ type }),
+        query: z.object({
+            ...page,
+            name_contains: optional,
+            url_contains: optional,
+            channel_urls: optional,
+            custom_types: optional,
+            show_empty: bool,
+        }),
+        response: z
+            .object({
+            channels: z.array(channelResponse),
+            next: z.string().optional(),
+        })
+            .passthrough(),
+        source: [channels, "fetchGroupChannels"],
+    });
+add({
+    name: "chat channel get",
+    description: "Get a channel",
+    method: "GET",
+    path: "/platform/v3/{kind}/{id}",
+    scope: "app",
+    params: z.object(channel),
+    response: channelResponse,
+    source: [channels, "fetchGroupChannel"],
+});
+add({
+    name: "chat channel create",
+    description: "Create an Open, Group or Supergroup channel",
+    method: "POST",
+    path: "/platform/v3/{kind}",
+    scope: "app",
+    params: z.object({ type }),
+    // The CLI has no cover-file field here. Use typed JSON rather than the
+    // browser's FormData: the staging Platform proxy rejects fileless multipart.
+    multipart: false,
+    body: z
+        .object({
+        name: optional,
+        channel_url: optional,
+        cover_url: optional,
+        custom_type: optional,
+        user_ids: z.array(text).optional(),
+        is_distinct: bool,
+        is_public: bool,
+        data: optional,
+    })
+        .strict(),
+    response: channelResponse,
+    source: [channels, "createGroupChannel"],
+    example: { name: "Demo", user_ids: ["alice", "bob"] },
+});
+add({
+    name: "chat channel update",
+    description: "Update channel properties",
+    method: "PUT",
+    path: "/platform/v3/{kind}/{id}",
+    scope: "app",
+    params: z.object(channel),
+    // The CLI has no cover-file field here. Use typed JSON rather than the
+    // browser's FormData: the staging Platform proxy rejects fileless multipart.
+    multipart: false,
+    body: z
+        .object({ name: optional, custom_type: optional, data: optional })
+        .strict(),
+    response: channelResponse,
+    source: [channels, "editChannel"],
+});
+add({
+    name: "chat channel delete",
+    description: "Delete a channel",
+    method: "DELETE",
+    path: "/platform/v3/{kind}/{id}",
+    scope: "app",
+    params: z.object(channel),
+    response: object.nullable(),
+    source: [channels, "deleteChannel"],
+    danger: true,
+});
+add({
+    name: "chat channel metadata get",
+    description: "Read channel metadata",
+    method: "GET",
+    path: "/platform/v3/{kind}/{id}/metadata",
+    scope: "app",
+    params: z.object(channel),
+    response: object,
+    source: [channels, "fetchMetadata"],
+});
+add({
+    name: "chat channel metadata set",
+    description: "Upsert channel metadata",
+    method: "PUT",
+    path: "/platform/v3/{kind}/{id}/metadata",
+    scope: "app",
+    params: z.object(channel),
+    body: z.object({ metadata }).strict(),
+    response: object,
+    source: [channels, "setMetadata"],
+    defaults: { upsert: true },
+});
+add({
+    name: "chat channel metadata delete",
+    description: "Delete one channel metadata key",
+    method: "DELETE",
+    path: "/platform/v3/{kind}/{id}/metadata/{key}",
+    scope: "app",
+    params: z.object({ ...channel, key: text }),
+    response: object.nullable(),
+    source: [channels, "setMetadata"],
+    danger: true,
+});
+const groupChannel = z.object({
+    id: text,
+    type: z.enum(["group", "supergroup"]),
+});
+add({
+    name: "chat channel members list",
+    description: "List Group or Supergroup members",
+    method: "GET",
+    path: "/platform/v3/{kind}/{id}/members",
+    scope: "app",
+    params: groupChannel,
+    query: z.object(page),
+    response: z
+        .object({ members: z.array(object), next: z.string().optional() })
+        .passthrough(),
+    source: ["app/chat/api/channelModeration.ts", "fetchGroupChannelMembers"],
+});
+add({
+    name: "chat channel members invite",
+    description: "Invite users to a Group or Supergroup channel",
+    method: "POST",
+    path: "/platform/v3/{kind}/{id}/invite",
+    scope: "app",
+    params: groupChannel,
+    body: z.object({ user_ids: z.array(text).min(1) }).strict(),
+    response: channelResponse,
+    source: [channels, "inviteAsGroupChannelMember"],
+});
+add({
+    name: "support ticket submit",
+    description: "Submit a Chat technical support case",
+    method: "POST",
+    path: "/dashboard_api/sf_cases/",
+    scope: "app",
+    multipart: true,
+    body: z
+        .object({
+        Subject: text,
+        Description: text,
+        Development_Platform__c: z.enum([
+            "Platform API",
+            "JavaScript",
+            "Android",
+            "iOS",
+            ".Net",
+            "Unity",
+            "Flutter",
+            "Unreal",
+            "Others",
+        ]),
+        SDK_Version__c: optional,
+        Steps_to_Reproduce__c: optional,
+        Priority: z
+            .enum([
+            "P3: General Issue",
+            "P2: Moderate impact in Production with workarounds",
+            "P1: Key functionality impaired in Production: No workarounds",
+        ])
+            .default("P3: General Issue"),
+    })
+        .strict(),
+    defaults: { Product__c: "Chat", Issue_Type__c: "Technical Issue" },
+    response: object.nullable(),
+    source: ["app/common/api/support.ts", "submitSupportForm"],
+    example: {
+        Subject: "Chat connection issue",
+        Description: "Describe the behavior",
+        Development_Platform__c: "JavaScript",
+    },
+});
+// Billing v2 subscriptions are scoped to the authenticated organization's
+// session, not an org UID in the URL. runner.ts binds that session to --org-id.
+add({
+    name: "billing plan current",
+    description: "Read current and scheduled Chat subscriptions for the selected organization",
+    method: "GET",
+    path: "/dashboard_api/billing/subscriptions/info/",
+    scope: "org",
+    query: z.object({ product: z.literal("CHAT").default("CHAT") }),
+    response: z
+        .object({
+        current_subscription: object.nullable(),
+        future_subscription: object.nullable(),
+    })
+        .passthrough(),
+    source: [billing, "fetchSubscriptionInfo"],
+});
+add({
+    name: "billing plan list",
+    description: "Read the organization's plan catalog (requires organization.general.all); entries are not eligibility or price quotes",
+    method: "GET",
+    path: "/dashboard_api/billing/plans/",
+    scope: "org",
+    query: z.object({}),
+    // Dashboard's type declaration says array, but its UI iterates keyed plan
+    // names via Object.entries(response.data). Validate the observed shape.
+    response: z.record(z.string(), z
+        .object({ plan: object, billing_cycle_months: z.number().optional() })
+        .passthrough()),
+    source: [billing, "fetchSubscriptionPlans"],
+});
+// BILL-02 composes GETs and prepares Dashboard handoff. No quote API means
+// this alpha cannot safely present a subscription POST as a confirmed purchase.
+for (const action of ["check", "change", "verify"]) {
+    add({
+        name: `billing plan ${action}`,
+        description: action === "check"
+            ? "Check Chat plan selection, billing channel and payment readiness; not a quote"
+            : action === "change"
+                ? "Prepare a confirmed Dashboard handoff for a Chat plan change; does not change billing"
+                : "Read whether the requested Chat plan is current, scheduled or not reflected",
+        method: "GET",
+        path: "/dashboard_api/billing/subscriptions/info/",
+        scope: "org",
+        danger: action === "change",
+        query: z
+            .object({
+            plan: z.string().regex(/^[a-z][a-z0-9_]{0,127}$/),
+            ...(action === "change" ? { confirm_org_name: text } : {}),
+        })
+            .strict(),
+        response: action === "verify" ? billingVerificationSchema : billingHandoffSchema,
+        source: [billing, "fetchSubscriptionInfo"],
+        example: {
+            plan: "plan_a_5k",
+            ...(action === "change"
+                ? { confirm_org_name: "YOUR_ORGANIZATION_NAME" }
+                : {}),
+        },
+    });
+}
+add({
+    name: "usage chat org",
+    description: "Read monthly Chat feature usage for the selected organization",
+    method: "GET",
+    path: "/dashboard_api/organizations/{orgId}/monthly_usage/",
+    scope: "org",
+    query: z.object({
+        start_month: z.string().regex(/^\d{4}-(0[1-9]|1[0-2])$/),
+        end_month: z.string().regex(/^\d{4}-(0[1-9]|1[0-2])$/),
+    }),
+    response: z.object({ data: z.array(object) }).passthrough(),
+    source: [usage, "fetchOrganizationMonthlyUsage"],
+});
+add({
+    name: "usage chat app",
+    description: "Read one application's monthly Chat usage with organization context",
+    method: "GET",
+    path: "/dashboard_api/applications/{appId}/monthly_usage_with_org_usages/",
+    scope: "app",
+    query: z.object({
+        target_month: z.string().regex(/^\d{4}-(0[1-9]|1[0-2])$/),
+    }),
+    response: z.object({ data: object }).passthrough(),
+    source: [usage, "fetchApplicationMonthlyUsageWithOrgUsages"],
+});
+add({
+    name: "usage calls org",
+    description: "Read Calls and Live credit usage by application for the selected organization",
+    method: "GET",
+    path: "/dashboard_api/organizations/{orgId}/voice_video_usage",
+    scope: "org",
+    response: z
+        .object({
+        data: z.union([
+            z.array(z
+                .object({
+                app_id: z.string().min(1),
+                app_name: z.string(),
+                used_credit: z.number(),
+                usage: z.number(),
+                call_enabled: z.boolean(),
+                percentage: z.number(),
+            })
+                .passthrough()),
+            object,
+        ]),
+    })
+        .passthrough(),
+    source: [billing, "fetchVoucherCreditUsageByAllApps"],
+});
+add({
+    name: "usage calls app",
+    description: "Read one application's Calls and Live credit usage and organization totals",
+    method: "GET",
+    path: "/dashboard_api/applications/{appId}/voice_video_usage_with_org_usages",
+    scope: "app",
+    response: z.object({ data: object }).passthrough(),
+    source: [billing, "fetchVoucherCreditUsageByApp"],
+});
+add({
+    name: "usage calls trend",
+    description: "Read daily or monthly Calls and Live credit usage trend for an organization",
+    method: "GET",
+    path: "/dashboard_api/organizations/{orgId}/voice_video_usage/{resolution}",
+    scope: "org",
+    params: z.object({ resolution: z.enum(["daily", "monthly"]) }),
+    query: z.object({ start: text, end: text }),
+    response: z
+        .object({
+        data: z
+            .object({
+            total: z.array(object),
+            calls: z.array(object),
+            live: z.array(object),
+        })
+            .passthrough(),
+    })
+        .passthrough(),
+    source: [billing, "fetchVoucherCreditUsageByRange"],
+});
+add({
+    name: "usage calls app-trend",
+    description: "Read an application's daily or monthly voice/video usage breakdown",
+    method: "GET",
+    path: "/dashboard_api/applications/{appId}/voice_video_usage/{resolution}",
+    scope: "app",
+    params: z.object({ resolution: z.enum(["daily", "monthly"]) }),
+    query: z.object({ start: text, end: text }),
+    response: z.object({ data: z.array(object) }).passthrough(),
+    source: [billing, "fetchVoucherCreditUsageByAppWithRange"],
+});
+export const definitions = [...defs, ...callsDefinitions];
+export function jsonSchema(s) {
+    return s
+        ? z.toJSONSchema(s, { unrepresentable: "any" })
+        : { type: "object", properties: {} };
+}
+export function describe(d) {
+    return {
+        command: `sendbird ${d.name}`,
+        description: d.description,
+        method: d.method,
+        path: d.path,
+        scope: d.scope,
+        ...(d.requiresOrg ? { requires_org_context: true } : {}),
+        params: jsonSchema(d.params),
+        query: jsonSchema(d.query),
+        body: jsonSchema(d.body),
+        response: jsonSchema(d.resultSchema ?? d.response),
+        example: d.example ?? {},
+        dangerous: !!d.danger,
+        source: d.source,
+        ...(d.privateFields?.length
+            ? { private_input_fields: d.privateFields }
+            : {}),
+    };
+}
+function sample(schema) {
+    if ("default" in schema)
+        return schema.default;
+    if ("const" in schema)
+        return schema.const;
+    if (Array.isArray(schema.enum))
+        return schema.enum[0];
+    if (Array.isArray(schema.anyOf))
+        return sample(schema.anyOf[0]);
+    switch (schema.type) {
+        case "string":
+            return "example";
+        case "number":
+        case "integer":
+            return schema.minimum ?? 1;
+        case "boolean":
+            return false;
+        case "array":
+            return [sample(schema.items)];
+        case "object": {
+            const props = (schema.properties ?? {});
+            return Object.fromEntries(Object.entries(props)
+                .filter(([k, v]) => (schema.required ?? []).includes(k) ||
+                "default" in v)
+                .map(([k, v]) => [k, sample(v)]));
+        }
+        default:
+            return {};
+    }
+}
+export function exampleFor(d) {
+    const params = {
+        ...sample(jsonSchema(d.params)),
+        ...d.exampleParams,
+    };
+    if (d.name === "chat channel create")
+        params.type = "group";
+    const query = {
+        ...sample(jsonSchema(d.query)),
+        ...d.exampleQuery,
+    };
+    if (d.name === "usage chat org") {
+        query.start_month = "2026-10";
+        query.end_month = "2026-10";
+    }
+    if (d.name === "usage chat app")
+        query.target_month = "2026-10";
+    if (d.name === "usage calls trend" || d.name === "usage calls app-trend") {
+        query.start = "2026-10-01";
+        query.end = "2026-10-06";
+    }
+    const body = {
+        ...sample(jsonSchema(d.body)),
+        ...d.example,
+    };
+    if (d.name.endsWith(" update") && Object.keys(body).length === 0) {
+        const props = jsonSchema(d.body).properties;
+        const key = Object.keys(props)[0];
+        if (key)
+            body[key] = "Updated example";
+    }
+    if ("metadata" in body && Object.keys(body.metadata).length === 0)
+        body.metadata = { topic: "demo" };
+    return {
+        command: `sendbird ${d.name}`,
+        params,
+        query,
+        body,
+        context: d.scope === "app"
+            ? {
+                "app-id": "APP_ID",
+                ...(d.name === "app feature set" || d.requiresOrg
+                    ? { "org-id": "ORG_UID" }
+                    : {}),
+            }
+            : d.scope === "org"
+                ? { "org-id": "ORG_UID" }
+                : {},
+    };
+}
+//# sourceMappingURL=catalog.js.map