@spacemade/ui 0.0.1

package/src/store/model/user.model.ts

@@ -0,0 +1,97 @@
+import { Address, MediaAttachment, OrgMembership, UserPermissionRow } from '@store/model'
+
+export interface User {
+	id: string
+	name: string
+	email: string
+	isSystemAdmin?: boolean
+	firstName?: string | null
+	lastName?: string | null
+	nonce?: string | null
+	bio?: string | null
+	shortBio?: string | null
+	timezone?: string | null
+	timeZone?: string | null
+	twitterUsername?: string | null
+	instagramUsername?: string | null
+	linkedinUsername?: string | null
+	siteUrl?: string | null
+	rpmGlbUrl?: string | null
+	systemRole?: UserSystemRoles | null
+	createdAt: string
+	updatedAt: string | null
+	addressId: string | null
+	address?: Address
+	isVerified: boolean
+	nextStep: boolean
+	isSuspended?: boolean
+	createdBy: 	string | null
+	featuredLinks: FeaturedLink[] | null
+	profileMediaId?: string
+	profileMedia?: MediaAttachment | null
+	bannerMedia?: MediaAttachment | null
+	bannerMediaId?: string
+	companyLogoMediaId?: string
+	companyLogoMedia?: MediaAttachment | null
+	huggingfaceApiToken?:string
+	openaiApiKey?:string
+	bedrockAwsAccessKeyId?:string
+	bedrockAwsSecretAccessKey?:string
+	bedrockAwsRegion?:string
+	permissions?: UserPermissionRow[] | null
+	orgMemberships?: OrgMembership[] | null
+}
+
+export interface UserPayload {
+	id?: string | null
+	name?: string | null
+	firstName?: string | null
+	lastName?: string | null
+	nonce?: string | null
+	email?: string | null
+	bio?: string | null
+	shortBio?: string | null
+	timezone?: string | null
+	timeZone?: string | null
+	twitterUsername?: string | null
+	instagramUsername?: string | null
+	linkedinUsername?: string | null
+	siteUrl?: string | null
+	rpmGlbUrl?: string | null
+	streetAddress?: string | null
+	streetAddress2?: string | null
+	city?: string | null
+	state?: string | null
+	postalCode?: string | null
+	country?: string | null
+	systemRole?: UserSystemRoles | null
+	isSuspended?: boolean | null
+	featuredLinks?: FeaturedLink[]
+	profileMediaId?: string | null
+	bannerMediaId?: string | null
+	companyLogoMediaId?: string
+	huggingfaceApiToken?:string
+	openaiApiKey?:string
+	bedrockAwsAccessKeyId?:string,
+	bedrockAwsSecretAccessKey?:string,
+	bedrockAwsRegion?:string,
+	createdBy?: 	string | null
+}
+
+export enum UserSystemRoles {
+	admin = 'ADMIN',
+	editor = 'EDITOR',
+}
+
+export interface FeaturedLink {
+	url: string
+	label: string
+}
+
+export type PaymentMethod = {
+	cardName: string
+	brand: string
+	expMonth: number
+	expYear: number
+	last4: string
+}

package/src/store/model/vector-store-file.model.ts

@@ -0,0 +1,40 @@
+export type VectorStoreFileStatus =
+  | 'pending'
+  | 'ready'
+  | 'failed'
+  | 'completed'
+
+export type MediaType =
+  | 'image'
+  | 'csv'
+  | 'pdf'
+  | 'document'
+
+export interface VectorStoreFile {
+  id: string
+  vectorStoreId: string                // FK → vector_store.id
+  providerSettingId?: string | null    // FK → provider_settings.id
+  fileName: string
+  vectorFileId?: string | null
+  mimeType: string
+  mediaType: MediaType
+  fileSizeBytes?: number | null
+  fileStatus?: VectorStoreFileStatus | null
+
+  createdAt: string
+  updatedAt: string
+  user?: string | null
+}
+export interface VectorStoreFilePayload {
+  id?: string                          // only for updates
+  vectorStoreId: string
+  providerSettingId?: string | null
+
+  fileName: string
+  vectorFileId?: string | null
+  fileStatus?: VectorStoreFileStatus | null
+
+  /** optional on create/update (backend can infer) */
+  mimeType?: string
+  mediaType?: MediaType
+}

package/src/store/model/vector-store.model.ts

@@ -0,0 +1,41 @@
+import type { User } from '@store/model'
+
+export type VectorStoreStatus = 'pending' | 'ready' | 'failed'
+
+export interface VectorStore {
+  id: string
+
+  name: string
+  description: string | null
+  providerSettingId: string | null
+  providerStoreId: string | null
+  providerCollectionArn: string | null
+  providerRoleArn: string | null
+  providerEmbeddingModelArn: string | null
+  providerIndexName: string | null
+  providerStatus: VectorStoreStatus | null
+  providerCreatedAt: string | null
+  isDefault: boolean
+  ownerId: string | null
+  owner?: User | null
+  orgId?: string | null
+  modifiedBy: string | null
+  modifier?: User | null
+  createdAt: string
+  updatedAt: string
+}
+
+export interface VectorStorePayload {
+  id?: string
+  name?: string
+  description?: string | null
+  providerSettingId?: string | null
+  providerStoreId?: string | null
+  providerCollectionArn?: string | null
+  providerRoleArn?: string | null
+  providerEmbeddingModelArn?: string | null
+  providerIndexName?: string | null
+  providerStatus?: VectorStoreStatus | null
+  providerCreatedAt?: string | null
+  isDefault?: boolean
+}

package/src/store/slice/api/accountApiSlice.ts

@@ -0,0 +1,92 @@
+import { createApi, fetchBaseQuery } from '@reduxjs/toolkit/query/react'
+import { HYDRATE } from '@store/hydrate'
+import { User, UserPayload } from '@store/model'
+import { BASE_API_URL } from '@helpers/api'
+import { keysToCamel } from '@helpers/data-transform'
+import { mediaApiSlice } from '@store/slice/api/mediaApiSlice'
+import { orgApiSlice } from '@store/slice/api/orgApiSlice'
+
+export const accountApiSlice = createApi({
+	reducerPath: 'api/account',
+	baseQuery: fetchBaseQuery({
+		baseUrl: BASE_API_URL,
+		credentials: 'include',
+	}),
+	extractRehydrationInfo(action, { reducerPath }) {
+		if (action.type === HYDRATE) {
+			return (action as any).payload[reducerPath]
+		}
+	},
+	tagTypes: ['Account'],
+	endpoints: (builder) => ({
+		getAuthUser: builder.query<{ user: User; activeOrgId: string | null }, void>({
+			query: () => `/auth/user`,
+			transformResponse: (res) => keysToCamel(res) as { user: User; activeOrgId: string | null },
+			providesTags: ['Account'],
+		}),
+
+		updateUser: builder.mutation<User, UserPayload>({
+			query: ({ id, ...patch }) => ({
+				url: `/users/${id}`,
+				method: 'PATCH',
+				body: {
+					name: patch.name,
+					first_name: patch.firstName,
+					last_name: patch.lastName,
+					nonce: patch.nonce,
+					email: patch.email,
+					bio: patch.bio,
+					short_bio: patch.shortBio,
+					timezone: patch.timezone,
+					time_zone: patch.timeZone,
+					twitter_username: patch.twitterUsername,
+					instagram_username: patch.instagramUsername,
+					linkedin_username: patch.linkedinUsername,
+					site_url: patch.siteUrl,
+					rpm_glb_url: patch.rpmGlbUrl,
+					street_address: patch.streetAddress,
+					street_address2: patch.streetAddress2,
+					city: patch.city,
+					state: patch.state,
+					postal_code: patch.postalCode,
+					country: patch.country,
+					system_role: patch.systemRole,
+					is_suspended: patch.isSuspended,
+					featured_links: patch.featuredLinks,
+					profile_media_id: patch.profileMediaId,
+					banner_media_id: patch.bannerMediaId,
+					company_logo_media_id: patch.companyLogoMediaId,
+					huggingface_api_token: patch.huggingfaceApiToken,
+					openai_api_key: patch.openaiApiKey,
+					bedrock_aws_access_key_id: patch.bedrockAwsAccessKeyId,
+					bedrock_aws_secret_access_key: patch.bedrockAwsSecretAccessKey,
+					bedrock_aws_region: patch.bedrockAwsRegion,
+				},
+			}),
+			async onQueryStarted(args, { dispatch, queryFulfilled }) {
+				const shouldClearMediaCache = Object.prototype.hasOwnProperty.call(
+					args,
+					'profileMediaId'
+				)
+				try {
+					await queryFulfilled
+					if (shouldClearMediaCache) {
+						dispatch(mediaApiSlice.util.resetApiState())
+						dispatch(orgApiSlice.util.invalidateTags(['OrgMemberships']))
+					}
+				} catch {
+					// ignore
+				}
+			},
+			transformResponse: ({ user }: { user: User }) => keysToCamel(user),
+			invalidatesTags: ['Account'],
+		}),
+	}),
+})
+
+export const {
+	useGetAuthUserQuery,
+	useLazyGetAuthUserQuery,
+	useUpdateUserMutation,
+	util: { getRunningQueriesThunk },
+} = accountApiSlice

package/src/store/slice/api/accountSlice.ts

@@ -0,0 +1,57 @@
+// store/slice/accountSlice.ts
+import { PayloadAction, createSlice } from '@reduxjs/toolkit'
+import { User } from '@store/model'
+import type { RootState } from '@store/store'
+
+export type AccountState = {
+  isConnected: boolean
+  user: User | null
+  isDataLoaded: boolean
+  activeOrgId: string | null
+}
+
+const initialState: AccountState = {
+  isConnected: false,
+  user: null,
+  isDataLoaded: false,
+  activeOrgId: null,
+}
+
+export const accountSlice = createSlice({
+  name: 'account',
+  initialState,
+  reducers: {
+    onSetProfile: (state, action: PayloadAction<User>) => {
+      state.isConnected = true
+      state.isDataLoaded = true
+      state.user = action.payload
+    },
+    onSetIsDataLoaded: (state, action: PayloadAction<boolean>) => {
+      state.isDataLoaded = action.payload
+    },
+    onSetConnected: (state, action: PayloadAction<boolean>) => {
+      state.isConnected = action.payload
+      // do not flip isDataLoaded here; caller controls it
+    },
+    onSetActiveOrgId: (state, action: PayloadAction<string | null>) => {
+      state.activeOrgId = action.payload
+    },
+    onCleanAccount: (state) => {
+      state.isConnected = initialState.isConnected
+      state.user = initialState.user
+      state.isDataLoaded = initialState.isDataLoaded
+      state.activeOrgId = initialState.activeOrgId
+    },
+  },
+})
+
+export const {
+  onSetProfile,
+  onSetIsDataLoaded,
+  onSetConnected,
+  onSetActiveOrgId,
+  onCleanAccount,
+} = accountSlice.actions
+
+export const selectAccountState = (state: RootState) => state.account
+export default accountSlice.reducer

package/src/store/slice/api/activityApiSlice.ts

@@ -0,0 +1,218 @@
+import { createApi, fetchBaseQuery } from '@reduxjs/toolkit/query/react'
+import { HYDRATE } from '@store/hydrate'
+import { BASE_API_URL } from '@helpers/api'
+import { keysToCamel } from '@helpers/data-transform'
+import { ApiPagingResponse } from '@helpers/types'
+import { ActivityLogRecord, ActivityVisitorBan } from '@store/model'
+
+type ActivityListParams = {
+  limit?: number
+  page?: number
+  orgId?: string
+  entityType?: string
+  entityId?: string
+  userId?: string
+  ipAddress?: string
+  userAgentLike?: string
+}
+
+type ActivityBanListParams = {
+  limit?: number
+  page?: number
+  orgId?: string
+  isActive?: boolean
+  targetType?: 'ip_address' | 'user_agent' | 'fingerprint'
+  anonymousOnly?: boolean
+  permanentOnly?: boolean
+  targetValueLike?: string
+}
+
+type BanPayload = {
+  orgId?: string
+  visitorId?: string
+  targetType: 'ip_address' | 'user_agent' | 'fingerprint'
+  targetValue: string
+  reason?: string
+  isPermanent?: boolean
+  durationMinutes?: number
+  expiresAt?: string
+}
+
+type UnbanPayload = {
+  orgId?: string
+  targetType: 'ip_address' | 'user_agent' | 'fingerprint'
+  targetValue: string
+}
+
+type ActivitySettings = {
+  id: string
+  orgId?: string | null
+  importEnabled: boolean
+  importAllowUnknownSources: boolean
+  importSourceAllowlist?: string[] | null
+  rateLimitEnabled: boolean
+  rateLimitScope: 'ip_address' | 'fingerprint' | 'user_id'
+  rateLimitWindowSeconds: number
+  rateLimitMaxRequests: number
+  autoTempBanEnabled: boolean
+  tempBanDurationMinutes: number
+  escalationEnabled: boolean
+  escalationTempBanThreshold: number
+  escalationLookbackHours: number
+  escalateToPermanent: boolean
+}
+
+type ActivityBanRow = ActivityVisitorBan & {
+  visitor?: {
+    id: string
+    userId?: string | null
+    user?: { id: string; name?: string; email?: string }
+    ipAddress?: string | null
+    userAgent?: string | null
+    browser?: string | null
+    os?: string | null
+  } | null
+  createdBy?: { id: string; name?: string; email?: string } | null
+  revokedBy?: { id: string; name?: string; email?: string } | null
+}
+
+type ActivityBanStats = {
+  activeAnonymousBans: number
+  rateLimitTriggers24h: number
+  topAnonymousIps24h: Array<{ ipAddress: string; count: number }>
+}
+
+export const activityApiSlice = createApi({
+  reducerPath: 'api/activity',
+  baseQuery: fetchBaseQuery({ baseUrl: BASE_API_URL, credentials: 'include' }),
+  tagTypes: ['ActivityLog'],
+  extractRehydrationInfo(action, { reducerPath }) {
+    if (action.type === HYDRATE) return (action as any).payload[reducerPath]
+  },
+  endpoints: (builder) => ({
+    getAdminActivityLogs: builder.query<ApiPagingResponse<ActivityLogRecord>, ActivityListParams>({
+      query: (params) => ({
+        url: '/admin/activity',
+        params: {
+          limit: params.limit || 100,
+          page: params.page || 1,
+          ...(params.orgId ? { orgId: params.orgId } : {}),
+          ...(params.entityType ? { entityType: params.entityType } : {}),
+          ...(params.entityId ? { entityId: params.entityId } : {}),
+          ...(params.userId ? { userId: params.userId } : {}),
+          ...(params.ipAddress ? { ipAddress: params.ipAddress } : {}),
+          ...(params.userAgentLike ? { userAgentLike: params.userAgentLike } : {}),
+        },
+      }),
+      providesTags: ['ActivityLog'],
+      transformResponse: (res) => keysToCamel(res),
+    }),
+    getAdminActivityById: builder.query<{ activity: ActivityLogRecord }, { id: string; orgId?: string }>({
+      query: ({ id, orgId }) => ({
+        url: `/admin/activity/${id}`,
+        params: orgId ? { orgId } : undefined,
+      }),
+      providesTags: ['ActivityLog'],
+      transformResponse: (res) => keysToCamel(res),
+    }),
+    createVisitorBan: builder.mutation<{ ban: ActivityVisitorBan }, BanPayload>({
+      query: (payload) => ({
+        url: '/admin/activity/ban',
+        method: 'POST',
+        body: {
+          org_id: payload.orgId,
+          visitor_id: payload.visitorId,
+          target_type: payload.targetType,
+          target_value: payload.targetValue,
+          reason: payload.reason,
+          is_permanent: payload.isPermanent,
+          duration_minutes: payload.durationMinutes,
+          expires_at: payload.expiresAt,
+        },
+      }),
+      invalidatesTags: ['ActivityLog'],
+      transformResponse: (res) => keysToCamel(res),
+    }),
+    removeVisitorBan: builder.mutation<{ ban: ActivityVisitorBan }, UnbanPayload>({
+      query: (payload) => ({
+        url: '/admin/activity/ban',
+        method: 'DELETE',
+        body: {
+          org_id: payload.orgId,
+          target_type: payload.targetType,
+          target_value: payload.targetValue,
+        },
+      }),
+      invalidatesTags: ['ActivityLog'],
+      transformResponse: (res) => keysToCamel(res),
+    }),
+    getActivitySettings: builder.query<{ settings: ActivitySettings }, { orgId?: string }>({
+      query: ({ orgId }) => ({
+        url: '/admin/activity/settings',
+        params: orgId ? { orgId } : undefined,
+      }),
+      providesTags: ['ActivityLog'],
+      transformResponse: (res) => keysToCamel(res),
+    }),
+    updateActivitySettings: builder.mutation<{ settings: ActivitySettings }, Partial<ActivitySettings> & { orgId?: string }>({
+      query: (payload) => ({
+        url: '/admin/activity/settings',
+        method: 'PATCH',
+        body: {
+          org_id: payload.orgId,
+          import_enabled: payload.importEnabled,
+          import_allow_unknown_sources: payload.importAllowUnknownSources,
+          import_source_allowlist: payload.importSourceAllowlist,
+          rate_limit_enabled: payload.rateLimitEnabled,
+          rate_limit_scope: payload.rateLimitScope,
+          rate_limit_window_seconds: payload.rateLimitWindowSeconds,
+          rate_limit_max_requests: payload.rateLimitMaxRequests,
+          auto_temp_ban_enabled: payload.autoTempBanEnabled,
+          temp_ban_duration_minutes: payload.tempBanDurationMinutes,
+          escalation_enabled: payload.escalationEnabled,
+          escalation_temp_ban_threshold: payload.escalationTempBanThreshold,
+          escalation_lookback_hours: payload.escalationLookbackHours,
+          escalate_to_permanent: payload.escalateToPermanent,
+        },
+      }),
+      invalidatesTags: ['ActivityLog'],
+      transformResponse: (res) => keysToCamel(res),
+    }),
+    getActivityBans: builder.query<ApiPagingResponse<ActivityBanRow>, ActivityBanListParams>({
+      query: (params) => ({
+        url: '/admin/activity/bans',
+        params: {
+          limit: params.limit || 100,
+          page: params.page || 1,
+          ...(params.orgId ? { orgId: params.orgId } : {}),
+          ...(typeof params.isActive === 'boolean' ? { isActive: params.isActive } : {}),
+          ...(params.targetType ? { targetType: params.targetType } : {}),
+          ...(typeof params.anonymousOnly === 'boolean' ? { anonymousOnly: params.anonymousOnly } : {}),
+          ...(typeof params.permanentOnly === 'boolean' ? { permanentOnly: params.permanentOnly } : {}),
+          ...(params.targetValueLike ? { targetValueLike: params.targetValueLike } : {}),
+        },
+      }),
+      providesTags: ['ActivityLog'],
+      transformResponse: (res) => keysToCamel(res),
+    }),
+    getActivityBanStats: builder.query<{ stats: ActivityBanStats }, { orgId?: string }>({
+      query: ({ orgId }) => ({
+        url: '/admin/activity/bans/stats',
+        params: orgId ? { orgId } : undefined,
+      }),
+      providesTags: ['ActivityLog'],
+      transformResponse: (res) => keysToCamel(res),
+    }),
+  }),
+})
+
+export const {
+  useGetAdminActivityLogsQuery,
+  useGetAdminActivityByIdQuery,
+  useCreateVisitorBanMutation,
+  useRemoveVisitorBanMutation,
+  useGetActivitySettingsQuery,
+  useUpdateActivitySettingsMutation,
+  useGetActivityBansQuery,
+  useGetActivityBanStatsQuery,
+} = activityApiSlice

package/src/store/slice/api/apiTokenSlice.ts

@@ -0,0 +1,153 @@
+import { createApi, fetchBaseQuery } from '@reduxjs/toolkit/query/react'
+import { HYDRATE } from '@store/hydrate'
+import { BASE_API_URL } from '@helpers/api'
+import { keysToCamel } from '@helpers/data-transform'
+import { ApiToken, ApiTokenPayload } from '@store/model'
+
+export const apiTokenApiSlice = createApi({
+  reducerPath: 'api/openapi',
+  baseQuery: fetchBaseQuery({
+    baseUrl: BASE_API_URL, // e.g. https://your-domain/api
+    credentials: 'include',
+  }),
+  tagTypes: ['ApiToken'],
+
+  extractRehydrationInfo(action, { reducerPath }) {
+    if (action.type === HYDRATE) {
+      return (action as any)?.payload?.[reducerPath]
+    }
+  },
+
+  endpoints: (builder) => ({
+    /** ✅ Get all tokens - GET /api/openapi */
+    getApiTokens: builder.query<ApiToken[], void>({
+      query: () => '/openapi',
+      transformResponse: (res: { tokens: ApiToken[] }) => keysToCamel(res.tokens),
+      providesTags: (result) =>
+        result && result.length
+          ? [
+              ...result.map((t) => ({ type: 'ApiToken' as const, id: t.id })),
+              { type: 'ApiToken', id: 'LIST' },
+            ]
+          : [{ type: 'ApiToken', id: 'LIST' }],
+      keepUnusedDataFor: 60,
+    }),
+
+    /** ✅ Get single token - GET /api/openapi/[id] */
+    getApiToken: builder.query<ApiToken, string>({
+      query: (id) => `/openapi/${id}`,
+      transformResponse: (res: { token: ApiToken }) => keysToCamel(res.token),
+      providesTags: (result, _err, id) => [{ type: 'ApiToken', id }],
+      keepUnusedDataFor: 60,
+    }),
+
+    /** ✅ Create token - POST /api/openapi */
+    createApiToken: builder.mutation<ApiToken & { token: string }, { name: string; scopes?: string[]; expiresAt?: string | null }>({
+      query: (payload) => ({
+        url: '/openapi',
+        method: 'POST',
+        body: {
+          name: payload.name,
+          scopes: payload.scopes,
+          expires_at: payload.expiresAt,
+        },
+      }),
+      transformResponse: (res: { token: ApiToken & { token: string } }) => keysToCamel(res.token),
+      invalidatesTags: [{ type: 'ApiToken', id: 'LIST' }],
+    }),
+
+    /** ✅ Update token metadata - PATCH /api/openapi/[id] */
+    updateApiToken: builder.mutation<ApiToken, ApiTokenPayload>({
+      query: ({ id, ...body }) => ({
+        url: `/openapi/${id}`,
+        method: 'PATCH',
+        body: {
+          name: body.name,
+          status: body.status,
+          scopes: body.scopes,
+          expires_at: body.expiresAt,
+          revoked_at: body.revokedAt,
+        },
+      }),
+      transformResponse: (res: { token: ApiToken }) => keysToCamel(res.token),
+      async onQueryStarted(arg, { dispatch, queryFulfilled }) {
+        const patchToken = dispatch(
+          apiTokenApiSlice.util.updateQueryData('getApiToken', arg.id!, (draft) => {
+            Object.assign(draft as ApiToken, arg)
+          })
+        )
+
+        const patchList = dispatch(
+          apiTokenApiSlice.util.updateQueryData('getApiTokens', undefined, (draft) => {
+            const idx = draft.findIndex((t) => t.id === arg.id)
+            if (idx !== -1) draft[idx] = { ...draft[idx], ...(arg as any) } as ApiToken
+          })
+        )
+
+        try {
+          await queryFulfilled
+        } catch {
+          patchToken.undo()
+          patchList.undo()
+        }
+      },
+      invalidatesTags: (result, error, { id }) => [
+        { type: 'ApiToken', id },
+        { type: 'ApiToken', id: 'LIST' },
+      ],
+    }),
+
+    /** ✅ Rotate token - POST /api/openapi/[id] (action: "rotate") */
+    rotateApiToken: builder.mutation<ApiToken & { token: string }, { id: string }>({
+      query: ({ id }) => ({
+        url: `/openapi/${id}`,
+        method: 'POST',
+        body: { action: 'rotate' },
+      }),
+      transformResponse: (res: { token: ApiToken & { token: string } }) => keysToCamel(res.token),
+      invalidatesTags: (result, error, { id }) => [
+        { type: 'ApiToken', id },
+        { type: 'ApiToken', id: 'LIST' },
+      ],
+    }),
+
+    /** ✅ Delete token - DELETE /api/openapi/[id] */
+    deleteApiToken: builder.mutation<void, { id: string }>({
+      query: ({ id }) => ({
+        url: `/openapi/${id}`,
+        method: 'DELETE',
+      }),
+      async onQueryStarted({ id }, { dispatch, queryFulfilled }) {
+        const patchList = dispatch(
+          apiTokenApiSlice.util.updateQueryData('getApiTokens', undefined, (draft) => {
+            const idx = draft.findIndex((t) => t.id === id)
+            if (idx !== -1) draft.splice(idx, 1)
+          })
+        )
+        try {
+          await queryFulfilled
+        } catch {
+          patchList.undo()
+        }
+      },
+      invalidatesTags: (result, error, { id }) => [
+        { type: 'ApiToken', id },
+        { type: 'ApiToken', id: 'LIST' },
+      ],
+    }),
+  }),
+})
+
+export const {
+  useGetApiTokensQuery,
+  useGetApiTokenQuery,
+  useCreateApiTokenMutation,
+  useUpdateApiTokenMutation,
+  useRotateApiTokenMutation,
+  useDeleteApiTokenMutation,
+} = apiTokenApiSlice
+
+export const {
+  endpoints: { getApiTokens, getApiToken },
+  util: { getRunningQueriesThunk },
+} = apiTokenApiSlice