@hexclave/next 1.0.3 → 1.0.6

package/src/lib/hexclave-app/apps/implementations/admin-app-impl.ts

@@ -0,0 +1,1261 @@
+
+//===========================================
+// THIS FILE IS AUTO-GENERATED FROM TEMPLATE. DO NOT EDIT IT DIRECTLY UNLESS YOU ALSO EDIT THE CORRESPONDING FILE IN packages/template
+//===========================================
+import { KnownErrors, HexclaveAdminInterface } from "@hexclave/shared";
+import { getProductionModeErrors } from "@hexclave/shared/dist/helpers/production-mode";
+import { InternalApiKeyCreateCrudResponse } from "@hexclave/shared/dist/interface/admin-interface";
+import type { MetricsResponse, MetricsUserCounts, UserActivityResponse } from "@hexclave/shared/dist/interface/admin-metrics";
+import { AnalyticsQueryOptions, AnalyticsQueryResponse } from "@hexclave/shared/dist/interface/crud/analytics";
+import { EmailTemplateCrud } from "@hexclave/shared/dist/interface/crud/email-templates";
+import { InternalApiKeysCrud } from "@hexclave/shared/dist/interface/crud/internal-api-keys";
+import { ProjectsCrud } from "@hexclave/shared/dist/interface/crud/projects";
+import type { AdminGetSessionReplayChunkEventsResponse } from "@hexclave/shared/dist/interface/crud/session-replays";
+import type { Transaction, TransactionType } from "@hexclave/shared/dist/interface/crud/transactions";
+import type { RestrictedReason } from "@hexclave/shared/dist/schema-fields";
+import type { MoneyAmount } from "@hexclave/shared/dist/utils/currency-constants";
+import { HexclaveAssertionError, throwErr } from "@hexclave/shared/dist/utils/errors";
+import type { Json } from "@hexclave/shared/dist/utils/json";
+import { pick, typedEntries, typedValues } from "@hexclave/shared/dist/utils/objects";
+import { Result } from "@hexclave/shared/dist/utils/results";
+import { useMemo } from "react"; // THIS_LINE_PLATFORM react-like
+import { AdminEmailOutbox, AdminSentEmail } from "../..";
+import { EmailConfig, hexclaveAppInternalsSymbol } from "../../common";
+import { AdminEmailTemplate } from "../../email-templates";
+import { InternalApiKey, InternalApiKeyBase, InternalApiKeyBaseCrudRead, InternalApiKeyCreateOptions, InternalApiKeyFirstView, internalApiKeyCreateOptionsToCrud } from "../../internal-api-keys";
+import { AdminProjectPermission, AdminProjectPermissionDefinition, AdminProjectPermissionDefinitionCreateOptions, AdminProjectPermissionDefinitionUpdateOptions, AdminTeamPermission, AdminTeamPermissionDefinition, AdminTeamPermissionDefinitionCreateOptions, AdminTeamPermissionDefinitionUpdateOptions, adminProjectPermissionDefinitionCreateOptionsToCrud, adminProjectPermissionDefinitionUpdateOptionsToCrud, adminTeamPermissionDefinitionCreateOptionsToCrud, adminTeamPermissionDefinitionUpdateOptionsToCrud } from "../../permissions";
+import { AdminOwnedProject, AdminProject, AdminProjectUpdateOptions, PushConfigOptions, adminProjectUpdateOptionsToCrud } from "../../projects";
+import type { AdminSessionReplay, AdminSessionReplayChunk, ListSessionReplayChunksOptions, ListSessionReplayChunksResult, ListSessionReplaysOptions, ListSessionReplaysResult, SessionReplayAllEventsResult } from "../../session-replays";
+import { ManagedEmailProviderListItem, ManagedEmailProviderSetupResult, ManagedEmailProviderStatus, EmailOutboxUpdateOptions, StackAdminApp, StackAdminAppConstructorOptions } from "../interfaces/admin-app";
+import { clientVersion, createCache, getDefaultExtraRequestHeaders, getDefaultProjectId, getDefaultPublishableClientKey, getDefaultSecretServerKey, getDefaultSuperSecretAdminKey, resolveApiUrls, resolveConstructorOptions } from "./common";
+import { _HexclaveServerAppImplIncomplete } from "./server-app-impl";
+
+import { CompleteConfig, EnvironmentConfigOverrideOverride } from "@hexclave/shared/dist/config/schema";
+import { branchConfigSourceSchema } from "@hexclave/shared/dist/schema-fields";
+import * as yup from "yup";
+import { PushedConfigSource } from "../../projects";
+import { useAsyncCache } from "./common"; // THIS_LINE_PLATFORM react-like
+
+type BranchConfigSourceApi = yup.InferType<typeof branchConfigSourceSchema>;
+/**
+ * Converts a PushedConfigSource (SDK camelCase) to BranchConfigSourceApi (API snake_case).
+ */
+function pushedConfigSourceToApi(source: PushedConfigSource): BranchConfigSourceApi {
+  if (source.type === "pushed-from-github") {
+    return {
+      type: "pushed-from-github",
+      owner: source.owner,
+      repo: source.repo,
+      branch: source.branch,
+      commit_hash: source.commitHash,
+      config_file_path: source.configFilePath,
+      workflow_path: source.workflowPath,
+    };
+  }
+  return source;
+}
+
+/**
+ * Converts a BranchConfigSourceApi (API snake_case) to PushedConfigSource (SDK camelCase).
+ */
+function apiToPushedConfigSource(source: BranchConfigSourceApi): PushedConfigSource {
+  if (source.type === "pushed-from-github") {
+    return {
+      type: "pushed-from-github",
+      owner: source.owner,
+      repo: source.repo,
+      branch: source.branch,
+      commitHash: source.commit_hash,
+      configFilePath: source.config_file_path,
+      workflowPath: source.workflow_path,
+    };
+  }
+  return source;
+}
+
+export class _HexclaveAdminAppImplIncomplete<HasTokenStore extends boolean, ProjectId extends string> extends _HexclaveServerAppImplIncomplete<HasTokenStore, ProjectId> implements StackAdminApp<HasTokenStore, ProjectId> {
+  declare protected _interface: HexclaveAdminInterface;
+
+  private readonly _adminProjectCache = createCache(async () => {
+    return await this._interface.getProject();
+  });
+  private readonly _internalApiKeysCache = createCache(async () => {
+    const res = await this._interface.listInternalApiKeys();
+    return res;
+  });
+  private readonly _adminEmailThemeCache = createCache(async ([id]: [string]) => {
+    return await this._interface.getEmailTheme(id);
+  });
+  private readonly _adminEmailThemesCache = createCache(async () => {
+    return await this._interface.listEmailThemes();
+  });
+  private readonly _adminEmailTemplatesCache = createCache(async () => {
+    return await this._interface.listInternalEmailTemplates();
+  });
+  private readonly _adminEmailDraftsCache = createCache(async () => {
+    return await this._interface.listInternalEmailDrafts();
+  });
+  private readonly _adminTeamPermissionDefinitionsCache = createCache(async () => {
+    return await this._interface.listTeamPermissionDefinitions();
+  });
+  private readonly _adminProjectPermissionDefinitionsCache = createCache(async () => {
+    return await this._interface.listProjectPermissionDefinitions();
+  });
+  private readonly _svixTokenCache = createCache(async () => {
+    return await this._interface.getSvixToken();
+  });
+  private readonly _metricsCache = createCache(async ([includeAnonymous]: [boolean]) => {
+    return await this._interface.getMetrics(includeAnonymous);
+  });
+  private readonly _userActivityCache = createCache(async ([userId]: [string]) => {
+    return await this._interface.getUserActivity(userId);
+  });
+  private readonly _metricsUserCountsCache = createCache(async () => {
+    return await this._interface.getMetricsUserCounts();
+  });
+  private readonly _emailPreviewCache = createCache(async ([themeId, themeTsxSource, templateId, templateTsxSource]: [string | null | false | undefined, string | undefined, string | undefined, string | undefined]) => {
+    return await this._interface.renderEmailPreview({ themeId, themeTsxSource, templateId, templateTsxSource });
+  });
+  private readonly _emailPreviewWithEditableMarkersCache = createCache(async ([themeId, themeTsxSource, templateId, templateTsxSource, editableSource]: [string | null | false | undefined, string | undefined, string | undefined, string | undefined, 'template' | 'theme' | 'both' | undefined]) => {
+    return await this._interface.renderEmailPreview({ themeId, themeTsxSource, templateId, templateTsxSource, editableMarkers: true, editableSource });
+  });
+  private readonly _configOverridesCache = createCache(async () => {
+    return await this._interface.getConfig();
+  });
+  private readonly _stripeAccountInfoCache = createCache(async () => {
+    try {
+      return await this._interface.getStripeAccountInfo();
+    } catch (error: any) {
+      if (error?.status === 404) {
+        return null;
+      }
+      throw error;
+    }
+  });
+  private readonly _transactionsCache = createCache(async ([cursor, limit, type, customerType, customerId]: [string | undefined, number | undefined, TransactionType | undefined, 'user' | 'team' | 'custom' | undefined, string | undefined]) => {
+    return await this._interface.listTransactions({ cursor, limit, type, customerType, customerId });
+  });
+
+  constructor(options: StackAdminAppConstructorOptions<HasTokenStore, ProjectId>, extraOptions?: { uniqueIdentifier?: string, checkString?: string, interface?: HexclaveAdminInterface }) {
+    const resolvedOptions = resolveConstructorOptions(options);
+
+    const publishableClientKey = resolvedOptions.publishableClientKey ?? getDefaultPublishableClientKey();
+
+    super(resolvedOptions, {
+      ...extraOptions,
+      interface: extraOptions?.interface ?? (() => {
+        const apiUrls = resolveApiUrls(resolvedOptions.baseUrl);
+        return new HexclaveAdminInterface({
+          getBaseUrl: () => apiUrls()[0],
+          getApiUrls: apiUrls,
+          projectId: resolvedOptions.projectId ?? getDefaultProjectId(),
+          extraRequestHeaders: resolvedOptions.extraRequestHeaders ?? getDefaultExtraRequestHeaders(),
+          clientVersion,
+          ...resolvedOptions.projectOwnerSession ? {
+            projectOwnerSession: resolvedOptions.projectOwnerSession,
+          } : {
+            ...(publishableClientKey ? { publishableClientKey } : {}),
+            secretServerKey: resolvedOptions.secretServerKey ?? getDefaultSecretServerKey(),
+            superSecretAdminKey: resolvedOptions.superSecretAdminKey ?? getDefaultSuperSecretAdminKey(),
+          },
+        });
+      })(),
+    });
+  }
+
+  _adminConfigFromCrud(data: { config_string: string }): CompleteConfig {
+    return JSON.parse(data.config_string);
+  }
+
+  _adminOwnedProjectFromCrud(data: ProjectsCrud['Admin']['Read'], onRefresh: () => Promise<void>): AdminOwnedProject {
+    if (this._tokenStoreInit !== null) {
+      throw new HexclaveAssertionError("Owned apps must always have tokenStore === null — did you not create this project with app._createOwnedApp()?");
+    }
+    return {
+      ...this._adminProjectFromCrud(data, onRefresh),
+      app: this as StackAdminApp<false>,
+    };
+  }
+
+  _adminProjectFromCrud(data: ProjectsCrud['Admin']['Read'], onRefresh: () => Promise<void>): AdminProject {
+    if (data.id !== this.projectId) {
+      throw new HexclaveAssertionError(`The project ID of the provided project JSON (${data.id}) does not match the project ID of the app (${this.projectId})!`);
+    }
+
+    const app = this;
+    return {
+      id: data.id,
+      displayName: data.display_name,
+      description: data.description,
+      createdAt: new Date(data.created_at_millis),
+      isProductionMode: data.is_production_mode,
+      isDevelopmentEnvironment: data.is_development_environment,
+      ownerTeamId: data.owner_team_id,
+      onboardingStatus: data.onboarding_status,
+      logoUrl: data.logo_url,
+      logoFullUrl: data.logo_full_url,
+      logoDarkModeUrl: data.logo_dark_mode_url,
+      logoFullDarkModeUrl: data.logo_full_dark_mode_url,
+      config: {
+        signUpEnabled: data.config.sign_up_enabled,
+        credentialEnabled: data.config.credential_enabled,
+        magicLinkEnabled: data.config.magic_link_enabled,
+        passkeyEnabled: data.config.passkey_enabled,
+        clientTeamCreationEnabled: data.config.client_team_creation_enabled,
+        clientUserDeletionEnabled: data.config.client_user_deletion_enabled,
+        allowLocalhost: data.config.allow_localhost,
+        oauthAccountMergeStrategy: data.config.oauth_account_merge_strategy,
+        allowUserApiKeys: data.config.allow_user_api_keys,
+        allowTeamApiKeys: data.config.allow_team_api_keys,
+        oauthProviders: data.config.oauth_providers.map((p) => ((p.type === 'shared' ? {
+          id: p.id,
+          type: 'shared',
+        } as const : {
+          id: p.id,
+          type: 'standard',
+          clientId: p.client_id ?? throwErr("Client ID is missing"),
+          clientSecret: p.client_secret ?? throwErr("Client secret is missing"),
+          facebookConfigId: p.facebook_config_id,
+          microsoftTenantId: p.microsoft_tenant_id,
+          appleBundleIds: p.apple_bundle_ids,
+        } as const))),
+        emailConfig: data.config.email_config.type === 'shared' ? {
+          type: 'shared'
+        } : {
+          type: 'standard',
+          host: data.config.email_config.host ?? throwErr("Email host is missing"),
+          port: data.config.email_config.port ?? throwErr("Email port is missing"),
+          username: data.config.email_config.username ?? throwErr("Email username is missing"),
+          password: data.config.email_config.password ?? throwErr("Email password is missing"),
+          senderName: data.config.email_config.sender_name ?? throwErr("Email sender name is missing"),
+          senderEmail: data.config.email_config.sender_email ?? throwErr("Email sender email is missing"),
+        },
+        emailTheme: data.config.email_theme,
+        domains: data.config.domains.map((d) => ({
+          domain: d.domain,
+          handlerPath: d.handler_path,
+        })),
+        createTeamOnSignUp: data.config.create_team_on_sign_up,
+        teamCreatorDefaultPermissions: data.config.team_creator_default_permissions,
+        teamMemberDefaultPermissions: data.config.team_member_default_permissions,
+        userDefaultPermissions: data.config.user_default_permissions,
+      },
+      async getConfig() {
+        return app._adminConfigFromCrud(await app._interface.getConfig());
+      },
+      useConfig() {
+        const config = useAsyncCache(app._configOverridesCache, [], "project.useConfig()");
+        return useMemo(() => app._adminConfigFromCrud(config), [config]);
+      },
+      async updateConfig(configOverride: EnvironmentConfigOverrideOverride) {
+        await app._interface.updateConfigOverride("environment", configOverride);
+        await app._refreshProjectConfig();
+      },
+      async pushConfig(config: EnvironmentConfigOverrideOverride, options: PushConfigOptions) {
+        await app._interface.setConfigOverride("branch", config, pushedConfigSourceToApi(options.source));
+        await app._refreshProjectConfig();
+      },
+      async updatePushedConfig(config: EnvironmentConfigOverrideOverride) {
+        await app._interface.updateConfigOverride("branch", config);
+        await app._refreshProjectConfig();
+      },
+      async getPushedConfigSource(): Promise<PushedConfigSource> {
+        const apiSource = await app._interface.getPushedConfigSource();
+        return apiToPushedConfigSource(apiSource);
+      },
+      async unlinkPushedConfigSource(): Promise<void> {
+        await app._interface.unlinkPushedConfigSource();
+        await app._refreshProjectConfig();
+      },
+      async resetConfigOverrideKeys(level: "branch" | "environment", keys: string[]): Promise<void> {
+        await app._interface.resetConfigOverrideKeys(level, keys);
+        await app._refreshProjectConfig();
+      },
+      async getConfigOverride(level: "branch" | "environment"): Promise<Record<string, unknown>> {
+        const result = await app._interface.getConfigOverride(level);
+        return JSON.parse(result.config_string);
+      },
+      async replaceConfigOverride(level: "branch" | "environment", config: Record<string, unknown>): Promise<void> {
+        if (level === "branch") {
+          const source = await app._interface.getPushedConfigSource();
+          await app._interface.setConfigOverride(level, config, source);
+        } else {
+          await app._interface.setConfigOverride(level, config);
+        }
+        await app._refreshProjectConfig();
+      },
+      async update(update: AdminProjectUpdateOptions) {
+        const { requirePublishableClientKey, ...projectUpdate } = update;
+        const updateOptions = adminProjectUpdateOptionsToCrud(projectUpdate);
+        const hasConfigUpdate = !!updateOptions.config
+          && typedValues(updateOptions.config).some((value) => value !== undefined);
+        const hasProjectUpdate = typedEntries(updateOptions).some(([key, value]) => {
+          if (key === "config") return hasConfigUpdate;
+          return value !== undefined;
+        });
+
+        if (hasProjectUpdate) {
+          await app._interface.updateProject(updateOptions);
+          await onRefresh();
+        }
+
+        if (requirePublishableClientKey !== undefined) {
+          await app._interface.updateConfigOverride("project", {
+            "project.requirePublishableClientKey": requirePublishableClientKey,
+          });
+          await app._refreshProjectConfig();
+        }
+      },
+      async delete() {
+        await app._interface.deleteProject();
+      },
+      async getProductionModeErrors() {
+        return getProductionModeErrors(data);
+      },
+      useProductionModeErrors() {
+        return getProductionModeErrors(data);
+      },
+    };
+  }
+
+  _adminEmailTemplateFromCrud(data: EmailTemplateCrud['Admin']['Read']): AdminEmailTemplate {
+    return {
+      type: data.type,
+      subject: data.subject,
+      content: data.content,
+      isDefault: data.is_default,
+    };
+  }
+
+  override async getProject(): Promise<AdminProject> {
+    return this._adminProjectFromCrud(
+      Result.orThrow(await this._adminProjectCache.getOrWait([], "write-only")),
+      () => this._refreshProject()
+    );
+  }
+
+  override useProject(): AdminProject {
+    const crud = useAsyncCache(this._adminProjectCache, [], "adminApp.useProject()");
+    return useMemo(() => this._adminProjectFromCrud(
+      crud,
+      () => this._refreshProject()
+    ), [crud]);
+  }
+
+  protected _createInternalApiKeyBaseFromCrud(data: InternalApiKeyBaseCrudRead): InternalApiKeyBase {
+    const app = this;
+    return {
+      id: data.id,
+      description: data.description,
+      expiresAt: new Date(data.expires_at_millis),
+      manuallyRevokedAt: data.manually_revoked_at_millis ? new Date(data.manually_revoked_at_millis) : null,
+      createdAt: new Date(data.created_at_millis),
+      isValid() {
+        return this.whyInvalid() === null;
+      },
+      whyInvalid() {
+        if (this.expiresAt.getTime() < Date.now()) return "expired";
+        if (this.manuallyRevokedAt) return "manually-revoked";
+        return null;
+      },
+      async revoke() {
+        const res = await app._interface.revokeInternalApiKeyById(data.id);
+        await app._refreshInternalApiKeys();
+        return res;
+      }
+    };
+  }
+
+  protected _createInternalApiKeyFromCrud(data: InternalApiKeysCrud["Admin"]["Read"]): InternalApiKey {
+    return {
+      ...this._createInternalApiKeyBaseFromCrud(data),
+      publishableClientKey: data.publishable_client_key ? { lastFour: data.publishable_client_key.last_four } : null,
+      secretServerKey: data.secret_server_key ? { lastFour: data.secret_server_key.last_four } : null,
+      superSecretAdminKey: data.super_secret_admin_key ? { lastFour: data.super_secret_admin_key.last_four } : null,
+    };
+  }
+
+  protected _createInternalApiKeyFirstViewFromCrud(data: InternalApiKeyCreateCrudResponse): InternalApiKeyFirstView {
+    return {
+      ...this._createInternalApiKeyBaseFromCrud(data),
+      publishableClientKey: data.publishable_client_key,
+      secretServerKey: data.secret_server_key,
+      superSecretAdminKey: data.super_secret_admin_key,
+    };
+  }
+
+  async listInternalApiKeys(): Promise<InternalApiKey[]> {
+    const crud = Result.orThrow(await this._internalApiKeysCache.getOrWait([], "write-only"));
+    return crud.map((j) => this._createInternalApiKeyFromCrud(j));
+  }
+
+  useInternalApiKeys(): InternalApiKey[] {
+    const crud = useAsyncCache(this._internalApiKeysCache, [], "adminApp.useInternalApiKeys()");
+    return useMemo(() => {
+      return crud.map((j) => this._createInternalApiKeyFromCrud(j));
+    }, [crud]);
+  }
+
+  async createInternalApiKey(options: InternalApiKeyCreateOptions): Promise<InternalApiKeyFirstView> {
+    const crud = await this._interface.createInternalApiKey(internalApiKeyCreateOptionsToCrud(options));
+    await this._refreshInternalApiKeys();
+    return this._createInternalApiKeyFirstViewFromCrud(crud);
+  }
+
+
+  useEmailThemes(): { id: string, displayName: string }[] {
+    const crud = useAsyncCache(this._adminEmailThemesCache, [], "adminApp.useEmailThemes()");
+    return useMemo(() => {
+      return crud.map((theme) => ({
+        id: theme.id,
+        displayName: theme.display_name,
+      }));
+    }, [crud]);
+  }
+  useEmailTemplates(): { id: string, displayName: string, themeId?: string, tsxSource: string }[] {
+    const crud = useAsyncCache(this._adminEmailTemplatesCache, [], "adminApp.useEmailTemplates()");
+    return useMemo(() => {
+      return crud.map((template) => ({
+        id: template.id,
+        displayName: template.display_name,
+        themeId: template.theme_id,
+        tsxSource: template.tsx_source,
+      }));
+    }, [crud]);
+  }
+  useEmailDrafts(): { id: string, displayName: string, themeId: string | undefined | false, tsxSource: string, sentAt: Date | null }[] {
+    const crud = useAsyncCache(this._adminEmailDraftsCache, [], "adminApp.useEmailDrafts()");
+    return useMemo(() => {
+      return crud.map((draft) => ({
+        id: draft.id,
+        displayName: draft.display_name,
+        themeId: draft.theme_id,
+        tsxSource: draft.tsx_source,
+        sentAt: draft.sent_at_millis ? new Date(draft.sent_at_millis) : null,
+      }));
+    }, [crud]);
+  }
+  async listEmailThemes(): Promise<{ id: string, displayName: string }[]> {
+    const crud = Result.orThrow(await this._adminEmailThemesCache.getOrWait([], "write-only"));
+    return crud.map((theme) => ({
+      id: theme.id,
+      displayName: theme.display_name,
+    }));
+  }
+
+  async listEmailTemplates(): Promise<{ id: string, displayName: string, themeId?: string, tsxSource: string }[]> {
+    const crud = Result.orThrow(await this._adminEmailTemplatesCache.getOrWait([], "write-only"));
+    return crud.map((template) => ({
+      id: template.id,
+      displayName: template.display_name,
+      themeId: template.theme_id,
+      tsxSource: template.tsx_source,
+    }));
+  }
+
+  async listEmailDrafts(): Promise<{ id: string, displayName: string, themeId: string | undefined | false, tsxSource: string, sentAt: Date | null }[]> {
+    const crud = Result.orThrow(await this._adminEmailDraftsCache.getOrWait([], "write-only"));
+    return crud.map((draft) => ({
+      id: draft.id,
+      displayName: draft.display_name,
+      themeId: draft.theme_id,
+      tsxSource: draft.tsx_source,
+      sentAt: draft.sent_at_millis ? new Date(draft.sent_at_millis) : null,
+    }));
+  }
+
+
+  async createTeamPermissionDefinition(data: AdminTeamPermissionDefinitionCreateOptions): Promise<AdminTeamPermission> {
+    const crud = await this._interface.createTeamPermissionDefinition(adminTeamPermissionDefinitionCreateOptionsToCrud(data));
+    await this._adminTeamPermissionDefinitionsCache.refresh([]);
+    return this._serverTeamPermissionDefinitionFromCrud(crud);
+  }
+
+  async updateTeamPermissionDefinition(permissionId: string, data: AdminTeamPermissionDefinitionUpdateOptions) {
+    await this._interface.updateTeamPermissionDefinition(permissionId, adminTeamPermissionDefinitionUpdateOptionsToCrud(data));
+    await this._adminTeamPermissionDefinitionsCache.refresh([]);
+  }
+
+  async deleteTeamPermissionDefinition(permissionId: string): Promise<void> {
+    await this._interface.deleteTeamPermissionDefinition(permissionId);
+    await this._adminTeamPermissionDefinitionsCache.refresh([]);
+  }
+
+  async listTeamPermissionDefinitions(): Promise<AdminTeamPermissionDefinition[]> {
+    const crud = Result.orThrow(await this._adminTeamPermissionDefinitionsCache.getOrWait([], "write-only"));
+    return crud.map((p) => this._serverTeamPermissionDefinitionFromCrud(p));
+  }
+
+  async listTeamPermissionDefinitionsPaginated(
+    options: { limit: number, cursor?: string, query?: string },
+  ): Promise<{ items: AdminTeamPermissionDefinition[], nextCursor: string | null }> {
+    const result = await this._interface.listTeamPermissionDefinitionsPaginated(options);
+    return {
+      items: result.items.map((p) => this._serverTeamPermissionDefinitionFromCrud(p)),
+      nextCursor: result.nextCursor,
+    };
+  }
+
+  useTeamPermissionDefinitions(): AdminTeamPermissionDefinition[] {
+    const crud = useAsyncCache(this._adminTeamPermissionDefinitionsCache, [], "adminApp.useTeamPermissionDefinitions()");
+    return useMemo(() => {
+      return crud.map((p) => this._serverTeamPermissionDefinitionFromCrud(p));
+    }, [crud]);
+  }
+
+  async createProjectPermissionDefinition(data: AdminProjectPermissionDefinitionCreateOptions): Promise<AdminProjectPermission> {
+    const crud = await this._interface.createProjectPermissionDefinition(adminProjectPermissionDefinitionCreateOptionsToCrud(data));
+    await this._adminProjectPermissionDefinitionsCache.refresh([]);
+    return this._serverProjectPermissionDefinitionFromCrud(crud);
+  }
+
+  async updateProjectPermissionDefinition(permissionId: string, data: AdminProjectPermissionDefinitionUpdateOptions) {
+    await this._interface.updateProjectPermissionDefinition(permissionId, adminProjectPermissionDefinitionUpdateOptionsToCrud(data));
+    await this._adminProjectPermissionDefinitionsCache.refresh([]);
+  }
+
+  async deleteProjectPermissionDefinition(permissionId: string): Promise<void> {
+    await this._interface.deleteProjectPermissionDefinition(permissionId);
+    await this._adminProjectPermissionDefinitionsCache.refresh([]);
+  }
+
+  async listProjectPermissionDefinitions(): Promise<AdminProjectPermissionDefinition[]> {
+    const crud = Result.orThrow(await this._adminProjectPermissionDefinitionsCache.getOrWait([], "write-only"));
+    return crud.map((p) => this._serverProjectPermissionDefinitionFromCrud(p));
+  }
+
+  useProjectPermissionDefinitions(): AdminProjectPermissionDefinition[] {
+    const crud = useAsyncCache(this._adminProjectPermissionDefinitionsCache, [], "adminApp.useProjectPermissionDefinitions()");
+    return useMemo(() => {
+      return crud.map((p) => this._serverProjectPermissionDefinitionFromCrud(p));
+    }, [crud]);
+  }
+  useSvixToken(): { token: string, url: string | undefined } {
+    const crud = useAsyncCache(this._svixTokenCache, [], "adminApp.useSvixToken()");
+    return { token: crud.token, url: crud.url };
+  }
+
+  protected override async _refreshProject() {
+    await Promise.all([
+      super._refreshProject(),
+      this._adminProjectCache.refresh([]),
+    ]);
+  }
+
+  protected async _refreshProjectConfig() {
+    await Promise.all([
+      this._configOverridesCache.refresh([]),
+      this._adminProjectCache.refresh([]),
+    ]);
+  }
+
+  protected async _refreshInternalApiKeys() {
+    await this._internalApiKeysCache.refresh([]);
+  }
+
+  protected override async _refreshUsers() {
+    await Promise.all([
+      super._refreshUsers(),
+      this._metricsCache.refresh([false]),
+      this._metricsCache.refresh([true]),
+      this._metricsUserCountsCache.refresh([]),
+    ]);
+  }
+
+  get [hexclaveAppInternalsSymbol]() {
+    return {
+      ...super[hexclaveAppInternalsSymbol],
+      useMetrics: (includeAnonymous: boolean = false): MetricsResponse => {
+        return useAsyncCache(this._metricsCache, [includeAnonymous] as const, "adminApp.useMetrics()") as MetricsResponse;
+      },
+      useUserActivity: (userId: string): UserActivityResponse => {
+        return useAsyncCache(this._userActivityCache, [userId] as const, "adminApp.useUserActivity()") as UserActivityResponse;
+      },
+      useMetricsUserCounts: (): MetricsUserCounts => {
+        return useAsyncCache(this._metricsUserCountsCache, [] as const, "adminApp.useMetricsUserCounts()") as MetricsUserCounts;
+      },
+    };
+  }
+
+  async sendTestEmail(options: {
+    recipientEmail: string,
+    emailConfig: EmailConfig,
+  }): Promise<Result<undefined, { errorMessage: string }>> {
+    let response: { success: boolean, error_message?: string };
+    try {
+      response = await this._interface.sendTestEmail({
+        recipient_email: options.recipientEmail,
+        email_config: {
+          ...(pick(options.emailConfig, ['host', 'port', 'username', 'password'])),
+          sender_email: options.emailConfig.senderEmail,
+          sender_name: options.emailConfig.senderName,
+        },
+      });
+    } catch (error) {
+      // Translate the quota-exhaustion KnownError into the existing
+      // Result.error shape so SDK/dashboard callers don't need to branch on
+      // exceptions. The backend throws `ItemQuantityInsufficientAmount`
+      // (consistent with every other limit-rejection endpoint), but this
+      // method's historical contract has always been a `Result`.
+      if (error instanceof KnownErrors.ItemQuantityInsufficientAmount) {
+        return Result.error({
+          errorMessage: "Monthly email sending limit exceeded for your plan. Please upgrade your plan or wait until next month before sending more test emails.",
+        });
+      }
+      throw error;
+    }
+
+    if (response.success) {
+      return Result.ok(undefined);
+    } else {
+      return Result.error({ errorMessage: response.error_message ?? throwErr("Email test error not specified") });
+    }
+  }
+
+  async sendTestWebhook(options: { endpointId: string }): Promise<Result<undefined, { errorMessage: string }>> {
+    const response = await this._interface.sendTestWebhook({
+      endpoint_id: options.endpointId,
+    });
+
+    if (response.success) {
+      return Result.ok(undefined);
+    } else {
+      return Result.error({ errorMessage: response.error_message ?? throwErr("Webhook test error not specified") });
+    }
+  }
+
+  async listSentEmails(): Promise<AdminSentEmail[]> {
+    const response = await this._interface.listSentEmails();
+    return response.items.map((email) => ({
+      id: email.id,
+      to: email.to ?? [],
+      subject: email.subject,
+      recipient: email.to?.[0] ?? "",
+      sentAt: new Date(email.sent_at_millis),
+      error: email.error,
+    }));
+  }
+
+  async setupManagedEmailProvider(options: { subdomain: string, senderLocalPart: string }): Promise<ManagedEmailProviderSetupResult> {
+    const response = await this._interface.setupManagedEmailProvider({
+      subdomain: options.subdomain,
+      sender_local_part: options.senderLocalPart,
+    });
+    return {
+      domainId: response.domain_id,
+      subdomain: response.subdomain,
+      senderLocalPart: response.sender_local_part,
+      nameServerRecords: response.name_server_records,
+      status: response.status,
+    };
+  }
+
+  async checkManagedEmailStatus(options: { domainId: string, subdomain: string, senderLocalPart: string }): Promise<ManagedEmailProviderStatus> {
+    const response = await this._interface.checkManagedEmailStatus({
+      domain_id: options.domainId,
+      subdomain: options.subdomain,
+      sender_local_part: options.senderLocalPart,
+    });
+    return {
+      status: response.status,
+    };
+  }
+
+  async listManagedEmailDomains(): Promise<ManagedEmailProviderListItem[]> {
+    const response = await this._interface.listManagedEmailDomains();
+    return response.items.map((item) => ({
+      domainId: item.domain_id,
+      subdomain: item.subdomain,
+      senderLocalPart: item.sender_local_part,
+      status: item.status,
+      nameServerRecords: item.name_server_records,
+    }));
+  }
+
+  async applyManagedEmailProvider(options: { domainId: string }): Promise<{ status: "applied" }> {
+    const result = await this._interface.applyManagedEmailProvider({
+      domain_id: options.domainId,
+    });
+    await this._refreshProjectConfig();
+    return result;
+  }
+
+  async deleteManagedEmailDomain(options: { resendDomainId: string }): Promise<{ status: "deleted" }> {
+    return await this._interface.deleteManagedEmailDomain({
+      resend_domain_id: options.resendDomainId,
+    });
+  }
+
+  async sendSignInInvitationEmail(email: string, callbackUrl: string): Promise<void> {
+    await this._interface.sendSignInInvitationEmail(email, callbackUrl);
+  }
+
+  async createEmailTemplate(displayName: string): Promise<{ id: string }> {
+    const result = await this._interface.createEmailTemplate(displayName);
+    await this._adminEmailTemplatesCache.refresh([]);
+
+    return result;
+  }
+
+  async deleteEmailTemplate(id: string): Promise<void> {
+    await this._interface.deleteEmailTemplate(id);
+    await this._adminEmailTemplatesCache.refresh([]);
+  }
+
+  async createEmailDraft(options: { displayName: string, themeId?: string | false, tsxSource?: string }): Promise<{ id: string }> {
+    const result = await this._interface.createEmailDraft({
+      display_name: options.displayName,
+      theme_id: options.themeId,
+      tsx_source: options.tsxSource,
+    });
+    await this._adminEmailDraftsCache.refresh([]);
+    return result;
+  }
+
+  async updateEmailDraft(id: string, data: { displayName?: string, themeId?: string | undefined | false, tsxSource?: string }): Promise<void> {
+    await this._interface.updateEmailDraft(id, {
+      display_name: data.displayName,
+      theme_id: data.themeId,
+      tsx_source: data.tsxSource,
+    });
+    await this._adminEmailDraftsCache.refresh([]);
+  }
+
+  async deleteEmailDraft(id: string): Promise<void> {
+    await this._interface.deleteEmailDraft(id);
+    const current = this._adminEmailDraftsCache.getIfCached([]);
+    if (current.status === "ok" && current.data.status === "ok") {
+      this._adminEmailDraftsCache.forceSetCachedValue([], Result.ok(current.data.data.filter((d) => d.id !== id)));
+    }
+    await this._adminEmailDraftsCache.refresh([]);
+  }
+
+  async refreshEmailDrafts(): Promise<void> {
+    await this._adminEmailDraftsCache.refresh([]);
+  }
+
+  async saveChatMessage(threadId: string, message: any): Promise<void> {
+    await this._interface.saveChatMessage(threadId, message);
+  }
+
+  async listChatMessages(threadId: string): Promise<{ messages: Array<any> }> {
+    return await this._interface.listChatMessages(threadId);
+  }
+
+  async rewriteTemplateSourceWithAI(templateTsxSource: string): Promise<{ tsxSource: string }> {
+    const result = await this._interface.rewriteTemplateSourceWithAI(templateTsxSource);
+    return { tsxSource: result.tsx_source };
+  }
+
+  async createEmailTheme(displayName: string): Promise<{ id: string }> {
+    const result = await this._interface.createEmailTheme(displayName);
+    await this._adminEmailThemesCache.refresh([]);
+    return result;
+  }
+
+  async getEmailPreview(options: { themeId?: string | null | false, themeTsxSource?: string, templateId?: string, templateTsxSource?: string }): Promise<string> {
+    return (await this._interface.renderEmailPreview(options)).html;
+  }
+  useEmailPreview(options: { themeId?: string | null | false, themeTsxSource?: string, templateId?: string, templateTsxSource?: string }): string {
+    const crud = useAsyncCache(this._emailPreviewCache, [options.themeId, options.themeTsxSource, options.templateId, options.templateTsxSource] as const, "adminApp.useEmailPreview()");
+    return crud.html;
+  }
+  async getEmailPreviewWithEditableMarkers(options: { themeId?: string | null | false, themeTsxSource?: string, templateId?: string, templateTsxSource?: string, editableSource?: 'template' | 'theme' | 'both' }): Promise<{ html: string, editableRegions?: Record<string, unknown> }> {
+    const result = await this._interface.renderEmailPreview({ ...options, editableMarkers: true, editableSource: options.editableSource });
+    return { html: result.html, editableRegions: result.editable_regions };
+  }
+  useEmailPreviewWithEditableMarkers(options: { themeId?: string | null | false, themeTsxSource?: string, templateId?: string, templateTsxSource?: string, editableSource?: 'template' | 'theme' | 'both' }): { html: string, editableRegions?: Record<string, unknown> } {
+    const crud = useAsyncCache(this._emailPreviewWithEditableMarkersCache, [options.themeId, options.themeTsxSource, options.templateId, options.templateTsxSource, options.editableSource] as const, "adminApp.useEmailPreviewWithEditableMarkers()");
+    return { html: crud.html, editableRegions: crud.editable_regions };
+  }
+  useEmailTheme(id: string): { displayName: string, tsxSource: string } {
+    const crud = useAsyncCache(this._adminEmailThemeCache, [id] as const, "adminApp.useEmailTheme()");
+    return {
+      displayName: crud.display_name,
+      tsxSource: crud.tsx_source,
+    };
+  }
+  async updateEmailTheme(id: string, tsxSource: string): Promise<void> {
+    await this._interface.updateEmailTheme(id, tsxSource);
+    await this._adminEmailThemesCache.refresh([]);
+    await this._adminEmailThemeCache.invalidate([id]);
+  }
+
+  async deleteEmailTheme(id: string): Promise<void> {
+    await this._interface.deleteEmailTheme(id);
+    await this._adminEmailThemesCache.refresh([]);
+    await this._adminEmailThemeCache.invalidate([id]);
+  }
+
+  async updateEmailTemplate(id: string, tsxSource: string, themeId: string | null | false): Promise<{ renderedHtml: string }> {
+    const result = await this._interface.updateEmailTemplate(id, tsxSource, themeId);
+    await this._adminEmailTemplatesCache.refresh([]);
+    return { renderedHtml: result.rendered_html };
+  }
+
+  async setupPayments(): Promise<{ url: string }> {
+    const result = await this._interface.setupPayments();
+    await this._stripeAccountInfoCache.refresh([]);
+    return result;
+  }
+
+  async createStripeWidgetAccountSession(): Promise<{ client_secret: string }> {
+    return await this._interface.createStripeWidgetAccountSession();
+  }
+
+  async getPaymentMethodConfigs(): Promise<{ configId: string, methods: Array<{ id: string, name: string, enabled: boolean, available: boolean, overridable: boolean }> } | null> {
+    return await this._interface.getPaymentMethodConfigs();
+  }
+
+  async updatePaymentMethodConfigs(configId: string, updates: Record<string, 'on' | 'off'>): Promise<void> {
+    await this._interface.updatePaymentMethodConfigs(configId, updates);
+  }
+
+  async createItemQuantityChange(options: (
+    { userId: string, itemId: string, quantity: number, expiresAt?: string, description?: string } |
+    { teamId: string, itemId: string, quantity: number, expiresAt?: string, description?: string } |
+    { customCustomerId: string, itemId: string, quantity: number, expiresAt?: string, description?: string }
+  )): Promise<void> {
+    await this._interface.updateItemQuantity(
+      { itemId: options.itemId, ...("userId" in options ? { userId: options.userId } : ("teamId" in options ? { teamId: options.teamId } : { customCustomerId: options.customCustomerId })) },
+      {
+        delta: options.quantity,
+        expires_at: options.expiresAt,
+        description: options.description,
+        allow_negative: true,
+      }
+    );
+  }
+
+  async refundTransaction(options: {
+    type: "subscription" | "one-time-purchase",
+    id: string,
+    invoiceId?: string,
+    amountUsd: MoneyAmount,
+    endAction?: "now" | "at-period-end",
+  }): Promise<{ refundTransactionId: string }> {
+    const result = await this._interface.refundTransaction({
+      type: options.type,
+      id: options.id,
+      invoiceId: options.invoiceId,
+      amountUsd: options.amountUsd,
+      endAction: options.endAction,
+    });
+    await this._transactionsCache.invalidateWhere(() => true);
+    return { refundTransactionId: result.refundTransactionId };
+  }
+
+  async listTransactions(params: { cursor?: string, limit?: number, type?: TransactionType, customerType?: 'user' | 'team' | 'custom', customerId?: string }): Promise<{ transactions: Transaction[], nextCursor: string | null }> {
+    const crud = Result.orThrow(await this._transactionsCache.getOrWait([params.cursor, params.limit, params.type, params.customerType, params.customerId] as const, "write-only"));
+    return crud;
+  }
+
+  // Email Outbox methods
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Complex discriminated union conversion from API response
+  private _emailOutboxCrudToAdmin(crud: any): AdminEmailOutbox {
+    const recipient = crud.to;
+    let to: AdminEmailOutbox["to"];
+    if (recipient.type === "user-primary-email") {
+      to = { type: "user-primary-email", userId: recipient.user_id };
+    } else if (recipient.type === "user-custom-emails") {
+      to = { type: "user-custom-emails", userId: recipient.user_id, emails: recipient.emails };
+    } else {
+      to = { type: "custom-emails", emails: recipient.emails };
+    }
+
+    // Base fields present on all emails
+    const base = {
+      id: crud.id as string,
+      createdAt: new Date(crud.created_at_millis),
+      updatedAt: new Date(crud.updated_at_millis),
+      tsxSource: crud.tsx_source as string,
+      themeId: (crud.theme_id as string | null) ?? null,
+      to,
+      scheduledAt: new Date(crud.scheduled_at_millis),
+      // Source tracking for grouping emails by template/draft
+      createdWith: crud.created_with as "draft" | "programmatic-call",
+      emailDraftId: crud.email_draft_id as string | null,
+      emailProgrammaticCallTemplateId: crud.email_programmatic_call_template_id as string | null,
+      variables: (crud.variables ?? {}) as Record<string, Json>,
+      isPaused: false as const,
+      hasRendered: false as const,
+      hasDelivered: false as const,
+      // Retry tracking fields
+      sendRetries: crud.send_retries as number,
+      nextSendRetryAt: crud.next_send_retry_at_millis ? new Date(crud.next_send_retry_at_millis) : null,
+      sendAttemptErrors: crud.send_attempt_errors ? (crud.send_attempt_errors as Array<{
+        attempt_number: number,
+        timestamp: string,
+        external_message: string,
+        external_details: Record<string, unknown>,
+        internal_message: string,
+        internal_details: Record<string, unknown>,
+      }>).map((e) => ({
+        attemptNumber: e.attempt_number,
+        timestamp: e.timestamp,
+        externalMessage: e.external_message,
+        externalDetails: e.external_details,
+        internalMessage: e.internal_message,
+        internalDetails: e.internal_details,
+      })) : null,
+    };
+
+    // Rendered fields (available after rendering completes successfully)
+    const rendered = crud.has_rendered ? {
+      ...base,
+      startedRenderingAt: new Date(crud.started_rendering_at_millis),
+      renderedAt: new Date(crud.rendered_at_millis),
+      subject: crud.subject as string,
+      html: crud.html as string | null,
+      text: crud.text as string | null,
+      isTransactional: crud.is_transactional as boolean,
+      isHighPriority: crud.is_high_priority as boolean,
+      notificationCategoryId: crud.notification_category_id as string | null,
+      hasRendered: true as const,
+    } : null;
+
+    // Started sending fields
+    const startedSending = rendered && crud.started_sending_at_millis ? {
+      ...rendered,
+      startedSendingAt: new Date(crud.started_sending_at_millis),
+    } : null;
+
+    // Finished delivering fields
+    const finishedDelivering = startedSending && crud.has_delivered ? {
+      ...startedSending,
+      deliveredAt: new Date(crud.delivered_at_millis),
+      hasDelivered: true as const,
+    } : null;
+
+    // Use type assertion at the end because TypeScript has trouble with
+    // spread + override patterns on discriminated unions with const literal types
+    const result = (() => {
+      switch (crud.status) {
+        case "paused": {
+          return {
+            ...base,
+            status: "paused" as const,
+            simpleStatus: "in-progress" as const,
+            isPaused: true as const,
+          };
+        }
+        case "preparing": {
+          return {
+            ...base,
+            status: "preparing" as const,
+            simpleStatus: "in-progress" as const,
+          };
+        }
+        case "rendering": {
+          return {
+            ...base,
+            status: "rendering" as const,
+            simpleStatus: "in-progress" as const,
+            startedRenderingAt: new Date(crud.started_rendering_at_millis),
+          };
+        }
+        case "render-error": {
+          return {
+            ...base,
+            status: "render-error" as const,
+            simpleStatus: "error" as const,
+            startedRenderingAt: new Date(crud.started_rendering_at_millis),
+            renderedAt: new Date(crud.rendered_at_millis),
+            renderError: crud.render_error,
+          };
+        }
+        case "scheduled": {
+          return {
+            ...rendered!,
+            status: "scheduled" as const,
+            simpleStatus: "in-progress" as const,
+          };
+        }
+        case "queued": {
+          return {
+            ...rendered!,
+            status: "queued" as const,
+            simpleStatus: "in-progress" as const,
+          };
+        }
+        case "sending": {
+          return {
+            ...startedSending!,
+            status: "sending" as const,
+            simpleStatus: "in-progress" as const,
+          };
+        }
+        case "server-error": {
+          return {
+            ...startedSending!,
+            status: "server-error" as const,
+            simpleStatus: "error" as const,
+            errorAt: new Date(crud.error_at_millis),
+            serverError: crud.server_error,
+          };
+        }
+        case "skipped": {
+          return {
+            ...base,
+            status: "skipped" as const,
+            simpleStatus: "ok" as const,
+            skippedAt: new Date(crud.skipped_at_millis),
+            skippedReason: crud.skipped_reason,
+            skippedDetails: crud.skipped_details ?? {},
+            hasRendered: crud.has_rendered as boolean,
+            // Optional fields
+            startedRenderingAt: crud.started_rendering_at_millis ? new Date(crud.started_rendering_at_millis) : undefined,
+            renderedAt: crud.rendered_at_millis ? new Date(crud.rendered_at_millis) : undefined,
+            subject: crud.subject,
+            html: crud.html,
+            text: crud.text,
+            isTransactional: crud.is_transactional,
+            isHighPriority: crud.is_high_priority,
+            notificationCategoryId: crud.notification_category_id,
+            startedSendingAt: crud.started_sending_at_millis ? new Date(crud.started_sending_at_millis) : undefined,
+          };
+        }
+        case "bounced": {
+          return {
+            ...startedSending!,
+            status: "bounced" as const,
+            simpleStatus: "error" as const,
+            bouncedAt: new Date(crud.bounced_at_millis),
+          };
+        }
+        case "delivery-delayed": {
+          return {
+            ...startedSending!,
+            status: "delivery-delayed" as const,
+            simpleStatus: "ok" as const,
+            deliveryDelayedAt: new Date(crud.delivery_delayed_at_millis),
+          };
+        }
+        case "sent": {
+          return {
+            ...finishedDelivering!,
+            status: "sent" as const,
+            simpleStatus: "ok" as const,
+            canHaveDeliveryInfo: crud.can_have_delivery_info,
+          };
+        }
+        case "opened": {
+          return {
+            ...finishedDelivering!,
+            status: "opened" as const,
+            simpleStatus: "ok" as const,
+            openedAt: new Date(crud.opened_at_millis),
+            canHaveDeliveryInfo: true as const,
+          };
+        }
+        case "clicked": {
+          return {
+            ...finishedDelivering!,
+            status: "clicked" as const,
+            simpleStatus: "ok" as const,
+            clickedAt: new Date(crud.clicked_at_millis),
+            canHaveDeliveryInfo: true as const,
+          };
+        }
+        case "marked-as-spam": {
+          return {
+            ...finishedDelivering!,
+            status: "marked-as-spam" as const,
+            simpleStatus: "ok" as const,
+            markedAsSpamAt: new Date(crud.marked_as_spam_at_millis),
+            canHaveDeliveryInfo: true as const,
+          };
+        }
+        default: {
+          throw new HexclaveAssertionError(`Unknown email outbox status: ${crud.status}`, { status: crud.status });
+        }
+      }
+    })();
+    // The type system has difficulty with spread + override patterns on discriminated unions,
+    // so we use a type assertion here. The switch statement above ensures we return the correct shape.
+    return result as AdminEmailOutbox;
+  }
+
+  async listOutboxEmails(options?: { status?: string, simpleStatus?: string, limit?: number, cursor?: string }): Promise<{ items: AdminEmailOutbox[], nextCursor: string | null }> {
+    const response = await this._interface.listOutboxEmails({
+      status: options?.status,
+      simple_status: options?.simpleStatus,
+      limit: options?.limit,
+      cursor: options?.cursor,
+    });
+    return {
+      items: response.items.map((item) => this._emailOutboxCrudToAdmin(item)),
+      nextCursor: response.pagination?.next_cursor ?? null,
+    };
+  }
+
+  async getOutboxEmail(id: string): Promise<AdminEmailOutbox> {
+    const response = await this._interface.getOutboxEmail(id);
+    return this._emailOutboxCrudToAdmin(response);
+  }
+
+  async updateOutboxEmail(id: string, options: EmailOutboxUpdateOptions): Promise<AdminEmailOutbox> {
+    const response = await this._interface.updateOutboxEmail(id, {
+      is_paused: options.isPaused,
+      scheduled_at_millis: options.scheduledAtMillis,
+      cancel: options.cancel,
+      tsx_source: options.tsxSource,
+      theme_id: options.themeId,
+    });
+    return this._emailOutboxCrudToAdmin(response);
+  }
+
+  async pauseOutboxEmail(id: string): Promise<AdminEmailOutbox> {
+    return await this.updateOutboxEmail(id, { isPaused: true });
+  }
+
+  async unpauseOutboxEmail(id: string): Promise<AdminEmailOutbox> {
+    return await this.updateOutboxEmail(id, { isPaused: false });
+  }
+
+  async cancelOutboxEmail(id: string): Promise<AdminEmailOutbox> {
+    return await this.updateOutboxEmail(id, { cancel: true });
+  }
+
+  useTransactions(params: { cursor?: string, limit?: number, type?: TransactionType, customerType?: 'user' | 'team' | 'custom', customerId?: string }): { transactions: Transaction[], nextCursor: string | null } {
+    const data = useAsyncCache(this._transactionsCache, [params.cursor, params.limit, params.type, params.customerType, params.customerId] as const, "adminApp.useTransactions()");
+    return data;
+  }
+
+  async getStripeAccountInfo(): Promise<null | { account_id: string, charges_enabled: boolean, details_submitted: boolean, payouts_enabled: boolean }> {
+    return await this._interface.getStripeAccountInfo();
+  }
+
+  useStripeAccountInfo(): { account_id: string, charges_enabled: boolean, details_submitted: boolean, payouts_enabled: boolean } | null {
+    const data = useAsyncCache(this._stripeAccountInfoCache, [], "adminApp.useStripeAccountInfo()");
+    return data;
+  }
+
+  async queryAnalytics(options: AnalyticsQueryOptions): Promise<AnalyticsQueryResponse> {
+    return await this._interface.queryAnalytics(options);
+  }
+
+  async listSessionReplays(options?: ListSessionReplaysOptions): Promise<ListSessionReplaysResult> {
+    const response = await this._interface.listSessionReplays({
+      cursor: options?.cursor,
+      limit: options?.limit,
+      user_ids: options?.userIds,
+      team_ids: options?.teamIds,
+      duration_ms_min: options?.durationMsMin,
+      duration_ms_max: options?.durationMsMax,
+      last_event_at_from_millis: options?.lastEventAtFromMillis,
+      last_event_at_to_millis: options?.lastEventAtToMillis,
+      click_count_min: options?.clickCountMin,
+    });
+
+    const items: AdminSessionReplay[] = response.items.map((r) => ({
+      id: r.id,
+      projectUser: {
+        id: r.project_user.id,
+        displayName: r.project_user.display_name,
+        primaryEmail: r.project_user.primary_email,
+      },
+      startedAt: new Date(r.started_at_millis),
+      lastEventAt: new Date(r.last_event_at_millis),
+      chunkCount: r.chunk_count,
+      eventCount: r.event_count,
+    }));
+
+    return {
+      items,
+      nextCursor: response.pagination.next_cursor,
+    };
+  }
+
+  async getSessionReplay(sessionReplayId: string): Promise<AdminSessionReplay> {
+    const response = await this._interface.getSessionReplay(sessionReplayId);
+    return {
+      id: response.id,
+      projectUser: {
+        id: response.project_user.id,
+        displayName: response.project_user.display_name,
+        primaryEmail: response.project_user.primary_email,
+      },
+      startedAt: new Date(response.started_at_millis),
+      lastEventAt: new Date(response.last_event_at_millis),
+      chunkCount: response.chunk_count,
+      eventCount: response.event_count,
+    };
+  }
+
+  async listSessionReplayChunks(sessionReplayId: string, options?: ListSessionReplayChunksOptions): Promise<ListSessionReplayChunksResult> {
+    const response = await this._interface.listSessionReplayChunks(sessionReplayId, {
+      cursor: options?.cursor,
+      limit: options?.limit,
+    });
+
+    const items: AdminSessionReplayChunk[] = response.items.map((c) => ({
+      id: c.id,
+      batchId: c.batch_id,
+      sessionReplaySegmentId: c.session_replay_segment_id,
+      browserSessionId: c.browser_session_id,
+      eventCount: c.event_count,
+      byteLength: c.byte_length,
+      firstEventAt: new Date(c.first_event_at_millis),
+      lastEventAt: new Date(c.last_event_at_millis),
+      createdAt: new Date(c.created_at_millis),
+    }));
+
+    return {
+      items,
+      nextCursor: response.pagination.next_cursor,
+    };
+  }
+
+  async getSessionReplayChunkEvents(sessionReplayId: string, chunkId: string): Promise<AdminGetSessionReplayChunkEventsResponse> {
+    return await this._interface.getSessionReplayChunkEvents(sessionReplayId, chunkId);
+  }
+
+  async getSessionReplayEvents(sessionReplayId: string, options?: { offset?: number, limit?: number }): Promise<SessionReplayAllEventsResult> {
+    const response = await this._interface.getSessionReplayEvents(sessionReplayId, options);
+    return {
+      chunks: response.chunks.map((c) => ({
+        id: c.id,
+        batchId: c.batch_id,
+        sessionReplaySegmentId: c.session_replay_segment_id,
+        eventCount: c.event_count,
+        byteLength: c.byte_length,
+        firstEventAt: new Date(c.first_event_at_millis),
+        lastEventAt: new Date(c.last_event_at_millis),
+        createdAt: new Date(c.created_at_millis),
+      })),
+      chunkEvents: response.chunk_events.map((ce) => ({
+        chunkId: ce.chunk_id,
+        events: ce.events,
+      })),
+    };
+  }
+
+  async previewAffectedUsersByOnboardingChange(
+    onboarding: { requireEmailVerification?: boolean },
+    limit?: number,
+  ): Promise<{
+    affectedUsers: Array<{
+      id: string,
+      displayName: string | null,
+      primaryEmail: string | null,
+      restrictedReason: RestrictedReason,
+    }>,
+    totalAffectedCount: number,
+  }> {
+    const result = await this._interface.previewAffectedUsersByOnboardingChange(
+      { require_email_verification: onboarding.requireEmailVerification },
+      limit,
+    );
+    return {
+      affectedUsers: result.affected_users.map(u => ({
+        id: u.id,
+        displayName: u.display_name,
+        primaryEmail: u.primary_email,
+        restrictedReason: u.restricted_reason as RestrictedReason,
+      })),
+      totalAffectedCount: result.total_affected_count,
+    };
+  }
+}