@hexclave/shared 1.0.2 → 1.0.5

package/src/interface/crud/projects.ts

@@ -0,0 +1,229 @@
+import { CrudTypeOf, createCrud } from "../../crud";
+import { ALL_APPS } from "../../apps/apps-config";
+import * as schemaFields from "../../schema-fields";
+import { yupArray, yupObject, yupString } from "../../schema-fields";
+
+const teamPermissionSchema = yupObject({
+  id: yupString().defined(),
+}).defined();
+
+const oauthProviderReadSchema = yupObject({
+  provider_config_id: schemaFields.yupString().defined(),
+  id: schemaFields.oauthIdSchema.defined(),
+  type: schemaFields.oauthTypeSchema.defined(),
+  client_id: schemaFields.yupDefinedAndNonEmptyWhen(
+    schemaFields.oauthClientIdSchema,
+    { type: 'standard' },
+  ),
+  client_secret: schemaFields.yupDefinedAndNonEmptyWhen(
+    schemaFields.oauthClientSecretSchema,
+    { type: 'standard' },
+  ),
+
+  // extra params
+  facebook_config_id: schemaFields.oauthFacebookConfigIdSchema.optional(),
+  microsoft_tenant_id: schemaFields.oauthMicrosoftTenantIdSchema.optional(),
+  apple_bundle_ids: schemaFields.oauthAppleBundleIdsSchema.optional(),
+});
+
+const oauthProviderWriteSchema = oauthProviderReadSchema.omit(['provider_config_id']);
+
+const enabledOAuthProviderSchema = yupObject({
+  id: schemaFields.oauthIdSchema.defined(),
+});
+
+const onboardingConfigChoiceValues = ["create-new", "link-existing"] as const;
+const onboardingSignInMethodValues = ["credential", "magicLink", "passkey", "google", "github", "microsoft"] as const;
+const onboardingPaymentsCountryValues = ["US", "OTHER"] as const;
+
+const projectOnboardingStateSchema = yupObject({
+  selected_config_choice: yupString().oneOf(onboardingConfigChoiceValues).defined(),
+  selected_apps: yupArray(yupString().oneOf(Object.keys(ALL_APPS)).defined()).defined(),
+  selected_sign_in_methods: yupArray(yupString().oneOf(onboardingSignInMethodValues).defined()).defined(),
+  selected_email_theme_id: schemaFields.emailThemeSchema.nullable().defined(),
+  selected_payments_country: yupString().oneOf(onboardingPaymentsCountryValues).defined(),
+});
+
+export const emailConfigSchema = yupObject({
+  type: schemaFields.emailTypeSchema.defined(),
+  host: schemaFields.yupDefinedAndNonEmptyWhen(schemaFields.emailHostSchema, {
+    type: 'standard',
+  }),
+  port: schemaFields.yupDefinedWhen(schemaFields.emailPortSchema, {
+    type: 'standard',
+  }),
+  username: schemaFields.yupDefinedAndNonEmptyWhen(schemaFields.emailUsernameSchema, {
+    type: 'standard',
+  }),
+  password: schemaFields.yupDefinedAndNonEmptyWhen(schemaFields.emailPasswordSchema, {
+    type: 'standard',
+  }),
+  sender_name: schemaFields.yupDefinedAndNonEmptyWhen(schemaFields.emailSenderNameSchema, {
+    type: 'standard',
+  }),
+  sender_email: schemaFields.yupDefinedAndNonEmptyWhen(schemaFields.emailSenderEmailSchema, {
+    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://')
+    .meta({ openapiField: { description: 'URL. Must start with http:// or https://', exampleValue: 'https://example.com' } }),
+  handler_path: schemaFields.handlerPathSchema.defined(),
+});
+
+export const projectsCrudAdminReadSchema = yupObject({
+  id: schemaFields.projectIdSchema.defined(),
+  display_name: schemaFields.projectDisplayNameSchema.defined(),
+  description: schemaFields.projectDescriptionSchema.nonNullable().defined(),
+  logo_url: schemaFields.projectLogoUrlSchema.nullable().optional(),
+  logo_full_url: schemaFields.projectLogoFullUrlSchema.nullable().optional(),
+  logo_dark_mode_url: schemaFields.projectLogoDarkModeUrlSchema.nullable().optional(),
+  logo_full_dark_mode_url: schemaFields.projectLogoFullDarkModeUrlSchema.nullable().optional(),
+  created_at_millis: schemaFields.projectCreatedAtMillisSchema.defined(),
+  is_production_mode: schemaFields.projectIsProductionModeSchema.defined(),
+  is_development_environment: schemaFields.yupBoolean().defined(),
+  owner_team_id: schemaFields.yupString().nullable().defined(),
+  onboarding_status: schemaFields.projectOnboardingStatusSchema.defined(),
+  onboarding_state: projectOnboardingStateSchema.nullable().optional(),
+  /** @deprecated */
+  config: yupObject({
+    allow_localhost: schemaFields.projectAllowLocalhostSchema.defined(),
+    sign_up_enabled: schemaFields.projectSignUpEnabledSchema.defined(),
+    credential_enabled: schemaFields.projectCredentialEnabledSchema.defined(),
+    magic_link_enabled: schemaFields.projectMagicLinkEnabledSchema.defined(),
+    passkey_enabled: schemaFields.projectPasskeyEnabledSchema.defined(),
+    // TODO: remove this
+    client_team_creation_enabled: schemaFields.projectClientTeamCreationEnabledSchema.defined(),
+    client_user_deletion_enabled: schemaFields.projectClientUserDeletionEnabledSchema.defined(),
+    allow_user_api_keys: schemaFields.yupBoolean().defined(),
+    allow_team_api_keys: schemaFields.yupBoolean().defined(),
+    oauth_providers: yupArray(oauthProviderReadSchema.defined()).defined(),
+    enabled_oauth_providers: yupArray(enabledOAuthProviderSchema.defined()).defined().meta({ openapiField: { hidden: true } }),
+    domains: yupArray(domainSchema.defined()).defined(),
+    email_config: emailConfigSchema.defined(),
+    email_theme: schemaFields.emailThemeSchema.defined(),
+    create_team_on_sign_up: schemaFields.projectCreateTeamOnSignUpSchema.defined(),
+    team_creator_default_permissions: yupArray(teamPermissionSchema.defined()).defined(),
+    team_member_default_permissions: yupArray(teamPermissionSchema.defined()).defined(),
+    user_default_permissions: yupArray(teamPermissionSchema.defined()).defined(),
+    oauth_account_merge_strategy: schemaFields.oauthAccountMergeStrategySchema.defined(),
+  }).defined().meta({ openapiField: { hidden: true } }),
+}).defined();
+
+export const projectsCrudClientReadSchema = yupObject({
+  id: schemaFields.projectIdSchema.defined(),
+  display_name: schemaFields.projectDisplayNameSchema.defined(),
+  config: yupObject({
+    sign_up_enabled: schemaFields.projectSignUpEnabledSchema.defined(),
+    credential_enabled: schemaFields.projectCredentialEnabledSchema.defined(),
+    magic_link_enabled: schemaFields.projectMagicLinkEnabledSchema.defined(),
+    passkey_enabled: schemaFields.projectPasskeyEnabledSchema.defined(),
+    client_team_creation_enabled: schemaFields.projectClientTeamCreationEnabledSchema.defined(),
+    client_user_deletion_enabled: schemaFields.projectClientUserDeletionEnabledSchema.defined(),
+    allow_localhost: schemaFields.projectAllowLocalhostSchema.defined(),
+    allow_user_api_keys: schemaFields.yupBoolean().defined(),
+    allow_team_api_keys: schemaFields.yupBoolean().defined(),
+    enabled_oauth_providers: yupArray(enabledOAuthProviderSchema.defined()).defined().meta({ openapiField: { hidden: true } }),
+    domains: yupArray(domainSchema.defined()).defined(),
+  }).defined().meta({ openapiField: { hidden: true } }),
+}).defined();
+
+
+export const projectsCrudAdminUpdateSchema = yupObject({
+  display_name: schemaFields.projectDisplayNameSchema.optional(),
+  description: schemaFields.projectDescriptionSchema.optional(),
+  logo_url: schemaFields.projectLogoUrlSchema.nullable().optional(),
+  logo_full_url: schemaFields.projectLogoFullUrlSchema.nullable().optional(),
+  logo_dark_mode_url: schemaFields.projectLogoDarkModeUrlSchema.nullable().optional(),
+  logo_full_dark_mode_url: schemaFields.projectLogoFullDarkModeUrlSchema.nullable().optional(),
+  is_production_mode: schemaFields.projectIsProductionModeSchema.optional(),
+  onboarding_status: schemaFields.projectOnboardingStatusSchema.optional(),
+  onboarding_state: projectOnboardingStateSchema.nullable().optional(),
+  /** @deprecated */
+  config: yupObject({
+    sign_up_enabled: schemaFields.projectSignUpEnabledSchema.optional(),
+    credential_enabled: schemaFields.projectCredentialEnabledSchema.optional(),
+    magic_link_enabled: schemaFields.projectMagicLinkEnabledSchema.optional(),
+    passkey_enabled: schemaFields.projectPasskeyEnabledSchema.optional(),
+    client_team_creation_enabled: schemaFields.projectClientTeamCreationEnabledSchema.optional(),
+    client_user_deletion_enabled: schemaFields.projectClientUserDeletionEnabledSchema.optional(),
+    allow_localhost: schemaFields.projectAllowLocalhostSchema.optional(),
+    allow_user_api_keys: schemaFields.yupBoolean().optional(),
+    allow_team_api_keys: schemaFields.yupBoolean().optional(),
+    email_config: emailConfigSchema.optional().default(undefined),
+    email_theme: schemaFields.emailThemeSchema.optional(),
+    domains: yupArray(domainSchema.defined()).optional().default(undefined),
+    oauth_providers: yupArray(oauthProviderWriteSchema.defined()).optional().default(undefined),
+    create_team_on_sign_up: schemaFields.projectCreateTeamOnSignUpSchema.optional(),
+    team_creator_default_permissions: yupArray(teamPermissionSchema.defined()).optional(),
+    team_member_default_permissions: yupArray(teamPermissionSchema.defined()).optional(),
+    user_default_permissions: yupArray(teamPermissionSchema.defined()).optional(),
+    oauth_account_merge_strategy: schemaFields.oauthAccountMergeStrategySchema.optional(),
+    require_email_verification: schemaFields.yupBoolean().optional(),
+  }).optional().default(undefined),
+}).defined();
+
+export const projectsCrudAdminCreateSchema = projectsCrudAdminUpdateSchema.concat(yupObject({
+  display_name: schemaFields.projectDisplayNameSchema.defined(),
+  is_development_environment: schemaFields.yupBoolean().optional(),
+  owner_team_id: schemaFields.yupString().uuid().defined(),
+}).defined());
+
+export const projectsCrudAdminDeleteSchema = schemaFields.yupMixed();
+
+export const clientProjectsCrud = createCrud({
+  clientReadSchema: projectsCrudClientReadSchema,
+  docs: {
+    clientRead: {
+      summary: 'Get the current project',
+      description: 'Get the current project information including display name, OAuth providers and authentication methods. Useful for displaying the available login options to the user.',
+      tags: ['Projects'],
+    },
+  },
+});
+export type ClientProjectsCrud = CrudTypeOf<typeof clientProjectsCrud>;
+
+export const projectsCrud = createCrud({
+  adminReadSchema: projectsCrudAdminReadSchema,
+  adminUpdateSchema: projectsCrudAdminUpdateSchema,
+  adminDeleteSchema: projectsCrudAdminDeleteSchema,
+  docs: {
+    adminRead: {
+      summary: 'Get the current project',
+      description: 'Get the current project information and configuration including display name, OAuth providers, email configuration, etc.',
+      tags: ['Projects'],
+      hidden: true,
+    },
+    adminUpdate: {
+      summary: 'Update the current project',
+      description: 'Update the current project information and configuration including display name, OAuth providers, email configuration, etc.',
+      tags: ['Projects'],
+      hidden: true,
+    },
+    adminDelete: {
+      summary: 'Delete the current project',
+      description: 'Delete the current project and all associated data (including users, teams, API keys, project configs, etc.). Be careful, this action is irreversible.',
+      tags: ['Projects'],
+      hidden: true,
+    },
+  },
+});
+export type ProjectsCrud = CrudTypeOf<typeof projectsCrud>;
+
+export const adminUserProjectsCrud = createCrud({
+  clientReadSchema: projectsCrudAdminReadSchema,
+  clientCreateSchema: projectsCrudAdminCreateSchema,
+  docs: {
+    clientList: {
+      hidden: true,
+    },
+    clientCreate: {
+      hidden: true,
+    },
+  },
+});
+export type AdminUserProjectsCrud = CrudTypeOf<typeof adminUserProjectsCrud>;

package/src/interface/crud/session-replays.ts

@@ -0,0 +1,85 @@
+export type AdminListSessionReplaysOptions = {
+  limit?: number,
+  cursor?: string,
+  user_ids?: string[],
+  team_ids?: string[],
+  duration_ms_min?: number,
+  duration_ms_max?: number,
+  last_event_at_from_millis?: number,
+  last_event_at_to_millis?: number,
+  click_count_min?: number,
+};
+
+export type AdminListSessionReplaysResponse = {
+  items: Array<{
+    id: string,
+    project_user: {
+      id: string,
+      display_name: string | null,
+      primary_email: string | null,
+    },
+    started_at_millis: number,
+    last_event_at_millis: number,
+    chunk_count: number,
+    event_count: number,
+  }>,
+  pagination: {
+    next_cursor: string | null,
+  },
+};
+
+export type AdminGetSessionReplayResponse = {
+  id: string,
+  project_user: {
+    id: string,
+    display_name: string | null,
+    primary_email: string | null,
+  },
+  started_at_millis: number,
+  last_event_at_millis: number,
+  chunk_count: number,
+  event_count: number,
+};
+
+export type AdminListSessionReplayChunksOptions = {
+  limit?: number,
+  cursor?: string,
+};
+
+export type AdminListSessionReplayChunksResponse = {
+  items: Array<{
+    id: string,
+    batch_id: string,
+    session_replay_segment_id: string | null,
+    browser_session_id: string | null,
+    event_count: number,
+    byte_length: number,
+    first_event_at_millis: number,
+    last_event_at_millis: number,
+    created_at_millis: number,
+  }>,
+  pagination: {
+    next_cursor: string | null,
+  },
+};
+
+export type AdminGetSessionReplayChunkEventsResponse = {
+  events: unknown[],
+};
+
+export type AdminGetSessionReplayAllEventsResponse = {
+  chunks: Array<{
+    id: string,
+    batch_id: string,
+    session_replay_segment_id: string | null,
+    event_count: number,
+    byte_length: number,
+    first_event_at_millis: number,
+    last_event_at_millis: number,
+    created_at_millis: number,
+  }>,
+  chunk_events: Array<{
+    chunk_id: string,
+    events: unknown[],
+  }>,
+};

package/src/interface/crud/sessions.ts

@@ -0,0 +1,66 @@
+import { CrudTypeOf, 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"],
+    },
+  },
+});
+export type SessionsCrud = CrudTypeOf<typeof sessionsCrud>;

package/src/interface/crud/sign-up-rules.ts

@@ -0,0 +1,12 @@
+export type SignUpRuleAction = {
+  type: 'allow' | 'reject' | 'restrict' | 'log',
+  message?: string,
+};
+
+export type SignUpRule = {
+  enabled: boolean,
+  displayName: string | undefined,
+  priority: number,
+  condition: string | undefined,
+  action: SignUpRuleAction,
+};

package/src/interface/crud/svix-token.ts

@@ -0,0 +1,20 @@
+import { CrudTypeOf, createCrud } from "../../crud";
+import { yupObject, yupString } from "../../schema-fields";
+
+export const svixTokenAdminReadSchema = yupObject({
+  token: yupString().defined(),
+  url: yupString().optional(),
+}).defined();
+
+export const svixTokenAdminCreateSchema = yupObject({}).defined();
+
+export const svixTokenCrud = createCrud({
+  adminReadSchema: svixTokenAdminReadSchema,
+  adminCreateSchema: svixTokenAdminCreateSchema,
+  docs: {
+    adminCreate: {
+      hidden: true,
+    },
+  }
+});
+export type SvixTokenCrud = CrudTypeOf<typeof svixTokenCrud>;

package/src/interface/crud/team-invitation-details.ts

@@ -0,0 +1,22 @@
+import { CrudTypeOf, createCrud } from "../../crud";
+import * as schemaFields from "../../schema-fields";
+import { yupObject } from "../../schema-fields";
+
+
+export const teamInvitationDetailsClientReadSchema = yupObject({
+  team_id: schemaFields.teamIdSchema.defined(),
+  team_display_name: schemaFields.teamDisplayNameSchema.defined(),
+}).defined();
+
+export const teamInvitationDetailsCrud = createCrud({
+  clientReadSchema: teamInvitationDetailsClientReadSchema,
+  docs: {
+    clientRead: {
+      summary: "Get the team details with invitation code",
+      description: "",
+      tags: ["Teams"],
+    },
+  },
+});
+
+export type TeamInvitationDetailsCrud = CrudTypeOf<typeof teamInvitationDetailsCrud>;

package/src/interface/crud/team-invitation.ts

@@ -0,0 +1,35 @@
+import { CrudTypeOf, createCrud } from "../../crud";
+import * as schemaFields from "../../schema-fields";
+import { yupObject } from "../../schema-fields";
+
+export const teamInvitationDetailsClientReadSchema = yupObject({
+  id: schemaFields.yupString().uuid().defined(),
+  team_id: schemaFields.teamIdSchema.defined(),
+  team_display_name: schemaFields.yupString().defined(),
+  expires_at_millis: schemaFields.yupNumber().defined(),
+  recipient_email: schemaFields.emailSchema.defined(),
+}).defined();
+
+export const teamInvitationCrud = createCrud({
+  clientReadSchema: teamInvitationDetailsClientReadSchema,
+  clientDeleteSchema: schemaFields.yupMixed(),
+  docs: {
+    clientRead: {
+      summary: "Get the team details with invitation code",
+      description: "",
+      tags: ["Teams"],
+    },
+    clientList: {
+      summary: "List team invitations",
+      description: "",
+      tags: ["Teams"],
+    },
+    clientDelete: {
+      summary: "Delete a team invitation",
+      description: "",
+      tags: ["Teams"],
+    },
+  },
+});
+
+export type TeamInvitationCrud = CrudTypeOf<typeof teamInvitationCrud>;

package/src/interface/crud/team-member-profiles.ts

@@ -0,0 +1,61 @@
+import { CrudTypeOf, createCrud } from "../../crud";
+import * as schemaFields from "../../schema-fields";
+import { yupObject } from "../../schema-fields";
+import { usersCrudServerReadSchema } from "./users";
+
+
+export const teamMemberProfilesCrudClientReadSchema = yupObject({
+  team_id: schemaFields.teamIdSchema.defined(),
+  user_id: schemaFields.userIdSchema.defined(),
+  display_name: schemaFields.teamMemberDisplayNameSchema.nullable().defined(),
+  profile_image_url: schemaFields.teamMemberProfileImageUrlSchema.nullable().defined(),
+}).defined();
+
+export const teamMemberProfilesCrudServerReadSchema = teamMemberProfilesCrudClientReadSchema.concat(yupObject({
+  user: usersCrudServerReadSchema.defined(),
+})).defined();
+
+export const teamMemberProfilesCrudClientUpdateSchema = yupObject({
+  display_name: schemaFields.teamMemberDisplayNameSchema.optional(),
+  profile_image_url: schemaFields.teamMemberProfileImageUrlSchema.nullable().optional(),
+}).defined();
+
+export const teamMemberProfilesCrud = createCrud({
+  clientReadSchema: teamMemberProfilesCrudClientReadSchema,
+  serverReadSchema: teamMemberProfilesCrudServerReadSchema,
+  clientUpdateSchema: teamMemberProfilesCrudClientUpdateSchema,
+  docs: {
+    clientList: {
+      summary: "List team members profiles",
+      description: "List team members profiles. You always need to specify a `team_id` that your are a member of on the client. You can always filter for your own profile by setting `me` as the `user_id` in the path parameters. If you want list all the profiles in a team, you need to have the `$read_members` permission in that team.",
+      tags: ["Teams"],
+    },
+    serverList: {
+      summary: "List team members profiles",
+      description: "List team members profiles and filter by team ID and user ID",
+      tags: ["Teams"],
+    },
+    clientRead: {
+      summary: "Get a team member profile",
+      description: "Get a team member profile. you can always get your own profile by setting `me` as the `user_id` in the path parameters on the client. If you want to get someone else's profile in a team, you need to have the `$read_members` permission in that team.",
+      tags: ["Teams"],
+    },
+    serverRead: {
+      summary: "Get a team member profile",
+      description: "Get a team member profile by user ID",
+      tags: ["Teams"],
+    },
+    clientUpdate: {
+      summary: "Update your team member profile",
+      description: "Update your own team member profile. `user_id` must be `me` in the path parameters on the client.",
+      tags: ["Teams"],
+    },
+    serverUpdate: {
+      summary: "Update a team member profile",
+      description: "Update a team member profile by user ID",
+      tags: ["Teams"],
+    },
+  },
+});
+
+export type TeamMemberProfilesCrud = CrudTypeOf<typeof teamMemberProfilesCrud>;

package/src/interface/crud/team-memberships.ts

@@ -0,0 +1,56 @@
+import { CrudTypeOf, createCrud } from "../../crud";
+import { yupMixed, yupObject, yupString } from "../../schema-fields";
+import { WebhookEvent } from "../webhooks";
+
+export const teamMembershipsCrudClientReadSchema = yupObject({
+  team_id: yupString().defined(),
+  user_id: yupString().defined(),
+}).defined();
+export const teamMembershipsCrudServerCreateSchema = yupObject({}).defined();
+export const teamMembershipsCrudClientDeleteSchema = yupMixed();
+
+export const teamMembershipsCrud = createCrud({
+  // Client
+  clientReadSchema: teamMembershipsCrudClientReadSchema,
+  clientDeleteSchema: teamMembershipsCrudClientDeleteSchema,
+  // Server
+  serverCreateSchema: teamMembershipsCrudServerCreateSchema,
+  docs: {
+    serverCreate: {
+      summary: "Add a user to a team",
+      description: "",
+      tags: ["Teams"],
+    },
+    clientDelete: {
+      summary: "Remove a user from a team",
+      description: "All the users are allowed to remove themselves from a team (`user_id=me`). Only the users who have the `$remove_members` permission are allowed to remove other users from a team. `team_id` is must an ID of a team that the user is a member of.",
+      tags: ["Teams"],
+    },
+    serverDelete: {
+      summary: "Remove a user from a team",
+      description: "",
+      tags: ["Teams"],
+    },
+  },
+});
+export type TeamMembershipsCrud = CrudTypeOf<typeof teamMembershipsCrud>;
+
+export const teamMembershipCreatedWebhookEvent = {
+  type: "team_membership.created",
+  schema: teamMembershipsCrud.server.readSchema,
+  metadata: {
+    summary: "Team Membership Created",
+    description: "This event is triggered when a user is added to a team.",
+    tags: ["Teams"],
+  },
+} satisfies WebhookEvent<typeof teamMembershipsCrud.server.readSchema>;
+
+export const teamMembershipDeletedWebhookEvent = {
+  type: "team_membership.deleted",
+  schema: teamMembershipsCrud.server.readSchema,
+  metadata: {
+    summary: "Team Membership Deleted",
+    description: "This event is triggered when a user is removed from a team.",
+    tags: ["Teams"],
+  },
+} satisfies WebhookEvent<typeof teamMembershipsCrud.server.readSchema>;