@stackframe/stack 2.7.20 → 2.7.22

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # @stackframe/stack
 
+## 2.7.22
+
+### Patch Changes
+
+- Various changes
+- Updated dependencies
+  - @stackframe/stack-shared@2.7.22
+  - @stackframe/stack-ui@2.7.22
+  - @stackframe/stack-sc@2.7.22
+
+## 2.7.21
+
+### Patch Changes
+
+- Various changes
+- Updated dependencies
+  - @stackframe/stack-shared@2.7.21
+  - @stackframe/stack-ui@2.7.21
+  - @stackframe/stack-sc@2.7.21
+
 ## 2.7.20
 
 ### Patch Changes

package/dist/admin-app-impl-CTQhv9tV.d.ts

@@ -0,0 +1,395 @@
+import * as _stackframe_stack_shared_dist_sessions from '@stackframe/stack-shared/dist/sessions';
+import { InternalSession } from '@stackframe/stack-shared/dist/sessions';
+import * as _stackframe_stack_shared_dist_interface_crud_current_user from '@stackframe/stack-shared/dist/interface/crud/current-user';
+import { CurrentUserCrud } from '@stackframe/stack-shared/dist/interface/crud/current-user';
+import { f as StackClientAppConstructorOptions, a as StackClientApp, P as Project, w as TeamUser, t as TeamInvitation, T as Team, x as Auth, E as EditableTeamMemberProfile, G as BaseUser, H as UserExtra, I as InternalUserExtra, J as ProjectCurrentUser, K as UserUpdateOptions, A as AdminOwnedProject, l as AdminProjectUpdateOptions, g as StackClientAppJson, i as StackServerAppConstructorOptions, D as ServerUser, r as ServerTeamUser, L as ProjectCurrentServerUser, n as ServerTeam, M as ServerUserCreateOptions, m as ServerListUsersOptions, o as ServerTeamCreateOptions, d as StackAdminAppConstructorOptions, j as AdminProject } from './index-DQk7XJpU.js';
+import { TokenStoreInit, RedirectMethod, HandlerUrls, OAuthScopesOnSignIn, RequestLike, RedirectToOptions, GetUserOptions, stackAppInternalsSymbol, EmailConfig } from './lib/stack-app/common.js';
+import { StackClientInterface, KnownErrors, StackServerInterface, StackAdminInterface } from '@stackframe/stack-shared';
+import { Result } from '@stackframe/stack-shared/dist/utils/results';
+import { TeamPermission, AdminTeamPermission, AdminTeamPermissionDefinition, AdminTeamPermissionDefinitionCreateOptions, AdminTeamPermissionDefinitionUpdateOptions } from './lib/stack-app/permissions/index.js';
+import { ApiKeyCreateCrudResponse } from '@stackframe/stack-shared/dist/interface/adminInterface';
+import { ApiKeysCrud } from '@stackframe/stack-shared/dist/interface/crud/api-keys';
+import { EmailTemplateCrud, EmailTemplateType } from '@stackframe/stack-shared/dist/interface/crud/email-templates';
+import { ProjectsCrud, InternalProjectsCrud } from '@stackframe/stack-shared/dist/interface/crud/projects';
+import { ApiKeyBaseCrudRead, ApiKeyBase, ApiKey, ApiKeyFirstView, ApiKeyCreateOptions } from './lib/stack-app/api-keys/index.js';
+import { AdminEmailTemplate, AdminEmailTemplateUpdateOptions } from './lib/stack-app/email-templates/index.js';
+import { ContactChannelsCrud } from '@stackframe/stack-shared/dist/interface/crud/contact-channels';
+import { TeamInvitationCrud } from '@stackframe/stack-shared/dist/interface/crud/team-invitation';
+import { TeamMemberProfilesCrud } from '@stackframe/stack-shared/dist/interface/crud/team-member-profiles';
+import { TeamPermissionsCrud, TeamPermissionDefinitionsCrud } from '@stackframe/stack-shared/dist/interface/crud/team-permissions';
+import { TeamsCrud } from '@stackframe/stack-shared/dist/interface/crud/teams';
+import { UsersCrud } from '@stackframe/stack-shared/dist/interface/crud/users';
+import { ContactChannel, ServerContactChannel } from './lib/stack-app/contact-channels/index.js';
+import { ProviderType } from '@stackframe/stack-shared/dist/utils/oauth';
+import { Store } from '@stackframe/stack-shared/dist/utils/stores';
+import { CookieHelper } from './lib/cookie.js';
+import { TokenObject } from './lib/stack-app/apps/implementations/common.js';
+
+declare class _StackClientAppImplIncomplete<HasTokenStore extends boolean, ProjectId extends string = string> {
+    protected readonly _options: {
+        uniqueIdentifier?: string;
+        checkString?: string;
+    } & (StackClientAppConstructorOptions<HasTokenStore, ProjectId> | Exclude<StackClientAppConstructorOptions<HasTokenStore, ProjectId>, "baseUrl" | "projectId" | "publishableClientKey"> & {
+        interface: StackClientInterface;
+    });
+    /**
+     * There is a circular dependency between the admin app and the client app, as the former inherits from the latter and
+     * the latter needs to use the former when creating a new instance of an internal project.
+     *
+     * To break it, we set the admin app here lazily instead of importing it directly. This variable is set by ./index.ts,
+     * which imports both this file and ./admin-app-impl.ts.
+     */
+    static readonly LazyStackAdminAppImpl: {
+        value: typeof _StackAdminAppImplIncomplete | undefined;
+    };
+    protected _uniqueIdentifier: string | undefined;
+    protected _interface: StackClientInterface;
+    protected readonly _tokenStoreInit: TokenStoreInit<HasTokenStore>;
+    protected readonly _redirectMethod: RedirectMethod | undefined;
+    protected readonly _urlOptions: Partial<HandlerUrls>;
+    protected readonly _oauthScopesOnSignIn: Partial<OAuthScopesOnSignIn>;
+    private __DEMO_ENABLE_SLIGHT_FETCH_DELAY;
+    private readonly _ownedAdminApps;
+    private readonly _currentUserCache;
+    private readonly _currentProjectCache;
+    private readonly _ownedProjectsCache;
+    private readonly _currentUserPermissionsCache;
+    private readonly _currentUserTeamsCache;
+    private readonly _currentUserOAuthConnectionAccessTokensCache;
+    private readonly _currentUserOAuthConnectionCache;
+    private readonly _teamMemberProfilesCache;
+    private readonly _teamInvitationsCache;
+    private readonly _currentUserTeamProfileCache;
+    private readonly _clientContactChannelsCache;
+    protected _createCookieHelper(): Promise<CookieHelper>;
+    protected _getUserOAuthConnectionCacheFn(options: {
+        getUser: () => Promise<CurrentUserCrud['Client']['Read'] | null>;
+        getOrWaitOAuthToken: () => Promise<{
+            accessToken: string;
+        } | null>;
+        useOAuthToken: () => {
+            accessToken: string;
+        } | null;
+        providerId: ProviderType;
+        scope: string | null;
+    } & ({
+        redirect: true;
+        session: InternalSession | null;
+    } | {
+        redirect: false;
+    })): Promise<{
+        id: "google" | "github" | "microsoft" | "spotify" | "facebook" | "discord" | "gitlab" | "bitbucket" | "linkedin" | "apple" | "x";
+        getAccessToken(): Promise<{
+            accessToken: string;
+        }>;
+        useAccessToken(): {
+            accessToken: string;
+        };
+    } | null>;
+    constructor(_options: {
+        uniqueIdentifier?: string;
+        checkString?: string;
+    } & (StackClientAppConstructorOptions<HasTokenStore, ProjectId> | Exclude<StackClientAppConstructorOptions<HasTokenStore, ProjectId>, "baseUrl" | "projectId" | "publishableClientKey"> & {
+        interface: StackClientInterface;
+    }));
+    protected _initUniqueIdentifier(): void;
+    /**
+     * Cloudflare workers does not allow use of randomness on the global scope (on which the Stack app is probably
+     * initialized). For that reason, we generate the unique identifier lazily when it is first needed instead of in the
+     * constructor.
+     */
+    protected _getUniqueIdentifier(): string;
+    protected _checkFeatureSupport(name: string, options: any): Promise<never>;
+    protected _useCheckFeatureSupport(name: string, options: any): never;
+    protected _memoryTokenStore: Store<TokenObject>;
+    protected _nextServerCookiesTokenStores: WeakMap<object, Store<TokenObject>>;
+    protected _requestTokenStores: WeakMap<RequestLike, Store<TokenObject>>;
+    protected _storedBrowserCookieTokenStore: Store<TokenObject> | null;
+    protected get _refreshTokenCookieName(): string;
+    protected _getTokensFromCookies(cookies: {
+        refreshTokenCookie: string | null;
+        accessTokenCookie: string | null;
+    }): TokenObject;
+    protected get _accessTokenCookieName(): string;
+    protected _getBrowserCookieTokenStore(): Store<TokenObject>;
+    protected _getOrCreateTokenStore(cookieHelper: CookieHelper, overrideTokenStoreInit?: TokenStoreInit): Store<TokenObject>;
+    protected _useTokenStore(overrideTokenStoreInit?: TokenStoreInit): Store<TokenObject>;
+    /**
+     * A map from token stores and session keys to sessions.
+     *
+     * This isn't just a map from session keys to sessions for two reasons:
+     *
+     * - So we can garbage-collect Session objects when the token store is garbage-collected
+     * - So different token stores are separated and don't leak information between each other, eg. if the same user sends two requests to the same server they should get a different session object
+     */
+    private _sessionsByTokenStoreAndSessionKey;
+    protected _getSessionFromTokenStore(tokenStore: Store<TokenObject>): InternalSession;
+    protected _getSession(overrideTokenStoreInit?: TokenStoreInit): Promise<InternalSession>;
+    protected _useSession(overrideTokenStoreInit?: TokenStoreInit): InternalSession;
+    protected _signInToAccountWithTokens(tokens: {
+        accessToken: string | null;
+        refreshToken: string;
+    }): Promise<void>;
+    protected _hasPersistentTokenStore(overrideTokenStoreInit?: TokenStoreInit): this is StackClientApp<true, ProjectId>;
+    protected _ensurePersistentTokenStore(overrideTokenStoreInit?: TokenStoreInit): asserts this is StackClientApp<true, ProjectId>;
+    protected _isInternalProject(): this is {
+        projectId: "internal";
+    };
+    protected _ensureInternalProject(): asserts this is {
+        projectId: "internal";
+    };
+    protected _clientProjectFromCrud(crud: ProjectsCrud['Client']['Read']): Project;
+    protected _clientTeamPermissionFromCrud(crud: TeamPermissionsCrud['Client']['Read']): TeamPermission;
+    protected _clientTeamUserFromCrud(crud: TeamMemberProfilesCrud['Client']['Read']): TeamUser;
+    protected _clientTeamInvitationFromCrud(session: InternalSession, crud: TeamInvitationCrud['Client']['Read']): TeamInvitation;
+    protected _clientTeamFromCrud(crud: TeamsCrud['Client']['Read'], session: InternalSession): Team;
+    protected _clientContactChannelFromCrud(crud: ContactChannelsCrud['Client']['Read'], session: InternalSession): ContactChannel;
+    protected _createAuth(session: InternalSession): Auth;
+    protected _editableTeamProfileFromCrud(crud: TeamMemberProfilesCrud['Client']['Read'], session: InternalSession): EditableTeamMemberProfile;
+    protected _createBaseUser(crud: NonNullable<CurrentUserCrud['Client']['Read']> | UsersCrud['Server']['Read']): BaseUser;
+    protected _createUserExtraFromCurrent(crud: NonNullable<CurrentUserCrud['Client']['Read']>, session: InternalSession): UserExtra;
+    protected _createInternalUserExtra(session: InternalSession): InternalUserExtra;
+    protected _currentUserFromCrud(crud: NonNullable<CurrentUserCrud['Client']['Read']>, session: InternalSession): ProjectCurrentUser<ProjectId>;
+    protected _getOwnedAdminApp(forProjectId: string, session: InternalSession): _StackAdminAppImplIncomplete<false, string>;
+    get projectId(): ProjectId;
+    protected _isTrusted(url: string): Promise<boolean>;
+    get urls(): Readonly<HandlerUrls>;
+    protected _getCurrentUrl(): Promise<URL | null>;
+    protected _redirectTo(options: {
+        url: URL | string;
+        replace?: boolean;
+    }): Promise<void>;
+    useNavigate(): (to: string) => void;
+    protected _redirectIfTrusted(url: string, options?: RedirectToOptions): Promise<void>;
+    protected _redirectToHandler(handlerName: keyof HandlerUrls, options?: RedirectToOptions): Promise<void>;
+    redirectToSignIn(options?: RedirectToOptions): Promise<void>;
+    redirectToSignUp(options?: RedirectToOptions): Promise<void>;
+    redirectToSignOut(options?: RedirectToOptions): Promise<void>;
+    redirectToEmailVerification(options?: RedirectToOptions): Promise<void>;
+    redirectToPasswordReset(options?: RedirectToOptions): Promise<void>;
+    redirectToForgotPassword(options?: RedirectToOptions): Promise<void>;
+    redirectToHome(options?: RedirectToOptions): Promise<void>;
+    redirectToOAuthCallback(options?: RedirectToOptions): Promise<void>;
+    redirectToMagicLinkCallback(options?: RedirectToOptions): Promise<void>;
+    redirectToAfterSignIn(options?: RedirectToOptions): Promise<void>;
+    redirectToAfterSignUp(options?: RedirectToOptions): Promise<void>;
+    redirectToAfterSignOut(options?: RedirectToOptions): Promise<void>;
+    redirectToAccountSettings(options?: RedirectToOptions): Promise<void>;
+    redirectToError(options?: RedirectToOptions): Promise<void>;
+    redirectToTeamInvitation(options?: RedirectToOptions): Promise<void>;
+    sendForgotPasswordEmail(email: string, options?: {
+        callbackUrl?: string;
+    }): Promise<Result<undefined, KnownErrors["UserNotFound"]>>;
+    sendMagicLinkEmail(email: string, options?: {
+        callbackUrl?: string;
+    }): Promise<Result<{
+        nonce: string;
+    }, KnownErrors["RedirectUrlNotWhitelisted"]>>;
+    resetPassword(options: {
+        password: string;
+        code: string;
+    }): Promise<Result<undefined, KnownErrors["VerificationCodeError"]>>;
+    verifyPasswordResetCode(code: string): Promise<Result<undefined, KnownErrors["VerificationCodeError"]>>;
+    verifyTeamInvitationCode(code: string): Promise<Result<undefined, KnownErrors["VerificationCodeError"]>>;
+    acceptTeamInvitation(code: string): Promise<Result<undefined, KnownErrors["VerificationCodeError"]>>;
+    getTeamInvitationDetails(code: string): Promise<Result<{
+        teamDisplayName: string;
+    }, KnownErrors["VerificationCodeError"]>>;
+    verifyEmail(code: string): Promise<Result<undefined, KnownErrors["VerificationCodeError"]>>;
+    getUser(options: GetUserOptions<HasTokenStore> & {
+        or: 'redirect';
+    }): Promise<ProjectCurrentUser<ProjectId>>;
+    getUser(options: GetUserOptions<HasTokenStore> & {
+        or: 'throw';
+    }): Promise<ProjectCurrentUser<ProjectId>>;
+    getUser(options?: GetUserOptions<HasTokenStore>): Promise<ProjectCurrentUser<ProjectId> | null>;
+    useUser(options: GetUserOptions<HasTokenStore> & {
+        or: 'redirect';
+    }): ProjectCurrentUser<ProjectId>;
+    useUser(options: GetUserOptions<HasTokenStore> & {
+        or: 'throw';
+    }): ProjectCurrentUser<ProjectId>;
+    useUser(options?: GetUserOptions<HasTokenStore>): ProjectCurrentUser<ProjectId> | null;
+    protected _updateClientUser(update: UserUpdateOptions, session: InternalSession): Promise<void>;
+    signInWithOAuth(provider: ProviderType): Promise<void>;
+    /**
+     * @deprecated
+     * TODO remove
+     */
+    protected _experimentalMfa(error: KnownErrors['MultiFactorAuthenticationRequired'], session: InternalSession): Promise<{
+        accessToken: any;
+        refreshToken: any;
+        newUser: any;
+    }>;
+    /**
+     * @deprecated
+     * TODO remove
+     */
+    protected _catchMfaRequiredError<T, E>(callback: () => Promise<Result<T, E>>): Promise<Result<T | {
+        accessToken: string;
+        refreshToken: string;
+        newUser: boolean;
+    }, E>>;
+    signInWithCredential(options: {
+        email: string;
+        password: string;
+        noRedirect?: boolean;
+    }): Promise<Result<undefined, KnownErrors["EmailPasswordMismatch"] | KnownErrors["InvalidTotpCode"]>>;
+    signUpWithCredential(options: {
+        email: string;
+        password: string;
+        noRedirect?: boolean;
+        verificationCallbackUrl?: string;
+    }): Promise<Result<undefined, KnownErrors["UserEmailAlreadyExists"] | KnownErrors['PasswordRequirementsNotMet']>>;
+    signInWithMagicLink(code: string): Promise<Result<undefined, KnownErrors["VerificationCodeError"] | KnownErrors["InvalidTotpCode"]>>;
+    signInWithPasskey(): Promise<Result<undefined, KnownErrors["PasskeyAuthenticationFailed"] | KnownErrors["InvalidTotpCode"] | KnownErrors["PasskeyWebAuthnError"]>>;
+    callOAuthCallback(): Promise<boolean>;
+    protected _signOut(session: InternalSession, options?: {
+        redirectUrl?: URL | string;
+    }): Promise<void>;
+    signOut(options?: {
+        redirectUrl?: URL | string;
+    }): Promise<void>;
+    getProject(): Promise<Project>;
+    useProject(): Project;
+    protected _listOwnedProjects(session: InternalSession): Promise<AdminOwnedProject[]>;
+    protected _useOwnedProjects(session: InternalSession): AdminOwnedProject[];
+    protected _createProject(session: InternalSession, newProject: AdminProjectUpdateOptions & {
+        displayName: string;
+    }): Promise<AdminOwnedProject>;
+    protected _refreshUser(session: InternalSession): Promise<void>;
+    protected _refreshSession(session: InternalSession): Promise<void>;
+    protected _refreshUsers(): Promise<void>;
+    protected _refreshProject(): Promise<void>;
+    protected _refreshOwnedProjects(session: InternalSession): Promise<void>;
+    static get [stackAppInternalsSymbol](): {
+        fromClientJson: <HasTokenStore extends boolean, ProjectId extends string>(json: StackClientAppJson<HasTokenStore, ProjectId>) => StackClientApp<HasTokenStore, ProjectId>;
+    };
+    get [stackAppInternalsSymbol](): {
+        toClientJson: () => StackClientAppJson<HasTokenStore, ProjectId>;
+        setCurrentUser: (userJsonPromise: Promise<CurrentUserCrud["Client"]["Read"] | null>) => void;
+        sendRequest: (path: string, requestOptions: RequestInit, requestType?: "client" | "server" | "admin") => Promise<Response & {
+            usedTokens: {
+                accessToken: _stackframe_stack_shared_dist_sessions.AccessToken;
+                refreshToken: _stackframe_stack_shared_dist_sessions.RefreshToken | null;
+            } | null;
+        }>;
+    };
+}
+
+declare class _StackServerAppImplIncomplete<HasTokenStore extends boolean, ProjectId extends string> extends _StackClientAppImplIncomplete<HasTokenStore, ProjectId> {
+    protected _interface: StackServerInterface;
+    private readonly _currentServerUserCache;
+    private readonly _serverUsersCache;
+    private readonly _serverUserCache;
+    private readonly _serverTeamsCache;
+    private readonly _serverTeamUserPermissionsCache;
+    private readonly _serverUserOAuthConnectionAccessTokensCache;
+    private readonly _serverUserOAuthConnectionCache;
+    private readonly _serverTeamMemberProfilesCache;
+    private readonly _serverTeamInvitationsCache;
+    private readonly _serverUserTeamProfileCache;
+    private readonly _serverContactChannelsCache;
+    private _updateServerUser;
+    protected _serverEditableTeamProfileFromCrud(crud: TeamMemberProfilesCrud['Client']['Read']): EditableTeamMemberProfile;
+    protected _serverContactChannelFromCrud(userId: string, crud: ContactChannelsCrud['Server']['Read']): ServerContactChannel;
+    constructor(options: StackServerAppConstructorOptions<HasTokenStore, ProjectId> | {
+        interface: StackServerInterface;
+        tokenStore: TokenStoreInit<HasTokenStore>;
+        urls: Partial<HandlerUrls> | undefined;
+        oauthScopesOnSignIn?: Partial<OAuthScopesOnSignIn> | undefined;
+    });
+    protected _serverUserFromCrud(crud: UsersCrud['Server']['Read']): ServerUser;
+    protected _serverTeamUserFromCrud(crud: TeamMemberProfilesCrud["Server"]["Read"]): ServerTeamUser;
+    protected _serverTeamInvitationFromCrud(crud: TeamInvitationCrud['Server']['Read']): TeamInvitation;
+    protected _currentUserFromCrud(crud: UsersCrud['Server']['Read'], session: InternalSession): ProjectCurrentServerUser<ProjectId>;
+    protected _serverTeamFromCrud(crud: TeamsCrud['Server']['Read']): ServerTeam;
+    createUser(options: ServerUserCreateOptions): Promise<ServerUser>;
+    getUser(options: GetUserOptions<HasTokenStore> & {
+        or: 'redirect';
+    }): Promise<ProjectCurrentServerUser<ProjectId>>;
+    getUser(options: GetUserOptions<HasTokenStore> & {
+        or: 'throw';
+    }): Promise<ProjectCurrentServerUser<ProjectId>>;
+    getUser(options?: GetUserOptions<HasTokenStore>): Promise<ProjectCurrentServerUser<ProjectId> | null>;
+    getUser(id: string): Promise<ServerUser | null>;
+    getServerUser(): Promise<ProjectCurrentServerUser<ProjectId> | null>;
+    getServerUserById(userId: string): Promise<ServerUser | null>;
+    useUser(options: GetUserOptions<HasTokenStore> & {
+        or: 'redirect';
+    }): ProjectCurrentServerUser<ProjectId>;
+    useUser(options: GetUserOptions<HasTokenStore> & {
+        or: 'throw';
+    }): ProjectCurrentServerUser<ProjectId>;
+    useUser(options?: GetUserOptions<HasTokenStore>): ProjectCurrentServerUser<ProjectId> | null;
+    useUser(id: string): ServerUser | null;
+    useUserById(userId: string): ServerUser | null;
+    listUsers(options?: ServerListUsersOptions): Promise<ServerUser[] & {
+        nextCursor: string | null;
+    }>;
+    useUsers(options?: ServerListUsersOptions): ServerUser[] & {
+        nextCursor: string | null;
+    };
+    _serverPermissionFromCrud(crud: TeamPermissionsCrud['Server']['Read']): AdminTeamPermission;
+    _serverTeamPermissionDefinitionFromCrud(crud: TeamPermissionDefinitionsCrud['Admin']['Read']): AdminTeamPermissionDefinition;
+    listTeams(): Promise<ServerTeam[]>;
+    createTeam(data: ServerTeamCreateOptions): Promise<ServerTeam>;
+    useTeams(): ServerTeam[];
+    getTeam(teamId: string): Promise<ServerTeam | null>;
+    useTeam(teamId: string): ServerTeam | null;
+    protected _refreshSession(session: InternalSession): Promise<void>;
+    protected _refreshUsers(): Promise<void>;
+}
+
+declare class _StackAdminAppImplIncomplete<HasTokenStore extends boolean, ProjectId extends string> extends _StackServerAppImplIncomplete<HasTokenStore, ProjectId> {
+    protected _interface: StackAdminInterface;
+    private readonly _adminProjectCache;
+    private readonly _apiKeysCache;
+    private readonly _adminEmailTemplatesCache;
+    private readonly _adminTeamPermissionDefinitionsCache;
+    private readonly _svixTokenCache;
+    private readonly _metricsCache;
+    constructor(options: StackAdminAppConstructorOptions<HasTokenStore, ProjectId>);
+    _adminOwnedProjectFromCrud(data: InternalProjectsCrud['Admin']['Read'], onRefresh: () => Promise<void>): AdminOwnedProject;
+    _adminProjectFromCrud(data: InternalProjectsCrud['Admin']['Read'], onRefresh: () => Promise<void>): AdminProject;
+    _adminEmailTemplateFromCrud(data: EmailTemplateCrud['Admin']['Read']): AdminEmailTemplate;
+    getProject(): Promise<AdminProject>;
+    useProject(): AdminProject;
+    protected _createApiKeyBaseFromCrud(data: ApiKeyBaseCrudRead): ApiKeyBase;
+    protected _createApiKeyFromCrud(data: ApiKeysCrud["Admin"]["Read"]): ApiKey;
+    protected _createApiKeyFirstViewFromCrud(data: ApiKeyCreateCrudResponse): ApiKeyFirstView;
+    listApiKeys(): Promise<ApiKey[]>;
+    useApiKeys(): ApiKey[];
+    createApiKey(options: ApiKeyCreateOptions): Promise<ApiKeyFirstView>;
+    useEmailTemplates(): AdminEmailTemplate[];
+    listEmailTemplates(): Promise<AdminEmailTemplate[]>;
+    updateEmailTemplate(type: EmailTemplateType, data: AdminEmailTemplateUpdateOptions): Promise<void>;
+    resetEmailTemplate(type: EmailTemplateType): Promise<void>;
+    createTeamPermissionDefinition(data: AdminTeamPermissionDefinitionCreateOptions): Promise<AdminTeamPermission>;
+    updateTeamPermissionDefinition(permissionId: string, data: AdminTeamPermissionDefinitionUpdateOptions): Promise<void>;
+    deleteTeamPermissionDefinition(permissionId: string): Promise<void>;
+    listTeamPermissionDefinitions(): Promise<AdminTeamPermissionDefinition[]>;
+    useTeamPermissionDefinitions(): AdminTeamPermissionDefinition[];
+    useSvixToken(): string;
+    protected _refreshProject(): Promise<void>;
+    protected _refreshApiKeys(): Promise<void>;
+    get [stackAppInternalsSymbol](): {
+        useMetrics: () => any;
+        toClientJson: () => StackClientAppJson<HasTokenStore, ProjectId>;
+        setCurrentUser: (userJsonPromise: Promise<_stackframe_stack_shared_dist_interface_crud_current_user.CurrentUserCrud["Client"]["Read"] | null>) => void;
+        sendRequest: (path: string, requestOptions: RequestInit, requestType?: "client" | "server" | "admin") => Promise<Response & {
+            usedTokens: {
+                accessToken: _stackframe_stack_shared_dist_sessions.AccessToken;
+                refreshToken: _stackframe_stack_shared_dist_sessions.RefreshToken | null;
+            } | null;
+        }>;
+    };
+    sendTestEmail(options: {
+        recipientEmail: string;
+        emailConfig: EmailConfig;
+    }): Promise<Result<undefined, {
+        errorMessage: string;
+    }>>;
+}
+
+export { _StackAdminAppImplIncomplete as _, _StackClientAppImplIncomplete as a, _StackServerAppImplIncomplete as b };