@comergehq/studio 0.1.2 → 0.1.4

package/src/data/merge-requests/remote.ts

@@ -0,0 +1,76 @@
+import { api } from '../../core/services/http';
+import type { ServiceResponse } from '../types';
+import { BaseRemote } from '../base-remote';
+import type {
+  MergeRequest,
+  MergeRequestStatus,
+  MergeRequestsByStatus,
+  OpenMergeRequestRequest,
+  UpdateMergeRequestRequest,
+} from './types';
+
+export interface MergeRequestsRemoteDataSource {
+  list(params: { sourceAppId?: string; targetAppId?: string; status?: MergeRequestStatus }): Promise<ServiceResponse<MergeRequest[]>>;
+  listByStatuses(params: {
+    sourceAppId?: string;
+    targetAppId?: string;
+    statuses: MergeRequestStatus[];
+  }): Promise<ServiceResponse<MergeRequestsByStatus | MergeRequest[]>>;
+  open(payload: OpenMergeRequestRequest): Promise<ServiceResponse<MergeRequest>>;
+  getById(mrId: string): Promise<ServiceResponse<MergeRequest>>;
+  update(mrId: string, payload: UpdateMergeRequestRequest): Promise<ServiceResponse<MergeRequest>>;
+}
+
+class MergeRequestsRemoteDataSourceImpl extends BaseRemote implements MergeRequestsRemoteDataSource {
+  async list(params: { sourceAppId?: string; targetAppId?: string; status?: MergeRequestStatus }): Promise<ServiceResponse<MergeRequest[]>> {
+    const query: Record<string, string> = {};
+    if (params.sourceAppId) query.sourceAppId = params.sourceAppId;
+    if (params.targetAppId) query.targetAppId = params.targetAppId;
+    if (params.status) query.status = params.status;
+    const { data } = await api.get<ServiceResponse<MergeRequest[]>>('/v1/merge-requests', { params: query });
+    return data;
+  }
+
+  async listByStatuses(params: {
+    sourceAppId?: string;
+    targetAppId?: string;
+    statuses: MergeRequestStatus[];
+  }): Promise<ServiceResponse<MergeRequestsByStatus | MergeRequest[]>> {
+    const query: Record<string, string | string[]> = {};
+    if (params.sourceAppId) query.sourceAppId = params.sourceAppId;
+    if (params.targetAppId) query.targetAppId = params.targetAppId;
+    query.status = params.statuses;
+    const { data } = await api.get<ServiceResponse<MergeRequestsByStatus | MergeRequest[]>>(
+      '/v1/merge-requests',
+      {
+        params: query,
+        paramsSerializer: {
+          indexes: null,
+        },
+      }
+    );
+    return data;
+  }
+
+  async open(payload: OpenMergeRequestRequest): Promise<ServiceResponse<MergeRequest>> {
+    const { data } = await api.post<ServiceResponse<MergeRequest>>('/v1/merge-requests', payload);
+    return data;
+  }
+
+  async getById(mrId: string): Promise<ServiceResponse<MergeRequest>> {
+    const { data } = await api.get<ServiceResponse<MergeRequest>>(`/v1/merge-requests/${encodeURIComponent(mrId)}`);
+    return data;
+  }
+
+  async update(mrId: string, payload: UpdateMergeRequestRequest): Promise<ServiceResponse<MergeRequest>> {
+    const { data } = await api.patch<ServiceResponse<MergeRequest>>(
+      `/v1/merge-requests/${encodeURIComponent(mrId)}`,
+      payload
+    );
+    return data;
+  }
+}
+
+export const mergeRequestsRemoteDataSource: MergeRequestsRemoteDataSource = new MergeRequestsRemoteDataSourceImpl();
+
+

package/src/data/merge-requests/repository.ts

@@ -0,0 +1,66 @@
+import type { MergeRequestsRemoteDataSource } from './remote';
+import { mergeRequestsRemoteDataSource } from './remote';
+import type {
+  MergeRequest,
+  MergeRequestStatus,
+  MergeRequestsByStatus,
+  OpenMergeRequestRequest,
+  UpdateMergeRequestRequest,
+} from './types';
+import { BaseRepository } from '../../data/base-repository';
+
+export interface MergeRequestsRepository {
+  list(params: { sourceAppId?: string; targetAppId?: string; status?: MergeRequestStatus }): Promise<MergeRequest[]>;
+  listByStatuses(params: {
+    sourceAppId?: string;
+    targetAppId?: string;
+    statuses: MergeRequestStatus[];
+  }): Promise<MergeRequestsByStatus>;
+  open(payload: OpenMergeRequestRequest): Promise<MergeRequest>;
+  getById(mrId: string): Promise<MergeRequest>;
+  update(mrId: string, payload: UpdateMergeRequestRequest): Promise<MergeRequest>;
+}
+
+class MergeRequestsRepositoryImpl extends BaseRepository implements MergeRequestsRepository {
+  constructor(private readonly remote: MergeRequestsRemoteDataSource) {
+    super();
+  }
+
+  async list(params: { sourceAppId?: string; targetAppId?: string; status?: MergeRequestStatus }): Promise<MergeRequest[]> {
+    const res = await this.remote.list(params);
+    return this.unwrapOrThrow(res);
+  }
+
+  async listByStatuses(params: {
+    sourceAppId?: string;
+    targetAppId?: string;
+    statuses: MergeRequestStatus[];
+  }): Promise<MergeRequestsByStatus> {
+    if (!params.statuses || params.statuses.length === 0) return {};
+    const res = await this.remote.listByStatuses(params);
+    const payload = this.unwrapOrThrow(res);
+    if (Array.isArray(payload)) {
+      return { [params.statuses[0]]: payload };
+    }
+    return payload;
+  }
+
+  async open(payload: OpenMergeRequestRequest): Promise<MergeRequest> {
+    const res = await this.remote.open(payload);
+    return this.unwrapOrThrow(res);
+  }
+
+  async getById(mrId: string): Promise<MergeRequest> {
+    const res = await this.remote.getById(mrId);
+    return this.unwrapOrThrow(res);
+  }
+
+  async update(mrId: string, payload: UpdateMergeRequestRequest): Promise<MergeRequest> {
+    const res = await this.remote.update(mrId, payload);
+    return this.unwrapOrThrow(res);
+  }
+}
+
+export const mergeRequestsRepository: MergeRequestsRepository = new MergeRequestsRepositoryImpl(mergeRequestsRemoteDataSource);
+
+

package/src/data/merge-requests/types.ts

@@ -0,0 +1,33 @@
+export type MergeRequestStatus = 'open' | 'approved' | 'rejected' | 'merged' | 'closed';
+export type MergeRequestsByStatus = Partial<Record<MergeRequestStatus, MergeRequest[]>>;
+
+export type MergeRequest = {
+  id: string;
+  sourceAppId: string;
+  sourceCommitId: string;
+  sourceTipCommitId: string | null;
+  targetAppId: string;
+  targetCommitId: string | null;
+  status: MergeRequestStatus;
+  title: string | null;
+  description: string | null;
+  createdBy: string;
+  reviewedBy: string | null;
+  mergedBy: string | null;
+  createdAt: string;
+  updatedAt: string;
+  mergedAt: string | null;
+  closedAt: string | null;
+};
+
+export type OpenMergeRequestRequest = {
+  sourceAppId: string;
+};
+
+export type UpdateMergeRequestRequest = {
+  title?: string;
+  description?: string;
+  status?: MergeRequestStatus;
+};
+
+

package/src/data/messages/remote.ts

@@ -0,0 +1,21 @@
+import { api } from '../../core/services/http';
+import type { ServiceResponse } from '../types';
+import type { Message } from './types';
+import { BaseRemote } from '../base-remote';
+
+export interface MessagesRemoteDataSource {
+  list(threadId: string): Promise<ServiceResponse<Message[]>>;
+}
+
+class MessagesRemoteDataSourceImpl extends BaseRemote implements MessagesRemoteDataSource {
+  async list(threadId: string): Promise<ServiceResponse<Message[]>> {
+    const { data } = await api.get<ServiceResponse<Message[]>>(
+      `/v1/threads/${encodeURIComponent(threadId)}/messages`
+    );
+    return data;
+  }
+}
+
+export const messagesRemoteDataSource: MessagesRemoteDataSource = new MessagesRemoteDataSourceImpl();
+
+

package/src/data/messages/repository.ts

@@ -0,0 +1,104 @@
+import type { MessagesRemoteDataSource } from './remote';
+import { messagesRemoteDataSource } from './remote';
+import type { Message } from './types';
+import { BaseRepository } from '../../data/base-repository';
+import { getSupabaseClient } from '../../core/services/supabase';
+
+type DbMessageRow = {
+  id: string;
+  app_id: string;
+  thread_id: string;
+  commit_id: string | null;
+  parent_message_id: string | null;
+  author_type: 'human' | 'ai' | 'system';
+  user_id: string | null;
+  payload: Record<string, unknown>;
+  reference_id: string | null;
+  created_at: string;
+  updated_at: string;
+};
+
+function mapDbRowToMessage(row: DbMessageRow): Message {
+  return {
+    id: row.id,
+    appId: row.app_id,
+    threadId: row.thread_id,
+    commitId: row.commit_id,
+    parentMessageId: row.parent_message_id,
+    authorType: row.author_type === 'system' ? 'ai' : row.author_type,
+    userId: row.user_id,
+    payload: row.payload,
+    referenceId: row.reference_id,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at,
+  };
+}
+
+export interface MessagesRepository {
+  list(threadId: string): Promise<Message[]>;
+  subscribeThread(
+    threadId: string,
+    handlers: {
+      onInsert?: (m: Message) => void;
+      onUpdate?: (m: Message) => void;
+      onDelete?: (m: Message) => void;
+    }
+  ): () => void;
+}
+
+class MessagesRepositoryImpl extends BaseRepository implements MessagesRepository {
+  constructor(private readonly remote: MessagesRemoteDataSource) {
+    super();
+  }
+
+  async list(threadId: string): Promise<Message[]> {
+    const res = await this.remote.list(threadId);
+    return this.unwrapOrThrow(res);
+  }
+
+  subscribeThread(
+    threadId: string,
+    handlers: {
+      onInsert?: (m: Message) => void;
+      onUpdate?: (m: Message) => void;
+      onDelete?: (m: Message) => void;
+    }
+  ): () => void {
+    const supabase = getSupabaseClient();
+    const channel = supabase
+      .channel(`messages:thread:${threadId}`)
+      .on(
+        'postgres_changes',
+        { event: 'INSERT', schema: 'public', table: 'message', filter: `thread_id=eq.${threadId}` },
+        (payload) => {
+          const row = payload.new as DbMessageRow;
+          handlers.onInsert?.(mapDbRowToMessage(row));
+        }
+      )
+      .on(
+        'postgres_changes',
+        { event: 'UPDATE', schema: 'public', table: 'message', filter: `thread_id=eq.${threadId}` },
+        (payload) => {
+          const row = payload.new as DbMessageRow;
+          handlers.onUpdate?.(mapDbRowToMessage(row));
+        }
+      )
+      .on(
+        'postgres_changes',
+        { event: 'DELETE', schema: 'public', table: 'message', filter: `thread_id=eq.${threadId}` },
+        (payload) => {
+          const row = payload.old as DbMessageRow;
+          handlers.onDelete?.(mapDbRowToMessage(row));
+        }
+      )
+      .subscribe();
+
+    return () => {
+      supabase.removeChannel(channel);
+    };
+  }
+}
+
+export const messagesRepository: MessagesRepository = new MessagesRepositoryImpl(messagesRemoteDataSource);
+
+

package/src/data/messages/types.ts

@@ -0,0 +1,20 @@
+export type Message = {
+  id: string;
+  appId: string;
+  threadId: string;
+  commitId: string | null;
+  parentMessageId: string | null;
+  authorType: 'human' | 'ai';
+  userId: string | null;
+  payload: {
+    attachments?: AttachmentMeta[];
+    [key: string]: unknown;
+  };
+  referenceId: string | null;
+  createdAt: string;
+  updatedAt: string;
+};
+
+import type { AttachmentMeta } from '../../data/attachment/types';
+
+

package/src/data/public/studio-config/remote.ts

@@ -0,0 +1,19 @@
+import { publicApi } from "../../../core/services/http/public";
+import type { ServiceResponse } from "../../types";
+import { BaseRemote } from "../../base-remote";
+import type { StudioConfig } from "./types";
+
+export interface StudioConfigRemoteDataSource {
+	get(): Promise<ServiceResponse<StudioConfig>>;
+}
+
+class StudioConfigRemoteDataSourceImpl extends BaseRemote implements StudioConfigRemoteDataSource {
+	async get(): Promise<ServiceResponse<StudioConfig>> {
+		const { data } = await publicApi.get<ServiceResponse<StudioConfig>>("/v1/public/studio-config");
+		return data;
+	}
+}
+
+export const studioConfigRemoteDataSource: StudioConfigRemoteDataSource = new StudioConfigRemoteDataSourceImpl();
+
+

package/src/data/public/studio-config/repository.ts

@@ -0,0 +1,23 @@
+import { BaseRepository } from "../../base-repository";
+import type { StudioConfig } from "./types";
+import type { StudioConfigRemoteDataSource } from "./remote";
+import { studioConfigRemoteDataSource } from "./remote";
+
+export interface StudioConfigRepository {
+	get(): Promise<StudioConfig>;
+}
+
+class StudioConfigRepositoryImpl extends BaseRepository implements StudioConfigRepository {
+	constructor(private readonly remote: StudioConfigRemoteDataSource) {
+		super();
+	}
+
+	async get(): Promise<StudioConfig> {
+		const res = await this.remote.get();
+		return this.unwrapOrThrow(res);
+	}
+}
+
+export const studioConfigRepository: StudioConfigRepository = new StudioConfigRepositoryImpl(studioConfigRemoteDataSource);
+
+

package/src/data/public/studio-config/types.ts

@@ -0,0 +1,6 @@
+export type StudioConfig = {
+	url: string;
+	anonKey: string;
+};
+
+

package/src/data/ratings/remote.ts

@@ -0,0 +1,76 @@
+import { api } from '../../core/services/http';
+import type { ServiceResponse } from '../types';
+import { BaseRemote } from '../base-remote';
+import type {
+  AppRating,
+  AppRatingList,
+  AppRatingMutationResult,
+  AppRatingStatsResult,
+  CreateAppRatingInput,
+  ListAppRatingsQuery,
+  UpdateAppRatingInput,
+} from './types';
+
+export interface AppRatingsRemoteDataSource {
+  list(appId: string, query?: ListAppRatingsQuery): Promise<ServiceResponse<AppRatingList>>;
+  getById(appId: string, ratingId: string): Promise<ServiceResponse<AppRating>>;
+  create(appId: string, payload: CreateAppRatingInput): Promise<ServiceResponse<AppRatingMutationResult>>;
+  update(
+    appId: string,
+    ratingId: string,
+    payload: UpdateAppRatingInput
+  ): Promise<ServiceResponse<AppRatingMutationResult>>;
+  remove(appId: string, ratingId: string): Promise<ServiceResponse<AppRatingStatsResult>>;
+}
+
+class AppRatingsRemoteDataSourceImpl extends BaseRemote implements AppRatingsRemoteDataSource {
+  async list(appId: string, query?: ListAppRatingsQuery): Promise<ServiceResponse<AppRatingList>> {
+    const params = query ? { ...query } : undefined;
+    const { data } = await api.get<ServiceResponse<AppRatingList>>(
+      `/v1/apps/${encodeURIComponent(appId)}/ratings`,
+      { params }
+    );
+    return data;
+  }
+
+  async getById(appId: string, ratingId: string): Promise<ServiceResponse<AppRating>> {
+    const { data } = await api.get<ServiceResponse<AppRating>>(
+      `/v1/apps/${encodeURIComponent(appId)}/ratings/${encodeURIComponent(ratingId)}`
+    );
+    return data;
+  }
+
+  async create(
+    appId: string,
+    payload: CreateAppRatingInput
+  ): Promise<ServiceResponse<AppRatingMutationResult>> {
+    const { data } = await api.post<ServiceResponse<AppRatingMutationResult>>(
+      `/v1/apps/${encodeURIComponent(appId)}/ratings`,
+      payload
+    );
+    return data;
+  }
+
+  async update(
+    appId: string,
+    ratingId: string,
+    payload: UpdateAppRatingInput
+  ): Promise<ServiceResponse<AppRatingMutationResult>> {
+    const { data } = await api.patch<ServiceResponse<AppRatingMutationResult>>(
+      `/v1/apps/${encodeURIComponent(appId)}/ratings/${encodeURIComponent(ratingId)}`,
+      payload
+    );
+    return data;
+  }
+
+  async remove(appId: string, ratingId: string): Promise<ServiceResponse<AppRatingStatsResult>> {
+    const { data } = await api.delete<ServiceResponse<AppRatingStatsResult>>(
+      `/v1/apps/${encodeURIComponent(appId)}/ratings/${encodeURIComponent(ratingId)}`
+    );
+    return data;
+  }
+}
+
+export const appRatingsRemoteDataSource: AppRatingsRemoteDataSource = new AppRatingsRemoteDataSourceImpl();
+
+

package/src/data/ratings/repository.ts

@@ -0,0 +1,63 @@
+import type { AppRatingsRemoteDataSource } from './remote';
+import { appRatingsRemoteDataSource } from './remote';
+import type {
+  AppRating,
+  AppRatingList,
+  AppRatingMutationResult,
+  AppRatingStatsResult,
+  CreateAppRatingInput,
+  ListAppRatingsQuery,
+  UpdateAppRatingInput,
+} from './types';
+import { BaseRepository } from '../../data/base-repository';
+
+export interface AppRatingsRepository {
+  list(appId: string, query?: ListAppRatingsQuery): Promise<AppRatingList>;
+  getById(appId: string, ratingId: string): Promise<AppRating>;
+  create(appId: string, payload: CreateAppRatingInput): Promise<AppRatingMutationResult>;
+  update(
+    appId: string,
+    ratingId: string,
+    payload: UpdateAppRatingInput
+  ): Promise<AppRatingMutationResult>;
+  remove(appId: string, ratingId: string): Promise<AppRatingStatsResult>;
+}
+
+class AppRatingsRepositoryImpl extends BaseRepository implements AppRatingsRepository {
+  constructor(private readonly remote: AppRatingsRemoteDataSource) {
+    super();
+  }
+
+  async list(appId: string, query?: ListAppRatingsQuery): Promise<AppRatingList> {
+    const res = await this.remote.list(appId, query);
+    return this.unwrapOrThrow(res);
+  }
+
+  async getById(appId: string, ratingId: string): Promise<AppRating> {
+    const res = await this.remote.getById(appId, ratingId);
+    return this.unwrapOrThrow(res);
+  }
+
+  async create(appId: string, payload: CreateAppRatingInput): Promise<AppRatingMutationResult> {
+    const res = await this.remote.create(appId, payload);
+    return this.unwrapOrThrow(res);
+  }
+
+  async update(
+    appId: string,
+    ratingId: string,
+    payload: UpdateAppRatingInput
+  ): Promise<AppRatingMutationResult> {
+    const res = await this.remote.update(appId, ratingId, payload);
+    return this.unwrapOrThrow(res);
+  }
+
+  async remove(appId: string, ratingId: string): Promise<AppRatingStatsResult> {
+    const res = await this.remote.remove(appId, ratingId);
+    return this.unwrapOrThrow(res);
+  }
+}
+
+export const appRatingsRepository: AppRatingsRepository = new AppRatingsRepositoryImpl(appRatingsRemoteDataSource);
+
+

package/src/data/ratings/types.ts

@@ -0,0 +1,57 @@
+export type AppRating = {
+  id: string;
+  appId: string;
+  userId: string;
+  rating: number;
+  commentId: string | null;
+  title: string | null;
+  review: string | null;
+  metadata: Record<string, unknown>;
+  createdAt: string;
+  updatedAt: string;
+};
+
+export type ListAppRatingsQuery = {
+  page?: number;
+  pageSize?: number;
+  userId?: string;
+  minRating?: number;
+  maxRating?: number;
+};
+
+export type CreateAppRatingInput = {
+  rating: number;
+  commentId?: string | null;
+  title?: string | null;
+  review?: string | null;
+  metadata?: Record<string, unknown>;
+};
+
+export type UpdateAppRatingInput = Partial<CreateAppRatingInput>;
+
+export type AppRatingStats = {
+  total?: number;
+  average?: number | null;
+};
+
+export type AppRatingList = {
+  items: AppRating[];
+  pageInfo: {
+    page: number;
+    pageSize: number;
+    total: number;
+    hasMore: boolean;
+  };
+  stats: AppRatingStats;
+};
+
+export type AppRatingMutationResult = {
+  rating: AppRating;
+  stats?: AppRatingStats;
+};
+
+export type AppRatingStatsResult = {
+  stats?: AppRatingStats;
+};
+
+

package/src/data/threads/remote.ts

@@ -0,0 +1,40 @@
+import { api } from '../../core/services/http';
+import type { ServiceResponse } from '../types';
+import { BaseRemote } from '../base-remote';
+import type { Thread, UpdateThreadRequest } from './types';
+
+export interface ThreadsRemoteDataSource {
+  list(): Promise<ServiceResponse<Thread[]>>;
+  getById(threadId: string): Promise<ServiceResponse<Thread>>;
+  update(threadId: string, payload: UpdateThreadRequest): Promise<ServiceResponse<Thread>>;
+  delete(threadId: string): Promise<ServiceResponse<never>>;
+}
+
+class ThreadsRemoteDataSourceImpl extends BaseRemote implements ThreadsRemoteDataSource {
+  async list(): Promise<ServiceResponse<Thread[]>> {
+    const { data } = await api.get<ServiceResponse<Thread[]>>('/v1/threads');
+    return data;
+  }
+
+  async getById(threadId: string): Promise<ServiceResponse<Thread>> {
+    const { data } = await api.get<ServiceResponse<Thread>>(`/v1/threads/${encodeURIComponent(threadId)}`);
+    return data;
+  }
+
+  async update(threadId: string, payload: UpdateThreadRequest): Promise<ServiceResponse<Thread>> {
+    const { data } = await api.patch<ServiceResponse<Thread>>(
+      `/v1/threads/${encodeURIComponent(threadId)}`,
+      payload
+    );
+    return data;
+  }
+
+  async delete(threadId: string): Promise<ServiceResponse<never>> {
+    const { data } = await api.delete<ServiceResponse<never>>(`/v1/threads/${encodeURIComponent(threadId)}`);
+    return data;
+  }
+}
+
+export const threadsRemoteDataSource: ThreadsRemoteDataSource = new ThreadsRemoteDataSourceImpl();
+
+

package/src/data/threads/repository.ts

@@ -0,0 +1,41 @@
+import type { ThreadsRemoteDataSource } from './remote';
+import { threadsRemoteDataSource } from './remote';
+import type { Thread, UpdateThreadRequest } from './types';
+import { BaseRepository } from '../../data/base-repository';
+
+export interface ThreadsRepository {
+  list(): Promise<Thread[]>;
+  getById(threadId: string): Promise<Thread>;
+  update(threadId: string, payload: UpdateThreadRequest): Promise<Thread>;
+  delete(threadId: string): Promise<void>;
+}
+
+class ThreadsRepositoryImpl extends BaseRepository implements ThreadsRepository {
+  constructor(private readonly remote: ThreadsRemoteDataSource) {
+    super();
+  }
+
+  async list(): Promise<Thread[]> {
+    const res = await this.remote.list();
+    return this.unwrapOrThrow(res);
+  }
+
+  async getById(threadId: string): Promise<Thread> {
+    const res = await this.remote.getById(threadId);
+    return this.unwrapOrThrow(res);
+  }
+
+  async update(threadId: string, payload: UpdateThreadRequest): Promise<Thread> {
+    const res = await this.remote.update(threadId, payload);
+    return this.unwrapOrThrow(res);
+  }
+
+  async delete(threadId: string): Promise<void> {
+    const res = await this.remote.delete(threadId);
+    this.unwrapOrThrow(res as any);
+  }
+}
+
+export const threadsRepository: ThreadsRepository = new ThreadsRepositoryImpl(threadsRemoteDataSource);
+
+

package/src/data/threads/types.ts

@@ -0,0 +1,25 @@
+export type ThreadKind = 'chat' | 'review' | 'build' | 'system';
+
+export type Thread = {
+  id: string;
+  createdBy: string;
+  title: string | null;
+  kind: ThreadKind;
+  isLocked: boolean;
+  isArchived: boolean;
+  metadata: Record<string, unknown> | null;
+  messageCount: number;
+  lastMessageAt: string | null;
+  createdAt: string;
+  updatedAt: string;
+};
+
+export type UpdateThreadRequest = {
+  title?: string;
+  kind?: ThreadKind;
+  isLocked?: boolean;
+  isArchived?: boolean;
+  metadata?: Record<string, unknown>;
+};
+
+