figmanage 1.0.1 → 1.2.0

package/dist/operations/org.js

@@ -0,0 +1,205 @@
+import { internalClient } from '../clients/internal-api.js';
+import { requireOrgId } from '../tools/register.js';
+// -- Seat constants --
+export const SEAT_HIERARCHY = {
+    view: 0,
+    collab: 1,
+    dev: 2,
+    full: 3,
+};
+export const SEAT_LABELS = {
+    view: 'Viewer (free)',
+    collab: 'Collaborator ($5/mo)',
+    dev: 'Developer ($25/mo)',
+    full: 'Full ($55/mo)',
+};
+export const PAID_STATUSES = {
+    full: { expert: 'full' },
+    dev: { developer: 'full' },
+    collab: { collaborator: 'full' },
+    view: { collaborator: 'starter', developer: 'starter', expert: 'starter' },
+};
+export const SEAT_KEY_TO_TYPE = {
+    expert: 'full',
+    developer: 'dev',
+    collaborator: 'collab',
+};
+export async function listAdmins(config, params) {
+    const orgId = requireOrgId(config, params.org_id);
+    const res = await internalClient(config).get(`/api/orgs/${orgId}/admins`, { params: { include_license_admins: params.include_license_admins ?? false } });
+    return (res.data?.meta || []).map((a) => ({
+        user_id: a.user_id,
+        email: a.user?.email,
+        name: a.user?.handle,
+        permission: a.permission,
+        seat_type: a.active_seat_type?.key || null,
+        is_email_validated: a.is_email_validated,
+        license_admin: a.license_admin,
+    }));
+}
+export async function listOrgTeams(config, params) {
+    const orgId = requireOrgId(config, params.org_id);
+    const res = await internalClient(config).get(`/api/orgs/${orgId}/teams`, {
+        params: {
+            include_member_count: true,
+            include_project_count: true,
+            include_top_members: true,
+            include_secret_teams: params.include_secret_teams ?? false,
+        },
+    });
+    const teams = res.data?.meta || res.data;
+    return (Array.isArray(teams) ? teams : []).map((t) => ({
+        id: String(t.id),
+        name: t.name,
+        member_count: t.member_count ?? null,
+        project_count: t.project_count ?? null,
+        access_level: t.access_level ?? null,
+    }));
+}
+export async function seatUsage(config, params) {
+    const orgId = requireOrgId(config, params.org_id);
+    const reqParams = {};
+    if (params.search_query)
+        reqParams.search_query = params.search_query;
+    const res = await internalClient(config).get(`/api/orgs/${orgId}/org_users/filter_counts`, { params: reqParams });
+    return res.data?.meta || res.data;
+}
+export async function listTeamMembers(config, params) {
+    const res = await internalClient(config).get(`/api/teams/${params.team_id}/members`);
+    return (res.data?.meta || res.data || []).map((m) => ({
+        id: m.id,
+        name: m.name,
+        email: m.email,
+        img_url: m.img_url,
+        last_active: m.last_active,
+        team_role: m.team_role?.level || null,
+        permission: m.team_user?.permission || null,
+        seat_type: m.seat_type || null,
+    }));
+}
+export async function billingOverview(config, params) {
+    const orgId = requireOrgId(config, params.org_id);
+    const res = await internalClient(config).get(`/api/orgs/${orgId}/billing_data`);
+    const data = res.data?.meta || res.data;
+    const { shipping_address, ...billing } = data;
+    return billing;
+}
+export async function listInvoices(config, params) {
+    const orgId = requireOrgId(config, params.org_id);
+    const client = internalClient(config);
+    const [openResult, upcomingResult] = await Promise.allSettled([
+        client.get(`/api/plans/organization/${orgId}/invoices/open`),
+        client.get(`/api/plans/organization/${orgId}/invoices/upcoming`),
+    ]);
+    const response = {};
+    if (openResult.status === 'fulfilled')
+        response.open = openResult.value.data;
+    else
+        response.open_error = 'Failed to fetch open invoices';
+    if (upcomingResult.status === 'fulfilled')
+        response.upcoming = upcomingResult.value.data;
+    else
+        response.upcoming_error = 'Failed to fetch upcoming invoices';
+    return response;
+}
+export async function orgDomains(config, params) {
+    const orgId = requireOrgId(config, params.org_id);
+    const client = internalClient(config);
+    const [domainsResult, ssoResult] = await Promise.allSettled([
+        client.get(`/api/orgs/${orgId}/domains`),
+        client.get(`/api/org/${orgId}/org_saml_config`),
+    ]);
+    const response = {};
+    if (domainsResult.status === 'fulfilled')
+        response.domains = domainsResult.value.data;
+    else
+        response.domains_error = 'Failed to fetch domains';
+    if (ssoResult.status === 'fulfilled')
+        response.sso = ssoResult.value.data;
+    else
+        response.sso_error = 'SSO config not available';
+    return response;
+}
+export async function aiCreditUsage(config, params) {
+    const res = await internalClient(config).get(`/api/plans/${params.plan_id}/ai_credits/plan_usage_summary`);
+    return res.data;
+}
+export async function exportMembers(config, params) {
+    const orgId = requireOrgId(config, params.org_id);
+    await internalClient(config).post(`/api/orgs/${orgId}/export_members`);
+    return 'CSV export queued. It will be emailed to the org admin.';
+}
+export async function listOrgMembers(config, params) {
+    const orgId = requireOrgId(config, params.org_id);
+    const reqParams = {};
+    if (params.search_query)
+        reqParams.search_query = params.search_query;
+    const res = await internalClient(config).get(`/api/v2/orgs/${orgId}/org_users`, { params: reqParams });
+    const users = res.data?.meta?.users || res.data?.meta || res.data || [];
+    return (Array.isArray(users) ? users : []).map((m) => ({
+        org_user_id: String(m.id),
+        user_id: m.user_id,
+        email: m.user?.email,
+        name: m.user?.handle,
+        permission: m.permission,
+        seat_type: m.active_seat_type?.key || null,
+        last_active: m.last_seen || null,
+    }));
+}
+export async function contractRates(config, params) {
+    const orgId = requireOrgId(config, params.org_id);
+    const res = await internalClient(config).get(`/api/pricing/contract_rates`, { params: { plan_parent_id: orgId, plan_type: 'organization' } });
+    const seatProducts = new Set(['expert', 'developer', 'collaborator']);
+    const prices = res.data?.meta?.product_prices || [];
+    return prices
+        .filter((r) => seatProducts.has(r.billable_product_key))
+        .map((r) => ({
+        product: r.billable_product_key,
+        monthly_cents: r.amount,
+        monthly_dollars: (r.amount / 100).toFixed(2),
+    }));
+}
+export async function changeSeat(config, params) {
+    const orgId = requireOrgId(config, params.org_id);
+    const res = await internalClient(config).get(`/api/v2/orgs/${orgId}/org_users`, {
+        params: params.user_id.includes('@') ? { search_query: params.user_id } : {},
+    });
+    const users = res.data?.meta?.users || res.data?.meta || res.data || [];
+    const members = Array.isArray(users) ? users : [];
+    const member = members.find((m) => params.user_id.includes('@')
+        ? m.user?.email === params.user_id
+        : String(m.user_id) === String(params.user_id));
+    if (!member)
+        throw new Error(`User not found: ${params.user_id}`);
+    if (String(member.user_id) === String(config.userId)) {
+        throw new Error('Cannot change your own seat type. Use the Figma admin panel.');
+    }
+    const currentKey = member.active_seat_type?.key || null;
+    const currentType = currentKey ? (SEAT_KEY_TO_TYPE[currentKey] || 'view') : 'view';
+    if (currentType === params.seat_type) {
+        return `Already on ${SEAT_LABELS[params.seat_type]} seat. No change needed.`;
+    }
+    const isUpgrade = (SEAT_HIERARCHY[params.seat_type] ?? 0) > (SEAT_HIERARCHY[currentType] ?? 0);
+    if (isUpgrade && !params.confirm) {
+        throw new Error(`Upgrading from ${SEAT_LABELS[currentType]} to ${SEAT_LABELS[params.seat_type]} will increase billing. ` +
+            `Set confirm: true to authorize.`);
+    }
+    await internalClient(config).put(`/api/orgs/${orgId}/org_users`, {
+        org_user_ids: [String(member.id)],
+        paid_statuses: PAID_STATUSES[params.seat_type],
+        entry_point: 'members_tab',
+        seat_increase_authorized: 'true',
+        seat_swap_intended: 'false',
+        latest_ou_update: member.updated_at,
+        showing_billing_groups: 'true',
+    }, {
+        'axios-retry': { retries: 0 },
+    });
+    return {
+        user: member.user?.handle || member.user?.email,
+        email: member.user?.email,
+        old_seat: SEAT_LABELS[currentType],
+        new_seat: SEAT_LABELS[params.seat_type],
+    };
+}
+//# sourceMappingURL=org.js.map

package/dist/operations/permissions.d.ts

@@ -0,0 +1,59 @@
+import type { AuthConfig } from '../auth/client.js';
+export declare const LEVEL_MAP: Record<string, number>;
+export declare const LEVEL_NAMES: Record<number, string>;
+export declare function levelName(level: number): string;
+export declare function getRoles(config: AuthConfig, resourceType: string, resourceId: string): Promise<any[]>;
+export interface PermissionUser {
+    role_id: string;
+    user_id: string | undefined;
+    handle: string | undefined;
+    email: string | undefined;
+    role: string;
+    level: number;
+    pending: boolean;
+}
+export declare function getPermissions(config: AuthConfig, params: {
+    resource_type: string;
+    resource_id: string;
+}): Promise<PermissionUser[]>;
+export declare function setPermissions(config: AuthConfig, params: {
+    resource_type: string;
+    resource_id: string;
+    user_id: string;
+    role: string;
+}): Promise<string>;
+export interface ShareResult {
+    email: string;
+    role: string;
+    resource_type: string;
+    resource_id: string;
+    role_id?: string;
+}
+export declare function share(config: AuthConfig, params: {
+    resource_type: string;
+    resource_id: string;
+    email: string;
+    role?: string;
+}): Promise<ShareResult>;
+export declare function revokeAccess(config: AuthConfig, params: {
+    resource_type: string;
+    resource_id: string;
+    user_id: string;
+}): Promise<string>;
+export interface RoleRequest {
+    notification_id: string;
+    email: string | undefined;
+    action: string | undefined;
+    file_name: string | undefined;
+    pending: boolean;
+    is_unread: boolean;
+    created_at: string | undefined;
+}
+export declare function listRoleRequests(config: AuthConfig): Promise<RoleRequest[]>;
+export declare function approveRoleRequest(config: AuthConfig, params: {
+    notification_id: string;
+}): Promise<string>;
+export declare function denyRoleRequest(config: AuthConfig, params: {
+    notification_id: string;
+}): Promise<string>;
+//# sourceMappingURL=permissions.d.ts.map

package/dist/operations/permissions.js

@@ -0,0 +1,112 @@
+import { internalClient } from '../clients/internal-api.js';
+export const LEVEL_MAP = { owner: 999, editor: 300, viewer: 100 };
+export const LEVEL_NAMES = { 999: 'owner', 300: 'editor', 100: 'viewer' };
+export function levelName(level) {
+    return LEVEL_NAMES[level] || `level:${level}`;
+}
+export async function getRoles(config, resourceType, resourceId) {
+    const res = await internalClient(config).get(`/api/roles/${resourceType}/${resourceId}`);
+    const meta = res.data?.meta;
+    return Array.isArray(meta) ? meta : [];
+}
+export async function getPermissions(config, params) {
+    const roles = await getRoles(config, params.resource_type, params.resource_id);
+    return roles.map((r) => ({
+        role_id: String(r.id),
+        user_id: r.user_id ? String(r.user_id) : undefined,
+        handle: r.user?.handle,
+        email: r.user?.email || r.pending_email,
+        role: levelName(r.level),
+        level: r.level,
+        pending: !!r.pending_email,
+    }));
+}
+export async function setPermissions(config, params) {
+    const roles = await getRoles(config, params.resource_type, params.resource_id);
+    const target = roles.find((r) => String(r.user_id) === params.user_id);
+    if (!target) {
+        throw new Error(`User ${params.user_id} has no role on this ${params.resource_type}. Use share to invite them first.`);
+    }
+    const level = LEVEL_MAP[params.role];
+    await internalClient(config).put(`/api/roles/${target.id}`, { level });
+    return `Set ${params.role} (level ${level}) for user ${params.user_id} on ${params.resource_type} ${params.resource_id}`;
+}
+export async function share(config, params) {
+    const role = params.role || 'viewer';
+    const level = LEVEL_MAP[role];
+    const res = await internalClient(config).post('/api/invites', {
+        resource_type: params.resource_type,
+        resource_id_or_key: params.resource_id,
+        emails: [params.email],
+        level,
+    });
+    const invites = res.data?.meta?.invites || [];
+    const roleId = invites[0]?.id;
+    return {
+        email: params.email,
+        role,
+        resource_type: params.resource_type,
+        resource_id: params.resource_id,
+        role_id: roleId ? String(roleId) : undefined,
+    };
+}
+export async function revokeAccess(config, params) {
+    const roles = await getRoles(config, params.resource_type, params.resource_id);
+    const target = roles.find((r) => String(r.user_id) === params.user_id);
+    if (!target) {
+        throw new Error(`User ${params.user_id} has no role on this ${params.resource_type}.`);
+    }
+    await internalClient(config).delete(`/api/roles/${target.id}`);
+    return `Revoked access for user ${params.user_id} on ${params.resource_type} ${params.resource_id}`;
+}
+export async function listRoleRequests(config) {
+    const res = await internalClient(config).get('/api/user_notifications/server_driven/plan', {
+        params: { current_plan_id: '-1', app_version: '1', client_type: 'web' },
+    });
+    const notifications = res.data?.meta || [];
+    return (Array.isArray(notifications) ? notifications : [])
+        .filter((n) => n.notification_type === 'FileRoleRequestCreatedNotif')
+        .map((n) => {
+        const title = n.preferred_attachments?.[0]?.body?.title || [];
+        const subtitle = n.preferred_attachments?.[0]?.body?.subtitle || [];
+        const email = title[0]?.html_text?.replace(/<[^>]+>/g, '') || undefined;
+        const action = subtitle[0]?.html_text || undefined;
+        const fileName = subtitle[2]?.html_text || undefined;
+        const hasActions = !!n.preferred_attachments?.[0]?.actions;
+        return {
+            notification_id: n.notification_id,
+            email,
+            action,
+            file_name: fileName,
+            pending: hasActions,
+            is_unread: n.is_unread,
+            created_at: n.preferred_attachments?.[0]?.body?.created_at,
+        };
+    });
+}
+export async function approveRoleRequest(config, params) {
+    const res = await internalClient(config).put('/api/user_notifications/accept', {
+        id: params.notification_id,
+        medium: 'web',
+        appVersion: '1',
+        clientType: 'web',
+    });
+    const notif = res.data?.meta?.notification;
+    const locals = notif?.locals || {};
+    let msg = `Approved access request ${params.notification_id}`;
+    if (locals.file_name)
+        msg += ` for ${locals.file_name}`;
+    if (locals.user_id)
+        msg += ` (user ${locals.user_id})`;
+    return msg;
+}
+export async function denyRoleRequest(config, params) {
+    await internalClient(config).put('/api/user_notifications/reject', {
+        id: params.notification_id,
+        medium: 'web',
+        appVersion: '1',
+        clientType: 'web',
+    });
+    return `Declined access request ${params.notification_id}`;
+}
+//# sourceMappingURL=permissions.js.map

package/dist/operations/projects.d.ts

@@ -0,0 +1,29 @@
+import type { AuthConfig } from '../auth/client.js';
+export interface CreatedProject {
+    id: string;
+    name: string;
+    team_id: string;
+}
+export declare function createProject(config: AuthConfig, params: {
+    team_id: string;
+    name: string;
+}): Promise<CreatedProject>;
+export declare function renameProject(config: AuthConfig, params: {
+    project_id: string;
+    name: string;
+}): Promise<void>;
+export declare function moveProject(config: AuthConfig, params: {
+    project_id: string;
+    destination_team_id: string;
+}): Promise<void>;
+export declare function trashProject(config: AuthConfig, params: {
+    project_id: string;
+}): Promise<void>;
+export declare function restoreProject(config: AuthConfig, params: {
+    project_id: string;
+}): Promise<void>;
+export declare function setProjectDescription(config: AuthConfig, params: {
+    project_id: string;
+    description: string;
+}): Promise<void>;
+//# sourceMappingURL=projects.d.ts.map

package/dist/operations/projects.js

@@ -0,0 +1,40 @@
+import { internalClient } from '../clients/internal-api.js';
+export async function createProject(config, params) {
+    const res = await internalClient(config).post('/api/folders', {
+        team_id: params.team_id,
+        path: params.name,
+        sharing_audience_control: 'org_view',
+        team_access: 'team_edit',
+    });
+    const meta = res.data?.meta;
+    const p = Array.isArray(meta) ? meta[0] : (meta?.folder || meta || res.data);
+    return {
+        id: String(p.id),
+        name: p.name || p.path || params.name,
+        team_id: params.team_id,
+    };
+}
+export async function renameProject(config, params) {
+    await internalClient(config).put('/api/folders/rename', {
+        folder_id: params.project_id,
+        name: params.name,
+    });
+}
+export async function moveProject(config, params) {
+    await internalClient(config).put('/api/folders/move', {
+        folder_id: params.project_id,
+        team_id: params.destination_team_id,
+    });
+}
+export async function trashProject(config, params) {
+    await internalClient(config).put(`/api/folders/trash/${params.project_id}`);
+}
+export async function restoreProject(config, params) {
+    await internalClient(config).put(`/api/folders/restore/${params.project_id}`);
+}
+export async function setProjectDescription(config, params) {
+    await internalClient(config).put(`/api/folders/${params.project_id}/description`, {
+        description: params.description,
+    });
+}
+//# sourceMappingURL=projects.js.map

package/dist/operations/reading.d.ts

@@ -0,0 +1,12 @@
+import type { AuthConfig } from '../auth/client.js';
+export declare function getFile(config: AuthConfig, params: {
+    file_key: string;
+    depth?: number;
+    node_id?: string;
+}): Promise<any>;
+export declare function getNodes(config: AuthConfig, params: {
+    file_key: string;
+    node_ids: string[];
+    depth?: number;
+}): Promise<any>;
+//# sourceMappingURL=reading.d.ts.map

package/dist/operations/reading.js

@@ -0,0 +1,20 @@
+import { publicClient } from '../clients/public-api.js';
+export async function getFile(config, params) {
+    const queryParams = {};
+    if (params.depth !== undefined)
+        queryParams.depth = String(params.depth);
+    if (params.node_id)
+        queryParams['node-id'] = params.node_id;
+    const res = await publicClient(config).get(`/v1/files/${params.file_key}`, { params: queryParams });
+    return res.data;
+}
+export async function getNodes(config, params) {
+    const queryParams = {
+        ids: params.node_ids.join(','),
+    };
+    if (params.depth !== undefined)
+        queryParams.depth = String(params.depth);
+    const res = await publicClient(config).get(`/v1/files/${params.file_key}/nodes`, { params: queryParams });
+    return res.data;
+}
+//# sourceMappingURL=reading.js.map

package/dist/operations/teams.d.ts

@@ -0,0 +1,17 @@
+import type { AuthConfig } from '../auth/client.js';
+export interface CreatedTeam {
+    id: string;
+    name: string;
+}
+export declare function createTeam(config: AuthConfig, params: {
+    name: string;
+    org_id?: string;
+}): Promise<CreatedTeam>;
+export declare function renameTeam(config: AuthConfig, params: {
+    team_id: string;
+    name: string;
+}): Promise<string>;
+export declare function deleteTeam(config: AuthConfig, params: {
+    team_id: string;
+}): Promise<string>;
+//# sourceMappingURL=teams.d.ts.map

package/dist/operations/teams.js

@@ -0,0 +1,17 @@
+import { internalClient } from '../clients/internal-api.js';
+import { requireOrgId } from '../tools/register.js';
+export async function createTeam(config, params) {
+    const orgId = requireOrgId(config, params.org_id);
+    const res = await internalClient(config).post('/api/teams/create', { team_name: params.name, org_id: orgId, sharing_audience_control: 'org_view' });
+    const team = res.data?.meta?.team || res.data?.meta || res.data;
+    return { id: String(team.id), name: team.name };
+}
+export async function renameTeam(config, params) {
+    await internalClient(config).put(`/api/teams/${params.team_id}`, { name: params.name });
+    return `Team ${params.team_id} renamed to "${params.name}".`;
+}
+export async function deleteTeam(config, params) {
+    await internalClient(config).delete(`/api/teams/${params.team_id}`);
+    return `Team ${params.team_id} deleted.`;
+}
+//# sourceMappingURL=teams.js.map

package/dist/operations/variables.d.ts

@@ -0,0 +1,17 @@
+import type { AuthConfig } from '../auth/client.js';
+export declare const ENTERPRISE_ERROR = "Variables API requires Figma Enterprise plan. The file_variables:read/write scopes are not available on standard plans.";
+export declare function isEnterpriseScopeError(e: any): boolean;
+export declare function listLocalVariables(config: AuthConfig, params: {
+    file_key: string;
+}): Promise<Record<string, any>>;
+export declare function listPublishedVariables(config: AuthConfig, params: {
+    file_key: string;
+}): Promise<Record<string, any>>;
+export declare function updateVariables(config: AuthConfig, params: {
+    file_key: string;
+    variable_collections?: Record<string, any>[];
+    variable_modes?: Record<string, any>[];
+    variables?: Record<string, any>[];
+    variable_mode_values?: Record<string, any>[];
+}): Promise<any>;
+//# sourceMappingURL=variables.d.ts.map

package/dist/operations/variables.js

@@ -0,0 +1,39 @@
+import { publicClient } from '../clients/public-api.js';
+export const ENTERPRISE_ERROR = 'Variables API requires Figma Enterprise plan. The file_variables:read/write scopes are not available on standard plans.';
+export function isEnterpriseScopeError(e) {
+    if (e.response?.status !== 403)
+        return false;
+    const data = e.response?.data;
+    if (typeof data !== 'object' || !data)
+        return false;
+    const msg = String(data.message || data.error || data.err || '');
+    return msg.toLowerCase().includes('scope');
+}
+export async function listLocalVariables(config, params) {
+    const res = await publicClient(config).get(`/v1/files/${params.file_key}/variables/local`);
+    return res.data?.meta ?? {};
+}
+export async function listPublishedVariables(config, params) {
+    const res = await publicClient(config).get(`/v1/files/${params.file_key}/variables/published`);
+    return res.data?.meta ?? {};
+}
+export async function updateVariables(config, params) {
+    if (!params.variable_collections?.length &&
+        !params.variable_modes?.length &&
+        !params.variables?.length &&
+        !params.variable_mode_values?.length) {
+        throw new Error('At least one operation array is required.');
+    }
+    const body = {};
+    if (params.variable_collections)
+        body.variableCollections = params.variable_collections;
+    if (params.variable_modes)
+        body.variableModes = params.variable_modes;
+    if (params.variables)
+        body.variables = params.variables;
+    if (params.variable_mode_values)
+        body.variableModeValues = params.variable_mode_values;
+    const res = await publicClient(config).post(`/v1/files/${params.file_key}/variables`, body);
+    return res.data;
+}
+//# sourceMappingURL=variables.js.map

package/dist/operations/versions.d.ts

@@ -0,0 +1,23 @@
+import type { AuthConfig } from '../auth/client.js';
+export interface Version {
+    id: string;
+    label: string | null;
+    description: string | null;
+    created_at: string;
+    user: string | null;
+}
+export interface CreatedVersion {
+    id: string | null;
+    label: string;
+    description: string | null;
+    created_at: string | null;
+}
+export declare function listVersions(config: AuthConfig, params: {
+    file_key: string;
+}): Promise<Version[]>;
+export declare function createVersion(config: AuthConfig, params: {
+    file_key: string;
+    title: string;
+    description?: string;
+}): Promise<CreatedVersion>;
+//# sourceMappingURL=versions.d.ts.map

package/dist/operations/versions.js

@@ -0,0 +1,27 @@
+import { publicClient } from '../clients/public-api.js';
+import { internalClient } from '../clients/internal-api.js';
+export async function listVersions(config, params) {
+    const res = await publicClient(config).get(`/v1/files/${params.file_key}/versions`);
+    const versions = res.data?.versions || [];
+    return versions.map((v) => ({
+        id: v.id,
+        label: v.label || null,
+        description: v.description || null,
+        created_at: v.created_at,
+        user: v.user?.handle || v.user?.id || null,
+    }));
+}
+export async function createVersion(config, params) {
+    const res = await internalClient(config).post(`/api/multiplayer/${params.file_key}/create_savepoint`, {
+        label: params.title,
+        description: params.description || '',
+    });
+    const v = res.data?.meta || {};
+    return {
+        id: v.id || null,
+        label: v.label || params.title,
+        description: v.description || null,
+        created_at: v.created_at || null,
+    };
+}
+//# sourceMappingURL=versions.js.map

package/dist/operations/webhooks.d.ts

@@ -0,0 +1,25 @@
+import type { AuthConfig } from '../auth/client.js';
+export type WebhookEventType = 'FILE_UPDATE' | 'FILE_DELETE' | 'FILE_VERSION_UPDATE' | 'LIBRARY_PUBLISH' | 'FILE_COMMENT' | 'PING';
+export type WebhookStatus = 'ACTIVE' | 'PAUSED';
+export declare function listWebhooks(config: AuthConfig, params: {
+    team_id: string;
+}): Promise<any[]>;
+export declare function createWebhook(config: AuthConfig, params: {
+    team_id: string;
+    event_type: WebhookEventType;
+    endpoint: string;
+    passcode: string;
+    description?: string;
+}): Promise<Record<string, any>>;
+export declare function updateWebhook(config: AuthConfig, params: {
+    webhook_id: string;
+    event_type?: WebhookEventType;
+    endpoint?: string;
+    passcode?: string;
+    description?: string;
+    status?: WebhookStatus;
+}): Promise<Record<string, any>>;
+export declare function deleteWebhook(config: AuthConfig, params: {
+    webhook_id: string;
+}): Promise<void>;
+//# sourceMappingURL=webhooks.d.ts.map