@rynt/sdk 0.9.53

package/src/extensions/launcher-models/apis/accounts-contracts.ts

@@ -0,0 +1,102 @@
+/**
+ * Контракты домена Minecraft-аккаунтов (дублируют `packages/client/src/models/accounts`),
+ * чтобы типизировать `useModel('accounts')` без импорта клиентского кода.
+ */
+
+export enum ProviderType {
+  Microsoft = 'microsoft',
+  Ely = 'ely',
+  LittleSkin = 'littleskin',
+  Custom = 'custom',
+  Offline = 'offline',
+}
+
+export enum AuthType {
+  OAuth2 = 'oauth2',
+  Base = 'base',
+}
+
+export interface ProviderCapabilities {
+  registration: boolean;
+  skinsView: boolean;
+  skinsManage: boolean;
+  capesView: boolean;
+  capesManage: boolean;
+  refreshToken: boolean;
+  validateToken: boolean;
+}
+
+export interface ProfileData {
+  username: string;
+  uuid: string;
+  avatar?: string | null;
+  skinUrl?: string | null;
+  skinSha1?: string | null;
+  capeUrl?: string | null;
+  [key: string]: unknown;
+}
+
+export interface AuthResult {
+  accessToken: string;
+  refreshToken?: string;
+  clientToken?: string;
+  expiresAt?: number;
+  profile: ProfileData;
+}
+
+export interface Account {
+  id: string;
+  providerId: string;
+  providerType: ProviderType;
+  username: string;
+  uuid: string;
+  accessToken: string;
+  refreshToken?: string;
+  clientToken?: string;
+  expiresAt?: number;
+  profile?: ProfileData;
+  isActive: boolean;
+  createdAt: number;
+  lastUsedAt?: number;
+}
+
+export interface ProviderConfig {
+  id: string;
+  name: string;
+  type: ProviderType;
+  [key: string]: unknown;
+}
+
+export interface LoginOptions {
+  username?: string;
+  password?: string;
+  [key: string]: unknown;
+}
+
+export interface IAuthProvider {
+  readonly id: string;
+  readonly type: ProviderType;
+  readonly authType: AuthType;
+  readonly config: ProviderConfig;
+  readonly capabilities: ProviderCapabilities;
+  readonly skinManagementUrl?: string;
+  readonly minMinecraftVersion?: string;
+  readonly authlibInjectorUrl?: string;
+  readonly minecraftApiArgs?: Record<string, string>;
+
+  login(options?: LoginOptions): Promise<AuthResult>;
+  refresh(account: Account): Promise<AuthResult>;
+  validate(account: Account): Promise<boolean>;
+  getProfile(account: Account): Promise<ProfileData>;
+  shouldRefresh(account: Account): boolean;
+  register?(options?: LoginOptions): Promise<AuthResult>;
+  listSkins?(account: Account): Promise<unknown[]>;
+  uploadSkin?(
+    account: Account,
+    skinFile: File | Buffer,
+    model?: 'classic' | 'slim',
+  ): Promise<void>;
+  listCapes?(account: Account): Promise<unknown[]>;
+  uploadCape?(account: Account, capeFile: File | Buffer): Promise<void>;
+  getSkinUrl?(account: Account): Promise<string | null> | string | null;
+}

package/src/extensions/launcher-models/apis/launcher-model-apis.ts

@@ -0,0 +1,553 @@
+/**
+ * Return-типы сторов `packages/client/src/models/*`, доступных расширениям через `useModel`.
+ * При изменении публичного API стора обновляйте соответствующий интерфейс здесь.
+ */
+
+import type { ChildProcess } from 'node:child_process';
+import type { ComputedRef, Ref } from 'vue';
+
+import type {
+  LaunchProgress,
+  UseMinecraftLauncherReturn,
+} from '../../../shared/minecraft-types/minecraft-launcher-types';
+
+import type { Build, Version } from '../../../shared/api/builds';
+import type { LoginCredentials, RegisterData } from '../../../shared/api/auth';
+import type { CreateInviteInput } from '../../../shared/api/invites';
+import type { EventInput } from '../../../shared/api/events';
+import type { PostInput } from '../../../shared/api/posts';
+import type { ServerInput } from '../../../shared/api/projectServers';
+import type { ServerMemberInput } from '../../../shared/api/serverMembers';
+import type { LibraryStats } from '../../../shared/api/library';
+import type { BuildVersionManifest } from '../../../shared/minecraft-types/build-manifest';
+import type { MinecraftVersionManifest } from '../../../shared/minecraft-types/launcher-versions';
+import type {
+  EntityBuildLocal,
+  EntityEvent,
+  EntityInvite,
+  EntityPost,
+  EntityServer,
+  EntityServerMember,
+  EntityUser,
+} from '../../../shared/types/entities';
+import type { RunningBuild } from '../../../shared/types/running-build';
+import type { ServerMemberRole } from '../../../shared/types/serverMember';
+import type { LocalSettings } from '../../../shared/utils/local-settings';
+
+import type {
+  Account,
+  IAuthProvider,
+  LoginOptions,
+} from './accounts-contracts';
+import type { UserStatusDetail } from '../../../shared/types/user';
+
+type PublicBuildsQuery = Parameters<
+  typeof import('../../../shared/api/builds').getPublicBuilds
+>[0];
+
+type ProjectServersQuery = Parameters<
+  typeof import('../../../shared/api/projectServers').getServers
+>[0];
+
+type FriendSearchOptions = Parameters<
+  typeof import('../../../shared/api/friends').searchUsers
+>[1];
+
+type UpdateUserProfileInput = Parameters<
+  typeof import('../../../shared/api/auth').updateUserProfile
+>[0];
+
+export type UpdaterStatus =
+  | 'idle'
+  | 'checking'
+  | 'downloading'
+  | 'ready'
+  | 'error';
+
+export type AuthMode = 'login' | 'register';
+
+export interface AuthLoginFormData {
+  username: string;
+  password: string;
+}
+
+export interface AuthRegisterFormData {
+  username: string;
+  email: string;
+  password: string;
+  confirmPassword: string;
+  acceptTerms: boolean;
+}
+
+export interface LocalBuildIndexEntry {
+  path: string;
+  isUserBuild: boolean;
+}
+
+/** Элемент списка сборок из `getBuildsList` / `getBuildsListFn`. */
+export type LocalBuildListRow = EntityBuildLocal;
+
+export interface LocalLaunchBuildOptions {
+  accountId?: string;
+  username?: string;
+  onProgress?: (progress: LaunchProgress) => void;
+  providerId?: string;
+  serverInfo?: {
+    ip: string;
+    port: number;
+    serverId?: string;
+  };
+}
+
+type ServerPostsQuery = {
+  take?: number;
+  skip?: number;
+  orderBy?: Array<{ date?: 'asc' | 'desc' }>;
+};
+
+type ServerEventsQuery = {
+  take?: number;
+  skip?: number;
+  orderBy?: Array<{ startDateTime?: 'asc' | 'desc' }>;
+  filter?: 'all' | 'active' | 'upcoming' | 'past';
+};
+
+type EventListFilter = 'all' | 'active' | 'upcoming' | 'past';
+
+// --- Per-model public surfaces ---
+
+export interface BuildsModelApi {
+  myPublishedBuilds: Ref<Build[]>;
+  popularBuilds: Ref<Build[]>;
+  searchBuilds: Ref<Build[]>;
+  userBuilds: Ref<Build[]>;
+  versionsByBuildId: Ref<Map<string, Version[]>>;
+  isLoadingMyBuilds: Ref<boolean>;
+  isLoadingPopularBuilds: Ref<boolean>;
+  isLoadingSearchBuilds: Ref<boolean>;
+  error: Ref<Error | null>;
+  loadMyPublishedBuilds: () => Promise<Build[]>;
+  loadPopularBuilds: () => Promise<Build[]>;
+  searchPublicBuilds: (options?: PublicBuildsQuery) => Promise<Build[]>;
+  loadAllUserBuilds: () => Promise<Build[]>;
+  loadBuildVersions: (buildId: string) => Promise<Version[]>;
+  loadBuildWithLatestVersion: (
+    buildId: string,
+  ) => Promise<
+    ReturnType<
+      typeof import('../../../shared/api/builds').getBuildWithLatestVersion
+    > extends infer R
+      ? R extends Promise<infer U>
+        ? U
+        : never
+      : never
+  >;
+  checkBuildExists: typeof import('../../../shared/api/builds').checkBuildExists;
+  createBuild: typeof import('../../../shared/api/builds').createBuild;
+  updateBuild: typeof import('../../../shared/api/builds').updateBuild;
+  createVersion: typeof import('../../../shared/api/builds').createVersion;
+  getExistingAssetsBySha1: typeof import('../../../shared/api/assets').getAssetsBySha1;
+  uploadBuildAsset: typeof import('../../../shared/api/assets').uploadAsset;
+  addAuthorToBuildAsset: typeof import('../../../shared/api/builds').addAuthorToAsset;
+  loadUserStorageQuota: typeof import('../../../shared/api/auth').getUserStorageQuota;
+}
+
+export interface UserModelApi {
+  user: ComputedRef<EntityUser | null>;
+  isAuthenticated: ComputedRef<boolean>;
+  isLoading: Ref<boolean>;
+  error: Ref<string | null>;
+  init: () => Promise<void>;
+  login: (
+    credentials: LoginCredentials,
+    skipUserUpdate?: boolean,
+  ) => Promise<boolean>;
+  registerWithEmail: (data: RegisterData) => Promise<boolean>;
+  verifyRegistration: (
+    email: string,
+    code: string,
+    username: string,
+    password: string,
+    skipUserUpdate?: boolean,
+  ) => Promise<boolean>;
+  requestPasswordReset: (email: string) => Promise<boolean>;
+  verifyPasswordReset: (
+    email: string,
+    code: string,
+    newPassword: string,
+  ) => Promise<boolean>;
+  logout: () => Promise<boolean>;
+  refreshUser: () => Promise<void>;
+  updateProfile: (
+    data: UpdateUserProfileInput,
+  ) => Promise<EntityUser | undefined>;
+  setStatusDetail: (detail: UserStatusDetail) => Promise<void>;
+  clearStatusDetail: () => Promise<void>;
+}
+
+export interface FriendsModelApi {
+  friends: ComputedRef<EntityUser[]>;
+  onlineFriends: ComputedRef<EntityUser[]>;
+  isLoading: Ref<boolean>;
+  isFriendsListLoading: Ref<boolean>;
+  error: Ref<string | null>;
+  init: () => Promise<void>;
+  loadFriends: () => Promise<void>;
+  searchUsers: (
+    query: string,
+    options?: FriendSearchOptions,
+  ) => Promise<EntityUser[]>;
+  removeFriend: (friendId: string) => Promise<void>;
+  startAutoRefresh: () => void;
+  stopAutoRefresh: () => void;
+}
+
+export interface AuthModelApi {
+  authMode: Ref<AuthMode>;
+  showVerificationCode: Ref<boolean>;
+  verificationCode: Ref<string>;
+  isResendingCode: Ref<boolean>;
+  loginForm: Ref<AuthLoginFormData>;
+  registerForm: Ref<AuthRegisterFormData>;
+  localError: Ref<string | null>;
+  successMessage: Ref<string | null>;
+  showLoginPassword: Ref<boolean>;
+  showRegisterPassword: Ref<boolean>;
+  showConfirmPassword: Ref<boolean>;
+  displayError: ComputedRef<string | null>;
+  isRegisterFormValid: ComputedRef<boolean>;
+  isLoading: Ref<boolean>;
+  setAuthMode: (mode: AuthMode) => void;
+  handleLogin: () => Promise<void>;
+  handleRegister: () => Promise<void>;
+  handleVerifyRegistration: () => Promise<void>;
+  handleResendCode: () => Promise<void>;
+  backToRegisterForm: () => void;
+  resetForms: () => void;
+}
+
+export interface AccountsModelApi {
+  accounts: ComputedRef<readonly Account[]>;
+  activeAccount: ComputedRef<Account | null>;
+  isLoading: Ref<boolean>;
+  error: Ref<string | null>;
+  isUpdatingSkins: Ref<boolean>;
+  providers: ComputedRef<IAuthProvider[]>;
+  builtInProviders: ComputedRef<IAuthProvider[]>;
+  customProviders: ComputedRef<IAuthProvider[]>;
+  init: () => Promise<void>;
+  login: (
+    providerId: string,
+    options?: LoginOptions & { setActive?: boolean },
+  ) => Promise<Account>;
+  removeAccount: (id: string) => Promise<void>;
+  setActive: (id: string) => Promise<void>;
+  refreshAccount: (id: string) => Promise<Account>;
+  validateAccount: (id: string) => Promise<boolean>;
+  getProvider: (providerId: string) => IAuthProvider | undefined;
+  getAccountForLaunch: (accountId?: string) => Promise<Account | null>;
+  updateSkinsInBackground: () => Promise<void>;
+  updateAccountSkin: (accountId: string) => Promise<void>;
+  updateAccountProfile: (
+    accountId: string,
+    profile: Partial<NonNullable<Account['profile']>>,
+  ) => Promise<void>;
+}
+
+export interface SettingsModelApi {
+  settings: Ref<LocalSettings>;
+  authorMode: ComputedRef<boolean | null>;
+  notificationMode: ComputedRef<LocalSettings['notificationMode']>;
+  theme: ComputedRef<string>;
+  themeVariant: ComputedRef<'light' | 'dark'>;
+  radiusScale: ComputedRef<'none' | 'standard' | 'medium'>;
+  defaultMaxRam: ComputedRef<number>;
+  discordRpcEnabled: ComputedRef<boolean>;
+  disableSounds: ComputedRef<boolean>;
+  disableAutostart: ComputedRef<boolean>;
+  startInTray: ComputedRef<boolean>;
+  init: () => void;
+  setAuthorMode: (value: boolean | null) => void;
+  setNotificationMode: (value: LocalSettings['notificationMode']) => void;
+  setTheme: (value: string) => void;
+  setThemeVariant: (value: 'light' | 'dark') => void;
+  setRadiusScale: (value: 'none' | 'standard' | 'medium') => void;
+  setDefaultMaxRam: (value: number) => void;
+  setDiscordRpcEnabled: (value: boolean) => void;
+  setDisableSounds: (value: boolean) => void;
+  setDisableAutostart: (value: boolean) => void;
+  setStartInTray: (value: boolean) => void;
+  updateSettings: (newSettings: Partial<LocalSettings>) => void;
+  reload: () => void;
+}
+
+export interface UpdaterModelApi {
+  status: Ref<UpdaterStatus>;
+  downloadProgress: Ref<number>;
+  downloadedVersion: Ref<string | null>;
+  errorMessage: Ref<string>;
+  startBackgroundCheck: () => void;
+  stopBackgroundCheck: () => void;
+  runCheckAndUpdate: () => Promise<void>;
+  isCheckingOrDownloading: () => boolean;
+}
+
+export interface ServersModelApi {
+  selectedServerId: Ref<string | null>;
+  selectedServer: ComputedRef<EntityServer | null>;
+  isLoading: Ref<boolean>;
+  isLoadingUserServers: Ref<boolean>;
+  isLoadingPosts: Ref<boolean>;
+  isLoadingEvents: Ref<boolean>;
+  error: Ref<string | null>;
+  userServers: ComputedRef<EntityServer[]>;
+  ownedServers: ComputedRef<EntityServer[]>;
+  recentServers: ComputedRef<EntityServer[]>;
+  playedServers: ComputedRef<EntityServer[]>;
+  getServerPosts: ComputedRef<(serverId: string) => EntityPost[]>;
+  loadServerPosts: (
+    serverId: string,
+    options?: ServerPostsQuery,
+  ) => Promise<EntityPost[]>;
+  getActiveServerEvents: ComputedRef<(serverId: string) => EntityEvent[]>;
+  getUpcomingServerEvents: ComputedRef<(serverId: string) => EntityEvent[]>;
+  getServerEventsByFilter: ComputedRef<
+    (serverId: string, filter: EventListFilter) => EntityEvent[]
+  >;
+  loadServerEvents: (
+    serverId: string,
+    options?: ServerEventsQuery,
+  ) => Promise<EntityEvent[]>;
+  loadServer: (serverId: string) => Promise<EntityServer | null>;
+  loadUserServers: (userId: string) => Promise<EntityServer[]>;
+  createServer: (data: ServerInput) => Promise<EntityServer | null>;
+  updateServer: (
+    serverId: string,
+    data: Partial<ServerInput>,
+  ) => Promise<EntityServer | null>;
+  deleteServer: (serverId: string) => Promise<boolean>;
+  openServer: (id: string) => Promise<void>;
+  closeServer: () => void;
+  refreshServer: (serverId: string) => Promise<void>;
+  init: (userId: string) => Promise<void>;
+  launchServer: (serverId: string) => Promise<void>;
+}
+
+export interface InvitesModelApi {
+  incomingInvites: ComputedRef<EntityInvite[]>;
+  outgoingInvites: ComputedRef<EntityInvite[]>;
+  isLoading: Ref<boolean>;
+  isLoadingIncoming: Ref<boolean>;
+  isLoadingOutgoing: Ref<boolean>;
+  error: Ref<string | null>;
+  pendingIncomingInvites: ComputedRef<EntityInvite[]>;
+  pendingOutgoingInvites: ComputedRef<EntityInvite[]>;
+  friendInvites: ComputedRef<EntityInvite[]>;
+  init: () => Promise<void>;
+  startIncomingInvitesPolling: () => void;
+  stopIncomingInvitesPolling: () => void;
+  loadIncomingInvites: (options?: {
+    type?: EntityInvite['type'];
+    status?: EntityInvite['status'];
+  }) => Promise<void>;
+  loadOutgoingInvites: (options?: {
+    type?: EntityInvite['type'];
+    status?: EntityInvite['status'];
+  }) => Promise<void>;
+  loadAllInvites: () => Promise<void>;
+  createInvite: (input: CreateInviteInput) => Promise<EntityInvite | undefined>;
+  acceptInvite: (inviteId: string) => Promise<void>;
+  rejectInvite: (inviteId: string) => Promise<void>;
+  checkFriendInviteExists: (targetId: string) => Promise<boolean>;
+}
+
+export interface EventsModelApi {
+  selectedEventId: Ref<string | null>;
+  showEventDialog: Ref<boolean>;
+  editingEventId: Ref<string | null>;
+  creatingEventServerId: Ref<string | null>;
+  creatingEventProjectId: Ref<string | null>;
+  isLoading: Ref<boolean>;
+  isLoadingList: Ref<boolean>;
+  error: Ref<string | null>;
+  selectedEvent: ComputedRef<EntityEvent | undefined | null>;
+  getActiveServerEvents: ComputedRef<(serverId: string) => EntityEvent[]>;
+  getUpcomingServerEvents: ComputedRef<(serverId: string) => EntityEvent[]>;
+  getServerEventsByFilter: ComputedRef<
+    (serverId: string, filter: EventListFilter) => EntityEvent[]
+  >;
+  loadEvent: (eventId: string) => Promise<EntityEvent | undefined | null>;
+  loadServerEvents: (
+    serverId: string,
+    options?: {
+      take?: number;
+      skip?: number;
+      orderBy?: Array<{ startDateTime?: 'asc' | 'desc' }>;
+      filter?: EventListFilter;
+    },
+  ) => Promise<EntityEvent[]>;
+  createEvent: (data: EventInput) => Promise<EntityEvent | null>;
+  updateEvent: (
+    eventId: string,
+    data: Partial<Omit<EventInput, 'projectId'>>,
+  ) => Promise<EntityEvent | null>;
+  deleteEvent: (eventId: string) => Promise<boolean>;
+  openEvent: (id: string) => Promise<void>;
+  closeEvent: () => void;
+  refreshEvent: (eventId: string) => Promise<void>;
+  openCreateEventDialog: (options?: {
+    serverId?: string;
+    projectId?: string;
+  }) => void;
+  openEditEventDialog: (eventId: string) => void;
+  closeEventDialog: () => void;
+}
+
+export interface PostsModelApi {
+  selectedPostId: Ref<string | null>;
+  showPostDialog: Ref<boolean>;
+  editingPostId: Ref<string | null>;
+  creatingPostServerId: Ref<string | null>;
+  creatingPostProjectId: Ref<string | null>;
+  isLoading: Ref<boolean>;
+  isLoadingList: Ref<boolean>;
+  error: Ref<string | null>;
+  selectedPost: ComputedRef<EntityPost | undefined | null>;
+  getServerPosts: ComputedRef<(serverId: string) => EntityPost[]>;
+  loadPost: (postId: string) => Promise<EntityPost | undefined | null>;
+  loadProjectPosts: (
+    projectId: string,
+    options?: {
+      take?: number;
+      skip?: number;
+      orderBy?: Array<{ date?: 'asc' | 'desc' }>;
+    },
+  ) => Promise<EntityPost[]>;
+  loadServerPosts: (
+    serverId: string,
+    options?: {
+      take?: number;
+      skip?: number;
+      orderBy?: Array<{ date?: 'asc' | 'desc' }>;
+    },
+  ) => Promise<EntityPost[]>;
+  loadPostsByServers: (
+    serverIds: string[],
+    options?: {
+      take?: number;
+      skip?: number;
+      orderBy?: Array<{ date?: 'asc' | 'desc' }>;
+    },
+  ) => Promise<EntityPost[]>;
+  loadAllPosts: (options?: {
+    take?: number;
+    skip?: number;
+    orderBy?: Array<{ date?: 'asc' | 'desc' }>;
+  }) => Promise<EntityPost[]>;
+  createPost: (data: PostInput) => Promise<EntityPost | null>;
+  updatePost: (
+    postId: string,
+    data: Partial<Omit<PostInput, 'projectId'>>,
+  ) => Promise<EntityPost | null>;
+  deletePost: (postId: string) => Promise<boolean>;
+  openPost: (id: string) => Promise<void>;
+  closePost: () => void;
+  refreshPost: (postId: string) => Promise<void>;
+  openCreatePostDialog: (options?: {
+    serverId?: string;
+    projectId?: string;
+  }) => void;
+  openEditPostDialog: (postId: string) => void;
+  closePostDialog: () => void;
+}
+
+export interface LibraryModelApi {
+  stats: Ref<LibraryStats | null>;
+  popularServers: Ref<EntityServer[]>;
+  searchServers: Ref<EntityServer[]>;
+  isLoadingStats: Ref<boolean>;
+  isLoadingPopularServers: Ref<boolean>;
+  isLoadingSearchServers: Ref<boolean>;
+  error: Ref<Error | null>;
+  loadStats: () => Promise<LibraryStats | null>;
+  loadPopularServers: () => Promise<EntityServer[]>;
+  searchPublicServers: (
+    options?: ProjectServersQuery,
+  ) => Promise<EntityServer[]>;
+}
+
+export interface LocalBuildsModelApi {
+  manifestsCache: Ref<Map<string, BuildVersionManifest>>;
+  buildsIndex: Ref<Map<string, LocalBuildIndexEntry>>;
+  runningBuilds: ComputedRef<RunningBuild[]>;
+  selectedRunningBuildId: Ref<string | null>;
+  loadAllManifests: () => Promise<void>;
+  getManifestById: (id: string) => BuildVersionManifest | null;
+  getManifestByUuid: (uuid: string) => Promise<BuildVersionManifest | null>;
+  isLocalBuild: (uuid: string) => boolean;
+  downloadBuild: (
+    buildId: string,
+    version?: string,
+    preserveLocalId?: string,
+  ) => Promise<string | null>;
+  saveManifest: (
+    manifest: BuildVersionManifest,
+    name?: string,
+  ) => string | null;
+  deleteBuild: (id: string) => Promise<boolean>;
+  launchBuild: (
+    buildId: string,
+    options?: LocalLaunchBuildOptions,
+  ) => Promise<ChildProcess>;
+  isBuildRunning: (buildId: string) => boolean;
+  stopBuild: (buildId: string) => Promise<boolean>;
+  selectRunningBuild: (buildId: string | null) => void;
+  dismissRunningBuild: (buildId: string) => void;
+  getAllBuilds: ComputedRef<BuildVersionManifest[]>;
+  getBuildsList: ComputedRef<LocalBuildListRow[]>;
+  recentBuilds: ComputedRef<LocalBuildListRow[]>;
+  getBuildsListFn: (filterUserBuild?: boolean) => LocalBuildListRow[];
+}
+
+export interface LauncherRuntimeModelApi {
+  versionsManifest: Ref<MinecraftVersionManifest | undefined>;
+  launcher: UseMinecraftLauncherReturn;
+  initialize: () => Promise<boolean>;
+}
+
+export interface ServerMembersModelApi {
+  isLoading: Ref<boolean>;
+  isLoadingList: Ref<boolean>;
+  error: Ref<string | null>;
+  getServerMembers: ComputedRef<(serverId: string) => EntityServerMember[]>;
+  loadServerMembers: (serverId: string) => Promise<EntityServerMember[]>;
+  joinServer: (serverId: string) => Promise<EntityServerMember | null>;
+  getCurrentUserServerRole: (
+    serverId: string,
+  ) => Promise<ServerMemberRole | null>;
+  inviteMember: (data: ServerMemberInput) => Promise<EntityServerMember | null>;
+  updateMemberRole: (
+    memberId: string,
+    role: ServerMemberRole,
+  ) => Promise<EntityServerMember | null>;
+  removeMember: (memberId: string) => Promise<boolean>;
+  refreshServerMembers: (serverId: string) => Promise<void>;
+}
+
+export interface LauncherModelApis {
+  builds: BuildsModelApi;
+  user: UserModelApi;
+  friends: FriendsModelApi;
+  auth: AuthModelApi;
+  accounts: AccountsModelApi;
+  settings: SettingsModelApi;
+  updater: UpdaterModelApi;
+  servers: ServersModelApi;
+  invites: InvitesModelApi;
+  events: EventsModelApi;
+  posts: PostsModelApi;
+  library: LibraryModelApi;
+  local_builds: LocalBuildsModelApi;
+  launcher: LauncherRuntimeModelApi;
+  server_members: ServerMembersModelApi;
+}

package/src/extensions/launcher-models/keys.ts

@@ -0,0 +1,23 @@
+/**
+ * Ключи моделей лаунчера, доступных расширениям через `useModel`.
+ * Не включает `chats` и `calls` по продуктовому решению.
+ */
+export const RYNT_LAUNCHER_MODEL_KEYS = [
+  'builds',
+  'user',
+  'friends',
+  'auth',
+  'accounts',
+  'settings',
+  'updater',
+  'servers',
+  'invites',
+  'events',
+  'posts',
+  'library',
+  'local_builds',
+  'launcher',
+  'server_members',
+] as const;
+
+export type RyntLauncherModelKey = (typeof RYNT_LAUNCHER_MODEL_KEYS)[number];

package/src/extensions/launcher-models/public.ts

@@ -0,0 +1,9 @@
+/** Публичный API моделей для расширений: все контракты из `launcher-model-apis`. */
+export { useModel } from './registry-core';
+export type * from './apis/launcher-model-apis';
+export type { RyntLauncherModelKey } from './keys';
+export { RYNT_LAUNCHER_MODEL_KEYS } from './keys';
+
+export type * from '../../shared/types/entities';
+
+export * from '../../shared/utils/entity-build-from-api';