@stackframe/stack-shared 2.8.8 → 2.8.11

package/dist/esm/interface/crud/users.js

@@ -0,0 +1,139 @@
+// src/interface/crud/users.ts
+import { createCrud } from "../../crud";
+import * as fieldSchema from "../../schema-fields";
+import { teamsCrudServerReadSchema } from "./teams";
+var usersCrudServerUpdateSchema = fieldSchema.yupObject({
+  display_name: fieldSchema.userDisplayNameSchema.optional(),
+  profile_image_url: fieldSchema.profileImageUrlSchema.nullable().optional(),
+  client_metadata: fieldSchema.userClientMetadataSchema.optional(),
+  client_read_only_metadata: fieldSchema.userClientReadOnlyMetadataSchema.optional(),
+  server_metadata: fieldSchema.userServerMetadataSchema.optional(),
+  primary_email: fieldSchema.primaryEmailSchema.nullable().optional().nonEmpty(),
+  primary_email_verified: fieldSchema.primaryEmailVerifiedSchema.optional(),
+  primary_email_auth_enabled: fieldSchema.primaryEmailAuthEnabledSchema.optional(),
+  passkey_auth_enabled: fieldSchema.userOtpAuthEnabledSchema.optional(),
+  password: fieldSchema.userPasswordMutationSchema.optional(),
+  password_hash: fieldSchema.userPasswordHashMutationSchema.optional(),
+  otp_auth_enabled: fieldSchema.userOtpAuthEnabledMutationSchema.optional(),
+  totp_secret_base64: fieldSchema.userTotpSecretMutationSchema.optional(),
+  selected_team_id: fieldSchema.selectedTeamIdSchema.nullable().optional(),
+  is_anonymous: fieldSchema.yupBoolean().oneOf([false]).optional()
+}).defined();
+var usersCrudServerReadSchema = fieldSchema.yupObject({
+  id: fieldSchema.userIdSchema.defined(),
+  primary_email: fieldSchema.primaryEmailSchema.nullable().defined(),
+  primary_email_verified: fieldSchema.primaryEmailVerifiedSchema.defined(),
+  primary_email_auth_enabled: fieldSchema.primaryEmailAuthEnabledSchema.defined(),
+  display_name: fieldSchema.userDisplayNameSchema.nullable().defined(),
+  selected_team: teamsCrudServerReadSchema.nullable().defined(),
+  selected_team_id: fieldSchema.selectedTeamIdSchema.nullable().defined(),
+  profile_image_url: fieldSchema.profileImageUrlSchema.nullable().defined(),
+  signed_up_at_millis: fieldSchema.signedUpAtMillisSchema.defined(),
+  has_password: fieldSchema.userHasPasswordSchema.defined(),
+  otp_auth_enabled: fieldSchema.userOtpAuthEnabledSchema.defined(),
+  passkey_auth_enabled: fieldSchema.userOtpAuthEnabledSchema.defined(),
+  client_metadata: fieldSchema.userClientMetadataSchema,
+  client_read_only_metadata: fieldSchema.userClientReadOnlyMetadataSchema,
+  server_metadata: fieldSchema.userServerMetadataSchema,
+  last_active_at_millis: fieldSchema.userLastActiveAtMillisSchema.nonNullable().defined(),
+  is_anonymous: fieldSchema.yupBoolean().defined(),
+  oauth_providers: fieldSchema.yupArray(fieldSchema.yupObject({
+    id: fieldSchema.yupString().defined(),
+    account_id: fieldSchema.yupString().defined(),
+    email: fieldSchema.yupString().nullable()
+  }).defined()).defined().meta({ openapiField: { hidden: true } }),
+  /**
+   * @deprecated
+   */
+  auth_with_email: fieldSchema.yupBoolean().defined().meta({ openapiField: { hidden: true, description: "Whether the user can authenticate with their primary e-mail. If set to true, the user can log-in with credentials and/or magic link, if enabled in the project settings.", exampleValue: true } }),
+  /**
+   * @deprecated
+   */
+  requires_totp_mfa: fieldSchema.yupBoolean().defined().meta({ openapiField: { hidden: true, description: "Whether the user is required to use TOTP MFA to sign in", exampleValue: false } })
+}).defined();
+var usersCrudServerCreateSchema = usersCrudServerUpdateSchema.omit(["selected_team_id"]).concat(fieldSchema.yupObject({
+  oauth_providers: fieldSchema.yupArray(fieldSchema.yupObject({
+    id: fieldSchema.yupString().defined(),
+    account_id: fieldSchema.yupString().defined(),
+    email: fieldSchema.yupString().nullable().defined().default(null)
+  }).defined()).optional().meta({ openapiField: { hidden: true } }),
+  is_anonymous: fieldSchema.yupBoolean().optional()
+}).defined());
+var usersCrudServerDeleteSchema = fieldSchema.yupMixed();
+var usersCrud = createCrud({
+  serverReadSchema: usersCrudServerReadSchema,
+  serverUpdateSchema: usersCrudServerUpdateSchema,
+  serverCreateSchema: usersCrudServerCreateSchema,
+  serverDeleteSchema: usersCrudServerDeleteSchema,
+  docs: {
+    serverCreate: {
+      tags: ["Users"],
+      summary: "Create user",
+      description: "Creates a new user. E-mail authentication is always enabled, and no password is set, meaning the only way to authenticate the newly created user is through magic link."
+    },
+    serverRead: {
+      tags: ["Users"],
+      summary: "Get user",
+      description: "Gets a user by user ID."
+    },
+    serverUpdate: {
+      tags: ["Users"],
+      summary: "Update user",
+      description: "Updates a user. Only the values provided will be updated."
+    },
+    serverDelete: {
+      tags: ["Users"],
+      summary: "Delete user",
+      description: "Deletes a user. Use this with caution."
+    },
+    serverList: {
+      tags: ["Users"],
+      summary: "List users",
+      description: "Lists all the users in the project."
+    }
+  }
+});
+var userCreatedWebhookEvent = {
+  type: "user.created",
+  schema: usersCrud.server.readSchema,
+  metadata: {
+    summary: "User Created",
+    description: "This event is triggered when a user is created.",
+    tags: ["Users"]
+  }
+};
+var userUpdatedWebhookEvent = {
+  type: "user.updated",
+  schema: usersCrud.server.readSchema,
+  metadata: {
+    summary: "User Updated",
+    description: "This event is triggered when a user is updated.",
+    tags: ["Users"]
+  }
+};
+var webhookUserDeletedSchema = fieldSchema.yupObject({
+  id: fieldSchema.userIdSchema.defined(),
+  teams: fieldSchema.yupArray(fieldSchema.yupObject({
+    id: fieldSchema.yupString().defined()
+  })).defined()
+}).defined();
+var userDeletedWebhookEvent = {
+  type: "user.deleted",
+  schema: webhookUserDeletedSchema,
+  metadata: {
+    summary: "User Deleted",
+    description: "This event is triggered when a user is deleted.",
+    tags: ["Users"]
+  }
+};
+export {
+  userCreatedWebhookEvent,
+  userDeletedWebhookEvent,
+  userUpdatedWebhookEvent,
+  usersCrud,
+  usersCrudServerCreateSchema,
+  usersCrudServerDeleteSchema,
+  usersCrudServerReadSchema,
+  usersCrudServerUpdateSchema
+};
+//# sourceMappingURL=users.js.map

package/dist/esm/interface/crud/users.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/interface/crud/users.ts"],"sourcesContent":["import { CrudTypeOf, createCrud } from \"../../crud\";\nimport * as fieldSchema from \"../../schema-fields\";\nimport { WebhookEvent } from \"../webhooks\";\nimport { teamsCrudServerReadSchema } from \"./teams\";\n\nexport const usersCrudServerUpdateSchema = fieldSchema.yupObject({\n  display_name: fieldSchema.userDisplayNameSchema.optional(),\n  profile_image_url: fieldSchema.profileImageUrlSchema.nullable().optional(),\n  client_metadata: fieldSchema.userClientMetadataSchema.optional(),\n  client_read_only_metadata: fieldSchema.userClientReadOnlyMetadataSchema.optional(),\n  server_metadata: fieldSchema.userServerMetadataSchema.optional(),\n  primary_email: fieldSchema.primaryEmailSchema.nullable().optional().nonEmpty(),\n  primary_email_verified: fieldSchema.primaryEmailVerifiedSchema.optional(),\n  primary_email_auth_enabled: fieldSchema.primaryEmailAuthEnabledSchema.optional(),\n  passkey_auth_enabled: fieldSchema.userOtpAuthEnabledSchema.optional(),\n  password: fieldSchema.userPasswordMutationSchema.optional(),\n  password_hash: fieldSchema.userPasswordHashMutationSchema.optional(),\n  otp_auth_enabled: fieldSchema.userOtpAuthEnabledMutationSchema.optional(),\n  totp_secret_base64: fieldSchema.userTotpSecretMutationSchema.optional(),\n  selected_team_id: fieldSchema.selectedTeamIdSchema.nullable().optional(),\n  is_anonymous: fieldSchema.yupBoolean().oneOf([false]).optional(),\n}).defined();\n\nexport const usersCrudServerReadSchema = fieldSchema.yupObject({\n  id: fieldSchema.userIdSchema.defined(),\n  primary_email: fieldSchema.primaryEmailSchema.nullable().defined(),\n  primary_email_verified: fieldSchema.primaryEmailVerifiedSchema.defined(),\n  primary_email_auth_enabled: fieldSchema.primaryEmailAuthEnabledSchema.defined(),\n  display_name: fieldSchema.userDisplayNameSchema.nullable().defined(),\n  selected_team: teamsCrudServerReadSchema.nullable().defined(),\n  selected_team_id: fieldSchema.selectedTeamIdSchema.nullable().defined(),\n  profile_image_url: fieldSchema.profileImageUrlSchema.nullable().defined(),\n  signed_up_at_millis: fieldSchema.signedUpAtMillisSchema.defined(),\n  has_password: fieldSchema.userHasPasswordSchema.defined(),\n  otp_auth_enabled: fieldSchema.userOtpAuthEnabledSchema.defined(),\n  passkey_auth_enabled: fieldSchema.userOtpAuthEnabledSchema.defined(),\n  client_metadata: fieldSchema.userClientMetadataSchema,\n  client_read_only_metadata: fieldSchema.userClientReadOnlyMetadataSchema,\n  server_metadata: fieldSchema.userServerMetadataSchema,\n  last_active_at_millis: fieldSchema.userLastActiveAtMillisSchema.nonNullable().defined(),\n  is_anonymous: fieldSchema.yupBoolean().defined(),\n\n  oauth_providers: fieldSchema.yupArray(fieldSchema.yupObject({\n    id: fieldSchema.yupString().defined(),\n    account_id: fieldSchema.yupString().defined(),\n    email: fieldSchema.yupString().nullable(),\n  }).defined()).defined().meta({ openapiField: { hidden: true } }),\n\n  /**\n   * @deprecated\n   */\n  auth_with_email: fieldSchema.yupBoolean().defined().meta({ openapiField: { hidden: true, description: 'Whether the user can authenticate with their primary e-mail. If set to true, the user can log-in with credentials and/or magic link, if enabled in the project settings.', exampleValue: true } }),\n  /**\n   * @deprecated\n   */\n  requires_totp_mfa: fieldSchema.yupBoolean().defined().meta({ openapiField: { hidden: true, description: 'Whether the user is required to use TOTP MFA to sign in', exampleValue: false } }),\n}).defined();\n\nexport const usersCrudServerCreateSchema = usersCrudServerUpdateSchema.omit(['selected_team_id']).concat(fieldSchema.yupObject({\n  oauth_providers: fieldSchema.yupArray(fieldSchema.yupObject({\n    id: fieldSchema.yupString().defined(),\n    account_id: fieldSchema.yupString().defined(),\n    email: fieldSchema.yupString().nullable().defined().default(null),\n  }).defined()).optional().meta({ openapiField: { hidden: true } }),\n  is_anonymous: fieldSchema.yupBoolean().optional(),\n}).defined());\n\nexport const usersCrudServerDeleteSchema = fieldSchema.yupMixed();\n\nexport const usersCrud = createCrud({\n  serverReadSchema: usersCrudServerReadSchema,\n  serverUpdateSchema: usersCrudServerUpdateSchema,\n  serverCreateSchema: usersCrudServerCreateSchema,\n  serverDeleteSchema: usersCrudServerDeleteSchema,\n  docs: {\n    serverCreate: {\n      tags: [\"Users\"],\n      summary: 'Create user',\n      description: 'Creates a new user. E-mail authentication is always enabled, and no password is set, meaning the only way to authenticate the newly created user is through magic link.',\n    },\n    serverRead: {\n      tags: [\"Users\"],\n      summary: 'Get user',\n      description: 'Gets a user by user ID.',\n    },\n    serverUpdate: {\n      tags: [\"Users\"],\n      summary: 'Update user',\n      description: 'Updates a user. Only the values provided will be updated.',\n    },\n    serverDelete: {\n      tags: [\"Users\"],\n      summary: 'Delete user',\n      description: 'Deletes a user. Use this with caution.',\n    },\n    serverList: {\n      tags: [\"Users\"],\n      summary: 'List users',\n      description: 'Lists all the users in the project.',\n    },\n  },\n});\nexport type UsersCrud = CrudTypeOf<typeof usersCrud>;\n\nexport const userCreatedWebhookEvent = {\n  type: \"user.created\",\n  schema: usersCrud.server.readSchema,\n  metadata: {\n    summary: \"User Created\",\n    description: \"This event is triggered when a user is created.\",\n    tags: [\"Users\"],\n  },\n} satisfies WebhookEvent<typeof usersCrud.server.readSchema>;\n\nexport const userUpdatedWebhookEvent = {\n  type: \"user.updated\",\n  schema: usersCrud.server.readSchema,\n  metadata: {\n    summary: \"User Updated\",\n    description: \"This event is triggered when a user is updated.\",\n    tags: [\"Users\"],\n  },\n} satisfies WebhookEvent<typeof usersCrud.server.readSchema>;\n\nconst webhookUserDeletedSchema = fieldSchema.yupObject({\n  id: fieldSchema.userIdSchema.defined(),\n  teams: fieldSchema.yupArray(fieldSchema.yupObject({\n    id: fieldSchema.yupString().defined(),\n  })).defined(),\n}).defined();\n\nexport const userDeletedWebhookEvent = {\n  type: \"user.deleted\",\n  schema: webhookUserDeletedSchema,\n  metadata: {\n    summary: \"User Deleted\",\n    description: \"This event is triggered when a user is deleted.\",\n    tags: [\"Users\"],\n  },\n} satisfies WebhookEvent<typeof webhookUserDeletedSchema>;\n"],"mappings":"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","names":[]}

package/dist/esm/interface/serverInterface.js

@@ -0,0 +1,485 @@
+// src/interface/serverInterface.ts
+import { KnownErrors } from "../known-errors";
+import { StackAssertionError } from "../utils/errors";
+import { filterUndefined } from "../utils/objects";
+import { Result } from "../utils/results";
+import { urlString } from "../utils/urls";
+import {
+  StackClientInterface
+} from "./clientInterface";
+var StackServerInterface = class extends StackClientInterface {
+  constructor(options) {
+    super(options);
+    this.options = options;
+  }
+  async sendServerRequest(path, options, session, requestType = "server") {
+    return await this.sendClientRequest(
+      path,
+      {
+        ...options,
+        headers: {
+          "x-stack-secret-server-key": "secretServerKey" in this.options ? this.options.secretServerKey : "",
+          ...options.headers
+        }
+      },
+      session,
+      requestType
+    );
+  }
+  async sendServerRequestAndCatchKnownError(path, requestOptions, tokenStoreOrNull, errorsToCatch) {
+    try {
+      return Result.ok(await this.sendServerRequest(path, requestOptions, tokenStoreOrNull));
+    } catch (e) {
+      for (const errorType of errorsToCatch) {
+        if (e instanceof errorType) {
+          return Result.error(e);
+        }
+      }
+      throw e;
+    }
+  }
+  async createServerUser(data) {
+    const response = await this.sendServerRequest(
+      "/users",
+      {
+        method: "POST",
+        headers: {
+          "content-type": "application/json"
+        },
+        body: JSON.stringify(data)
+      },
+      null
+    );
+    return await response.json();
+  }
+  async getServerUserByToken(session) {
+    const responseOrError = await this.sendServerRequestAndCatchKnownError(
+      "/users/me",
+      {},
+      session,
+      [KnownErrors.CannotGetOwnUserWithoutUser]
+    );
+    if (responseOrError.status === "error") {
+      if (responseOrError.error instanceof KnownErrors.CannotGetOwnUserWithoutUser) {
+        return null;
+      } else {
+        throw new StackAssertionError("Unexpected uncaught error", { cause: responseOrError.error });
+      }
+    }
+    const response = responseOrError.data;
+    const user = await response.json();
+    if (!user) throw new StackAssertionError("User endpoint returned null; this should never happen");
+    return user;
+  }
+  async getServerUserById(userId) {
+    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) {
+    const response = await this.sendServerRequest(
+      urlString`/team-invitations?team_id=${options.teamId}`,
+      {},
+      null
+    );
+    const result = await response.json();
+    return result.items;
+  }
+  async revokeServerTeamInvitation(invitationId, teamId) {
+    await this.sendServerRequest(
+      urlString`/team-invitations/${invitationId}?team_id=${teamId}`,
+      { method: "DELETE" },
+      null
+    );
+  }
+  async listServerTeamMemberProfiles(options) {
+    const response = await this.sendServerRequest(
+      urlString`/team-member-profiles?team_id=${options.teamId}`,
+      {},
+      null
+    );
+    const result = await response.json();
+    return result.items;
+  }
+  async getServerTeamMemberProfile(options) {
+    const response = await this.sendServerRequest(
+      urlString`/team-member-profiles/${options.teamId}/${options.userId}`,
+      {},
+      null
+    );
+    return await response.json();
+  }
+  async listServerTeamPermissions(options, session) {
+    const response = await this.sendServerRequest(
+      `/team-permissions?${new URLSearchParams(filterUndefined({
+        user_id: options.userId,
+        team_id: options.teamId,
+        recursive: options.recursive.toString()
+      }))}`,
+      {},
+      session
+    );
+    const result = await response.json();
+    return result.items;
+  }
+  async listServerProjectPermissions(options, session) {
+    const response = await this.sendServerRequest(
+      `/project-permissions?${new URLSearchParams(filterUndefined({
+        user_id: options.userId,
+        recursive: options.recursive.toString()
+      }))}`,
+      {},
+      session
+    );
+    const result = await response.json();
+    return result.items;
+  }
+  async listServerUsers(options) {
+    const searchParams = new URLSearchParams(filterUndefined({
+      cursor: options.cursor,
+      limit: options.limit?.toString(),
+      desc: options.desc?.toString(),
+      ...options.orderBy ? {
+        order_by: {
+          signedUpAt: "signed_up_at"
+        }[options.orderBy]
+      } : {},
+      ...options.query ? {
+        query: options.query
+      } : {}
+    }));
+    const response = await this.sendServerRequest("/users?" + searchParams.toString(), {}, null);
+    return await response.json();
+  }
+  async listServerTeams(options) {
+    const response = await this.sendServerRequest(
+      `/teams?${new URLSearchParams(filterUndefined({
+        user_id: options?.userId
+      }))}`,
+      {},
+      null
+    );
+    const result = await response.json();
+    return result.items;
+  }
+  async getServerTeam(teamId) {
+    const response = await this.sendServerRequest(
+      `/teams/${teamId}`,
+      {},
+      null
+    );
+    return await response.json();
+  }
+  async listServerTeamUsers(teamId) {
+    const response = await this.sendServerRequest(`/users?team_id=${teamId}`, {}, null);
+    const result = await response.json();
+    return result.items;
+  }
+  /* when passing a session, the user will be added to the team */
+  async createServerTeam(data) {
+    const response = await this.sendServerRequest(
+      "/teams",
+      {
+        method: "POST",
+        headers: {
+          "content-type": "application/json"
+        },
+        body: JSON.stringify(data)
+      },
+      null
+    );
+    return await response.json();
+  }
+  async updateServerTeam(teamId, data) {
+    const response = await this.sendServerRequest(
+      urlString`/teams/${teamId}`,
+      {
+        method: "PATCH",
+        headers: {
+          "content-type": "application/json"
+        },
+        body: JSON.stringify(data)
+      },
+      null
+    );
+    return await response.json();
+  }
+  async deleteServerTeam(teamId) {
+    await this.sendServerRequest(
+      urlString`/teams/${teamId}`,
+      { method: "DELETE" },
+      null
+    );
+  }
+  async addServerUserToTeam(options) {
+    const response = await this.sendServerRequest(
+      urlString`/team-memberships/${options.teamId}/${options.userId}`,
+      {
+        method: "POST",
+        headers: {
+          "content-type": "application/json"
+        },
+        body: JSON.stringify({})
+      },
+      null
+    );
+    return await response.json();
+  }
+  async removeServerUserFromTeam(options) {
+    await this.sendServerRequest(
+      urlString`/team-memberships/${options.teamId}/${options.userId}`,
+      {
+        method: "DELETE",
+        headers: {
+          "content-type": "application/json"
+        },
+        body: JSON.stringify({})
+      },
+      null
+    );
+  }
+  async updateServerUser(userId, update) {
+    const response = await this.sendServerRequest(
+      urlString`/users/${userId}`,
+      {
+        method: "PATCH",
+        headers: {
+          "content-type": "application/json"
+        },
+        body: JSON.stringify(update)
+      },
+      null
+    );
+    return await response.json();
+  }
+  async createServerProviderAccessToken(userId, provider, scope) {
+    const response = await this.sendServerRequest(
+      urlString`/connected-accounts/${userId}/${provider}/access-token`,
+      {
+        method: "POST",
+        headers: {
+          "content-type": "application/json"
+        },
+        body: JSON.stringify({ scope })
+      },
+      null
+    );
+    return await response.json();
+  }
+  async createServerUserSession(userId, expiresInMillis, isImpersonation) {
+    const response = await this.sendServerRequest(
+      "/auth/sessions",
+      {
+        method: "POST",
+        headers: {
+          "content-type": "application/json"
+        },
+        body: JSON.stringify({
+          user_id: userId,
+          expires_in_millis: expiresInMillis,
+          is_impersonation: isImpersonation
+        })
+      },
+      null
+    );
+    const result = await response.json();
+    return {
+      accessToken: result.access_token,
+      refreshToken: result.refresh_token
+    };
+  }
+  async leaveServerTeam(options) {
+    await this.sendClientRequest(
+      urlString`/team-memberships/${options.teamId}/${options.userId}`,
+      {
+        method: "DELETE",
+        headers: {
+          "content-type": "application/json"
+        },
+        body: JSON.stringify({})
+      },
+      null
+    );
+  }
+  async updateServerTeamMemberProfile(options) {
+    await this.sendServerRequest(
+      urlString`/team-member-profiles/${options.teamId}/${options.userId}`,
+      {
+        method: "PATCH",
+        headers: {
+          "content-type": "application/json"
+        },
+        body: JSON.stringify(options.profile)
+      },
+      null
+    );
+  }
+  async grantServerTeamUserPermission(teamId, userId, permissionId) {
+    await this.sendServerRequest(
+      urlString`/team-permissions/${teamId}/${userId}/${permissionId}`,
+      {
+        method: "POST",
+        headers: {
+          "content-type": "application/json"
+        },
+        body: JSON.stringify({})
+      },
+      null
+    );
+  }
+  async revokeServerTeamUserPermission(teamId, userId, permissionId) {
+    await this.sendServerRequest(
+      urlString`/team-permissions/${teamId}/${userId}/${permissionId}`,
+      {
+        method: "DELETE",
+        headers: {
+          "content-type": "application/json"
+        },
+        body: JSON.stringify({})
+      },
+      null
+    );
+  }
+  async deleteServerUser(userId) {
+    await this.sendServerRequest(
+      urlString`/users/${userId}`,
+      {
+        method: "DELETE",
+        headers: {
+          "content-type": "application/json"
+        },
+        body: JSON.stringify({})
+      },
+      null
+    );
+  }
+  async createServerContactChannel(data) {
+    const response = await this.sendServerRequest(
+      "/contact-channels",
+      {
+        method: "POST",
+        headers: {
+          "content-type": "application/json"
+        },
+        body: JSON.stringify(data)
+      },
+      null
+    );
+    return await response.json();
+  }
+  async updateServerContactChannel(userId, contactChannelId, data) {
+    const response = await this.sendServerRequest(
+      urlString`/contact-channels/${userId}/${contactChannelId}`,
+      {
+        method: "PATCH",
+        headers: {
+          "content-type": "application/json"
+        },
+        body: JSON.stringify(data)
+      },
+      null
+    );
+    return await response.json();
+  }
+  async deleteServerContactChannel(userId, contactChannelId) {
+    await this.sendServerRequest(
+      urlString`/contact-channels/${userId}/${contactChannelId}`,
+      {
+        method: "DELETE"
+      },
+      null
+    );
+  }
+  async listServerContactChannels(userId) {
+    const response = await this.sendServerRequest(
+      urlString`/contact-channels?user_id=${userId}`,
+      {
+        method: "GET"
+      },
+      null
+    );
+    const json = await response.json();
+    return json.items;
+  }
+  async sendServerContactChannelVerificationEmail(userId, contactChannelId, callbackUrl) {
+    await this.sendServerRequest(
+      urlString`/contact-channels/${userId}/${contactChannelId}/send-verification-code`,
+      {
+        method: "POST",
+        headers: {
+          "content-type": "application/json"
+        },
+        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",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          email: options.email,
+          team_id: options.teamId,
+          callback_url: options.callbackUrl
+        })
+      },
+      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;
+    }
+  }
+};
+export {
+  StackServerInterface
+};
+//# sourceMappingURL=serverInterface.js.map