@beeuni/sdk 0.1.0

package/dist/core/client/beeuni.js

@@ -0,0 +1,96 @@
+import { bindCatalog } from './facade-catalog.js';
+import { bindCommerce } from './facade-commerce.js';
+import { bindIdentity } from './facade-identity.js';
+import { bindPreviewOptions } from './facade-preview.js';
+import { session } from './session-handle.js';
+export { SessionNotReadyError } from './session-shared.js';
+import { bindProjectAccessResources } from './project-access-resources.js';
+import { bindProjectAccessSecurity } from './project-access-security.js';
+import { projectConnections } from './project-connections.js';
+import { connectorDataPlane, connectorHandle } from './project-connectors.js';
+import { bindProjectCore } from './project-core.js';
+import { bindProjectOperations } from './project-operations.js';
+import { bindProjectPlatformResources } from './project-platform-resources.js';
+import { bindProjectPlatformSecurity } from './project-platform-security.js';
+import { getClient } from '../runtime/client.js';
+import { configureBeeuni } from '../http/config.js';
+import * as P from '../rest/projects-client/index.js';
+function runtime() {
+    return getClient();
+}
+let lastGlobalConfig = null;
+let warnedGlobalRepoint = false;
+function noteGlobalClient(config) {
+    const previous = lastGlobalConfig;
+    lastGlobalConfig = config;
+    if (warnedGlobalRepoint || !previous)
+        return;
+    if (previous.backendUrl === config.backendUrl && previous.getToken === config.getToken)
+        return;
+    warnedGlobalRepoint = true;
+    console.warn('[beeuni] createBeeuni() was called again with a different backendUrl or getToken. ' +
+        'Every client shares one process-global config, so the earlier client now uses the new one. ' +
+        'For several tenants in one process use createScopedBeeuni() from @beeuni/sdk/server.');
+}
+export function createBeeuni(config, opts) {
+    if (opts?.global !== false)
+        noteGlobalClient(config);
+    configureBeeuni(config, opts);
+    const resolvePreviewOptsForSandbox = bindPreviewOptions(config);
+    const { auth, accounts, iam, accountInvites } = bindIdentity();
+    const { billing, sandboxShares } = bindCommerce();
+    const { projects, github, gitBackend, connectStatus, marketplace } = bindCatalog();
+    function project(projectId) {
+        const connections = projectConnections(projectId);
+        return {
+            ...bindProjectCore(projectId),
+            ...bindProjectAccessResources(projectId),
+            ...bindProjectAccessSecurity(projectId),
+            ...bindProjectOperations(projectId, connections),
+            ...bindProjectPlatformResources(projectId),
+            ...bindProjectPlatformSecurity(projectId),
+            connector: (slug) => connectorHandle(projectId, slug),
+            session: (sessionId) => session(projectId, sessionId, config, resolvePreviewOptsForSandbox),
+        };
+    }
+    return {
+        config,
+        auth,
+        accounts,
+        providerConnections: {
+            list: P.listUserProviderConnections,
+            saveApiKey: P.saveUserProviderApiKey,
+            remove: P.deleteUserProviderConnection,
+            startOAuth: P.startUserProviderOAuth,
+            pollOAuth: P.pollUserProviderOAuth,
+            listProject: P.listProjectPersonalProviders,
+            setProject: P.setProjectPersonalProvider,
+        },
+        iam,
+        accountInvites,
+        projects,
+        connectors: connectorDataPlane(),
+        connector: (slug) => connectorHandle(undefined, slug),
+        project,
+        session: (projectId, sessionId) => session(projectId, sessionId, config, resolvePreviewOptsForSandbox),
+        github,
+        gitBackend,
+        billing,
+        sandboxShares,
+        connectStatus,
+        marketplace,
+        notifications: {
+            registerDeviceToken: P.registerDeviceToken,
+            unregisterDeviceToken: P.unregisterDeviceToken,
+            list: P.listNotifications,
+            markRead: P.markNotificationsRead,
+            preferences: P.getNotificationPreferences,
+            updatePreferences: P.updateNotificationPreferences,
+            webPushPublicKey: P.getWebPushPublicKey,
+            registerWebPushSubscription: P.registerWebPushSubscription,
+            unregisterWebPushSubscription: P.unregisterWebPushSubscription,
+        },
+        validateToken: P.validateToken,
+        runtime,
+    };
+}

package/dist/core/client/binding-types.d.ts

@@ -0,0 +1 @@
+export type DropFirst<T extends unknown[]> = T extends [unknown, ...infer R] ? R : [];

package/dist/core/client/binding-types.js

@@ -0,0 +1 @@
+export {};

package/dist/core/client/facade-accounts.d.ts

@@ -0,0 +1,51 @@
+import * as P from '../rest/projects-client/index.js';
+export declare function bindAccounts(): {
+    list: typeof P.listAccounts;
+    get: typeof P.getAccount;
+    create: typeof P.createAccount;
+    secretResources: {
+        list: typeof P.listAccountSecretResources;
+        create: typeof P.createAccountSecretResource;
+        rotate: typeof P.rotateAccountSecretResource;
+        retry: typeof P.retryAccountSecretResource;
+        remove: typeof P.deleteAccountSecretResource;
+        grant: typeof P.grantAccountSecretResource;
+        revoke: typeof P.revokeAccountSecretResourceGrant;
+        setAccess: typeof P.setAccountSecretResourceAccess;
+    };
+    updateName: typeof P.updateAccountName;
+    branding: {
+        get: typeof P.getAccountBranding;
+        update: typeof P.updateAccountBranding;
+        uploadAsset: typeof P.uploadAccountBrandingAsset;
+        removeAsset: typeof P.removeAccountBrandingAsset;
+        reset: typeof P.resetAccountBranding;
+    };
+    leave: typeof P.leaveAccount;
+    members: typeof P.listAccountMembers;
+    invite: typeof P.inviteAccountMember;
+    removeMember: typeof P.removeAccountMember;
+    updateMemberRole: typeof P.updateAccountMemberRole;
+    invites: typeof P.listAccountInvites;
+    cancelInvite: typeof P.cancelAccountInvite;
+    resendInvite: typeof P.resendAccountInvite;
+    tokens: {
+        list: typeof P.listAccountTokens;
+        create: typeof P.createAccountToken;
+        revoke: typeof P.revokeAccountToken;
+    };
+    connectedApps: {
+        list: typeof P.listOAuthGrants;
+        revoke: typeof P.revokeOAuthGrant;
+    };
+    audit: {
+        log: typeof P.listAccountAudit;
+        export: typeof P.exportAccountAudit;
+        webhooks: {
+            list: typeof P.listAccountAuditWebhooks;
+            create: typeof P.createAccountAuditWebhook;
+            update: typeof P.updateAccountAuditWebhook;
+            remove: typeof P.removeAccountAuditWebhook;
+        };
+    };
+};

package/dist/core/client/facade-accounts.js

@@ -0,0 +1,53 @@
+import * as P from '../rest/projects-client/index.js';
+export function bindAccounts() {
+    return {
+        list: P.listAccounts,
+        get: P.getAccount,
+        create: P.createAccount,
+        secretResources: {
+            list: P.listAccountSecretResources,
+            create: P.createAccountSecretResource,
+            rotate: P.rotateAccountSecretResource,
+            retry: P.retryAccountSecretResource,
+            remove: P.deleteAccountSecretResource,
+            grant: P.grantAccountSecretResource,
+            revoke: P.revokeAccountSecretResourceGrant,
+            setAccess: P.setAccountSecretResourceAccess,
+        },
+        updateName: P.updateAccountName,
+        branding: {
+            get: P.getAccountBranding,
+            update: P.updateAccountBranding,
+            uploadAsset: P.uploadAccountBrandingAsset,
+            removeAsset: P.removeAccountBrandingAsset,
+            reset: P.resetAccountBranding,
+        },
+        leave: P.leaveAccount,
+        members: P.listAccountMembers,
+        invite: P.inviteAccountMember,
+        removeMember: P.removeAccountMember,
+        updateMemberRole: P.updateAccountMemberRole,
+        invites: P.listAccountInvites,
+        cancelInvite: P.cancelAccountInvite,
+        resendInvite: P.resendAccountInvite,
+        tokens: {
+            list: P.listAccountTokens,
+            create: P.createAccountToken,
+            revoke: P.revokeAccountToken,
+        },
+        connectedApps: {
+            list: P.listOAuthGrants,
+            revoke: P.revokeOAuthGrant,
+        },
+        audit: {
+            log: P.listAccountAudit,
+            export: P.exportAccountAudit,
+            webhooks: {
+                list: P.listAccountAuditWebhooks,
+                create: P.createAccountAuditWebhook,
+                update: P.updateAccountAuditWebhook,
+                remove: P.removeAccountAuditWebhook,
+            },
+        },
+    };
+}

package/dist/core/client/facade-catalog.d.ts

@@ -0,0 +1,54 @@
+import * as P from '../rest/projects-client/index.js';
+export declare function bindCatalog(): {
+    projects: {
+        list: typeof P.listProjects;
+        listForAccount: typeof P.listProjectsForAccount;
+        get: typeof P.getProject;
+        detail: typeof P.getProjectDetail;
+        create: typeof P.createProject;
+        createRepo: typeof P.createProjectRepo;
+        provision: typeof P.provisionProject;
+        update: typeof P.updateProject;
+        archive: typeof P.archiveProject;
+        llmCatalog: typeof P.getProjectLlmCatalog;
+        modelPicker: typeof P.getProjectModelPicker;
+        modelAccess: typeof P.getProjectModelAccess;
+        setModelAccess: typeof P.setProjectModelAccess;
+        sandboxHealth: typeof P.getProjectSandboxHealth;
+        sandboxTemplates: typeof P.listProjectSandboxTemplates;
+        sessions: typeof P.listProjectSessions;
+        createSession: typeof P.createProjectSession;
+    };
+    github: {
+        linkRepository: typeof P.linkRepository;
+        replaceProjectRepository: typeof P.replaceProjectRepository;
+        getInstallation: typeof P.getGitHubInstallation;
+        listInstallations: typeof P.listGitHubInstallations;
+        listLinkableInstallations: typeof P.listLinkableGitHubInstallations;
+        listRepositories: typeof P.listGitHubRepositories;
+        listRepositoryBranches: typeof P.listGitHubRepositoryBranches;
+        linkInstallation: typeof P.linkGitHubInstallation;
+        saveInstallation: typeof P.saveGitHubInstallation;
+        deleteInstallation: typeof P.deleteGitHubInstallation;
+        storeUserToken: typeof P.storeGitHubUserToken;
+    };
+    gitBackend: {
+        get: typeof P.getManagedGitBackend;
+        repositories: typeof P.listManagedGitRepositories;
+    };
+    connectStatus: typeof P.getConnectStatus;
+    marketplace: {
+        items: (options?: Parameters<typeof P.listMarketplaceCatalogItems>[0]) => Promise<P.MarketplaceItemsResponse>;
+        item: (id: string) => Promise<Record<string, unknown>>;
+        itemFile: (id: string, path: string) => Promise<P.MarketplaceItemFile>;
+        marketplaces: () => Promise<P.MarketplacesResponse>;
+        featured: () => Promise<P.FeaturedMarketplacesResponse>;
+        sources: {
+            list: () => Promise<P.MarketplaceSourcesResponse>;
+            add: (input: Parameters<typeof P.addMarketplaceSource>[0]) => Promise<P.AddMarketplaceSourceResponse>;
+            remove: (id: string) => Promise<{
+                ok: boolean;
+            }>;
+        };
+    };
+};

package/dist/core/client/facade-catalog.js

@@ -0,0 +1,53 @@
+import * as P from '../rest/projects-client/index.js';
+export function bindCatalog() {
+    const projects = {
+        list: P.listProjects,
+        listForAccount: P.listProjectsForAccount,
+        get: P.getProject,
+        detail: P.getProjectDetail,
+        create: P.createProject,
+        createRepo: P.createProjectRepo,
+        provision: P.provisionProject,
+        update: P.updateProject,
+        archive: P.archiveProject,
+        llmCatalog: P.getProjectLlmCatalog,
+        modelPicker: P.getProjectModelPicker,
+        modelAccess: P.getProjectModelAccess,
+        setModelAccess: P.setProjectModelAccess,
+        sandboxHealth: P.getProjectSandboxHealth,
+        sandboxTemplates: P.listProjectSandboxTemplates,
+        sessions: P.listProjectSessions,
+        createSession: P.createProjectSession,
+    };
+    const github = {
+        linkRepository: P.linkRepository,
+        replaceProjectRepository: P.replaceProjectRepository,
+        getInstallation: P.getGitHubInstallation,
+        listInstallations: P.listGitHubInstallations,
+        listLinkableInstallations: P.listLinkableGitHubInstallations,
+        listRepositories: P.listGitHubRepositories,
+        listRepositoryBranches: P.listGitHubRepositoryBranches,
+        linkInstallation: P.linkGitHubInstallation,
+        saveInstallation: P.saveGitHubInstallation,
+        deleteInstallation: P.deleteGitHubInstallation,
+        storeUserToken: P.storeGitHubUserToken,
+    };
+    const gitBackend = {
+        get: P.getManagedGitBackend,
+        repositories: P.listManagedGitRepositories,
+    };
+    const connectStatus = P.getConnectStatus;
+    const marketplace = {
+        items: (options) => P.listMarketplaceCatalogItems(options),
+        item: (id) => P.getMarketplaceCatalogItem(id),
+        itemFile: (id, path) => P.getMarketplaceCatalogItemFile(id, path),
+        marketplaces: () => P.listMarketplaces(),
+        featured: () => P.listFeaturedMarketplaces(),
+        sources: {
+            list: () => P.listMarketplaceSources(),
+            add: (input) => P.addMarketplaceSource(input),
+            remove: (id) => P.removeMarketplaceSource(id),
+        },
+    };
+    return { projects, github, gitBackend, connectStatus, marketplace };
+}

package/dist/core/client/facade-commerce.d.ts

@@ -0,0 +1,39 @@
+import * as P from '../rest/projects-client/index.js';
+export declare function bindCommerce(): {
+    billing: {
+        accountState: typeof P.getAccountState;
+        accountStateMinimal: typeof P.getAccountStateMinimal;
+        transactions: typeof P.listBillingTransactions;
+        transactionsSummary: typeof P.getBillingTransactionsSummary;
+        creditBreakdown: typeof P.getBillingCreditBreakdown;
+        usageHistory: typeof P.getBillingUsageHistory;
+        usageRollup: typeof P.getUsageRollup;
+        sessionCosts: {
+            list: typeof P.listSessionCosts;
+            get: typeof P.getSessionCostRecord;
+        };
+        tierConfigurations: typeof P.getBillingTierConfigurations;
+        checkout: {
+            createSession: (input: Parameters<typeof P.createCheckoutSession>[0]) => Promise<P.CheckoutSessionResult>;
+            confirmSession: (sessionId: string, accountId?: string) => Promise<P.ConfirmCheckoutSessionResult>;
+        };
+        subscription: {
+            createPortalSession: (returnUrl: string, accountId?: string) => Promise<P.PortalSessionResult>;
+            cancel: (feedback?: string, accountId?: string) => Promise<P.SubscriptionMutationResult>;
+            reactivate: (accountId?: string) => Promise<P.SubscriptionMutationResult>;
+            scheduleDowngrade: (targetTierKey: string, commitmentType?: string, accountId?: string) => Promise<P.SubscriptionMutationResult>;
+            cancelScheduledChange: (accountId?: string) => Promise<P.SubscriptionMutationResult>;
+            prorationPreview: (newPriceId: string, accountId?: string) => Promise<P.ProrationPreviewResult>;
+        };
+        credits: {
+            purchase: (input: Parameters<typeof P.purchaseCredits>[0]) => Promise<P.PurchaseCreditsResult>;
+            autoTopupSettings: (accountId?: string) => Promise<P.AutoTopupSettings>;
+            configureAutoTopup: (input: Parameters<typeof P.configureAutoTopup>[0]) => Promise<P.AutoTopupSettings>;
+        };
+    };
+    sandboxShares: {
+        list: typeof P.listSandboxShares;
+        create: typeof P.createSandboxShare;
+        revoke: typeof P.revokeSandboxShare;
+    };
+};

package/dist/core/client/facade-commerce.js

@@ -0,0 +1,40 @@
+import * as P from '../rest/projects-client/index.js';
+export function bindCommerce() {
+    const billing = {
+        accountState: P.getAccountState,
+        accountStateMinimal: P.getAccountStateMinimal,
+        transactions: P.listBillingTransactions,
+        transactionsSummary: P.getBillingTransactionsSummary,
+        creditBreakdown: P.getBillingCreditBreakdown,
+        usageHistory: P.getBillingUsageHistory,
+        usageRollup: P.getUsageRollup,
+        sessionCosts: {
+            list: P.listSessionCosts,
+            get: P.getSessionCostRecord,
+        },
+        tierConfigurations: P.getBillingTierConfigurations,
+        checkout: {
+            createSession: (input) => P.createCheckoutSession(input),
+            confirmSession: (sessionId, accountId) => P.confirmCheckoutSession(sessionId, accountId),
+        },
+        subscription: {
+            createPortalSession: (returnUrl, accountId) => P.createPortalSession(returnUrl, accountId),
+            cancel: (feedback, accountId) => P.cancelSubscription(feedback, accountId),
+            reactivate: (accountId) => P.reactivateSubscription(accountId),
+            scheduleDowngrade: (targetTierKey, commitmentType, accountId) => P.scheduleDowngrade(targetTierKey, commitmentType, accountId),
+            cancelScheduledChange: (accountId) => P.cancelScheduledChange(accountId),
+            prorationPreview: (newPriceId, accountId) => P.getProrationPreview(newPriceId, accountId),
+        },
+        credits: {
+            purchase: (input) => P.purchaseCredits(input),
+            autoTopupSettings: (accountId) => P.getAutoTopupSettings(accountId),
+            configureAutoTopup: (input) => P.configureAutoTopup(input),
+        },
+    };
+    const sandboxShares = {
+        list: P.listSandboxShares,
+        create: P.createSandboxShare,
+        revoke: P.revokeSandboxShare,
+    };
+    return { billing, sandboxShares };
+}

package/dist/core/client/facade-iam.d.ts

@@ -0,0 +1,43 @@
+import * as P from '../rest/projects-client/index.js';
+export declare function bindIam(): {
+    assignments: {
+        list: typeof P.listAssignments;
+        create: typeof P.createAssignment;
+        revoke: typeof P.revokeAssignment;
+    };
+    permissions: {
+        list: typeof P.listPermissions;
+        forRole: typeof P.getRolePermissions;
+    };
+    roles: {
+        list: typeof P.listRoles;
+        create: typeof P.createRole;
+        update: typeof P.updateRole;
+        setPermissions: typeof P.updateRolePermissions;
+        remove: typeof P.deleteRole;
+        usage: typeof P.getRoleUsage;
+    };
+    groups: {
+        list: typeof P.listGroups;
+        get: typeof P.getGroup;
+        create: typeof P.createGroup;
+        update: typeof P.updateGroup;
+        remove: typeof P.deleteGroup;
+        members: {
+            list: typeof P.listGroupMembers;
+            add: typeof P.addGroupMembers;
+            remove: typeof P.removeGroupMember;
+        };
+    };
+    agentIdentities: typeof P.listAgentIdentities;
+    oauthClients: {
+        list: typeof P.listOAuthClients;
+        get: typeof P.getOAuthClient;
+        create: typeof P.createOAuthClient;
+        update: typeof P.updateOAuthClient;
+        rotateSecret: typeof P.rotateOAuthClientSecret;
+        remove: typeof P.deleteOAuthClient;
+    };
+    can: typeof P.probeEffectivePermission;
+    canBatch: typeof P.probeEffectivePermissions;
+};

package/dist/core/client/facade-iam.js

@@ -0,0 +1,45 @@
+import * as P from '../rest/projects-client/index.js';
+export function bindIam() {
+    return {
+        assignments: {
+            list: P.listAssignments,
+            create: P.createAssignment,
+            revoke: P.revokeAssignment,
+        },
+        permissions: {
+            list: P.listPermissions,
+            forRole: P.getRolePermissions,
+        },
+        roles: {
+            list: P.listRoles,
+            create: P.createRole,
+            update: P.updateRole,
+            setPermissions: P.updateRolePermissions,
+            remove: P.deleteRole,
+            usage: P.getRoleUsage,
+        },
+        groups: {
+            list: P.listGroups,
+            get: P.getGroup,
+            create: P.createGroup,
+            update: P.updateGroup,
+            remove: P.deleteGroup,
+            members: {
+                list: P.listGroupMembers,
+                add: P.addGroupMembers,
+                remove: P.removeGroupMember,
+            },
+        },
+        agentIdentities: P.listAgentIdentities,
+        oauthClients: {
+            list: P.listOAuthClients,
+            get: P.getOAuthClient,
+            create: P.createOAuthClient,
+            update: P.updateOAuthClient,
+            rotateSecret: P.rotateOAuthClientSecret,
+            remove: P.deleteOAuthClient,
+        },
+        can: P.probeEffectivePermission,
+        canBatch: P.probeEffectivePermissions,
+    };
+}

package/dist/core/client/facade-identity.d.ts

@@ -0,0 +1,103 @@
+import * as A from '../rest/platform-client/auth.js';
+import * as P from '../rest/projects-client/index.js';
+export declare function bindIdentity(): {
+    auth: A.HeadlessAuthApi;
+    accounts: {
+        list: typeof P.listAccounts;
+        get: typeof P.getAccount;
+        create: typeof P.createAccount;
+        secretResources: {
+            list: typeof P.listAccountSecretResources;
+            create: typeof P.createAccountSecretResource;
+            rotate: typeof P.rotateAccountSecretResource;
+            retry: typeof P.retryAccountSecretResource;
+            remove: typeof P.deleteAccountSecretResource;
+            grant: typeof P.grantAccountSecretResource;
+            revoke: typeof P.revokeAccountSecretResourceGrant;
+            setAccess: typeof P.setAccountSecretResourceAccess;
+        };
+        updateName: typeof P.updateAccountName;
+        branding: {
+            get: typeof P.getAccountBranding;
+            update: typeof P.updateAccountBranding;
+            uploadAsset: typeof P.uploadAccountBrandingAsset;
+            removeAsset: typeof P.removeAccountBrandingAsset;
+            reset: typeof P.resetAccountBranding;
+        };
+        leave: typeof P.leaveAccount;
+        members: typeof P.listAccountMembers;
+        invite: typeof P.inviteAccountMember;
+        removeMember: typeof P.removeAccountMember;
+        updateMemberRole: typeof P.updateAccountMemberRole;
+        invites: typeof P.listAccountInvites;
+        cancelInvite: typeof P.cancelAccountInvite;
+        resendInvite: typeof P.resendAccountInvite;
+        tokens: {
+            list: typeof P.listAccountTokens;
+            create: typeof P.createAccountToken;
+            revoke: typeof P.revokeAccountToken;
+        };
+        connectedApps: {
+            list: typeof P.listOAuthGrants;
+            revoke: typeof P.revokeOAuthGrant;
+        };
+        audit: {
+            log: typeof P.listAccountAudit;
+            export: typeof P.exportAccountAudit;
+            webhooks: {
+                list: typeof P.listAccountAuditWebhooks;
+                create: typeof P.createAccountAuditWebhook;
+                update: typeof P.updateAccountAuditWebhook;
+                remove: typeof P.removeAccountAuditWebhook;
+            };
+        };
+    };
+    iam: {
+        assignments: {
+            list: typeof P.listAssignments;
+            create: typeof P.createAssignment;
+            revoke: typeof P.revokeAssignment;
+        };
+        permissions: {
+            list: typeof P.listPermissions;
+            forRole: typeof P.getRolePermissions;
+        };
+        roles: {
+            list: typeof P.listRoles;
+            create: typeof P.createRole;
+            update: typeof P.updateRole;
+            setPermissions: typeof P.updateRolePermissions;
+            remove: typeof P.deleteRole;
+            usage: typeof P.getRoleUsage;
+        };
+        groups: {
+            list: typeof P.listGroups;
+            get: typeof P.getGroup;
+            create: typeof P.createGroup;
+            update: typeof P.updateGroup;
+            remove: typeof P.deleteGroup;
+            members: {
+                list: typeof P.listGroupMembers;
+                add: typeof P.addGroupMembers;
+                remove: typeof P.removeGroupMember;
+            };
+        };
+        agentIdentities: typeof P.listAgentIdentities;
+        oauthClients: {
+            list: typeof P.listOAuthClients;
+            get: typeof P.getOAuthClient;
+            create: typeof P.createOAuthClient;
+            update: typeof P.updateOAuthClient;
+            rotateSecret: typeof P.rotateOAuthClientSecret;
+            remove: typeof P.deleteOAuthClient;
+        };
+        can: typeof P.probeEffectivePermission;
+        canBatch: typeof P.probeEffectivePermissions;
+    };
+    accountInvites: {
+        listMine: typeof P.listMyAccountInvites;
+        describe: typeof P.describeAccountInvite;
+        accept: typeof P.acceptAccountInvite;
+        decline: typeof P.declineAccountInvite;
+    };
+};

package/dist/core/client/facade-identity.js

@@ -0,0 +1,33 @@
+import { createBeeuniSession } from '../auth/session.js';
+import * as A from '../rest/platform-client/auth.js';
+import * as P from '../rest/projects-client/index.js';
+import { bindAccounts } from './facade-accounts.js';
+import { bindIam } from './facade-iam.js';
+export function bindIdentity() {
+    const auth = {
+        signUp: A.signUp,
+        signInWithPassword: A.signInWithPassword,
+        sendMagicLink: A.sendMagicLink,
+        verifyOtp: A.verifyOtp,
+        signInWithProvider: A.signInWithProvider,
+        exchangeCode: A.exchangeCode,
+        refresh: A.refreshSession,
+        resetPassword: A.resetPassword,
+        updatePassword: A.updatePassword,
+        updateUserMetadata: A.updateUserMetadata,
+        signInWithSso: A.signInWithSso,
+        mfa: A.authMfa,
+        user: A.authUser,
+        signOut: A.signOut,
+        session: createBeeuniSession,
+    };
+    const accounts = bindAccounts();
+    const iam = bindIam();
+    const accountInvites = {
+        listMine: P.listMyAccountInvites,
+        describe: P.describeAccountInvite,
+        accept: P.acceptAccountInvite,
+        decline: P.declineAccountInvite,
+    };
+    return { auth, accounts, iam, accountInvites };
+}

package/dist/core/client/facade-preview.d.ts

@@ -0,0 +1,3 @@
+import { type BeeuniPlatformConfig } from '../http/config.js';
+import { type ResolvedPreviewOptions } from '../session/preview-options.js';
+export declare function bindPreviewOptions(config: BeeuniPlatformConfig): (sandboxId: string) => ResolvedPreviewOptions;

package/dist/core/client/facade-preview.js

@@ -0,0 +1,30 @@
+import { ApiError } from '../http/api/errors.js';
+import { platformConfig } from '../http/config.js';
+import { resolvePreviewOptions } from '../session/preview-options.js';
+export function bindPreviewOptions(config) {
+    function parseBackendUrlForPort(apiBaseUrl) {
+        try {
+            return new URL(apiBaseUrl);
+        }
+        catch {
+            if (typeof window !== 'undefined' && window.location?.origin) {
+                try {
+                    return new URL(apiBaseUrl, window.location.origin);
+                }
+                catch {
+                    return null;
+                }
+            }
+            throw new ApiError(`Beeuni SDK: backendUrl must be an absolute URL outside the browser (got ${JSON.stringify(apiBaseUrl)}). Relative paths like "/api/beeuni" only resolve against a page origin — configure an absolute backendUrl for server-side hosts.`, { code: 'INVALID_BACKEND_URL' });
+        }
+    }
+    return function resolvePreviewOptsForSandbox(sandboxId) {
+        const apiBaseUrl = platformConfig().backendUrl ?? config.backendUrl;
+        let backendPort = 80;
+        const u = parseBackendUrlForPort(apiBaseUrl);
+        if (u) {
+            backendPort = u.port ? Number(u.port) : u.protocol === 'https:' ? 443 : 80;
+        }
+        return resolvePreviewOptions({ sandboxId, apiBaseUrl, backendPort });
+    };
+}