@hexclave/next 1.0.0

package/dist/esm/lib/stack-app/apps/implementations/admin-app-impl.js

@@ -0,0 +1,1044 @@
+import { HexclaveAssertionError, throwErr } from "@hexclave/shared/dist/utils/errors";
+import { useMemo } from "react";
+import { HexclaveAdminInterface, KnownErrors } from "@hexclave/shared";
+import { pick, typedEntries, typedValues } from "@hexclave/shared/dist/utils/objects";
+import { Result } from "@hexclave/shared/dist/utils/results";
+import { clientVersion, createCache, getDefaultExtraRequestHeaders, getDefaultProjectId, getDefaultPublishableClientKey, getDefaultSecretServerKey, getDefaultSuperSecretAdminKey, resolveApiUrls, resolveConstructorOptions, useAsyncCache } from "./common.js";
+import { getProductionModeErrors } from "@hexclave/shared/dist/helpers/production-mode";
+import { stackAppInternalsSymbol } from "../../common.js";
+import { internalApiKeyCreateOptionsToCrud } from "../../internal-api-keys/index.js";
+import { adminProjectPermissionDefinitionCreateOptionsToCrud, adminProjectPermissionDefinitionUpdateOptionsToCrud, adminTeamPermissionDefinitionCreateOptionsToCrud, adminTeamPermissionDefinitionUpdateOptionsToCrud } from "../../permissions/index.js";
+import { adminProjectUpdateOptionsToCrud } from "../../projects/index.js";
+import { _StackServerAppImplIncomplete } from "./server-app-impl.js";
+
+//#region src/lib/stack-app/apps/implementations/admin-app-impl.ts
+/**
+* Converts a PushedConfigSource (SDK camelCase) to BranchConfigSourceApi (API snake_case).
+*/
+function pushedConfigSourceToApi(source) {
+	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) {
+	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;
+}
+var _StackAdminAppImplIncomplete = class extends _StackServerAppImplIncomplete {
+	constructor(options, extraOptions) {
+		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()
+					}
+				});
+			})()
+		});
+		this._adminProjectCache = createCache(async () => {
+			return await this._interface.getProject();
+		});
+		this._internalApiKeysCache = createCache(async () => {
+			return await this._interface.listInternalApiKeys();
+		});
+		this._adminEmailThemeCache = createCache(async ([id]) => {
+			return await this._interface.getEmailTheme(id);
+		});
+		this._adminEmailThemesCache = createCache(async () => {
+			return await this._interface.listEmailThemes();
+		});
+		this._adminEmailTemplatesCache = createCache(async () => {
+			return await this._interface.listInternalEmailTemplates();
+		});
+		this._adminEmailDraftsCache = createCache(async () => {
+			return await this._interface.listInternalEmailDrafts();
+		});
+		this._adminTeamPermissionDefinitionsCache = createCache(async () => {
+			return await this._interface.listTeamPermissionDefinitions();
+		});
+		this._adminProjectPermissionDefinitionsCache = createCache(async () => {
+			return await this._interface.listProjectPermissionDefinitions();
+		});
+		this._svixTokenCache = createCache(async () => {
+			return await this._interface.getSvixToken();
+		});
+		this._metricsCache = createCache(async ([includeAnonymous]) => {
+			return await this._interface.getMetrics(includeAnonymous);
+		});
+		this._userActivityCache = createCache(async ([userId]) => {
+			return await this._interface.getUserActivity(userId);
+		});
+		this._metricsUserCountsCache = createCache(async () => {
+			return await this._interface.getMetricsUserCounts();
+		});
+		this._emailPreviewCache = createCache(async ([themeId, themeTsxSource, templateId, templateTsxSource]) => {
+			return await this._interface.renderEmailPreview({
+				themeId,
+				themeTsxSource,
+				templateId,
+				templateTsxSource
+			});
+		});
+		this._emailPreviewWithEditableMarkersCache = createCache(async ([themeId, themeTsxSource, templateId, templateTsxSource, editableSource]) => {
+			return await this._interface.renderEmailPreview({
+				themeId,
+				themeTsxSource,
+				templateId,
+				templateTsxSource,
+				editableMarkers: true,
+				editableSource
+			});
+		});
+		this._configOverridesCache = createCache(async () => {
+			return await this._interface.getConfig();
+		});
+		this._stripeAccountInfoCache = createCache(async () => {
+			try {
+				return await this._interface.getStripeAccountInfo();
+			} catch (error) {
+				if (error?.status === 404) return null;
+				throw error;
+			}
+		});
+		this._transactionsCache = createCache(async ([cursor, limit, type, customerType, customerId]) => {
+			return await this._interface.listTransactions({
+				cursor,
+				limit,
+				type,
+				customerType,
+				customerId
+			});
+		});
+	}
+	_adminConfigFromCrud(data) {
+		return JSON.parse(data.config_string);
+	}
+	_adminOwnedProjectFromCrud(data, onRefresh) {
+		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
+		};
+	}
+	_adminProjectFromCrud(data, onRefresh) {
+		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"
+				} : {
+					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
+				}),
+				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) {
+				await app._interface.updateConfigOverride("environment", configOverride);
+				await app._refreshProjectConfig();
+			},
+			async pushConfig(config, options) {
+				await app._interface.setConfigOverride("branch", config, pushedConfigSourceToApi(options.source));
+				await app._refreshProjectConfig();
+			},
+			async updatePushedConfig(config) {
+				await app._interface.updateConfigOverride("branch", config);
+				await app._refreshProjectConfig();
+			},
+			async getPushedConfigSource() {
+				return apiToPushedConfigSource(await app._interface.getPushedConfigSource());
+			},
+			async unlinkPushedConfigSource() {
+				await app._interface.unlinkPushedConfigSource();
+				await app._refreshProjectConfig();
+			},
+			async resetConfigOverrideKeys(level, keys) {
+				await app._interface.resetConfigOverrideKeys(level, keys);
+				await app._refreshProjectConfig();
+			},
+			async getConfigOverride(level) {
+				const result = await app._interface.getConfigOverride(level);
+				return JSON.parse(result.config_string);
+			},
+			async replaceConfigOverride(level, config) {
+				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) {
+				const { requirePublishableClientKey, ...projectUpdate } = update;
+				const updateOptions = adminProjectUpdateOptionsToCrud(projectUpdate);
+				const hasConfigUpdate = !!updateOptions.config && typedValues(updateOptions.config).some((value) => value !== void 0);
+				if (typedEntries(updateOptions).some(([key, value]) => {
+					if (key === "config") return hasConfigUpdate;
+					return value !== void 0;
+				})) {
+					await app._interface.updateProject(updateOptions);
+					await onRefresh();
+				}
+				if (requirePublishableClientKey !== void 0) {
+					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) {
+		return {
+			type: data.type,
+			subject: data.subject,
+			content: data.content,
+			isDefault: data.is_default
+		};
+	}
+	async getProject() {
+		return this._adminProjectFromCrud(Result.orThrow(await this._adminProjectCache.getOrWait([], "write-only")), () => this._refreshProject());
+	}
+	useProject() {
+		const crud = useAsyncCache(this._adminProjectCache, [], "adminApp.useProject()");
+		return useMemo(() => this._adminProjectFromCrud(crud, () => this._refreshProject()), [crud]);
+	}
+	_createInternalApiKeyBaseFromCrud(data) {
+		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;
+			}
+		};
+	}
+	_createInternalApiKeyFromCrud(data) {
+		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
+		};
+	}
+	_createInternalApiKeyFirstViewFromCrud(data) {
+		return {
+			...this._createInternalApiKeyBaseFromCrud(data),
+			publishableClientKey: data.publishable_client_key,
+			secretServerKey: data.secret_server_key,
+			superSecretAdminKey: data.super_secret_admin_key
+		};
+	}
+	async listInternalApiKeys() {
+		return Result.orThrow(await this._internalApiKeysCache.getOrWait([], "write-only")).map((j) => this._createInternalApiKeyFromCrud(j));
+	}
+	useInternalApiKeys() {
+		const crud = useAsyncCache(this._internalApiKeysCache, [], "adminApp.useInternalApiKeys()");
+		return useMemo(() => {
+			return crud.map((j) => this._createInternalApiKeyFromCrud(j));
+		}, [crud]);
+	}
+	async createInternalApiKey(options) {
+		const crud = await this._interface.createInternalApiKey(internalApiKeyCreateOptionsToCrud(options));
+		await this._refreshInternalApiKeys();
+		return this._createInternalApiKeyFirstViewFromCrud(crud);
+	}
+	useEmailThemes() {
+		const crud = useAsyncCache(this._adminEmailThemesCache, [], "adminApp.useEmailThemes()");
+		return useMemo(() => {
+			return crud.map((theme) => ({
+				id: theme.id,
+				displayName: theme.display_name
+			}));
+		}, [crud]);
+	}
+	useEmailTemplates() {
+		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() {
+		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() {
+		return Result.orThrow(await this._adminEmailThemesCache.getOrWait([], "write-only")).map((theme) => ({
+			id: theme.id,
+			displayName: theme.display_name
+		}));
+	}
+	async listEmailTemplates() {
+		return Result.orThrow(await this._adminEmailTemplatesCache.getOrWait([], "write-only")).map((template) => ({
+			id: template.id,
+			displayName: template.display_name,
+			themeId: template.theme_id,
+			tsxSource: template.tsx_source
+		}));
+	}
+	async listEmailDrafts() {
+		return Result.orThrow(await this._adminEmailDraftsCache.getOrWait([], "write-only")).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) {
+		const crud = await this._interface.createTeamPermissionDefinition(adminTeamPermissionDefinitionCreateOptionsToCrud(data));
+		await this._adminTeamPermissionDefinitionsCache.refresh([]);
+		return this._serverTeamPermissionDefinitionFromCrud(crud);
+	}
+	async updateTeamPermissionDefinition(permissionId, data) {
+		await this._interface.updateTeamPermissionDefinition(permissionId, adminTeamPermissionDefinitionUpdateOptionsToCrud(data));
+		await this._adminTeamPermissionDefinitionsCache.refresh([]);
+	}
+	async deleteTeamPermissionDefinition(permissionId) {
+		await this._interface.deleteTeamPermissionDefinition(permissionId);
+		await this._adminTeamPermissionDefinitionsCache.refresh([]);
+	}
+	async listTeamPermissionDefinitions() {
+		return Result.orThrow(await this._adminTeamPermissionDefinitionsCache.getOrWait([], "write-only")).map((p) => this._serverTeamPermissionDefinitionFromCrud(p));
+	}
+	async listTeamPermissionDefinitionsPaginated(options) {
+		const result = await this._interface.listTeamPermissionDefinitionsPaginated(options);
+		return {
+			items: result.items.map((p) => this._serverTeamPermissionDefinitionFromCrud(p)),
+			nextCursor: result.nextCursor
+		};
+	}
+	useTeamPermissionDefinitions() {
+		const crud = useAsyncCache(this._adminTeamPermissionDefinitionsCache, [], "adminApp.useTeamPermissionDefinitions()");
+		return useMemo(() => {
+			return crud.map((p) => this._serverTeamPermissionDefinitionFromCrud(p));
+		}, [crud]);
+	}
+	async createProjectPermissionDefinition(data) {
+		const crud = await this._interface.createProjectPermissionDefinition(adminProjectPermissionDefinitionCreateOptionsToCrud(data));
+		await this._adminProjectPermissionDefinitionsCache.refresh([]);
+		return this._serverProjectPermissionDefinitionFromCrud(crud);
+	}
+	async updateProjectPermissionDefinition(permissionId, data) {
+		await this._interface.updateProjectPermissionDefinition(permissionId, adminProjectPermissionDefinitionUpdateOptionsToCrud(data));
+		await this._adminProjectPermissionDefinitionsCache.refresh([]);
+	}
+	async deleteProjectPermissionDefinition(permissionId) {
+		await this._interface.deleteProjectPermissionDefinition(permissionId);
+		await this._adminProjectPermissionDefinitionsCache.refresh([]);
+	}
+	async listProjectPermissionDefinitions() {
+		return Result.orThrow(await this._adminProjectPermissionDefinitionsCache.getOrWait([], "write-only")).map((p) => this._serverProjectPermissionDefinitionFromCrud(p));
+	}
+	useProjectPermissionDefinitions() {
+		const crud = useAsyncCache(this._adminProjectPermissionDefinitionsCache, [], "adminApp.useProjectPermissionDefinitions()");
+		return useMemo(() => {
+			return crud.map((p) => this._serverProjectPermissionDefinitionFromCrud(p));
+		}, [crud]);
+	}
+	useSvixToken() {
+		const crud = useAsyncCache(this._svixTokenCache, [], "adminApp.useSvixToken()");
+		return {
+			token: crud.token,
+			url: crud.url
+		};
+	}
+	async _refreshProject() {
+		await Promise.all([super._refreshProject(), this._adminProjectCache.refresh([])]);
+	}
+	async _refreshProjectConfig() {
+		await Promise.all([this._configOverridesCache.refresh([]), this._adminProjectCache.refresh([])]);
+	}
+	async _refreshInternalApiKeys() {
+		await this._internalApiKeysCache.refresh([]);
+	}
+	async _refreshUsers() {
+		await Promise.all([
+			super._refreshUsers(),
+			this._metricsCache.refresh([false]),
+			this._metricsCache.refresh([true]),
+			this._metricsUserCountsCache.refresh([])
+		]);
+	}
+	get [stackAppInternalsSymbol]() {
+		return {
+			...super[stackAppInternalsSymbol],
+			useMetrics: (includeAnonymous = false) => {
+				return useAsyncCache(this._metricsCache, [includeAnonymous], "adminApp.useMetrics()");
+			},
+			useUserActivity: (userId) => {
+				return useAsyncCache(this._userActivityCache, [userId], "adminApp.useUserActivity()");
+			},
+			useMetricsUserCounts: () => {
+				return useAsyncCache(this._metricsUserCountsCache, [], "adminApp.useMetricsUserCounts()");
+			}
+		};
+	}
+	async sendTestEmail(options) {
+		let response;
+		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) {
+			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(void 0);
+		else return Result.error({ errorMessage: response.error_message ?? throwErr("Email test error not specified") });
+	}
+	async sendTestWebhook(options) {
+		const response = await this._interface.sendTestWebhook({ endpoint_id: options.endpointId });
+		if (response.success) return Result.ok(void 0);
+		else return Result.error({ errorMessage: response.error_message ?? throwErr("Webhook test error not specified") });
+	}
+	async listSentEmails() {
+		return (await this._interface.listSentEmails()).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) {
+		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) {
+		return { status: (await this._interface.checkManagedEmailStatus({
+			domain_id: options.domainId,
+			subdomain: options.subdomain,
+			sender_local_part: options.senderLocalPart
+		})).status };
+	}
+	async listManagedEmailDomains() {
+		return (await this._interface.listManagedEmailDomains()).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) {
+		const result = await this._interface.applyManagedEmailProvider({ domain_id: options.domainId });
+		await this._refreshProjectConfig();
+		return result;
+	}
+	async deleteManagedEmailDomain(options) {
+		return await this._interface.deleteManagedEmailDomain({ resend_domain_id: options.resendDomainId });
+	}
+	async sendSignInInvitationEmail(email, callbackUrl) {
+		await this._interface.sendSignInInvitationEmail(email, callbackUrl);
+	}
+	async createEmailTemplate(displayName) {
+		const result = await this._interface.createEmailTemplate(displayName);
+		await this._adminEmailTemplatesCache.refresh([]);
+		return result;
+	}
+	async deleteEmailTemplate(id) {
+		await this._interface.deleteEmailTemplate(id);
+		await this._adminEmailTemplatesCache.refresh([]);
+	}
+	async createEmailDraft(options) {
+		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, data) {
+		await this._interface.updateEmailDraft(id, {
+			display_name: data.displayName,
+			theme_id: data.themeId,
+			tsx_source: data.tsxSource
+		});
+		await this._adminEmailDraftsCache.refresh([]);
+	}
+	async deleteEmailDraft(id) {
+		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() {
+		await this._adminEmailDraftsCache.refresh([]);
+	}
+	async saveChatMessage(threadId, message) {
+		await this._interface.saveChatMessage(threadId, message);
+	}
+	async listChatMessages(threadId) {
+		return await this._interface.listChatMessages(threadId);
+	}
+	async rewriteTemplateSourceWithAI(templateTsxSource) {
+		return { tsxSource: (await this._interface.rewriteTemplateSourceWithAI(templateTsxSource)).tsx_source };
+	}
+	async createEmailTheme(displayName) {
+		const result = await this._interface.createEmailTheme(displayName);
+		await this._adminEmailThemesCache.refresh([]);
+		return result;
+	}
+	async getEmailPreview(options) {
+		return (await this._interface.renderEmailPreview(options)).html;
+	}
+	useEmailPreview(options) {
+		return useAsyncCache(this._emailPreviewCache, [
+			options.themeId,
+			options.themeTsxSource,
+			options.templateId,
+			options.templateTsxSource
+		], "adminApp.useEmailPreview()").html;
+	}
+	async getEmailPreviewWithEditableMarkers(options) {
+		const result = await this._interface.renderEmailPreview({
+			...options,
+			editableMarkers: true,
+			editableSource: options.editableSource
+		});
+		return {
+			html: result.html,
+			editableRegions: result.editable_regions
+		};
+	}
+	useEmailPreviewWithEditableMarkers(options) {
+		const crud = useAsyncCache(this._emailPreviewWithEditableMarkersCache, [
+			options.themeId,
+			options.themeTsxSource,
+			options.templateId,
+			options.templateTsxSource,
+			options.editableSource
+		], "adminApp.useEmailPreviewWithEditableMarkers()");
+		return {
+			html: crud.html,
+			editableRegions: crud.editable_regions
+		};
+	}
+	useEmailTheme(id) {
+		const crud = useAsyncCache(this._adminEmailThemeCache, [id], "adminApp.useEmailTheme()");
+		return {
+			displayName: crud.display_name,
+			tsxSource: crud.tsx_source
+		};
+	}
+	async updateEmailTheme(id, tsxSource) {
+		await this._interface.updateEmailTheme(id, tsxSource);
+		await this._adminEmailThemesCache.refresh([]);
+		await this._adminEmailThemeCache.invalidate([id]);
+	}
+	async deleteEmailTheme(id) {
+		await this._interface.deleteEmailTheme(id);
+		await this._adminEmailThemesCache.refresh([]);
+		await this._adminEmailThemeCache.invalidate([id]);
+	}
+	async updateEmailTemplate(id, tsxSource, themeId) {
+		const result = await this._interface.updateEmailTemplate(id, tsxSource, themeId);
+		await this._adminEmailTemplatesCache.refresh([]);
+		return { renderedHtml: result.rendered_html };
+	}
+	async setupPayments() {
+		return await this._interface.setupPayments();
+	}
+	async createStripeWidgetAccountSession() {
+		return await this._interface.createStripeWidgetAccountSession();
+	}
+	async getPaymentMethodConfigs() {
+		return await this._interface.getPaymentMethodConfigs();
+	}
+	async updatePaymentMethodConfigs(configId, updates) {
+		await this._interface.updatePaymentMethodConfigs(configId, updates);
+	}
+	async createItemQuantityChange(options) {
+		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) {
+		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) {
+		return Result.orThrow(await this._transactionsCache.getOrWait([
+			params.cursor,
+			params.limit,
+			params.type,
+			params.customerType,
+			params.customerId
+		], "write-only"));
+	}
+	_emailOutboxCrudToAdmin(crud) {
+		const recipient = crud.to;
+		let 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
+		};
+		const base = {
+			id: crud.id,
+			createdAt: new Date(crud.created_at_millis),
+			updatedAt: new Date(crud.updated_at_millis),
+			tsxSource: crud.tsx_source,
+			themeId: crud.theme_id ?? null,
+			to,
+			scheduledAt: new Date(crud.scheduled_at_millis),
+			createdWith: crud.created_with,
+			emailDraftId: crud.email_draft_id,
+			emailProgrammaticCallTemplateId: crud.email_programmatic_call_template_id,
+			variables: crud.variables ?? {},
+			isPaused: false,
+			hasRendered: false,
+			hasDelivered: false,
+			sendRetries: crud.send_retries,
+			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.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
+		};
+		const rendered = crud.has_rendered ? {
+			...base,
+			startedRenderingAt: new Date(crud.started_rendering_at_millis),
+			renderedAt: new Date(crud.rendered_at_millis),
+			subject: crud.subject,
+			html: crud.html,
+			text: crud.text,
+			isTransactional: crud.is_transactional,
+			isHighPriority: crud.is_high_priority,
+			notificationCategoryId: crud.notification_category_id,
+			hasRendered: true
+		} : null;
+		const startedSending = rendered && crud.started_sending_at_millis ? {
+			...rendered,
+			startedSendingAt: new Date(crud.started_sending_at_millis)
+		} : null;
+		const finishedDelivering = startedSending && crud.has_delivered ? {
+			...startedSending,
+			deliveredAt: new Date(crud.delivered_at_millis),
+			hasDelivered: true
+		} : null;
+		return (() => {
+			switch (crud.status) {
+				case "paused": return {
+					...base,
+					status: "paused",
+					simpleStatus: "in-progress",
+					isPaused: true
+				};
+				case "preparing": return {
+					...base,
+					status: "preparing",
+					simpleStatus: "in-progress"
+				};
+				case "rendering": return {
+					...base,
+					status: "rendering",
+					simpleStatus: "in-progress",
+					startedRenderingAt: new Date(crud.started_rendering_at_millis)
+				};
+				case "render-error": return {
+					...base,
+					status: "render-error",
+					simpleStatus: "error",
+					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",
+					simpleStatus: "in-progress"
+				};
+				case "queued": return {
+					...rendered,
+					status: "queued",
+					simpleStatus: "in-progress"
+				};
+				case "sending": return {
+					...startedSending,
+					status: "sending",
+					simpleStatus: "in-progress"
+				};
+				case "server-error": return {
+					...startedSending,
+					status: "server-error",
+					simpleStatus: "error",
+					errorAt: new Date(crud.error_at_millis),
+					serverError: crud.server_error
+				};
+				case "skipped": return {
+					...base,
+					status: "skipped",
+					simpleStatus: "ok",
+					skippedAt: new Date(crud.skipped_at_millis),
+					skippedReason: crud.skipped_reason,
+					skippedDetails: crud.skipped_details ?? {},
+					hasRendered: crud.has_rendered,
+					startedRenderingAt: crud.started_rendering_at_millis ? new Date(crud.started_rendering_at_millis) : void 0,
+					renderedAt: crud.rendered_at_millis ? new Date(crud.rendered_at_millis) : void 0,
+					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) : void 0
+				};
+				case "bounced": return {
+					...startedSending,
+					status: "bounced",
+					simpleStatus: "error",
+					bouncedAt: new Date(crud.bounced_at_millis)
+				};
+				case "delivery-delayed": return {
+					...startedSending,
+					status: "delivery-delayed",
+					simpleStatus: "ok",
+					deliveryDelayedAt: new Date(crud.delivery_delayed_at_millis)
+				};
+				case "sent": return {
+					...finishedDelivering,
+					status: "sent",
+					simpleStatus: "ok",
+					canHaveDeliveryInfo: crud.can_have_delivery_info
+				};
+				case "opened": return {
+					...finishedDelivering,
+					status: "opened",
+					simpleStatus: "ok",
+					openedAt: new Date(crud.opened_at_millis),
+					canHaveDeliveryInfo: true
+				};
+				case "clicked": return {
+					...finishedDelivering,
+					status: "clicked",
+					simpleStatus: "ok",
+					clickedAt: new Date(crud.clicked_at_millis),
+					canHaveDeliveryInfo: true
+				};
+				case "marked-as-spam": return {
+					...finishedDelivering,
+					status: "marked-as-spam",
+					simpleStatus: "ok",
+					markedAsSpamAt: new Date(crud.marked_as_spam_at_millis),
+					canHaveDeliveryInfo: true
+				};
+				default: throw new HexclaveAssertionError(`Unknown email outbox status: ${crud.status}`, { status: crud.status });
+			}
+		})();
+	}
+	async listOutboxEmails(options) {
+		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) {
+		const response = await this._interface.getOutboxEmail(id);
+		return this._emailOutboxCrudToAdmin(response);
+	}
+	async updateOutboxEmail(id, options) {
+		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) {
+		return await this.updateOutboxEmail(id, { isPaused: true });
+	}
+	async unpauseOutboxEmail(id) {
+		return await this.updateOutboxEmail(id, { isPaused: false });
+	}
+	async cancelOutboxEmail(id) {
+		return await this.updateOutboxEmail(id, { cancel: true });
+	}
+	useTransactions(params) {
+		return useAsyncCache(this._transactionsCache, [
+			params.cursor,
+			params.limit,
+			params.type,
+			params.customerType,
+			params.customerId
+		], "adminApp.useTransactions()");
+	}
+	async getStripeAccountInfo() {
+		return await this._interface.getStripeAccountInfo();
+	}
+	useStripeAccountInfo() {
+		return useAsyncCache(this._stripeAccountInfoCache, [], "adminApp.useStripeAccountInfo()");
+	}
+	async queryAnalytics(options) {
+		return await this._interface.queryAnalytics(options);
+	}
+	async listSessionReplays(options) {
+		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
+		});
+		return {
+			items: 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
+			})),
+			nextCursor: response.pagination.next_cursor
+		};
+	}
+	async getSessionReplay(sessionReplayId) {
+		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, options) {
+		const response = await this._interface.listSessionReplayChunks(sessionReplayId, {
+			cursor: options?.cursor,
+			limit: options?.limit
+		});
+		return {
+			items: 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)
+			})),
+			nextCursor: response.pagination.next_cursor
+		};
+	}
+	async getSessionReplayChunkEvents(sessionReplayId, chunkId) {
+		return await this._interface.getSessionReplayChunkEvents(sessionReplayId, chunkId);
+	}
+	async getSessionReplayEvents(sessionReplayId, options) {
+		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, limit) {
+		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
+			})),
+			totalAffectedCount: result.total_affected_count
+		};
+	}
+};
+
+//#endregion
+export { _StackAdminAppImplIncomplete };
+//# sourceMappingURL=admin-app-impl.js.map