@8wave/ai-elements 0.114.0-beta.28 → 0.114.0-beta.43

package/dist-vue/packages/auth/src/add-member-to-organization.d.ts

@@ -1,5 +1,11 @@
 /**
  * Adds a user as member of an organization if not already present.
- * Shared by external-auth and organization-auto-join flows.
+ * Shared by external-auth and organization-auto-join flows. Only auto-join
+ * passes `respectMemberLimit`: the widget's external login must never fail
+ * because the organization is full. An automatic join does not take a seat
+ * an open invitation holds either, and a skipped one is not retried at the
+ * next sign-in: the person joins through an invitation once a seat is free.
  */
-export declare function addMemberToOrganizationIfNotExists(userId: string, organizationId: string, role?: string): Promise<boolean>;
+export declare function addMemberToOrganizationIfNotExists(userId: string, organizationId: string, role?: string, { respectMemberLimit }?: {
+    respectMemberLimit?: boolean;
+}): Promise<boolean>;

package/dist-vue/packages/auth/src/organization-member-limit.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Whether an organization already holds as many members as the limit the
+ * system panel set on it. An organization with no limit is never full.
+ * With `countPendingInvitations` an open invitation holds a seat until it is
+ * accepted or expires, so a new one cannot be sent for a seat another
+ * invitation already promised. The count runs outside the write that
+ * follows, like better-auth's own check: two joins racing for the last seat
+ * can both pass.
+ */
+export declare function isOrganizationFull(organizationId: string, { countPendingInvitations, }?: {
+    countPendingInvitations?: boolean;
+}): Promise<boolean>;

package/dist-vue/packages/auth/src/two-factor-admin-plugin.d.ts

@@ -0,0 +1,2 @@
+import { BetterAuthPlugin } from 'better-auth';
+export declare function twoFactorAdmin(): BetterAuthPlugin;

package/dist-vue/packages/auth/src/two-factor-policy-client-plugin.d.ts

@@ -1,4 +1,44 @@
+import { SignInSecurityState } from '../../models/src';
 import { BetterFetch } from 'better-auth/client';
+/**
+ * What `GET /two-factor-policy/user-security` answers to a system
+ * administrator, see docs/specs/two-factor-system-assistance.md (D3). Dates
+ * arrive as ISO strings.
+ */
+export interface UserSignInSecurity {
+    state: SignInSecurityState;
+    factor: {
+        enabled: boolean;
+        method: 'totp' | 'otp' | null;
+        backupCodesRemaining: number | null;
+        /** Wrong codes in a row since the last right one. */
+        failedAttempts: number;
+        /** Set only while the pause after too many wrong codes lasts. */
+        lockedUntil: string | null;
+    };
+    passkeys: {
+        id: string;
+        name: string | null;
+        /** `multiDevice` when synced across the user's devices. */
+        deviceType: string;
+        backedUp: boolean;
+        createdAt: string | null;
+    }[];
+    trustedDevices: {
+        count: number;
+        lastExpiresAt: string | null;
+    };
+    hasPassword: boolean;
+    requiredBy: {
+        id: string;
+        name: string;
+    }[];
+    /** The latest changes, from the notices the user received. */
+    changes: {
+        action: string;
+        createdAt: string;
+    }[];
+}
 /** What `GET /two-factor-policy/status` answers. */
 export interface TwoFactorStatus {
     enabled: boolean;
@@ -19,8 +59,9 @@ export interface TwoFactorStatus {
     passkeys: number;
 }
 /**
- * Client counterpart of the server `twoFactorPolicy()` plugin, see
- * docs/specs/two-factor-authentication.md.
+ * Client counterpart of the server `twoFactorPolicy()` and `twoFactorAdmin()`
+ * plugins, see docs/specs/two-factor-authentication.md and
+ * docs/specs/two-factor-system-assistance.md.
  */
 export declare function twoFactorPolicyClient(): {
     id: "two-factor-policy";
@@ -52,9 +93,71 @@ export declare function twoFactorPolicyClient(): {
                 };
                 error: null;
             }>;
+            userSecurity: (query: {
+                userId: string;
+            }) => Promise<{
+                data: null;
+                error: {
+                    message?: string | undefined;
+                    status: number;
+                    statusText: string;
+                };
+            } | {
+                data: UserSignInSecurity;
+                error: null;
+            }>;
+            unlock: (data: {
+                userId: string;
+            }) => Promise<{
+                data: null;
+                error: {
+                    message?: string | undefined;
+                    status: number;
+                    statusText: string;
+                };
+            } | {
+                data: {
+                    status: boolean;
+                };
+                error: null;
+            }>;
+            removePasskey: (data: {
+                userId: string;
+                passkeyId: string;
+            }) => Promise<{
+                data: null;
+                error: {
+                    message?: string | undefined;
+                    status: number;
+                    statusText: string;
+                };
+            } | {
+                data: {
+                    status: boolean;
+                };
+                error: null;
+            }>;
+            forgetTrustedDevices: (data: {
+                userId: string;
+            }) => Promise<{
+                data: null;
+                error: {
+                    message?: string | undefined;
+                    status: number;
+                    statusText: string;
+                };
+            } | {
+                data: {
+                    status: boolean;
+                };
+                error: null;
+            }>;
         };
     };
     pathMethods: {
         '/two-factor-policy/reset': "POST";
+        '/two-factor-policy/unlock': "POST";
+        '/two-factor-policy/remove-passkey': "POST";
+        '/two-factor-policy/forget-trusted-devices': "POST";
     };
 };

package/dist-vue/packages/auth/src/two-factor-policy-plugin.d.ts

@@ -1,5 +1,6 @@
 import { BetterAuthPlugin } from 'better-auth';
 import { createAuthMiddleware } from 'better-auth/api';
+import { symmetricDecrypt } from 'better-auth/crypto';
 import { TwoFactorChange } from 'email';
 /**
  * Carries the challenge for a client that cannot hold the cookie: the widget,
@@ -9,6 +10,14 @@ import { TwoFactorChange } from 'email';
 export declare const TWO_FACTOR_TOKEN_HEADER = "x-two-factor-token";
 /** Time the code sent by email stays valid, in minutes. */
 export declare const TWO_FACTOR_OTP_PERIOD_MINUTES = 5;
+export type TwoFactorRow = {
+    id: string;
+    userId: string;
+    backupCodes: string;
+    verified?: boolean | null;
+    failedVerificationCount?: number | null;
+    lockedUntil?: Date | string | null;
+};
 type ChangedUser = {
     id: string;
     email: string;
@@ -21,6 +30,37 @@ export type MiddlewareContext = Parameters<Parameters<typeof createAuthMiddlewar
  * written.
  */
 export declare function announceTwoFactorChange(user: ChangedUser, change: TwoFactorChange): Promise<void>;
+/**
+ * The verification rows that remember a device on which the user chose to
+ * skip the code: the `twoFactor` plugin names them `trust-device-<id>` and
+ * stores the user id as their value.
+ */
+export declare function trustedDeviceWhere(userId: string): ({
+    field: string;
+    value: string;
+    operator?: undefined;
+} | {
+    field: string;
+    operator: "starts_with";
+    value: string;
+})[];
+/**
+ * Forgets every device on which the user chose to skip the code. They are
+ * verification rows holding the user id: left in place, one would skip the
+ * code once the factor is on again, on a device that may be the lost one.
+ * The plugin itself forgets only the device the factor is turned off from.
+ */
+export declare function forgetTrustedDevices(adapter: MiddlewareContext['context']['adapter'], userId: string): Promise<number>;
+/**
+ * How many recovery codes the user has left, or null when it cannot be told.
+ * better-auth keeps them encrypted with its secret, so only the count leaves
+ * this function, never a code.
+ */
+export declare function countBackupCodes(ctx: {
+    context: {
+        secretConfig: Parameters<typeof symmetricDecrypt>[0]['key'];
+    };
+}, row: Pick<TwoFactorRow, 'backupCodes'>): Promise<number | null>;
 type PolicyOrganization = {
     requireTwoFactor?: boolean | null;
     deleted?: boolean | null;
@@ -54,8 +94,9 @@ export declare function isTwoFactorSetupRequiredForSession(input: {
     organizations: readonly PolicyOrganization[] | (() => Promise<readonly PolicyOrganization[]>);
 }): Promise<boolean>;
 /**
- * The status endpoint, the administrator reset, the widget bridge and the
- * announcements of docs/specs/two-factor-authentication.md.
+ * The status endpoint, the widget bridge and the announcements of
+ * docs/specs/two-factor-authentication.md. The administrator's endpoints are
+ * in two-factor-admin-plugin.ts.
  *
  * The endpoints live under `/two-factor-policy/` and not `/two-factor/` on
  * purpose: the `twoFactor` plugin rate limits its prefix to three requests

package/dist-vue/packages/models/src/schema/Document.d.ts

@@ -118,6 +118,8 @@ declare const WebDocumentSourceSchema: z.ZodObject<{
     extractionInputHash: z.ZodOptional<z.ZodString>;
     finalUrl: z.ZodOptional<z.ZodString>;
     sourceId: z.ZodOptional<z.ZodUUID>;
+    lastSyncedAt: z.ZodOptional<z.ZodString>;
+    lastmod: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 /**
  * `metadata.source`, discriminated on `provider`.
@@ -149,6 +151,8 @@ export declare const DocumentSourceSchema: z.ZodPreprocess<z.ZodDiscriminatedUni
     extractionInputHash: z.ZodOptional<z.ZodString>;
     finalUrl: z.ZodOptional<z.ZodString>;
     sourceId: z.ZodOptional<z.ZodUUID>;
+    lastSyncedAt: z.ZodOptional<z.ZodString>;
+    lastmod: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>, z.ZodObject<{
     contentHash: z.ZodOptional<z.ZodString>;
     lastRefresh: z.ZodOptional<z.ZodObject<{
@@ -424,6 +428,14 @@ export interface DocumentProcessingJob {
      * that really did get shorter, so the guard would only stand in their way.
      */
     guarded?: boolean;
+    /**
+     * The web source whose sitemap asked for this early refresh. Nobody is
+     * watching it either, so it enforces the shrink guard; and it is void if
+     * the page no longer belongs to that source, which is what editing its text
+     * by hand does. Not `guarded`, which also voids a page without a trigger:
+     * a source reads its pages whether they have one or not.
+     */
+    sourceId?: string;
 }
 /**
  * Metadata structure for document.metadata column
@@ -447,6 +459,8 @@ export declare const DocumentMetadataSchema: z.ZodObject<{
         extractionInputHash: z.ZodOptional<z.ZodString>;
         finalUrl: z.ZodOptional<z.ZodString>;
         sourceId: z.ZodOptional<z.ZodUUID>;
+        lastSyncedAt: z.ZodOptional<z.ZodString>;
+        lastmod: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>, z.ZodObject<{
         contentHash: z.ZodOptional<z.ZodString>;
         lastRefresh: z.ZodOptional<z.ZodObject<{
@@ -883,6 +897,8 @@ export declare const DocumentSchema: z.ZodObject<{
             extractionInputHash: z.ZodOptional<z.ZodString>;
             finalUrl: z.ZodOptional<z.ZodString>;
             sourceId: z.ZodOptional<z.ZodUUID>;
+            lastSyncedAt: z.ZodOptional<z.ZodString>;
+            lastmod: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>, z.ZodObject<{
             contentHash: z.ZodOptional<z.ZodString>;
             lastRefresh: z.ZodOptional<z.ZodObject<{
@@ -1426,6 +1442,7 @@ export declare const DocumentCreateDtoSchema: z.ZodObject<{
     pages: z.ZodOptional<z.ZodString>;
     priority: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
     refreshInterval: z.ZodOptional<z.ZodNullable<z.ZodEnum<typeof DocumentRefreshInterval>>>;
+    syncSourceId: z.ZodOptional<z.ZodUUID>;
 }, z.core.$strip>;
 /**
  * Document update schema for PUT /documents/:id endpoint

package/dist-vue/packages/models/src/schema/DocumentFolder.d.ts

@@ -39,6 +39,16 @@ export type DocumentFolder = z.infer<typeof DocumentFolderSchema>;
  * business, which is why it reads the first segment and stops.
  */
 export declare function documentFolderProvider(folder: Pick<DocumentFolder, 'externalId'>): DocumentSourceProvider | undefined;
+/**
+ * Whether a folder is read-only because a source that owns its documents
+ * fills it.
+ *
+ * Not the same question as `documentFolderProvider`: a web source's folder has
+ * a provider, and an icon and a badge that say so, but its pages stay editable
+ * and anything can be added to it. The backend answers the same question with
+ * `owningSourceCondition`, from the same policy.
+ */
+export declare function documentFolderIsReadOnly(folder: Pick<DocumentFolder, 'externalId'>): boolean;
 export type DocumentFolderCreateDto = z.infer<typeof DocumentFolderCreateDtoSchema>;
 export type DocumentFolderUpdateDto = z.infer<typeof DocumentFolderUpdateDtoSchema>;
 export type DocumentFolderQuerystring = z.infer<typeof DocumentFolderQuerystringSchema>;

package/dist-vue/packages/models/src/schema/DocumentSyncSource.d.ts

@@ -1,5 +1,32 @@
-import { DocumentSourceProvider } from './Document';
+import { DocumentRefreshInterval, DocumentSourceProvider } from './Document';
 import * as z from 'zod';
+/**
+ * What a provider's sources do with the documents they bring in.
+ *
+ * - `materialize`: `download` stores the remote file in a blob and makes a
+ *   `file` document of it; `url` makes a `url` document and leaves the reading
+ *   to the processor, so there is nothing to download.
+ * - `ownsDocuments`: true makes the source's folder read-only and propagates
+ *   remote deletions; false only discovers, and the documents stay as
+ *   editable as anything a person imported.
+ *
+ * These two values are everything the backend, the sync function and the
+ * interface read to decide how a document is created and whether it can be
+ * touched by hand. A web source that removes the pages leaving its sitemap does
+ * so through an option of that source, not by owning its documents.
+ */
+export interface DocumentSourcePolicy {
+    materialize: 'download' | 'url';
+    ownsDocuments: boolean;
+}
+export declare const DOCUMENT_SOURCE_POLICIES: Record<DocumentSourceProvider, DocumentSourcePolicy>;
+/**
+ * Whether a provider's sources govern their documents.
+ *
+ * An unknown provider counts as owning: the mistake in that direction makes a
+ * folder read-only, the other one lets people edit what a job will overwrite.
+ */
+export declare function sourceOwnsDocuments(provider: string): boolean;
 /**
  * How often a source is checked.
  *
@@ -96,8 +123,42 @@ export declare const DocumentSyncRunStatsSchema: z.ZodObject<{
     skippedUnsupported: z.ZodDefault<z.ZodNumber>;
     skippedTooLarge: z.ZodDefault<z.ZodNumber>;
     failed: z.ZodDefault<z.ZodNumber>;
+    capped: z.ZodDefault<z.ZodNumber>;
+    removalHeld: z.ZodDefault<z.ZodNumber>;
 }, z.core.$strip>;
 export type DocumentSyncRunStats = z.infer<typeof DocumentSyncRunStatsSchema>;
+/**
+ * Where a web source reads its pages: a sitemap, or a walk from one page.
+ *
+ * The same fields as the crawler dialog's two modes, because the source is
+ * that dialog's parameters saved.
+ */
+export declare const WebSourceRemoteSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    sitemapUrl: z.ZodURL;
+    kind: z.ZodLiteral<"sitemap">;
+}, z.core.$strip>, z.ZodObject<{
+    startUrl: z.ZodURL;
+    maxPages: z.ZodDefault<z.ZodNumber>;
+    maxDepth: z.ZodDefault<z.ZodNumber>;
+    followExternal: z.ZodDefault<z.ZodBoolean>;
+    kind: z.ZodLiteral<"depth">;
+}, z.core.$strip>], "kind">;
+export type WebSourceRemote = z.infer<typeof WebSourceRemoteSchema>;
+/**
+ * The keys of a web source's `options` that are about the source rather than
+ * about converting a page. Everything else in `options` is conversion options,
+ * handed to the processor as they are.
+ */
+export declare const WebSourceOptionsSchema: z.ZodObject<{
+    refreshInterval: z.ZodOptional<z.ZodNullable<z.ZodEnum<typeof DocumentRefreshInterval>>>;
+    removeMissing: z.ZodOptional<z.ZodBoolean>;
+    confirmedRemovals: z.ZodOptional<z.ZodNumber>;
+}, z.core.$loose>;
+export type WebSourceOptions = z.infer<typeof WebSourceOptionsSchema>;
+/** The `options` keys that never reach the processor as conversion options. */
+export declare const WEB_SOURCE_OWN_OPTION_KEYS: readonly ["refreshInterval", "removeMissing", "confirmedRemovals"];
+/** The URL a web source reads, whichever mode it is in. */
+export declare function webSourceUrl(remote: Record<string, unknown>): string;
 export declare const DocumentSyncSourceSchema: z.ZodObject<{
     id: z.ZodUUID;
     organizationId: z.ZodUUID;
@@ -123,6 +184,8 @@ export declare const DocumentSyncSourceSchema: z.ZodObject<{
         skippedUnsupported: z.ZodDefault<z.ZodNumber>;
         skippedTooLarge: z.ZodDefault<z.ZodNumber>;
         failed: z.ZodDefault<z.ZodNumber>;
+        capped: z.ZodDefault<z.ZodNumber>;
+        removalHeld: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strip>>;
     lastSyncAt: z.ZodNullable<z.ZodCoercedDate<unknown>>;
     lastError: z.ZodNullable<z.ZodString>;
@@ -149,13 +212,20 @@ export declare const DocumentSyncSourceCreateDtoSchema: z.ZodObject<{
     remote: z.ZodRecord<z.ZodString, z.ZodUnknown>;
     interval: z.ZodDefault<z.ZodEnum<typeof DocumentSyncInterval>>;
     options: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    deferFirstRun: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 export type DocumentSyncSourceCreateDto = z.infer<typeof DocumentSyncSourceCreateDtoSchema>;
 export declare const DocumentSyncSourceUpdateDtoSchema: z.ZodObject<{
     interval: z.ZodOptional<z.ZodEnum<typeof DocumentSyncInterval>>;
     enabled: z.ZodOptional<z.ZodBoolean>;
+    removeMissing: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 export type DocumentSyncSourceUpdateDto = z.infer<typeof DocumentSyncSourceUpdateDtoSchema>;
+/** "Sync now", optionally approving the removal the last run held back. */
+export declare const DocumentSyncSourceSyncDtoSchema: z.ZodObject<{
+    confirmRemovals: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type DocumentSyncSourceSyncDto = z.infer<typeof DocumentSyncSourceSyncDtoSchema>;
 export declare const DocumentSyncSourceQuerystringSchema: z.ZodObject<{
     agentId: z.ZodUUID;
 }, z.core.$strip>;

package/dist-vue/packages/models/src/schema/Lead.d.ts

@@ -9,7 +9,7 @@ export declare const LeadSchema: z.ZodObject<{
     phone: z.ZodNullable<z.ZodString>;
     agentId: z.ZodString;
     organizationId: z.ZodString;
-    chatId: z.ZodString;
+    chatId: z.ZodNullable<z.ZodString>;
     metadata: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     createdAt: z.ZodCoercedDate<unknown>;
     createdBy: z.ZodString;

package/dist-vue/packages/models/src/schema/Member.d.ts

@@ -122,6 +122,13 @@ export declare const MemberSchema: z.ZodObject<{
         twoFactorEnabled: z.ZodOptional<z.ZodBoolean>;
         hasPassword: z.ZodOptional<z.ZodBoolean>;
         hasPasskey: z.ZodOptional<z.ZodBoolean>;
+        signInSecurity: z.ZodOptional<z.ZodEnum<{
+            required: "required";
+            none: "none";
+            totp: "totp";
+            otp: "otp";
+            passkey: "passkey";
+        }>>;
     }, z.core.$strip>;
 }, z.core.$strip>;
 export type Member = z.infer<typeof MemberSchema>;

package/dist-vue/packages/models/src/schema/Notification.d.ts

@@ -8,11 +8,40 @@ export declare const NotificationType: {
     readonly TwoFactor: "two_factor";
     /** A sync took documents out because the remote no longer has them. */
     readonly DocumentSyncRemoved: "document_sync_removed";
+    /** A web source took out pages its sitemap no longer lists. */
+    readonly WebSourcePagesRemoved: "web_source_pages_removed";
+    /** A web source held back a removal too large to trust without a person. */
+    readonly WebSourceRemovalHeld: "web_source_removal_held";
     readonly ChatWarning: "chat_warning";
     readonly ChatBlocked: "chat_blocked";
     readonly Generic: "generic";
 };
 export type NotificationType = (typeof NotificationType)[keyof typeof NotificationType];
+/**
+ * Group key of the admins' notification about a flagged conversation: one row
+ * per chat and admin, bumped by every later analysis of that chat.
+ */
+export declare const chatAnalysisNotificationGroupKey: (chatId: string) => string;
+/**
+ * Title of the admins' notification about a flagged conversation. It tells a
+ * block from a warning on a stored row better than `type` does: a group bump
+ * rewrites the title, the body and the metadata, never the type, so a chat
+ * warned first and blocked later keeps `type = chat_warning`.
+ */
+export declare const chatAnalysisNotificationTitle: (blocked: boolean) => string;
+/**
+ * Body of the admins' notification about a flagged conversation
+ * (`chat_warning` or `chat_blocked`). The writer quotes the chat's title; the
+ * GDPR erasure (`eraseConversationRows`) rebuilds the body without it, from the
+ * same sentences, so the notification and its link to the chat survive with
+ * nothing the user wrote. Migration `erase_chat_residuals` holds a SQL copy
+ * of these sentences for the rows erased before it.
+ */
+export declare function chatAnalysisNotificationBody({ blocked, riskScore, chatTitle, }: {
+    blocked: boolean;
+    riskScore?: number;
+    chatTitle?: string;
+}): string;
 export declare const NotificationSchema: z.ZodObject<{
     id: z.ZodString;
     organizationId: z.ZodNullable<z.ZodString>;

package/dist-vue/packages/models/src/schema/Organization.d.ts

@@ -222,6 +222,16 @@ export declare const OrganizationRetentionPolicySchema: z.ZodObject<{
     anonymousRetentionDays: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
 }, z.core.$strip>;
 export type OrganizationRetentionPolicy = z.infer<typeof OrganizationRetentionPolicySchema>;
+/**
+ * Per-organization limits an operator sets from the system panel, persisted
+ * inside the `organization.metadata` text column. `members` counts every
+ * member, the ones the widget's external login brings in included; absent or
+ * `null` means no limit.
+ */
+export declare const OrganizationLimitsSchema: z.ZodObject<{
+    members: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+}, z.core.$strip>;
+export type OrganizationLimits = z.infer<typeof OrganizationLimitsSchema>;
 /**
  * Product features an operator can switch on or off per organization from the
  * system panel. A feature is listed here when a contract can plausibly exclude
@@ -358,6 +368,9 @@ export declare const OrganizationMetadataSchema: z.ZodObject<{
         utilityModel: z.ZodOptional<z.ZodString>;
         disabledGatewayModels: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodString>>>;
     }, z.core.$strip>>>;
+    limits: z.ZodCatch<z.ZodOptional<z.ZodObject<{
+        members: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    }, z.core.$strip>>>;
 }, z.core.$loose>;
 export type OrganizationMetadata = z.infer<typeof OrganizationMetadataSchema>;
 /**
@@ -382,6 +395,12 @@ export declare function parseOrganizationMetadata(metadata: string | Record<stri
  * malformed metadata resolves to the platform defaults instead of failing.
  */
 export declare function resolveOrganizationFeatures(metadata: string | Record<string, unknown> | null | undefined): OrganizationFeatures;
+/**
+ * The most members an organization may hold, from its raw `metadata` value,
+ * or `null` when it sets no limit. A malformed value reads as no limit, so a
+ * bad write can never lock an organization out of adding people.
+ */
+export declare function resolveOrganizationMemberLimit(metadata: string | Record<string, unknown> | null | undefined): number | null;
 export declare const OrganizationPublicSchema: z.ZodObject<{
     id: z.ZodString;
     name: z.ZodString;