@voltro/plugin-social 0.0.0-stage → 0.88.0

package/dist/components.js

@@ -0,0 +1,201 @@
+import { useEffect as e, useId as t, useRef as n } from "react";
+import { Button as r, Dialog as i, DialogDescription as a, DialogFooter as o, DialogHeader as s, DialogTitle as c, Input as l } from "@voltro/ui-shadcn";
+import { jsx as u, jsxs as d } from "react/jsx-runtime";
+// src/components.tsx
+var f = {
+	en: {
+		title: "Friends",
+		empty: "Your friends will appear here after a request is accepted.",
+		loading: "Loading friends…",
+		error: "Friends could not be loaded. Try again.",
+		online: "Online",
+		offline: "Offline",
+		unknown: "Status unavailable",
+		invite: "Invite to party",
+		message: "Message",
+		profile: "Profile"
+	},
+	de: {
+		title: "Freunde",
+		empty: "Deine Freunde erscheinen hier, sobald eine Anfrage angenommen wurde.",
+		loading: "Freunde werden geladen…",
+		error: "Freunde konnten nicht geladen werden. Versuche es erneut.",
+		online: "Online",
+		offline: "Offline",
+		unknown: "Status nicht verfügbar",
+		invite: "In Party einladen",
+		message: "Nachricht",
+		profile: "Profil"
+	}
+}, p = ({ friend: e, labels: t = f.en, pending: n = !1, onInvite: i, onMessage: a, onProfile: o }) => /* @__PURE__ */ d("li", {
+	className: "flex min-w-0 flex-wrap items-center justify-between gap-4 py-4",
+	children: [/* @__PURE__ */ d("div", {
+		className: "min-w-0 flex-1 space-y-1",
+		children: [/* @__PURE__ */ d("p", {
+			className: "break-words font-medium",
+			children: [e.displayName, /* @__PURE__ */ d("span", {
+				className: "text-muted-foreground",
+				children: ["#", e.tag]
+			})]
+		}), /* @__PURE__ */ d("p", {
+			className: "break-words text-sm text-muted-foreground",
+			children: [e.online === null ? t.unknown : e.online ? t.online : t.offline, e.activity ? ` · ${e.activity}` : ""]
+		})]
+	}), /* @__PURE__ */ u("div", {
+		className: "flex flex-wrap gap-2",
+		children: [
+			[i, t.invite],
+			[a, t.message],
+			[o, t.profile]
+		].map(([t, i]) => t ? /* @__PURE__ */ u(r, {
+			type: "button",
+			variant: "outline",
+			size: "sm",
+			"aria-disabled": n,
+			onClick: () => {
+				n || t(e.subjectId);
+			},
+			children: i
+		}, i) : null)
+	})]
+}), m = ({ friends: e, loading: n = !1, error: r, pending: i = !1, labels: a = f.en, ...o }) => {
+	let s = t();
+	return /* @__PURE__ */ d("section", {
+		"aria-labelledby": s,
+		"aria-busy": n,
+		className: "min-w-0 space-y-3",
+		children: [/* @__PURE__ */ u("h2", {
+			id: s,
+			className: "text-lg font-semibold",
+			children: a.title
+		}), r === void 0 ? n && e.length === 0 ? /* @__PURE__ */ u("p", {
+			role: "status",
+			className: "text-sm text-muted-foreground",
+			children: a.loading
+		}) : e.length === 0 ? /* @__PURE__ */ u("p", {
+			className: "max-w-prose text-sm text-muted-foreground",
+			children: a.empty
+		}) : /* @__PURE__ */ u("ul", {
+			className: "divide-y divide-border",
+			children: e.map((e) => /* @__PURE__ */ u(p, {
+				friend: e,
+				labels: a,
+				pending: i || n,
+				...o
+			}, e.subjectId))
+		}) : /* @__PURE__ */ u("p", {
+			role: "alert",
+			className: "text-sm text-destructive",
+			children: a.error
+		})]
+	});
+}, h = {
+	en: {
+		title: "Add a friend",
+		description: "Find a player by their exact name and four-digit tag.",
+		name: "Name#Tag",
+		find: "Find player",
+		request: "Send friend request",
+		close: "Close",
+		notFound: "No player matches this name and tag.",
+		failed: "The operation failed. Check the result before retrying."
+	},
+	de: {
+		title: "Freund hinzufügen",
+		description: "Finde einen Spieler über seinen genauen Namen und vierstelligen Tag.",
+		name: "Name#Tag",
+		find: "Spieler finden",
+		request: "Freundesanfrage senden",
+		close: "Schließen",
+		notFound: "Kein Spieler mit diesem Namen und Tag gefunden.",
+		failed: "Der Vorgang ist fehlgeschlagen. Prüfe das Ergebnis vor einem erneuten Versuch."
+	}
+}, g = ({ open: f, onOpenChange: p, query: m, onQueryChange: g, found: _, scopeKey: v, pending: y = !1, error: b, labels: x = h.en, onFind: S, onRequest: C }) => {
+	let w = n(null), T = t(), E = t(), D = t();
+	e(() => {
+		let e = w.current;
+		e && (f && !e.open ? e.showModal() : !f && e.open && e.close());
+	}, [f]);
+	let O = _ && _.query === m.trim() && _.scopeKey === v ? _ : void 0;
+	return /* @__PURE__ */ d(i, {
+		ref: w,
+		"aria-labelledby": T,
+		"aria-describedby": E,
+		onClose: () => p(!1),
+		className: "max-h-[90dvh] max-w-[min(32rem,calc(100vw-2rem))] overflow-y-auto",
+		children: [
+			/* @__PURE__ */ d(s, { children: [/* @__PURE__ */ u(c, {
+				id: T,
+				children: x.title
+			}), /* @__PURE__ */ u(a, {
+				id: E,
+				children: x.description
+			})] }),
+			/* @__PURE__ */ d("form", {
+				className: "space-y-4",
+				"aria-busy": y,
+				onSubmit: (e) => {
+					e.preventDefault(), !y && m.trim() && S(m.trim());
+				},
+				children: [
+					/* @__PURE__ */ d("div", {
+						className: "space-y-2",
+						children: [/* @__PURE__ */ u("label", {
+							htmlFor: D,
+							className: "text-sm font-medium",
+							children: x.name
+						}), /* @__PURE__ */ u(l, {
+							id: D,
+							value: m,
+							maxLength: 261,
+							autoComplete: "off",
+							readOnly: y,
+							onChange: (e) => {
+								y || g(e.target.value);
+							}
+						})]
+					}),
+					/* @__PURE__ */ u(r, {
+						type: "submit",
+						variant: "outline",
+						"aria-disabled": y || !m.trim(),
+						children: x.find
+					}),
+					b === void 0 ? _ === null ? /* @__PURE__ */ u("p", {
+						role: "status",
+						className: "text-sm text-muted-foreground",
+						children: x.notFound
+					}) : O ? /* @__PURE__ */ d("div", {
+						className: "space-y-3",
+						children: [/* @__PURE__ */ d("p", {
+							className: "break-words font-medium",
+							children: [
+								O.displayName,
+								"#",
+								O.tag
+							]
+						}), /* @__PURE__ */ u(r, {
+							type: "button",
+							"aria-disabled": y,
+							onClick: () => {
+								y || C(O.subjectId);
+							},
+							children: x.request
+						})]
+					}) : null : /* @__PURE__ */ u("p", {
+						role: "alert",
+						className: "text-sm text-destructive",
+						children: x.failed
+					})
+				]
+			}),
+			/* @__PURE__ */ u(o, { children: /* @__PURE__ */ u(r, {
+				type: "button",
+				variant: "ghost",
+				onClick: () => p(!1),
+				children: x.close
+			}) })
+		]
+	});
+};
+export { g as AddFriendDialog, p as FriendRow, m as FriendsPanel, h as addFriendLabels, f as friendsLabels };

package/dist/contract.js

@@ -0,0 +1,39 @@
+import { Schema as e } from "effect";
+// src/contract.ts
+var t = "_voltro_social_relations", n = "_voltro_social_recent", r = "_voltro_social_settings", i = e.Number.pipe(e.check(e.isInt()), e.check(e.isGreaterThanOrEqualTo(0))), a = e.Struct({
+	ownerId: e.String,
+	requestsFrom: e.Literals([
+		"anyone",
+		"friends-of-friends",
+		"nobody"
+	]),
+	showOnline: e.Boolean,
+	showActivity: e.Boolean,
+	allowPartyInvites: e.Literals(["friends", "anyone"]),
+	metadata: e.Record(e.String, e.Unknown)
+}), o = e.Struct({
+	id: e.String,
+	fromId: e.String,
+	toId: e.String,
+	kind: e.Literals([
+		"request",
+		"friend",
+		"block",
+		"favorite"
+	]),
+	createdAt: i,
+	respondedAt: e.NullOr(i),
+	note: e.NullOr(e.String),
+	metadata: e.Record(e.String, e.Unknown)
+}), s = e.Struct({
+	id: e.String,
+	otherId: e.String,
+	context: e.String,
+	at: i,
+	metadata: e.Record(e.String, e.Unknown)
+}), c = e.Struct({
+	subjectId: e.String,
+	mutualFriends: e.Number.pipe(e.check(e.isInt()), e.check(e.isGreaterThan(0))),
+	recentMatches: i
+});
+export { n as RECENT_TABLE, t as RELATIONS_TABLE, s as RecentPlayerSchema, r as SETTINGS_TABLE, o as SocialRelationSchema, a as SocialSettingsSchema, c as SuggestionSchema };

package/dist/errors.d.ts

@@ -0,0 +1,13 @@
+import { Schema } from 'effect';
+import { YieldableError } from 'effect/Cause';
+
+export declare class SocialError extends SocialError_base {
+}
+
+export declare const socialError: (code: SocialError["code"]) => SocialError;
+
+declare const SocialError_base: Schema.Class<SocialError, Schema.TaggedStruct<"SocialError", {
+    readonly code: Schema.Literals<readonly ["identity_required", "invalid_input", "blocked", "request_refused", "not_found", "friend_limit", "pending_limit", "rate_limited", "unavailable", "export_limit"]>;
+}>, YieldableError>;
+
+export { }

package/dist/errors.js

@@ -0,0 +1,15 @@
+import { Schema as e } from "effect";
+// src/errors.ts
+var t = class extends e.TaggedError()("SocialError", { code: e.Literals([
+	"identity_required",
+	"invalid_input",
+	"blocked",
+	"request_refused",
+	"not_found",
+	"friend_limit",
+	"pending_limit",
+	"rate_limited",
+	"unavailable",
+	"export_limit"
+]) }) {}, n = (e) => new t({ code: e });
+export { t as SocialError, n as socialError };

package/dist/eventProducer.d.ts

@@ -0,0 +1,8 @@
+import { ChangeEvent } from '@voltro/database';
+import { SubscribeContext } from '@voltro/runtime';
+
+export declare const publishSocialChange: (event: ChangeEvent, ctx: SubscribeContext) => Promise<void>;
+
+export declare const socialEventTenant: (event: ChangeEvent) => string;
+
+export { }

package/dist/eventProducer.js

@@ -0,0 +1,19 @@
+import "./contract.js";
+import { accepted as e, requested as t } from "./events.js";
+// src/eventProducer.ts
+var n = (e) => {
+	if (e.table !== "_voltro_social_relations") throw Error("Social events require the owned relation table");
+	let t = (e.op === "delete" ? e.old : e.new)?.tenantId;
+	if (typeof t != "string" || !t.trim() || t.length > 256 || t.includes("\0") || t === "~" || e.op === "update" && e.old?.tenantId !== t) throw Error("Social events require stable committed tenant evidence");
+	return t;
+}, r = async (r, i) => {
+	if (n(r), r.op !== "insert") return;
+	let a = r.new;
+	if (!(!a || a.kind !== "request" && a.kind !== "friend")) {
+		if (!i.publish) throw Error("Social event publisher is unavailable");
+		if (typeof a.id != "string" || !a.id || a.id.length > 64 || typeof a.fromId != "string" || !a.fromId.trim() || typeof a.toId != "string" || !a.toId.trim() || a.fromId === a.toId) throw Error("Social events require committed relation evidence");
+		if (a.kind === "request") await i.publish(t, { recipientId: a.toId }, { relationId: a.id });
+		else for (let t of [a.fromId, a.toId]) await i.publish(e, { recipientId: t }, { relationId: a.id });
+	}
+};
+export { r as publishSocialChange, n as socialEventTenant };

package/dist/events.d.ts

@@ -0,0 +1,22 @@
+import { DeclaredAccess } from '@voltro/protocol';
+import { EventDescriptor } from '@voltro/protocol';
+import { Schema } from 'effect';
+
+export declare const accepted: EventDescriptor<"social.accepted", Schema.Struct<{
+    readonly recipientId: Schema.String;
+}>, Schema.Struct<{
+    readonly relationId: Schema.String;
+}>, DeclaredAccess<{
+    readonly recipientId: string;
+}>>;
+
+/** Operator-scoped CDC notifications; not a public player event stream. */
+export declare const requested: EventDescriptor<"social.requested", Schema.Struct<{
+    readonly recipientId: Schema.String;
+}>, Schema.Struct<{
+    readonly relationId: Schema.String;
+}>, DeclaredAccess<{
+    readonly recipientId: string;
+}>>;
+
+export { }

package/dist/events.js

@@ -0,0 +1,15 @@
+import { Schema as e } from "effect";
+import { defineEvent as t } from "@voltro/protocol";
+// src/events.ts
+var n = t({
+	name: "social.requested",
+	key: e.Struct({ recipientId: e.String }),
+	payload: e.Struct({ relationId: e.String }),
+	guards: [{ scope: "social:events:read" }]
+}), r = t({
+	name: "social.accepted",
+	key: e.Struct({ recipientId: e.String }),
+	payload: e.Struct({ relationId: e.String }),
+	guards: [{ scope: "social:events:read" }]
+});
+export { r as accepted, n as requested };

package/dist/index.d.ts

@@ -0,0 +1,235 @@
+import { ColumnBuilder } from '@voltro/database';
+import { Context } from 'effect';
+import { DataStore } from '@voltro/database';
+import { Effect } from 'effect';
+import { FieldDefinitions } from '@voltro/database';
+import { PluginPrivacyTarget } from '@voltro/protocol';
+import { RateLimitStore } from '@voltro/plugin-ratelimit';
+import { RedisStoreOptions } from '@voltro/plugin-ratelimit';
+import { Schema } from 'effect';
+import { Subject } from '@voltro/protocol';
+import { Table } from '@voltro/database';
+import { VoltroPlugin } from '@voltro/protocol';
+import { YieldableError } from 'effect/Cause';
+
+/** All graph decisions read SQL. The HotStore only owns ephemeral request-rate counters. */
+export declare const dataStoreSocial: (store: DataStore, options: ResolvedSocialOptions, limiter: RateLimitStore) => {
+    service: SocialService;
+    blockPort: SocialBlockService;
+    exportSubject: (target: PluginPrivacyTarget) => Effect.Effect<unknown, SocialError, never>;
+    eraseSubject: (target: PluginPrivacyTarget) => Effect.Effect<void, SocialError, never>;
+    pruneRecent: (subject: Subject) => Effect.Effect<void, SocialError, never>;
+};
+
+export declare const defaultSocialStrategies: SocialStrategies;
+
+declare const mutualMatchSuggestions: (candidates: ReadonlyArray<SocialSuggestion>, limit: number) => ReadonlyArray<SocialSuggestion>;
+
+export declare type RecentPlayer = typeof RecentPlayerSchema.Type;
+
+declare const RecentPlayerSchema: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly otherId: Schema.String;
+    readonly context: Schema.String;
+    readonly at: Schema.Number;
+    readonly metadata: Schema.$Record<Schema.String, Schema.Unknown>;
+}>;
+
+export declare interface RecentPolicyInput {
+    readonly ownerId: string;
+    readonly otherId: string;
+    readonly context: string;
+    readonly at: number;
+}
+
+export declare interface RecordRecentInput {
+    readonly tenantId: string;
+    readonly participants: ReadonlyArray<string>;
+    readonly context: string;
+    readonly at?: number;
+}
+
+export declare interface RequestPolicyInput {
+    readonly settings: SocialSettings;
+    readonly mutualFriends: number;
+}
+
+declare type ResolvedSocialOptions = ReturnType<typeof resolveSocialOptions>;
+
+export declare const resolveSocialOptions: (options?: SocialOptions) => Readonly<{
+    maxFriends: number;
+    maxPendingRequests: number;
+    recentLimit: number;
+    recentRetentionMs: number;
+    maxMatchParticipants: number;
+    maxExportRows: number;
+    requestLimit: number;
+    requestWindowMs: number;
+    suggestionLimit: number;
+    strategies: Readonly<{
+        suggestions: typeof mutualMatchSuggestions;
+        requestPolicy: (input: RequestPolicyInput) => boolean;
+        recentPolicy: (input: RecentPolicyInput) => boolean;
+    }>;
+    rateLimit: RedisStoreOptions | undefined;
+    now: () => number;
+}>;
+
+export declare type SettingsPatch = Partial<Omit<SocialSettings, 'ownerId' | 'metadata'>>;
+
+export declare class SocialBlockPort extends SocialBlockPort_base {
+}
+
+declare const SocialBlockPort_base: Context.ServiceClass<SocialBlockPort, "@voltro/SocialBlockPort", SocialBlockService>;
+
+/** Chat, matchmaking and party admission depend on this port, never Social SQL. */
+export declare interface SocialBlockService {
+    readonly isBlocked: (subject: Subject, otherId: string) => Effect.Effect<boolean, SocialError>;
+    readonly blockPairs: (subject: Subject, subjectIds: ReadonlyArray<string>) => Effect.Effect<ReadonlyArray<readonly [string, string]>, SocialError>;
+    readonly canMessage: (subject: Subject, otherId: string) => Effect.Effect<boolean, SocialError>;
+    readonly canInvite: (subject: Subject, otherId: string) => Effect.Effect<boolean, SocialError>;
+    readonly recordRecent: (subject: Subject, input: RecordRecentInput) => Effect.Effect<void, SocialError>;
+}
+
+export declare class SocialError extends SocialError_base {
+}
+
+declare const SocialError_base: Schema.Class<SocialError, Schema.TaggedStruct<"SocialError", {
+    readonly code: Schema.Literals<readonly ["identity_required", "invalid_input", "blocked", "request_refused", "not_found", "friend_limit", "pending_limit", "rate_limited", "unavailable", "export_limit"]>;
+}>, YieldableError>;
+
+export declare interface SocialOptions {
+    readonly maxFriends?: number;
+    readonly maxPendingRequests?: number;
+    readonly recentLimit?: number;
+    readonly recentRetentionMs?: number;
+    readonly maxMatchParticipants?: number;
+    readonly maxExportRows?: number;
+    readonly requestLimit?: number;
+    readonly requestWindowMs?: number;
+    readonly suggestionLimit?: number;
+    readonly strategies?: Partial<SocialStrategies>;
+    readonly rateLimit?: RedisStoreOptions;
+    readonly now?: () => number;
+}
+
+export declare const socialPlugin: (input?: SocialOptions) => VoltroPlugin;
+
+export declare const socialRecentTable: Table<"_voltro_social_recent", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly ownerId: ColumnBuilder<string, "text", boolean>;
+    readonly otherId: ColumnBuilder<string, "text", boolean>;
+    readonly context: ColumnBuilder<string, "text", boolean>;
+    readonly at: ColumnBuilder<Date, "timestamp", boolean>;
+    readonly metadata: ColumnBuilder<unknown, "json", boolean>;
+}>, true, never>;
+
+export declare type SocialRelation = typeof SocialRelationSchema.Type;
+
+declare const SocialRelationSchema: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly fromId: Schema.String;
+    readonly toId: Schema.String;
+    readonly kind: Schema.Literals<readonly ["request", "friend", "block", "favorite"]>;
+    readonly createdAt: Schema.Number;
+    readonly respondedAt: Schema.NullOr<Schema.Number>;
+    readonly note: Schema.NullOr<Schema.String>;
+    readonly metadata: Schema.$Record<Schema.String, Schema.Unknown>;
+}>;
+
+export declare const socialRelationsTable: Table<"_voltro_social_relations", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly fromId: ColumnBuilder<string, "text", boolean>;
+    readonly toId: ColumnBuilder<string, "text", boolean>;
+    readonly pairKey: ColumnBuilder<string, "text", boolean>;
+    readonly kind: ColumnBuilder<"request" | "friend" | "block" | "favorite", "text", boolean>;
+    readonly createdAt: ColumnBuilder<Date, "timestamp", boolean>;
+    readonly respondedAt: ColumnBuilder<Date | null, "timestamp", boolean>;
+    readonly note: ColumnBuilder<string | null, "text", boolean>;
+    readonly metadata: ColumnBuilder<unknown, "json", boolean>;
+}>, true, never>;
+
+export declare interface SocialService {
+    readonly request: (subject: Subject, otherId: string) => Effect.Effect<SocialRelation, SocialError>;
+    readonly accept: (subject: Subject, otherId: string) => Effect.Effect<SocialRelation, SocialError>;
+    readonly decline: (subject: Subject, otherId: string) => Effect.Effect<void, SocialError>;
+    readonly cancel: (subject: Subject, otherId: string) => Effect.Effect<void, SocialError>;
+    readonly remove: (subject: Subject, otherId: string) => Effect.Effect<void, SocialError>;
+    readonly block: (subject: Subject, otherId: string) => Effect.Effect<void, SocialError>;
+    readonly unblock: (subject: Subject, otherId: string) => Effect.Effect<void, SocialError>;
+    readonly favorite: (subject: Subject, otherId: string, enabled: boolean) => Effect.Effect<void, SocialError>;
+    readonly setSettings: (subject: Subject, patch: SettingsPatch) => Effect.Effect<SocialSettings, SocialError>;
+    readonly getSettings: (subject: Subject) => Effect.Effect<SocialSettings, SocialError>;
+    readonly friends: (subject: Subject) => Effect.Effect<ReadonlyArray<SocialRelation>, SocialError>;
+    readonly favorites: (subject: Subject) => Effect.Effect<ReadonlyArray<SocialRelation>, SocialError>;
+    readonly requests: (subject: Subject) => Effect.Effect<ReadonlyArray<SocialRelation>, SocialError>;
+    readonly blocked: (subject: Subject) => Effect.Effect<ReadonlyArray<SocialRelation>, SocialError>;
+    readonly recent: (subject: Subject) => Effect.Effect<ReadonlyArray<RecentPlayer>, SocialError>;
+    readonly suggestions: (subject: Subject) => Effect.Effect<ReadonlyArray<SocialSuggestion>, SocialError>;
+}
+
+export declare type SocialSettings = typeof SocialSettingsSchema.Type;
+
+declare const SocialSettingsSchema: Schema.Struct<{
+    readonly ownerId: Schema.String;
+    readonly requestsFrom: Schema.Literals<readonly ["anyone", "friends-of-friends", "nobody"]>;
+    readonly showOnline: Schema.Boolean;
+    readonly showActivity: Schema.Boolean;
+    readonly allowPartyInvites: Schema.Literals<readonly ["friends", "anyone"]>;
+    readonly metadata: Schema.$Record<Schema.String, Schema.Unknown>;
+}>;
+
+export declare const socialSettingsTable: Table<"_voltro_social_settings", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly ownerId: ColumnBuilder<string, "text", boolean>;
+    readonly requestsFrom: ColumnBuilder<"anyone" | "friends-of-friends" | "nobody", "text", boolean>;
+    readonly showOnline: ColumnBuilder<boolean, "boolean", boolean>;
+    readonly showActivity: ColumnBuilder<boolean, "boolean", boolean>;
+    readonly allowPartyInvites: ColumnBuilder<"anyone" | "friends", "text", boolean>;
+    readonly admission: ColumnBuilder<number, "integer", boolean>;
+    readonly metadata: ColumnBuilder<unknown, "json", boolean>;
+}>, true, never>;
+
+export declare interface SocialStrategies {
+    readonly suggestions: typeof mutualMatchSuggestions;
+    readonly requestPolicy: (input: RequestPolicyInput) => boolean;
+    readonly recentPolicy: (input: RecentPolicyInput) => boolean;
+}
+
+export declare type SocialSuggestion = typeof SuggestionSchema.Type;
+
+export declare const socialSystemContract: {
+    readonly slots: {
+        readonly suggestions: {
+            readonly defaultExport: "mutualMatchSuggestions";
+            readonly fixtureExport: "socialSuggestionsFixture";
+        };
+        readonly requestPolicy: {
+            readonly defaultExport: "recipientRequestPolicy";
+            readonly fixtureExport: "socialRequestPolicyFixture";
+        };
+        readonly recentPolicy: {
+            readonly defaultExport: "distinctRecentPeers";
+            readonly fixtureExport: "socialRecentPolicyFixture";
+        };
+    };
+    readonly ports: {
+        readonly socialBlock: {
+            readonly tagExport: "SocialBlockPort";
+            readonly fakeLayerExport: "socialBlockFakeLayer";
+            readonly fixtureExport: "socialBlockPortFixture";
+        };
+    };
+    readonly events: readonly ["social.requested", "social.accepted"];
+};
+
+declare const SuggestionSchema: Schema.Struct<{
+    readonly subjectId: Schema.String;
+    readonly mutualFriends: Schema.Number;
+    readonly recentMatches: Schema.Number;
+}>;
+
+export { }