@stackframe/stack-shared 2.7.26 → 2.7.28

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @stackframe/stack-shared
 
+## 2.7.28
+
+### Patch Changes
+
+- Various changes
+
+## 2.7.27
+
+### Patch Changes
+
+- Various changes
+
 ## 2.7.26
 
 ### Patch Changes

package/dist/interface/adminInterface.d.ts

@@ -1,6 +1,7 @@
 import { InternalSession } from "../sessions";
 import { ApiKeysCrud } from "./crud/api-keys";
 import { EmailTemplateCrud, EmailTemplateType } from "./crud/email-templates";
+import { InternalEmailsCrud } from "./crud/emails";
 import { ProjectsCrud } from "./crud/projects";
 import { SvixTokenCrud } from "./crud/svix-token";
 import { TeamPermissionDefinitionsCrud } from "./crud/team-permissions";
@@ -61,4 +62,5 @@ export declare class StackAdminInterface extends StackServerInterface {
         success: boolean;
         error_message?: string;
     }>;
+    listSentEmails(): Promise<InternalEmailsCrud["Admin"]["List"]>;
 }

package/dist/interface/adminInterface.js

@@ -136,4 +136,10 @@ export class StackAdminInterface extends StackServerInterface {
         }, null);
         return await response.json();
     }
+    async listSentEmails() {
+        const response = await this.sendAdminRequest("/internal/emails", {
+            method: "GET",
+        }, null);
+        return await response.json();
+    }
 }

package/dist/interface/clientInterface.d.ts

@@ -7,6 +7,7 @@ import { ContactChannelsCrud } from './crud/contact-channels';
 import { CurrentUserCrud } from './crud/current-user';
 import { ConnectedAccountAccessTokenCrud } from './crud/oauth';
 import { InternalProjectsCrud, ProjectsCrud } from './crud/projects';
+import { SessionsCrud } from './crud/sessions';
 import { TeamInvitationCrud } from './crud/team-invitation';
 import { TeamMemberProfilesCrud } from './crud/team-member-profiles';
 import { TeamPermissionsCrud } from './crud/team-permissions';
@@ -14,6 +15,7 @@ import { TeamsCrud } from './crud/teams';
 export type ClientInterfaceOptions = {
     clientVersion: string;
     getBaseUrl: () => string;
+    extraRequestHeaders: Record<string, string>;
     projectId: string;
     prepareRequest?: () => Promise<void>;
 } & ({
@@ -193,6 +195,9 @@ export declare class StackClientInterface {
     createClientContactChannel(data: ContactChannelsCrud['Client']['Create'], session: InternalSession): Promise<ContactChannelsCrud['Client']['Read']>;
     updateClientContactChannel(id: string, data: ContactChannelsCrud['Client']['Update'], session: InternalSession): Promise<ContactChannelsCrud['Client']['Read']>;
     deleteClientContactChannel(id: string, session: InternalSession): Promise<void>;
+    deleteSession(sessionId: string, session: InternalSession): Promise<void>;
+    listSessions(session: InternalSession): Promise<SessionsCrud['Client']['List']>;
     listClientContactChannels(session: InternalSession): Promise<ContactChannelsCrud['Client']['Read'][]>;
     sendCurrentUserContactChannelVerificationEmail(contactChannelId: string, callbackUrl: string, session: InternalSession): Promise<Result<undefined, KnownErrors["EmailAlreadyVerified"]>>;
+    cliLogin(loginCode: string, refreshToken: string, session: InternalSession): Promise<Result<undefined, KnownErrors["SchemaError"]>>;
 }

package/dist/interface/clientInterface.js

@@ -212,6 +212,7 @@ export class StackClientInterface {
                  * the case (I haven't actually tested.)
                  */
                 "X-Stack-Random-Nonce": generateSecureRandomString(),
+                ...this.options.extraRequestHeaders,
                 ...options.headers,
             },
             /**
@@ -876,6 +877,17 @@ export class StackClientInterface {
             method: "DELETE",
         }, session);
     }
+    async deleteSession(sessionId, session) {
+        await this.sendClientRequest(`/auth/sessions/${sessionId}?user_id=me`, {
+            method: "DELETE",
+        }, session);
+    }
+    async listSessions(session) {
+        const response = await this.sendClientRequest("/auth/sessions?user_id=me", {
+            method: "GET",
+        }, session);
+        return await response.json();
+    }
     async listClientContactChannels(session) {
         const response = await this.sendClientRequest("/contact-channels?user_id=me", {
             method: "GET",
@@ -896,4 +908,20 @@ export class StackClientInterface {
         }
         return Result.ok(undefined);
     }
+    async cliLogin(loginCode, refreshToken, session) {
+        const responseOrError = await this.sendClientRequestAndCatchKnownError("/auth/cli/complete", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+                login_code: loginCode,
+                refresh_token: refreshToken,
+            }),
+        }, session, [KnownErrors.SchemaError]);
+        if (responseOrError.status === "error") {
+            return Result.error(responseOrError.error);
+        }
+        return Result.ok(undefined);
+    }
 }

package/dist/interface/crud/emails.d.ts

@@ -0,0 +1,64 @@
+import { CrudTypeOf } from "../../crud";
+export declare const sentEmailReadSchema: import("yup").ObjectSchema<{
+    id: string;
+    subject: string;
+    sent_at_millis: number;
+    to: string[] | undefined;
+    sender_config: {
+        host?: string | undefined;
+        port?: number | undefined;
+        username?: string | undefined;
+        sender_name?: string | undefined;
+        sender_email?: string | undefined;
+        type: "shared" | "standard";
+    };
+    error: {} | null | undefined;
+}, import("yup").AnyObject, {
+    id: undefined;
+    subject: undefined;
+    sent_at_millis: undefined;
+    to: undefined;
+    sender_config: {
+        type: undefined;
+        host: undefined;
+        port: undefined;
+        username: undefined;
+        password: undefined;
+        sender_name: undefined;
+        sender_email: undefined;
+    };
+    error: undefined;
+}, "">;
+export declare const internalEmailsCrud: import("../../crud").CrudSchemaFromOptions<{
+    adminReadSchema: import("yup").ObjectSchema<{
+        id: string;
+        subject: string;
+        sent_at_millis: number;
+        to: string[] | undefined;
+        sender_config: {
+            host?: string | undefined;
+            port?: number | undefined;
+            username?: string | undefined;
+            sender_name?: string | undefined;
+            sender_email?: string | undefined;
+            type: "shared" | "standard";
+        };
+        error: {} | null | undefined;
+    }, import("yup").AnyObject, {
+        id: undefined;
+        subject: undefined;
+        sent_at_millis: undefined;
+        to: undefined;
+        sender_config: {
+            type: undefined;
+            host: undefined;
+            port: undefined;
+            username: undefined;
+            password: undefined;
+            sender_name: undefined;
+            sender_email: undefined;
+        };
+        error: undefined;
+    }, "">;
+}>;
+export type InternalEmailsCrud = CrudTypeOf<typeof internalEmailsCrud>;

package/dist/interface/crud/emails.js

@@ -0,0 +1,14 @@
+import { createCrud } from "../../crud";
+import * as fieldSchema from "../../schema-fields";
+import { emailConfigWithoutPasswordSchema } from "./projects";
+export const sentEmailReadSchema = fieldSchema.yupObject({
+    id: fieldSchema.yupString().defined(),
+    subject: fieldSchema.yupString().defined(),
+    sent_at_millis: fieldSchema.yupNumber().defined(),
+    to: fieldSchema.yupArray(fieldSchema.yupString().defined()),
+    sender_config: emailConfigWithoutPasswordSchema.defined(),
+    error: fieldSchema.yupMixed().nullable().optional(),
+}).defined();
+export const internalEmailsCrud = createCrud({
+    adminReadSchema: sentEmailReadSchema,
+});

package/dist/interface/crud/projects.d.ts

@@ -16,6 +16,22 @@ export declare const emailConfigSchema: import("yup").ObjectSchema<{
     sender_name: undefined;
     sender_email: undefined;
 }, "">;
+export declare const emailConfigWithoutPasswordSchema: import("yup").ObjectSchema<{
+    type: "shared" | "standard";
+    host: string | undefined;
+    port: number | undefined;
+    username: string | undefined;
+    sender_name: string | undefined;
+    sender_email: string | undefined;
+}, import("yup").AnyObject, {
+    type: undefined;
+    host: undefined;
+    port: undefined;
+    username: undefined;
+    password: undefined;
+    sender_name: undefined;
+    sender_email: undefined;
+}, "">;
 export declare const projectsCrudAdminReadSchema: import("yup").ObjectSchema<{
     id: string;
     display_name: string;

package/dist/interface/crud/projects.js

@@ -44,6 +44,7 @@ export const emailConfigSchema = yupObject({
         type: 'standard',
     }),
 });
+export const emailConfigWithoutPasswordSchema = emailConfigSchema.pick(['type', 'host', 'port', 'username', 'sender_name', 'sender_email']);
 const domainSchema = yupObject({
     domain: schemaFields.urlSchema.defined()
         .matches(/^https?:\/\//, 'URL must start with http:// or https://')

package/dist/interface/crud/sessions.d.ts

@@ -0,0 +1,144 @@
+import { CrudTypeOf } from "../../crud";
+export declare const sessionsCrudServerCreateSchema: import("yup").ObjectSchema<{
+    user_id: string;
+    expires_in_millis: number;
+    is_impersonation: boolean;
+}, import("yup").AnyObject, {
+    user_id: undefined;
+    expires_in_millis: number;
+    is_impersonation: false;
+}, "">;
+export declare const sessionsCreateOutputSchema: import("yup").ObjectSchema<{
+    refresh_token: string;
+    access_token: string;
+}, import("yup").AnyObject, {
+    refresh_token: undefined;
+    access_token: undefined;
+}, "">;
+export declare const sessionsCrudReadSchema: import("yup").ObjectSchema<{
+    id: string;
+    user_id: string;
+    created_at: number;
+    is_impersonation: boolean;
+    last_used_at: number | undefined;
+    is_current_session: boolean | undefined;
+    last_used_at_end_user_ip_info: {
+        countryCode?: string | null | undefined;
+        regionCode?: string | null | undefined;
+        cityName?: string | null | undefined;
+        latitude?: number | null | undefined;
+        longitude?: number | null | undefined;
+        tzIdentifier?: string | null | undefined;
+        ip: string;
+    } | undefined;
+}, import("yup").AnyObject, {
+    id: undefined;
+    user_id: undefined;
+    created_at: undefined;
+    is_impersonation: undefined;
+    last_used_at: undefined;
+    is_current_session: undefined;
+    last_used_at_end_user_ip_info: {
+        ip: undefined;
+        countryCode: undefined;
+        regionCode: undefined;
+        cityName: undefined;
+        latitude: undefined;
+        longitude: undefined;
+        tzIdentifier: undefined;
+    };
+}, "">;
+export declare const sessionsCrudDeleteSchema: import("yup").MixedSchema<{} | undefined, import("yup").AnyObject, undefined, "">;
+export declare const sessionsCrud: import("../../crud").CrudSchemaFromOptions<{
+    serverReadSchema: import("yup").ObjectSchema<{
+        id: string;
+        user_id: string;
+        created_at: number;
+        is_impersonation: boolean;
+        last_used_at: number | undefined;
+        is_current_session: boolean | undefined;
+        last_used_at_end_user_ip_info: {
+            countryCode?: string | null | undefined;
+            regionCode?: string | null | undefined;
+            cityName?: string | null | undefined;
+            latitude?: number | null | undefined;
+            longitude?: number | null | undefined;
+            tzIdentifier?: string | null | undefined;
+            ip: string;
+        } | undefined;
+    }, import("yup").AnyObject, {
+        id: undefined;
+        user_id: undefined;
+        created_at: undefined;
+        is_impersonation: undefined;
+        last_used_at: undefined;
+        is_current_session: undefined;
+        last_used_at_end_user_ip_info: {
+            ip: undefined;
+            countryCode: undefined;
+            regionCode: undefined;
+            cityName: undefined;
+            latitude: undefined;
+            longitude: undefined;
+            tzIdentifier: undefined;
+        };
+    }, "">;
+    serverDeleteSchema: import("yup").MixedSchema<{} | undefined, import("yup").AnyObject, undefined, "">;
+    clientReadSchema: import("yup").ObjectSchema<{
+        id: string;
+        user_id: string;
+        created_at: number;
+        is_impersonation: boolean;
+        last_used_at: number | undefined;
+        is_current_session: boolean | undefined;
+        last_used_at_end_user_ip_info: {
+            countryCode?: string | null | undefined;
+            regionCode?: string | null | undefined;
+            cityName?: string | null | undefined;
+            latitude?: number | null | undefined;
+            longitude?: number | null | undefined;
+            tzIdentifier?: string | null | undefined;
+            ip: string;
+        } | undefined;
+    }, import("yup").AnyObject, {
+        id: undefined;
+        user_id: undefined;
+        created_at: undefined;
+        is_impersonation: undefined;
+        last_used_at: undefined;
+        is_current_session: undefined;
+        last_used_at_end_user_ip_info: {
+            ip: undefined;
+            countryCode: undefined;
+            regionCode: undefined;
+            cityName: undefined;
+            latitude: undefined;
+            longitude: undefined;
+            tzIdentifier: undefined;
+        };
+    }, "">;
+    clientDeleteSchema: import("yup").MixedSchema<{} | undefined, import("yup").AnyObject, undefined, "">;
+    docs: {
+        serverList: {
+            summary: string;
+            description: string;
+            tags: string[];
+        };
+        serverDelete: {
+            summary: string;
+            description: string;
+            tags: string[];
+        };
+        clientList: {
+            summary: string;
+            description: string;
+            tags: string[];
+        };
+        clientDelete: {
+            summary: string;
+            description: string;
+            tags: string[];
+        };
+    };
+}>;
+export type SessionsCrud = CrudTypeOf<typeof sessionsCrud>;

package/dist/interface/crud/sessions.js

@@ -0,0 +1,55 @@
+import { createCrud } from "../../crud";
+import { yupBoolean, yupMixed, yupNumber, yupObject, yupString } from "../../schema-fields";
+import { geoInfoSchema } from "../../utils/geo";
+// Create
+export const sessionsCrudServerCreateSchema = yupObject({
+    user_id: yupString().uuid().defined(),
+    expires_in_millis: yupNumber().max(1000 * 60 * 60 * 24 * 367).default(1000 * 60 * 60 * 24 * 365),
+    is_impersonation: yupBoolean().default(false),
+}).defined();
+export const sessionsCreateOutputSchema = yupObject({
+    refresh_token: yupString().defined(),
+    access_token: yupString().defined(),
+}).defined();
+export const sessionsCrudReadSchema = yupObject({
+    id: yupString().defined(),
+    user_id: yupString().uuid().defined(),
+    created_at: yupNumber().defined(),
+    is_impersonation: yupBoolean().defined(),
+    last_used_at: yupNumber().optional(),
+    is_current_session: yupBoolean(),
+    // TODO move this to a shared type
+    // TODO: what about if not trusted?
+    last_used_at_end_user_ip_info: geoInfoSchema.optional(),
+}).defined();
+// Delete
+export const sessionsCrudDeleteSchema = yupMixed();
+export const sessionsCrud = createCrud({
+    // serverCreateSchema: sessionsCrudServerCreateSchema,
+    serverReadSchema: sessionsCrudReadSchema,
+    serverDeleteSchema: sessionsCrudDeleteSchema,
+    clientReadSchema: sessionsCrudReadSchema,
+    clientDeleteSchema: sessionsCrudDeleteSchema,
+    docs: {
+        serverList: {
+            summary: "List sessions",
+            description: "List all sessions for the current user.",
+            tags: ["Sessions"],
+        },
+        serverDelete: {
+            summary: "Delete session",
+            description: "Delete a session by ID.",
+            tags: ["Sessions"],
+        },
+        clientList: {
+            summary: "List sessions",
+            description: "List all sessions for the current user.",
+            tags: ["Sessions"],
+        },
+        clientDelete: {
+            summary: "Delete session",
+            description: "Delete a session by ID.",
+            tags: ["Sessions"],
+        },
+    },
+});

package/dist/interface/crud/team-permissions.d.ts

@@ -46,6 +46,40 @@ export declare const teamPermissionsCrud: import("../../crud").CrudSchemaFromOpt
     };
 }>;
 export type TeamPermissionsCrud = CrudTypeOf<typeof teamPermissionsCrud>;
+export declare const teamPermissionCreatedWebhookEvent: {
+    type: string;
+    schema: import("yup").ObjectSchema<{
+        id: string;
+        user_id: string;
+        team_id: string;
+    }, import("yup").AnyObject, {
+        id: undefined;
+        user_id: undefined;
+        team_id: undefined;
+    }, "">;
+    metadata: {
+        summary: string;
+        description: string;
+        tags: string[];
+    };
+};
+export declare const teamPermissionDeletedWebhookEvent: {
+    type: string;
+    schema: import("yup").ObjectSchema<{
+        id: string;
+        user_id: string;
+        team_id: string;
+    }, import("yup").AnyObject, {
+        id: undefined;
+        user_id: undefined;
+        team_id: undefined;
+    }, "">;
+    metadata: {
+        summary: string;
+        description: string;
+        tags: string[];
+    };
+};
 export declare const teamPermissionDefinitionsCrudAdminReadSchema: import("yup").ObjectSchema<{
     id: string;
     description: string | undefined;

package/dist/interface/crud/team-permissions.js

@@ -36,6 +36,24 @@ export const teamPermissionsCrud = createCrud({
         },
     },
 });
+export const teamPermissionCreatedWebhookEvent = {
+    type: "team_permission.created",
+    schema: teamPermissionsCrud.server.readSchema,
+    metadata: {
+        summary: "Team Permission Created",
+        description: "This event is triggered when a team permission is created.",
+        tags: ["Teams"],
+    },
+};
+export const teamPermissionDeletedWebhookEvent = {
+    type: "team_permission.deleted",
+    schema: teamPermissionsCrud.server.readSchema,
+    metadata: {
+        summary: "Team Permission Deleted",
+        description: "This event is triggered when a team permission is deleted.",
+        tags: ["Teams"],
+    },
+};
 // =============== Team permission definitions =================
 export const teamPermissionDefinitionsCrudAdminReadSchema = yupObject({
     id: schemaFields.teamPermissionDefinitionIdSchema.defined(),

package/dist/interface/serverInterface.d.ts

@@ -5,6 +5,7 @@ import { ClientInterfaceOptions, StackClientInterface } from "./clientInterface"
 import { ContactChannelsCrud } from "./crud/contact-channels";
 import { CurrentUserCrud } from "./crud/current-user";
 import { ConnectedAccountAccessTokenCrud } from "./crud/oauth";
+import { SessionsCrud } from "./crud/sessions";
 import { TeamInvitationCrud } from "./crud/team-invitation";
 import { TeamMemberProfilesCrud } from "./crud/team-member-profiles";
 import { TeamMembershipsCrud } from "./crud/team-memberships";
@@ -74,7 +75,7 @@ export declare class StackServerInterface extends StackClientInterface {
     }): Promise<void>;
     updateServerUser(userId: string, update: UsersCrud['Server']['Update']): Promise<UsersCrud['Server']['Read']>;
     createServerProviderAccessToken(userId: string, provider: string, scope: string): Promise<ConnectedAccountAccessTokenCrud['Server']['Read']>;
-    createServerUserSession(userId: string, expiresInMillis: number): Promise<{
+    createServerUserSession(userId: string, expiresInMillis: number, isImpersonation: boolean): Promise<{
         accessToken: string;
         refreshToken: string;
     }>;
@@ -95,9 +96,15 @@ export declare class StackServerInterface extends StackClientInterface {
     deleteServerContactChannel(userId: string, contactChannelId: string): Promise<void>;
     listServerContactChannels(userId: string): Promise<ContactChannelsCrud['Server']['Read'][]>;
     sendServerContactChannelVerificationEmail(userId: string, contactChannelId: string, callbackUrl: string): Promise<void>;
+    listServerSessions(userId: string): Promise<SessionsCrud['Server']['Read'][]>;
+    deleteServerSession(sessionId: string): Promise<void>;
     sendServerTeamInvitation(options: {
         email: string;
         teamId: string;
         callbackUrl: string;
     }): Promise<void>;
+    updatePassword(options: {
+        oldPassword: string;
+        newPassword: string;
+    }): Promise<KnownErrors["PasswordConfirmationMismatch"] | KnownErrors["PasswordRequirementsNotMet"] | undefined>;
 }

package/dist/interface/serverInterface.js

@@ -58,10 +58,11 @@ export class StackServerInterface extends StackClientInterface {
         return user;
     }
     async getServerUserById(userId) {
-        const response = await this.sendServerRequest(urlString `/users/${userId}`, {}, null);
-        const user = await response.json();
-        if (!user)
-            return Result.error(new Error("Failed to get user"));
+        const responseOrError = await this.sendServerRequestAndCatchKnownError(urlString `/users/${userId}`, {}, null, [KnownErrors.UserNotFound]);
+        if (responseOrError.status === "error") {
+            return Result.error(responseOrError.error);
+        }
+        const user = await responseOrError.data.json();
         return Result.ok(user);
     }
     async listServerTeamInvitations(options) {
@@ -182,7 +183,7 @@ export class StackServerInterface extends StackClientInterface {
         }, null);
         return await response.json();
     }
-    async createServerUserSession(userId, expiresInMillis) {
+    async createServerUserSession(userId, expiresInMillis, isImpersonation) {
         const response = await this.sendServerRequest("/auth/sessions", {
             method: "POST",
             headers: {
@@ -191,6 +192,7 @@ export class StackServerInterface extends StackClientInterface {
             body: JSON.stringify({
                 user_id: userId,
                 expires_in_millis: expiresInMillis,
+                is_impersonation: isImpersonation,
             }),
         }, null);
         const result = await response.json();
@@ -285,6 +287,17 @@ export class StackServerInterface extends StackClientInterface {
             body: JSON.stringify({ callback_url: callbackUrl }),
         }, null);
     }
+    async listServerSessions(userId) {
+        const response = await this.sendServerRequest(urlString `/auth/sessions?user_id=${userId}`, {
+            method: "GET",
+        }, null);
+        return await response.json();
+    }
+    async deleteServerSession(sessionId) {
+        await this.sendServerRequest(urlString `/auth/sessions/${sessionId}`, {
+            method: "DELETE",
+        }, null);
+    }
     async sendServerTeamInvitation(options) {
         await this.sendServerRequest("/team-invitations/send-code", {
             method: "POST",
@@ -298,4 +311,19 @@ export class StackServerInterface extends StackClientInterface {
             }),
         }, null);
     }
+    async updatePassword(options) {
+        const res = await this.sendServerRequestAndCatchKnownError("/auth/password/update", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+                old_password: options.oldPassword,
+                new_password: options.newPassword,
+            }),
+        }, null, [KnownErrors.PasswordConfirmationMismatch, KnownErrors.PasswordRequirementsNotMet]);
+        if (res.status === "error") {
+            return res.error;
+        }
+    }
 }

package/dist/known-errors.d.ts

@@ -46,6 +46,11 @@ export type KnownErrors = {
     [K in keyof typeof KnownErrors]: InstanceType<typeof KnownErrors[K]>;
 };
 export declare const KnownErrors: {
+    CannotDeleteCurrentSession: KnownErrorConstructor<KnownError & KnownErrorBrand<"REFRESH_TOKEN_ERROR"> & {
+        constructorArgs: [statusCode: number, humanReadableMessage: string, details?: Json | undefined];
+    } & KnownErrorBrand<"CANNOT_DELETE_CURRENT_SESSION">, []> & {
+        errorCode: "CANNOT_DELETE_CURRENT_SESSION";
+    };
     UnsupportedError: KnownErrorConstructor<KnownError & KnownErrorBrand<"UNSUPPORTED_ERROR">, [originalErrorCode: string]> & {
         errorCode: "UNSUPPORTED_ERROR";
     };
@@ -194,7 +199,7 @@ export declare const KnownErrors: {
     };
     AccessTokenExpired: KnownErrorConstructor<KnownError & KnownErrorBrand<"SESSION_AUTHENTICATION_ERROR"> & {
         constructorArgs: [statusCode: number, humanReadableMessage: string, details?: Json | undefined];
-    } & KnownErrorBrand<"INVALID_SESSION_AUTHENTICATION"> & KnownErrorBrand<"INVALID_ACCESS_TOKEN"> & KnownErrorBrand<"ACCESS_TOKEN_EXPIRED">, [expiredAt: Date | undefined]> & {
+    } & KnownErrorBrand<"INVALID_SESSION_AUTHENTICATION"> & KnownErrorBrand<"INVALID_ACCESS_TOKEN"> & KnownErrorBrand<"ACCESS_TOKEN_EXPIRED">, [Date | undefined]> & {
         errorCode: "ACCESS_TOKEN_EXPIRED";
     };
     InvalidProjectForAccessToken: KnownErrorConstructor<KnownError & KnownErrorBrand<"SESSION_AUTHENTICATION_ERROR"> & {
@@ -386,5 +391,8 @@ export declare const KnownErrors: {
     ContactChannelAlreadyUsedForAuthBySomeoneElse: KnownErrorConstructor<KnownError & KnownErrorBrand<"CONTACT_CHANNEL_ALREADY_USED_FOR_AUTH_BY_SOMEONE_ELSE">, [type: "email", contactChannelValue?: string | undefined]> & {
         errorCode: "CONTACT_CHANNEL_ALREADY_USED_FOR_AUTH_BY_SOMEONE_ELSE";
     };
+    InvalidPollingCodeError: KnownErrorConstructor<KnownError & KnownErrorBrand<"INVALID_POLLING_CODE">, [details?: Json | undefined]> & {
+        errorCode: "INVALID_POLLING_CODE";
+    };
 };
 export {};

package/dist/known-errors.js

@@ -245,7 +245,7 @@ const AccessTokenExpired = createKnownErrorConstructor(InvalidAccessToken, "ACCE
     401,
     `Access token has expired. Please refresh it and try again.${expiredAt ? ` (The access token expired at ${expiredAt.toISOString()}.)` : ""}`,
     { expired_at_millis: expiredAt?.getTime() ?? null },
-], (json) => [json.expired_at_millis ?? undefined]);
+], (json) => [json.expired_at_millis ? new Date(json.expired_at_millis) : undefined]);
 const InvalidProjectForAccessToken = createKnownErrorConstructor(InvalidAccessToken, "INVALID_PROJECT_FOR_ACCESS_TOKEN", () => [
     401,
     "Access token not valid for this project.",
@@ -255,6 +255,10 @@ const RefreshTokenNotFoundOrExpired = createKnownErrorConstructor(RefreshTokenEr
     401,
     "Refresh token not found for this project, or the session has expired/been revoked.",
 ], () => []);
+const CannotDeleteCurrentSession = createKnownErrorConstructor(RefreshTokenError, "CANNOT_DELETE_CURRENT_SESSION", () => [
+    400,
+    "Cannot delete the current session.",
+], () => []);
 const ProviderRejected = createKnownErrorConstructor(RefreshTokenError, "PROVIDER_REJECTED", () => [
     401,
     "The provider refused to refresh their token. This usually means that the provider used to authenticate the user no longer regards this session as valid, and the user must re-authenticate.",
@@ -542,7 +546,13 @@ const ContactChannelAlreadyUsedForAuthBySomeoneElse = createKnownErrorConstructo
         `This ${type} is already used for authentication by another account.`,
     { type, contact_channel_value: contactChannelValue ?? null },
 ], (json) => [json.type, json.contact_channel_value]);
+const InvalidPollingCodeError = createKnownErrorConstructor(KnownError, "INVALID_POLLING_CODE", (details) => [
+    400,
+    "The polling code is invalid or does not exist.",
+    details,
+], (json) => [json]);
 export const KnownErrors = {
+    CannotDeleteCurrentSession,
     UnsupportedError,
     BodyParsingError,
     SchemaError,
@@ -633,6 +643,7 @@ export const KnownErrors = {
     TeamPermissionNotFound,
     OAuthProviderAccessDenied,
     ContactChannelAlreadyUsedForAuthBySomeoneElse,
+    InvalidPollingCodeError,
 };
 // ensure that all known error codes are unique
 const knownErrorCodes = new Set();

package/dist/utils/geo.d.ts

@@ -0,0 +1,19 @@
+import * as yup from "yup";
+export declare const geoInfoSchema: yup.ObjectSchema<{
+    ip: string;
+    countryCode: string | null | undefined;
+    regionCode: string | null | undefined;
+    cityName: string | null | undefined;
+    latitude: number | null | undefined;
+    longitude: number | null | undefined;
+    tzIdentifier: string | null | undefined;
+}, yup.AnyObject, {
+    ip: undefined;
+    countryCode: undefined;
+    regionCode: undefined;
+    cityName: undefined;
+    latitude: undefined;
+    longitude: undefined;
+    tzIdentifier: undefined;
+}, "">;
+export type GeoInfo = yup.InferType<typeof geoInfoSchema>;

package/dist/utils/geo.js

@@ -0,0 +1,10 @@
+import { yupNumber, yupObject, yupString } from "../schema-fields";
+export const geoInfoSchema = yupObject({
+    ip: yupString().defined(),
+    countryCode: yupString().nullable(),
+    regionCode: yupString().nullable(),
+    cityName: yupString().nullable(),
+    latitude: yupNumber().nullable(),
+    longitude: yupNumber().nullable(),
+    tzIdentifier: yupString().nullable(),
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stackframe/stack-shared",
-  "version": "2.7.26",
+  "version": "2.7.28",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "type": "module",