@beeuni/sdk 0.1.0

package/dist/react/use-admin-accounts.d.ts

@@ -0,0 +1,236 @@
+export type AdminTrialStatus = 'none' | 'active' | 'expired' | 'revoked' | 'converted';
+export interface AdminAccountTrial {
+    status: AdminTrialStatus | string;
+    tier: string | null;
+    seats: number | null;
+    startedAt: string | null;
+    endsAt: string | null;
+    note: string | null;
+}
+export interface AdminAccountPlan {
+    key: string;
+    family: 'free' | 'team' | 'enterprise';
+    label: string;
+    sublabel: string | null;
+    status: 'current' | 'grandfathered' | 'retired' | 'non_plan';
+    is_grandfathered: boolean;
+}
+export interface AdminEntitlementOverrideEntry {
+    value: unknown;
+    expires_at?: string;
+}
+export type AdminEntitlementOverrides = Record<string, AdminEntitlementOverrideEntry>;
+export declare const ADMIN_OVERRIDE_KEYS: readonly ["enterpriseEntitled", "demoEnterprise", "managedModelsOverride", "maxConcurrentSessions", "computeRateMultiplier", "sso", "scim", "rbac", "auditAccess", "branding", "managedModels"];
+export type AdminOverrideKey = (typeof ADMIN_OVERRIDE_KEYS)[number];
+export type AdminEntitlementOverridePatch = Partial<Record<AdminOverrideKey, {
+    value: boolean | number;
+    expires_at?: string;
+} | null>>;
+export declare function adminAccountOverridesPath(accountId: string): string;
+export interface AdminAccount {
+    accountId: string;
+    name: string | null;
+    displayName?: string | null;
+    ownerEmail: string | null;
+    memberCount: number;
+    balance: string | null;
+    expiringCredits: string | null;
+    nonExpiringCredits: string | null;
+    dailyCreditsBalance: string | null;
+    tier: string | null;
+    plan?: AdminAccountPlan;
+    paymentStatus: string | null;
+    provider: string | null;
+    planType: string | null;
+    stripeSubscriptionId: string | null;
+    billingCustomerId: string | null;
+    billingCustomerEmail: string | null;
+    createdAt: string | null;
+    billingModel: string | null;
+    seatCount: number | null;
+    trial: AdminAccountTrial;
+    managedModelsOverride: boolean | null;
+    demoEnterprise: boolean;
+    enterpriseEntitled: boolean;
+    entitlementOverrides?: AdminEntitlementOverrides | null;
+    computeRateMultiplier?: number;
+}
+export interface AdminAccountsSummary {
+    totalCredits: string;
+    paidCount: number;
+    negativeCount: number;
+    pastDueCount: number;
+}
+export interface AdminAccountsResponse {
+    accounts: AdminAccount[];
+    total: number;
+    page: number;
+    limit: number;
+    summary: AdminAccountsSummary | null;
+    error?: string;
+}
+export interface AdminAccountUser {
+    user_id: string;
+    email: string;
+    account_role: string;
+    signed_up_at: string | null;
+    last_sign_in_at: string | null;
+    email_confirmed_at: string | null;
+    banned_until: string | null;
+    provider: string | null;
+    providers: string[] | null;
+}
+export interface AdminAccountSandbox {
+    sandboxId: string;
+    name: string | null;
+    provider: string | null;
+    externalId: string | null;
+    status: string | null;
+    baseUrl: string | null;
+    metadata: unknown;
+    createdAt: string;
+    updatedAt: string;
+    lastUsedAt: string | null;
+}
+export type AdminAccountsSortBy = 'balance' | 'members' | 'name' | 'created';
+export type AdminAccountsSortDir = 'asc' | 'desc';
+export interface AdminAccountsFilters {
+    search?: string;
+    tier?: string[];
+    paymentStatus?: string[];
+    paidOnly?: boolean;
+    hasSubscription?: boolean | null;
+    minBalance?: number | null;
+    maxBalance?: number | null;
+    sortBy?: AdminAccountsSortBy;
+    sortDir?: AdminAccountsSortDir;
+    page?: number;
+    limit?: number;
+}
+export declare function useAdminAccounts(filters?: AdminAccountsFilters): import("@tanstack/react-query").UseQueryResult<AdminAccountsResponse, Error>;
+export declare function adminAccountLookupPath(accountId: string): string;
+export declare function useAdminAccount(accountId: string | null): import("@tanstack/react-query").UseQueryResult<AdminAccount | null, Error>;
+export declare function useAdminAccountUsers(accountId: string | null): import("@tanstack/react-query").UseQueryResult<{
+    users: AdminAccountUser[];
+}, Error>;
+export declare function useAdminGrantCredits(): import("@tanstack/react-query").UseMutationResult<unknown, Error, {
+    accountId: string;
+    amount: number;
+    description: string;
+    isExpiring: boolean;
+}, unknown>;
+export declare function useAdminDebitCredits(): import("@tanstack/react-query").UseMutationResult<unknown, Error, {
+    accountId: string;
+    amount: number;
+    description: string;
+}, unknown>;
+export declare function useAdminSetTier(): import("@tanstack/react-query").UseMutationResult<unknown, Error, {
+    accountId: string;
+    tier: string;
+}, unknown>;
+export interface AdminGrantTrialVariables {
+    accountId: string;
+    tierKey: string;
+    seats: number;
+    durationDays: number;
+    creditGrant?: number;
+    note?: string;
+}
+export interface AdminTrialMutationResult {
+    ok: boolean;
+    trial: AdminAccountTrial;
+    credit_granted?: number;
+}
+export declare function useAdminGrantTrial(): import("@tanstack/react-query").UseMutationResult<AdminTrialMutationResult, Error, AdminGrantTrialVariables, unknown>;
+export declare function useAdminRevokeTrial(): import("@tanstack/react-query").UseMutationResult<AdminTrialMutationResult, Error, {
+    accountId: string;
+}, unknown>;
+export declare function useAdminSetManagedModels(): import("@tanstack/react-query").UseMutationResult<{
+    ok: boolean;
+    override: boolean | null;
+}, Error, {
+    accountId: string;
+    override: boolean | null;
+}, unknown>;
+export declare function useAdminSetEnterpriseDemo(): import("@tanstack/react-query").UseMutationResult<{
+    ok: boolean;
+    enabled: boolean;
+}, Error, {
+    accountId: string;
+    enabled: boolean;
+}, unknown>;
+export declare function useAdminSetEnterpriseEntitled(): import("@tanstack/react-query").UseMutationResult<{
+    ok: boolean;
+    enabled: boolean;
+}, Error, {
+    accountId: string;
+    enabled: boolean;
+}, unknown>;
+export declare function useAdminSetOverrides(): import("@tanstack/react-query").UseMutationResult<{
+    ok: boolean;
+    overrides: AdminEntitlementOverrides;
+}, Error, {
+    accountId: string;
+    patch: AdminEntitlementOverridePatch;
+}, unknown>;
+export type AdminAccountMemberRole = 'owner' | 'admin' | 'member';
+export declare function adminMemberRolePath(accountId: string, userId: string): string;
+export declare function useAdminSetMemberRole(): import("@tanstack/react-query").UseMutationResult<{
+    ok: boolean;
+    user_id: string;
+    account_role: string;
+}, Error, {
+    accountId: string;
+    userId: string;
+    role: AdminAccountMemberRole;
+}, unknown>;
+export interface AdminLedgerEntry {
+    id: string;
+    amount: string;
+    balanceAfter: string;
+    type: string;
+    description: string | null;
+    isExpiring: boolean | null;
+    createdAt: string | null;
+    createdBy: string | null;
+}
+export declare function useAdminAccountLedger(accountId: string | null, limit?: number): import("@tanstack/react-query").UseQueryResult<{
+    entries: AdminLedgerEntry[];
+}, Error>;
+export interface AdminAccountProject {
+    projectId: string;
+    name: string;
+    status: string | null;
+    repoUrl: string | null;
+    defaultBranch: string | null;
+    createdAt: string | null;
+    updatedAt: string | null;
+    lastOpenedAt: string | null;
+    sessionCount: number;
+    activeSessionCount: number;
+    lastSessionAt: string | null;
+}
+export declare function useAdminAccountProjects(accountId: string | null): import("@tanstack/react-query").UseQueryResult<{
+    projects: AdminAccountProject[];
+}, Error>;
+export declare function useAdminAccountSandboxes(accountId: string | null): import("@tanstack/react-query").UseQueryResult<{
+    sandboxes: AdminAccountSandbox[];
+}, Error>;
+export interface AdminAccountSubscription {
+    id: string;
+    status: string;
+    description: string | null;
+    productName: string | null;
+    priceId: string | null;
+    unitAmountUsd: number | null;
+    quantity: number;
+    totalAmountUsd: number | null;
+    interval: string | null;
+    currency: string | null;
+    currentPeriodEnd: string | null;
+    cancelAtPeriodEnd: boolean;
+}
+export declare function adminAccountSubscriptionPath(accountId: string): string;
+export declare function useAdminAccountSubscription(accountId: string | null): import("@tanstack/react-query").UseQueryResult<{
+    subscription: AdminAccountSubscription | null;
+}, Error>;

package/dist/react/use-admin-accounts.js

@@ -0,0 +1,287 @@
+import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
+import { backendApi } from '../core/http/api-client.js';
+import { useRetiredQuery } from './retired-endpoint.js';
+export const ADMIN_OVERRIDE_KEYS = [
+    'enterpriseEntitled',
+    'demoEnterprise',
+    'managedModelsOverride',
+    'maxConcurrentSessions',
+    'computeRateMultiplier',
+    'sso',
+    'scim',
+    'rbac',
+    'auditAccess',
+    'branding',
+    'managedModels',
+];
+export function adminAccountOverridesPath(accountId) {
+    return `/admin/api/accounts/${encodeURIComponent(accountId)}/overrides`;
+}
+const ADMIN_ACCOUNTS_RETRY = false;
+export function useAdminAccounts(filters = {}) {
+    const { search = '', tier = [], paymentStatus = [], paidOnly = false, hasSubscription = null, minBalance = null, maxBalance = null, sortBy = 'created', sortDir = 'desc', page = 1, limit = 50, } = filters;
+    return useQuery({
+        queryKey: [
+            'admin',
+            'accounts',
+            search,
+            tier.join(','),
+            paymentStatus.join(','),
+            paidOnly,
+            hasSubscription,
+            minBalance,
+            maxBalance,
+            sortBy,
+            sortDir,
+            page,
+            limit,
+        ],
+        queryFn: async () => {
+            const q = new URLSearchParams();
+            if (search)
+                q.set('search', search);
+            if (tier.length)
+                q.set('tier', tier.join(','));
+            if (paymentStatus.length)
+                q.set('paymentStatus', paymentStatus.join(','));
+            if (paidOnly)
+                q.set('paid', 'true');
+            if (hasSubscription === true)
+                q.set('hasSubscription', 'true');
+            if (hasSubscription === false)
+                q.set('hasSubscription', 'false');
+            if (minBalance !== null && Number.isFinite(minBalance))
+                q.set('minBalance', String(minBalance));
+            if (maxBalance !== null && Number.isFinite(maxBalance))
+                q.set('maxBalance', String(maxBalance));
+            q.set('sortBy', sortBy);
+            q.set('sortDir', sortDir);
+            q.set('page', String(page));
+            q.set('limit', String(limit));
+            const response = await backendApi.get(`/admin/api/accounts?${q.toString()}`);
+            if (response.error)
+                throw new Error(response.error.message);
+            return response.data;
+        },
+        staleTime: 15_000,
+        retry: ADMIN_ACCOUNTS_RETRY,
+        placeholderData: (prev) => prev,
+    });
+}
+export function adminAccountLookupPath(accountId) {
+    return `/admin/api/accounts?accountId=${encodeURIComponent(accountId)}&limit=1`;
+}
+export function useAdminAccount(accountId) {
+    return useQuery({
+        queryKey: ['admin', 'accounts', accountId, 'detail'],
+        enabled: !!accountId,
+        queryFn: async () => {
+            const response = await backendApi.get(adminAccountLookupPath(accountId));
+            if (response.error)
+                throw new Error(response.error.message);
+            return response.data?.accounts?.[0] ?? null;
+        },
+        staleTime: 5_000,
+        retry: ADMIN_ACCOUNTS_RETRY,
+    });
+}
+export function useAdminAccountUsers(accountId) {
+    return useQuery({
+        queryKey: ['admin', 'accounts', accountId, 'users'],
+        enabled: !!accountId,
+        queryFn: async () => {
+            const response = await backendApi.get(`/admin/api/accounts/${accountId}/users`);
+            if (response.error)
+                throw new Error(response.error.message);
+            return response.data;
+        },
+    });
+}
+export function useAdminGrantCredits() {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async ({ accountId, amount, description, isExpiring }) => {
+            const response = await backendApi.post(`/admin/api/accounts/${accountId}/credits`, { amount, description, isExpiring });
+            if (response.error)
+                throw new Error(response.error.message);
+            return response.data;
+        },
+        onSuccess: (_data, { accountId }) => {
+            queryClient.invalidateQueries({ queryKey: ['admin', 'accounts'] });
+            queryClient.invalidateQueries({ queryKey: ['admin', 'accounts', accountId] });
+        },
+    });
+}
+export function useAdminDebitCredits() {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async ({ accountId, amount, description }) => {
+            const response = await backendApi.post(`/admin/api/accounts/${accountId}/credits/debit`, { amount, description });
+            if (response.error)
+                throw new Error(response.error.message);
+            return response.data;
+        },
+        onSuccess: (_data, { accountId }) => {
+            queryClient.invalidateQueries({ queryKey: ['admin', 'accounts'] });
+            queryClient.invalidateQueries({ queryKey: ['admin', 'accounts', accountId] });
+        },
+    });
+}
+export function useAdminSetTier() {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async ({ accountId, tier }) => {
+            const response = await backendApi.post(`/admin/api/accounts/${accountId}/tier`, { tier });
+            if (response.error)
+                throw new Error(response.error.message);
+            return response.data;
+        },
+        onSuccess: (_data, { accountId }) => {
+            queryClient.invalidateQueries({ queryKey: ['admin', 'accounts'] });
+            queryClient.invalidateQueries({ queryKey: ['admin', 'accounts', accountId] });
+        },
+    });
+}
+function invalidateAdminAccount(queryClient, accountId) {
+    queryClient.invalidateQueries({ queryKey: ['admin', 'accounts'] });
+    queryClient.invalidateQueries({ queryKey: ['admin', 'accounts', accountId] });
+}
+export function useAdminGrantTrial() {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async ({ accountId, tierKey, seats, durationDays, creditGrant, note }) => {
+            const body = {
+                tier_key: tierKey,
+                seats,
+                duration_days: durationDays,
+            };
+            if (creditGrant !== undefined)
+                body.credit_grant = creditGrant;
+            if (note !== undefined)
+                body.note = note;
+            const response = await backendApi.post(`/admin/api/accounts/${accountId}/trial`, body);
+            if (response.error)
+                throw new Error(response.error.message);
+            return response.data;
+        },
+        onSuccess: (_data, { accountId }) => invalidateAdminAccount(queryClient, accountId),
+    });
+}
+export function useAdminRevokeTrial() {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async ({ accountId }) => {
+            const response = await backendApi.delete(`/admin/api/accounts/${accountId}/trial`);
+            if (response.error)
+                throw new Error(response.error.message);
+            return response.data;
+        },
+        onSuccess: (_data, { accountId }) => invalidateAdminAccount(queryClient, accountId),
+    });
+}
+export function useAdminSetManagedModels() {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async ({ accountId, override }) => {
+            const response = await backendApi.post(`/admin/api/accounts/${accountId}/managed-models`, { override });
+            if (response.error)
+                throw new Error(response.error.message);
+            return response.data;
+        },
+        onSuccess: (_data, { accountId }) => invalidateAdminAccount(queryClient, accountId),
+    });
+}
+export function useAdminSetEnterpriseDemo() {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async ({ accountId, enabled }) => {
+            const response = await backendApi.post(`/admin/api/accounts/${accountId}/enterprise-demo`, { enabled });
+            if (response.error)
+                throw new Error(response.error.message);
+            return response.data;
+        },
+        onSuccess: (_data, { accountId }) => invalidateAdminAccount(queryClient, accountId),
+    });
+}
+export function useAdminSetEnterpriseEntitled() {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async ({ accountId, enabled }) => {
+            const response = await backendApi.post(`/admin/api/accounts/${accountId}/enterprise-entitlement`, { enabled });
+            if (response.error)
+                throw new Error(response.error.message);
+            return response.data;
+        },
+        onSuccess: (_data, { accountId }) => invalidateAdminAccount(queryClient, accountId),
+    });
+}
+export function useAdminSetOverrides() {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async ({ accountId, patch }) => {
+            const response = await backendApi.put(adminAccountOverridesPath(accountId), patch);
+            if (response.error)
+                throw new Error(response.error.message);
+            return response.data;
+        },
+        onSuccess: (_data, { accountId }) => invalidateAdminAccount(queryClient, accountId),
+    });
+}
+export function adminMemberRolePath(accountId, userId) {
+    return `/admin/api/accounts/${accountId}/members/${userId}/role`;
+}
+export function useAdminSetMemberRole() {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async ({ accountId, userId, role }) => {
+            const response = await backendApi.post(adminMemberRolePath(accountId, userId), { role });
+            if (response.error)
+                throw new Error(response.error.message);
+            return response.data;
+        },
+        onSuccess: (_data, { accountId }) => invalidateAdminAccount(queryClient, accountId),
+    });
+}
+export function useAdminAccountLedger(accountId, limit = 50) {
+    return useQuery({
+        queryKey: ['admin', 'accounts', accountId, 'ledger', limit],
+        enabled: !!accountId,
+        queryFn: async () => {
+            const response = await backendApi.get(`/admin/api/accounts/${accountId}/ledger?limit=${limit}`);
+            if (response.error)
+                throw new Error(response.error.message);
+            return response.data;
+        },
+    });
+}
+export function useAdminAccountProjects(accountId) {
+    return useQuery({
+        queryKey: ['admin', 'accounts', accountId, 'projects'],
+        enabled: !!accountId,
+        queryFn: async () => {
+            const response = await backendApi.get(`/admin/api/accounts/${accountId}/projects`);
+            if (response.error)
+                throw new Error(response.error.message);
+            return response.data;
+        },
+    });
+}
+export function useAdminAccountSandboxes(accountId) {
+    return useRetiredQuery('useAdminAccountSandboxes', ['admin', 'accounts', accountId, 'sandboxes'], !!accountId);
+}
+export function adminAccountSubscriptionPath(accountId) {
+    return `/admin/api/accounts/${encodeURIComponent(accountId)}/subscription`;
+}
+export function useAdminAccountSubscription(accountId) {
+    return useQuery({
+        queryKey: ['admin', 'accounts', accountId, 'subscription'],
+        enabled: !!accountId,
+        queryFn: async () => {
+            const response = await backendApi.get(adminAccountSubscriptionPath(accountId));
+            if (response.error)
+                throw new Error(response.error.message);
+            return response.data;
+        },
+        staleTime: 60_000,
+    });
+}

package/dist/react/use-admin-activity-analytics.d.ts

@@ -0,0 +1,48 @@
+export declare const ADMIN_ANALYTICS_DEFAULT_DAYS = 30;
+export declare const ADMIN_ANALYTICS_MAX_DAYS = 90;
+export declare const ADMIN_ANALYTICS_MIN_DAYS = 1;
+export interface AdminActivityDay {
+    date: string;
+    sessionsCreated: number;
+    activeAccounts: number;
+    activeUsers: number;
+    newAccounts: number;
+    activeProjects: number;
+}
+export interface AdminActivitySummary {
+    sessionsLast7d: number;
+    sessionsPrev7d: number;
+    dau: number;
+    wau: number;
+    mau: number;
+    totalAccounts: number;
+    totalProjects: number;
+}
+export interface AdminActivityAnalytics {
+    days: AdminActivityDay[];
+    summary: AdminActivitySummary;
+}
+export interface AdminUsageDay {
+    date: string;
+    computeUsd: number;
+    llmUsd: number;
+    otherUsd: number;
+    totalUsd: number;
+    payingAccounts: number;
+}
+export interface AdminUsageSummary {
+    totalUsd: number;
+    computeUsd: number;
+    llmUsd: number;
+    otherUsd: number;
+    spendLast7d: number;
+    spendPrev7d: number;
+    payingAccountsLast7d: number;
+}
+export interface AdminUsageAnalytics {
+    days: AdminUsageDay[];
+    summary: AdminUsageSummary;
+}
+export declare function clampAdminAnalyticsDays(days?: number): number;
+export declare function useAdminActivityAnalytics(days?: number): import("@tanstack/react-query").UseQueryResult<AdminActivityAnalytics, Error>;
+export declare function useAdminUsageAnalytics(days?: number): import("@tanstack/react-query").UseQueryResult<AdminUsageAnalytics, Error>;

package/dist/react/use-admin-activity-analytics.js

@@ -0,0 +1,47 @@
+import { useQuery } from '@tanstack/react-query';
+import { backendApi } from '../core/http/api-client.js';
+export const ADMIN_ANALYTICS_DEFAULT_DAYS = 30;
+export const ADMIN_ANALYTICS_MAX_DAYS = 90;
+export const ADMIN_ANALYTICS_MIN_DAYS = 1;
+export function clampAdminAnalyticsDays(days) {
+    if (typeof days !== 'number' || !Number.isFinite(days))
+        return ADMIN_ANALYTICS_DEFAULT_DAYS;
+    const truncated = Math.trunc(days);
+    if (truncated < ADMIN_ANALYTICS_MIN_DAYS)
+        return ADMIN_ANALYTICS_MIN_DAYS;
+    if (truncated > ADMIN_ANALYTICS_MAX_DAYS)
+        return ADMIN_ANALYTICS_MAX_DAYS;
+    return truncated;
+}
+const ANALYTICS_STALE_TIME_MS = 60_000;
+const ANALYTICS_RETRY = false;
+export function useAdminActivityAnalytics(days = ADMIN_ANALYTICS_DEFAULT_DAYS) {
+    const window = clampAdminAnalyticsDays(days);
+    return useQuery({
+        queryKey: ['admin', 'analytics', 'activity', window],
+        queryFn: async () => {
+            const response = await backendApi.get(`/admin/analytics/activity?days=${window}`);
+            if (response.error)
+                throw new Error(response.error.message);
+            return response.data;
+        },
+        staleTime: ANALYTICS_STALE_TIME_MS,
+        retry: ANALYTICS_RETRY,
+        placeholderData: (previousData) => previousData,
+    });
+}
+export function useAdminUsageAnalytics(days = ADMIN_ANALYTICS_DEFAULT_DAYS) {
+    const window = clampAdminAnalyticsDays(days);
+    return useQuery({
+        queryKey: ['admin', 'analytics', 'usage', window],
+        queryFn: async () => {
+            const response = await backendApi.get(`/admin/analytics/usage?days=${window}`);
+            if (response.error)
+                throw new Error(response.error.message);
+            return response.data;
+        },
+        staleTime: ANALYTICS_STALE_TIME_MS,
+        retry: ANALYTICS_RETRY,
+        placeholderData: (previousData) => previousData,
+    });
+}