@beeuni/sdk 0.1.0

package/dist/core/rest/projects-client/assignments.js

@@ -0,0 +1,45 @@
+import { appendQuery } from './iam-query.js';
+import { backendApi } from '../../http/api-client.js';
+import { unwrap } from './shared.js';
+import { iamGet } from './iam-shared.js';
+function query(filter) {
+    return appendQuery({
+        principal_type: filter?.principalType,
+        principal_id: filter?.principalId,
+        scope_type: filter?.scopeType,
+        scope_id: filter?.scopeId,
+        object_type: filter?.objectType,
+        object_id: filter?.objectId,
+        role_id: filter?.roleId,
+        include_expired: filter?.includeExpired ? 'true' : undefined,
+    });
+}
+export async function listAssignments(accountId, filter) {
+    return unwrap(await iamGet(`/accounts/${accountId}/iam/assignments${query(filter)}`)).assignments;
+}
+export async function createAssignment(accountId, input) {
+    const body = {
+        principal_type: input.principal.type,
+        principal_id: input.principal.id,
+        scope_type: input.scope.type,
+        scope_id: input.scope.type === 'project' ? input.scope.id : null,
+    };
+    if (input.roleId)
+        body.role_id = input.roleId;
+    else
+        body.role_key = input.roleKey;
+    if (input.object) {
+        body.object_type = input.object.type;
+        body.object_id = input.object.id;
+    }
+    if (input.expiresAt !== undefined)
+        body.expires_at = input.expiresAt;
+    return unwrap(await backendApi.post(`/accounts/${accountId}/iam/assignments`, body));
+}
+export async function revokeAssignment(accountId, assignmentId) {
+    return unwrap(await backendApi.delete(`/accounts/${accountId}/iam/assignments/${assignmentId}`)).assignment;
+}
+export async function listPermissions(accountId, options) {
+    const qs = options?.scopeType ? `?scope_type=${options.scopeType}` : '';
+    return unwrap(await iamGet(`/accounts/${accountId}/iam/permissions${qs}`)).permissions;
+}

package/dist/core/rest/projects-client/audit-filter.d.ts

@@ -0,0 +1,4 @@
+import type { ListAuditFilter } from './iam.js';
+export declare function auditFilterQuery(filter: ListAuditFilter & {
+    format?: 'csv' | 'jsonl';
+}): URLSearchParams;

package/dist/core/rest/projects-client/audit-filter.js

@@ -0,0 +1,9 @@
+export function auditFilterQuery(filter) {
+    const search = new URLSearchParams();
+    const keys = ' format action actor actor_type project_id session_id source credential_kind phase outcome resource_type request_id correlation_id since until q cursor limit ';
+    for (const [key, value] of Object.entries(filter)) {
+        if (keys.includes(` ${key} `) && value != null && value !== '')
+            search.set(key, String(value));
+    }
+    return search;
+}

package/dist/core/rest/projects-client/audit.d.ts

@@ -0,0 +1,125 @@
+export interface AuditEvent {
+    event_id: string;
+    occurred_at: string;
+    account_id?: string | null;
+    project_id: string | null;
+    session_id: string | null;
+    runtime_session_id?: string | null;
+    opencode_session_id?: string | null;
+    turn_id?: string | null;
+    message_id?: string | null;
+    tool_call_id?: string | null;
+    execution_id?: string | null;
+    session_sequence?: number | null;
+    actor_user_id: string | null;
+    actor_type: 'human' | 'agent' | 'service_account' | 'system' | 'anonymous' | null;
+    agent_id?: string | null;
+    agent_name?: string | null;
+    initiator_actor_type?: string | null;
+    initiator_actor_id?: string | null;
+    on_behalf_of_user_id?: string | null;
+    parent_event_id?: string | null;
+    delegation_depth?: number;
+    source: string | null;
+    authoritative_source?: string | null;
+    client_reported_source?: string | null;
+    credential_kind?: string | null;
+    credential_id?: string | null;
+    credential_name?: string | null;
+    outcome: 'success' | 'failure' | 'denied' | 'pending' | null;
+    action: string;
+    phase?: string;
+    resource_type: string | null;
+    resource_id: string | null;
+    http_status: number | null;
+    duration_ms: number | null;
+    request_id: string | null;
+    trace_id: string | null;
+    correlation_id: string | null;
+    causation_id?: string | null;
+    source_ledger?: string | null;
+    source_record_id?: string | null;
+    source_revision?: string | null;
+    input_summary?: Record<string, unknown> | null;
+    output_summary?: Record<string, unknown> | null;
+    input_sha256?: string | null;
+    output_sha256?: string | null;
+    error_code?: string | null;
+    error_message?: string | null;
+    integrity_previous_hash?: string | null;
+    integrity_hash?: string | null;
+    before: unknown;
+    after: unknown;
+    ip: string | null;
+    user_agent: string | null;
+    metadata: unknown;
+}
+export interface AuditEventList {
+    events: AuditEvent[];
+    next_cursor: string | null;
+}
+export interface ListAccountAuditOptions {
+    action?: string;
+    actor?: string;
+    actorType?: 'human' | 'agent' | 'service_account' | 'system' | 'anonymous';
+    projectId?: string;
+    sessionId?: string;
+    source?: string;
+    credentialKind?: string;
+    phase?: string;
+    outcome?: 'success' | 'failure' | 'denied' | 'pending';
+    resourceType?: string;
+    requestId?: string;
+    correlationId?: string;
+    since?: string;
+    until?: string;
+    q?: string;
+    cursor?: string;
+    limit?: number;
+}
+export declare function listAccountAudit(accountId: string, options?: ListAccountAuditOptions): Promise<AuditEventList>;
+export declare function listProjectAudit(projectId: string, options?: ListAccountAuditOptions): Promise<AuditEventList>;
+export interface ExportAccountAuditOptions extends ListAccountAuditOptions {
+    format?: 'csv' | 'jsonl';
+    cursor?: string;
+    limit?: number;
+}
+export declare function exportAccountAudit(accountId: string, options?: ExportAccountAuditOptions): Promise<string | Blob>;
+export interface AuditWebhookTestResult {
+    ok: boolean;
+    status?: number;
+    error?: string;
+}
+export interface AuditWebhook {
+    webhook_id: string;
+    name: string;
+    url: string;
+    enabled: boolean;
+    action_prefix: string | null;
+    last_delivered_at: string | null;
+    last_error_at: string | null;
+    last_error: string | null;
+    created_at: string;
+    updated_at: string;
+    secret?: string;
+    test?: AuditWebhookTestResult;
+}
+export interface AuditWebhookListResponse {
+    webhooks: AuditWebhook[];
+}
+export declare function listAccountAuditWebhooks(accountId: string): Promise<AuditWebhookListResponse>;
+export interface CreateAuditWebhookInput {
+    name: string;
+    url: string;
+    action_prefix?: string;
+}
+export declare function createAccountAuditWebhook(accountId: string, input: CreateAuditWebhookInput): Promise<AuditWebhook>;
+export interface UpdateAuditWebhookInput {
+    name?: string;
+    enabled?: boolean;
+    action_prefix?: string | null;
+}
+export declare function updateAccountAuditWebhook(accountId: string, webhookId: string, input: UpdateAuditWebhookInput): Promise<AuditWebhook>;
+export declare function removeAccountAuditWebhook(accountId: string, webhookId: string): Promise<{
+    deleted: boolean;
+}>;

package/dist/core/rest/projects-client/audit.js

@@ -0,0 +1,49 @@
+import { backendApi } from '../../http/api-client.js';
+import { auditFilterQuery } from './audit-filter.js';
+import { unwrap } from './shared.js';
+function auditFilter(options = {}) {
+    return {
+        format: options.format,
+        action: options.action,
+        actor: options.actor,
+        actor_type: options.actorType,
+        project_id: options.projectId,
+        session_id: options.sessionId,
+        source: options.source,
+        credential_kind: options.credentialKind,
+        phase: options.phase,
+        outcome: options.outcome,
+        resource_type: options.resourceType,
+        request_id: options.requestId,
+        correlation_id: options.correlationId,
+        since: options.since,
+        until: options.until,
+        q: options.q,
+        cursor: options.cursor,
+        limit: options.limit,
+    };
+}
+export async function listAccountAudit(accountId, options) {
+    const qs = auditFilterQuery(auditFilter(options)).toString();
+    return unwrap(await backendApi.get(`/accounts/${accountId}/audit${qs ? `?${qs}` : ''}`));
+}
+export async function listProjectAudit(projectId, options) {
+    const qs = auditFilterQuery(auditFilter({ ...options, projectId: undefined })).toString();
+    return unwrap(await backendApi.get(`/projects/${projectId}/audit${qs ? `?${qs}` : ''}`));
+}
+export async function exportAccountAudit(accountId, options) {
+    const qs = auditFilterQuery(auditFilter(options)).toString();
+    return unwrap(await backendApi.get(`/accounts/${accountId}/audit/export${qs ? `?${qs}` : ''}`));
+}
+export async function listAccountAuditWebhooks(accountId) {
+    return unwrap(await backendApi.get(`/accounts/${accountId}/audit/webhooks`));
+}
+export async function createAccountAuditWebhook(accountId, input) {
+    return unwrap(await backendApi.post(`/accounts/${accountId}/audit/webhooks`, input));
+}
+export async function updateAccountAuditWebhook(accountId, webhookId, input) {
+    return unwrap(await backendApi.patch(`/accounts/${accountId}/audit/webhooks/${webhookId}`, input));
+}
+export async function removeAccountAuditWebhook(accountId, webhookId) {
+    return unwrap(await backendApi.delete(`/accounts/${accountId}/audit/webhooks/${webhookId}`));
+}

package/dist/core/rest/projects-client/billing.d.ts

@@ -0,0 +1,390 @@
+import { type ServerTokenOptions } from './shared.js';
+export type BillingState = 'active' | 'out_of_credits' | 'no_subscription' | 'payment_failed' | 'no_account';
+export type PlanFamily = 'free' | 'team' | 'enterprise';
+export interface AccountState {
+    credits: {
+        total: number;
+        daily: number;
+        monthly: number;
+        extra: number;
+        can_run: boolean;
+        lifetime_granted?: number;
+        lifetime_purchased?: number;
+        lifetime_used?: number;
+        daily_refresh: {
+            enabled: boolean;
+            daily_amount: number;
+            refresh_interval_hours: number;
+            last_refresh?: string;
+            next_refresh_at?: string;
+            seconds_until_refresh?: number;
+        } | null;
+    };
+    billing_state?: BillingState;
+    has_active_subscription?: boolean;
+    plan?: {
+        key: string;
+        family: PlanFamily;
+        label: string;
+        sublabel: string | null;
+        status: 'current' | 'grandfathered' | 'retired' | 'non_plan';
+        shape: 'none' | 'flat' | 'seat' | 'contract';
+        rank: number;
+        is_grandfathered: boolean;
+    };
+    subscription: {
+        tier_key: string;
+        tier_display_name: string;
+        status: string;
+        billing_period: 'monthly' | 'yearly' | 'yearly_commitment' | null;
+        provider: 'stripe' | 'revenuecat' | 'local';
+        subscription_id: string | null;
+        current_period_end: number | null;
+        cancel_at_period_end: boolean;
+        is_cancelled: boolean;
+        cancellation_effective_date: string | null;
+        has_scheduled_change: boolean;
+        scheduled_change: {
+            type: 'downgrade';
+            current_tier: {
+                name: string;
+                display_name: string;
+                monthly_credits?: number;
+            };
+            target_tier: {
+                name: string;
+                display_name: string;
+                monthly_credits?: number;
+            };
+            effective_date: string;
+        } | null;
+        commitment: {
+            has_commitment: boolean;
+            can_cancel: boolean;
+            commitment_type?: string | null;
+            months_remaining?: number | null;
+            commitment_end_date?: string | null;
+        };
+        can_purchase_credits: boolean;
+    };
+    models: Array<{
+        id: string;
+        name: string;
+        provider: string;
+        allowed: boolean;
+        context_window: number;
+        capabilities: string[];
+        priority: number;
+    }>;
+    limits?: {
+        concurrent_runs: {
+            running_count: number;
+            limit: number;
+            can_start: boolean;
+            tier_name: string;
+        };
+        ai_worker_count: {
+            current_count: number;
+            limit: number;
+            can_create: boolean;
+            tier_name: string;
+        };
+        custom_mcp_count: {
+            current_count: number;
+            limit: number;
+            can_create: boolean;
+            tier_name: string;
+        };
+        concurrent_sessions?: {
+            active: number;
+            limit: number;
+        };
+    };
+    tier: {
+        name: string;
+        display_name: string;
+        monthly_credits: number;
+        can_purchase_credits: boolean;
+        entitlements?: {
+            sso: boolean;
+            scim: boolean;
+            rbac: boolean;
+            auditAccess: boolean;
+            branding: boolean;
+        };
+    };
+    enterprise_license_available?: boolean;
+    enterprise_entitled?: boolean;
+    auto_topup?: {
+        enabled: boolean;
+        threshold: number;
+        amount: number;
+        disabled_reason?: string | null;
+        last_failure_reason?: string | null;
+        last_failure_at?: string | null;
+    };
+    instances?: Array<{
+        sandbox_id: string;
+        name: string;
+        provider: string;
+        status: string;
+        server_type: string | null;
+        location: string | null;
+        is_included: boolean;
+        stripe_subscription_id: string | null;
+        stripe_subscription_item_id: string | null;
+        cancel_at_period_end?: boolean;
+        cancel_at?: string | null;
+        created_at: string;
+    }>;
+    can_add_instances?: boolean;
+    can_claim_computer?: boolean;
+    can_manage_billing?: boolean;
+    can_claim_per_seat?: boolean;
+    billing_model?: 'legacy' | 'per_seat';
+    seats?: {
+        count: number;
+        price_per_seat_usd: number;
+        typical_compute_budget_per_seat_usd: number;
+        typical_llm_budget_per_seat_usd: number;
+    };
+    member_count?: number;
+    usage_this_period?: {
+        compute_usd: number;
+        llm_usd: number;
+        total_usd: number;
+        period_start: string | null;
+        period_end: string | null;
+    } | null;
+    _cache?: {
+        cached: boolean;
+        ttl_seconds?: number;
+        local_mode?: boolean;
+    };
+}
+export declare function getDefaultAccountState(): AccountState;
+export interface ResolvedPlanView {
+    family: PlanFamily;
+    label: string;
+    sublabel: string | null;
+    isGrandfathered: boolean;
+}
+export declare function resolvedPlan(state: AccountState | null | undefined): ResolvedPlanView;
+export interface GetAccountStateOptions {
+    skipCache?: boolean;
+    accountId?: string;
+}
+export declare function getAccountState(options?: GetAccountStateOptions): Promise<AccountState>;
+export declare function getAccountStateMinimal(options?: GetAccountStateOptions): Promise<AccountState>;
+export interface BillingTransaction {
+    id: string;
+    created_at: string;
+    amount: number;
+    balance_after: number;
+    type: string;
+    description: string | null;
+    is_expiring: boolean | null;
+    expires_at: string | null;
+    metadata: unknown;
+}
+export interface BillingTransactionsPage {
+    transactions: BillingTransaction[];
+    pagination: {
+        total: number;
+        limit: number;
+        offset: number;
+        has_more: boolean;
+    };
+}
+export interface ListBillingTransactionsOptions {
+    accountId?: string;
+    limit?: number;
+    offset?: number;
+    typeFilter?: string | string[];
+}
+export declare function listBillingTransactions(options?: ListBillingTransactionsOptions): Promise<BillingTransactionsPage>;
+export interface BillingTransactionsSummary {
+    totalCredits: number;
+    totalDebits: number;
+    count: number;
+}
+export declare function getBillingTransactionsSummary(options?: {
+    accountId?: string;
+    days?: number;
+}): Promise<BillingTransactionsSummary>;
+export interface BillingCreditBreakdown {
+    total: number;
+    expiring: number;
+    non_expiring: number;
+    daily: number;
+}
+export declare function getBillingCreditBreakdown(): Promise<BillingCreditBreakdown>;
+export declare function getBillingUsageHistory(days?: number): Promise<BillingTransactionsSummary>;
+export interface BillingTierConfiguration {
+    tier_key?: string;
+    name: string;
+    display_name: string;
+    monthly_price: number;
+    yearly_price: number;
+    monthly_credits: number;
+    can_purchase_credits: boolean;
+    project_limit?: number;
+    price_ids?: string[];
+}
+export interface BillingTierConfigurationsResponse {
+    success?: boolean;
+    tiers: BillingTierConfiguration[];
+    timestamp?: string;
+}
+export declare function getBillingTierConfigurations(): Promise<BillingTierConfigurationsResponse>;
+export interface AccountStateAppAccessView {
+    plan?: {
+        key?: string | null;
+    } | null;
+    subscription?: {
+        tier_key?: string | null;
+    } | null;
+    tier?: {
+        name?: string | null;
+    } | null;
+    credits?: {
+        can_run?: boolean | null;
+    } | null;
+}
+export interface FetchAccountStateWithTokenOptions extends ServerTokenOptions {
+    accountId?: string;
+}
+export declare function fetchAccountStateWithToken(opts: FetchAccountStateWithTokenOptions): Promise<AccountStateAppAccessView | null>;
+export interface CreateCheckoutSessionInput {
+    accountId?: string;
+    tierKey: string;
+    successUrl: string;
+    cancelUrl: string;
+    commitmentType?: string;
+    locale?: string;
+    serverType?: string;
+    location?: string;
+}
+export interface CheckoutSessionResult {
+    url?: string | null;
+    checkout_url?: string;
+    session_id?: string;
+    status?: string;
+    message?: string;
+    [key: string]: unknown;
+}
+export declare function createCheckoutSession(_input: CreateCheckoutSessionInput): Promise<CheckoutSessionResult>;
+export interface ConfirmCheckoutSessionResult {
+    ok?: boolean;
+    [key: string]: unknown;
+}
+export declare function confirmCheckoutSession(_sessionId: string, _accountId?: string): Promise<ConfirmCheckoutSessionResult>;
+export interface PortalSessionResult {
+    url?: string | null;
+    [key: string]: unknown;
+}
+export declare function createPortalSession(returnUrl: string, accountId?: string): Promise<PortalSessionResult>;
+export interface SubscriptionMutationResult {
+    ok?: boolean;
+    success: boolean;
+    message: string;
+    [key: string]: unknown;
+}
+export declare function cancelSubscription(feedback?: string, accountId?: string): Promise<SubscriptionMutationResult>;
+export declare function reactivateSubscription(accountId?: string): Promise<SubscriptionMutationResult>;
+export declare function scheduleDowngrade(_targetTierKey: string, _commitmentType?: string, _accountId?: string): Promise<SubscriptionMutationResult>;
+export declare function cancelScheduledChange(accountId?: string): Promise<SubscriptionMutationResult>;
+export interface ProrationPreviewResult {
+    [key: string]: unknown;
+}
+export declare function getProrationPreview(newPriceId: string, accountId?: string): Promise<ProrationPreviewResult>;
+export interface PurchaseCreditsInput {
+    amount: number;
+    accountId?: string;
+    successUrl?: string;
+    cancelUrl?: string;
+}
+export interface PurchaseCreditsResult {
+    checkout_url: string | null;
+}
+export declare function purchaseCredits(input: PurchaseCreditsInput): Promise<PurchaseCreditsResult>;
+export interface AutoTopupSettings {
+    enabled: boolean;
+    threshold: number;
+    amount: number;
+    disabled_reason?: string | null;
+    last_failure_reason?: string | null;
+    last_failure_at?: string | null;
+    [key: string]: unknown;
+}
+export declare function getAutoTopupSettings(accountId?: string): Promise<AutoTopupSettings>;
+export interface TopUpRequestResult {
+    notified: number;
+}
+export declare function requestTopUp(accountId: string): Promise<TopUpRequestResult>;
+export interface ConfigureAutoTopupInput {
+    accountId?: string;
+    enabled: boolean;
+    threshold: number;
+    amount: number;
+}
+export declare function configureAutoTopup(input: ConfigureAutoTopupInput): Promise<AutoTopupSettings>;
+export interface AutoTopupSetupStatus {
+    has_payment_method: boolean;
+    has_default_payment_method: boolean;
+    payment_method_source?: 'customer_default' | 'subscription_default' | 'attached' | null;
+}
+export declare function getAutoTopupSetupStatus(accountId?: string): Promise<AutoTopupSetupStatus>;
+export interface CreatePerSeatCheckoutInput {
+    accountId?: string;
+    successUrl: string;
+    cancelUrl: string;
+    locale?: string;
+}
+export interface CreatePerSeatCheckoutResult {
+    status: 'subscription_created' | 'checkout_created';
+    checkout_url?: string;
+    subscription_id?: string;
+    seat_count: number;
+}
+export declare function createPerSeatCheckout(input: CreatePerSeatCheckoutInput): Promise<CreatePerSeatCheckoutResult>;
+export interface ClaimPerSeatResult {
+    ok: boolean;
+    status: string;
+    credited_usd: number;
+    first_seat_covered_usd: number;
+    cancelled_subscriptions: number;
+    reason?: string | null;
+}
+export declare function claimPerSeatBilling(accountId?: string): Promise<ClaimPerSeatResult>;
+export declare function syncSubscription(accountId?: string): Promise<SubscriptionMutationResult>;
+export interface UsageTotals {
+    total_input_tokens: number;
+    total_output_tokens: number;
+    total_cached_tokens: number;
+    total_cache_write_tokens: number;
+    total_cost: number;
+    count: number;
+}
+export interface UsageBreakdownItem {
+    day?: string;
+    provider?: string | null;
+    model?: string;
+    input_tokens: number;
+    output_tokens: number;
+    cached_tokens: number;
+    cache_write_tokens: number;
+    cost: number;
+    count: number;
+}
+export interface UsageRollup {
+    data: UsageTotals;
+    breakdown?: UsageBreakdownItem[];
+}
+export interface UsageQueryOptions {
+    start?: string;
+    end?: string;
+    groupBy?: 'model' | 'provider' | 'day';
+    accountId?: string;
+}
+export declare function getUsageRollup(options?: UsageQueryOptions): Promise<UsageRollup>;