@voltro/plugin-matchmaking 0.0.0-stage → 0.87.0

package/dist/testing.d.ts

@@ -0,0 +1,296 @@
+import { Context } from 'effect';
+import { DataStore } from '@voltro/database';
+import { Effect } from 'effect';
+import { Layer } from 'effect';
+import { Schema } from 'effect';
+import { Subject } from '@voltro/protocol';
+import { YieldableError } from 'effect/Cause';
+
+declare type AvoidPair = readonly [string, string];
+
+/** Empty policy for an app without a block provider. Automatic optional Social
+ * port binding is separate integration work; it is not inferred here. */
+declare const defaultMatchmakingAvoidPairs: MatchmakingAvoidPairs;
+
+/** Players send a queue preference intent; never skill, members, state or assignments. */
+declare interface EnqueueIntent {
+    readonly queue: string;
+    readonly requestId: string;
+    readonly preferences: Readonly<Record<string, unknown>>;
+}
+
+/** A Director that reports a fixed pass; for code that schedules or observes Director runs. */
+export declare const fakeMatchmakingDirectorLayer: (result?: {
+    readonly cycles: number;
+    readonly assigned: number;
+    readonly skipped: number;
+    readonly failed: number;
+}) => Layer.Layer<MatchmakingDirectorPort, never, never>;
+
+export declare const fakeMatchmakingLayer: (overrides?: Partial<MatchmakingService>) => Layer.Layer<MatchmakingPort, never, never>;
+
+export declare const fakeMatchmakingService: (overrides?: Partial<MatchmakingService>) => MatchmakingService;
+
+/** Fake party roster: `members` maps party IDs to subject IDs. */
+export declare const fakePartyMembershipLayer: (members?: Readonly<Record<string, ReadonlyArray<string>>>) => Layer.Layer<PartyMembershipPort, never, never>;
+
+/** Supply a complete server roster implementation; absent fixtures fail closed. */
+export declare const fakePartyRosterLayer: (read?: PartyRosterService["read"]) => Layer.Layer<PartyRosterPort, never, never>;
+
+declare type MatchFunction<A = Readonly<Record<string, unknown>>> = (input: MatchInput<A>) => MatchOutput<A>;
+
+/** Real pure implementations and source probes; this is not whole-system conformance. */
+export declare const matchFunctionFixture: {
+    fifo: <A = Readonly<Record<string, unknown>>>() => MatchFunction<A>;
+    skillWindow: (options: SkillWindowOptions) => <A extends Readonly<Record<string, unknown>>>(input: MatchInput<A>) => MatchOutput<A>;
+    regionLatency: (options: {
+        readonly latencyMaxMs: number;
+    }) => <A extends Readonly<Record<string, unknown>>>(input: MatchInput<A>) => MatchOutput<A>;
+    input: () => MatchInput;
+};
+
+declare interface MatchInput<A = Readonly<Record<string, unknown>>> {
+    readonly tickets: ReadonlyArray<MatchTicket<A>>;
+    readonly now: number;
+    readonly queue: MatchQueueRules;
+    readonly avoid: ReadonlyArray<AvoidPair>;
+}
+
+declare interface MatchmakingAvoidContext {
+    readonly tenantId: string;
+    readonly queue: string;
+    readonly tickets: ReadonlyArray<MatchTicket>;
+    readonly maxPairs: number;
+    readonly query: DataStore['query'];
+}
+
+declare type MatchmakingAvoidPairs = (context: MatchmakingAvoidContext) => Effect.Effect<ReadonlyArray<AvoidPair>, MatchmakingError>;
+
+export declare const matchmakingAvoidPairsFixture: (query: DataStore["query"]) => {
+    readonly avoidPairs: typeof defaultMatchmakingAvoidPairs;
+    readonly context: MatchmakingAvoidContext;
+};
+
+/** System21 slot fixture for `avoidPairs`: the real default and a resolved override. */
+export declare const matchmakingAvoidPairsSlotFixture: {
+    kind: "slot";
+    defaultImplementation: MatchmakingAvoidPairs;
+    defaultProbe: {
+        run: () => Effect.Effect<readonly AvoidPair[], MatchmakingError, never>;
+        expected: never[];
+    };
+    overrideProbe: {
+        run: () => Effect.Effect<readonly AvoidPair[], MatchmakingError, never>;
+        expected: string[][];
+    };
+};
+
+export declare const matchmakingDirectorFakeLayer: Layer.Layer<MatchmakingDirectorPort, never, never>;
+
+/** A scheduled Director run: `runKey` makes the run idempotent; `maxPairs` bounds tenant×queue work per run. */
+declare const MatchmakingDirectorPayload: Schema.Struct<{
+    readonly runKey: Schema.NonEmptyString;
+    readonly maxPairs: Schema.Number;
+}>;
+
+declare type MatchmakingDirectorPayload = typeof MatchmakingDirectorPayload.Type;
+
+declare class MatchmakingDirectorPort extends MatchmakingDirectorPort_base {
+}
+
+declare const MatchmakingDirectorPort_base: Context.ServiceClass<MatchmakingDirectorPort, "@voltro/MatchmakingDirectorPort", MatchmakingDirectorService>;
+
+export declare const matchmakingDirectorPortFixture: {
+    kind: "port";
+    tag: typeof MatchmakingDirectorPort;
+    fakeLayer: Layer.Layer<MatchmakingDirectorPort, never, never>;
+    probe: {
+        run: () => Effect.Effect<{
+            readonly cycles: number;
+            readonly assigned: number;
+            readonly skipped: number;
+            readonly failed: number;
+        }, MatchmakingError, never>;
+        expected: {
+            cycles: number;
+            assigned: number;
+            skipped: number;
+            failed: number;
+        };
+    };
+};
+
+declare const MatchmakingDirectorResult: Schema.Struct<{
+    readonly cycles: Schema.Number;
+    readonly assigned: Schema.Number;
+    readonly skipped: Schema.Number;
+    readonly failed: Schema.Number;
+}>;
+
+declare type MatchmakingDirectorResult = typeof MatchmakingDirectorResult.Type;
+
+/** One Director pass over every tenant and queue with open tickets: plan, then assign. */
+declare interface MatchmakingDirectorService {
+    readonly run: (input: MatchmakingDirectorPayload) => Effect.Effect<MatchmakingDirectorResult, MatchmakingError>;
+}
+
+declare class MatchmakingError extends MatchmakingError_base {
+}
+
+declare const MatchmakingError_base: Schema.Class<MatchmakingError, Schema.TaggedStruct<"MatchmakingError", {
+    readonly code: Schema.Literals<readonly ["invalid_input", "invalid_queue", "invalid_proposal", "unavailable", "identity_required", "not_found", "already_searching", "conflict", "queue_full", "erased", "export_limit", "forbidden", "party_full", "already_in_party", "party_not_ready"]>;
+}>, YieldableError>;
+
+declare type MatchmakingEstimate = typeof MatchmakingEstimateSchema.Type;
+
+/** Expected wait in a queue: the median time recent searches of this tenant waited until matched, from up to
+ * `samples` searches matched in the last 30 minutes. `waitMs` is null with fewer than three such searches. */
+declare const MatchmakingEstimateSchema: Schema.Struct<{
+    readonly queue: Schema.String;
+    readonly waitMs: Schema.NullOr<Schema.Number>;
+    readonly samples: Schema.Number;
+}>;
+
+/** Layer values the System21 suite compares by identity with the port fixtures. */
+export declare const matchmakingFakeLayer: Layer.Layer<MatchmakingPort, never, never>;
+
+export declare const matchmakingInputFixture: () => MatchInput;
+
+declare class MatchmakingPort extends MatchmakingPort_base {
+}
+
+declare const MatchmakingPort_base: Context.ServiceClass<MatchmakingPort, "@voltro/MatchmakingPort", MatchmakingService>;
+
+export declare const matchmakingPortFixture: {
+    kind: "port";
+    tag: typeof MatchmakingPort;
+    fakeLayer: Layer.Layer<MatchmakingPort, never, never>;
+    probe: {
+        run: () => Effect.Effect<"invalid_input" | "invalid_queue" | "invalid_proposal" | "unavailable" | "identity_required" | "not_found" | "already_searching" | "conflict" | "queue_full" | "erased" | "export_limit" | "forbidden" | "party_full" | "already_in_party" | "party_not_ready" | "succeeded", never, never>;
+        expected: string;
+    };
+};
+
+/** Queries wrap status reactively; this port owns no transport or poll timer. */
+declare interface MatchmakingService {
+    readonly enqueue: (subject: Subject, input: EnqueueIntent) => Effect.Effect<MatchmakingTicket, MatchmakingError>;
+    readonly cancel: (subject: Subject, ticketId: string) => Effect.Effect<void, MatchmakingError>;
+    readonly status: (subject: Subject, ticketId: string) => Effect.Effect<MatchmakingTicket, MatchmakingError>;
+    /** Median recent wait in a declared queue for the caller's tenant. Optional for replacement ports: without it
+     * `matchmaking.estimate` answers `unavailable`. */
+    readonly estimate?: (subject: Subject, queue: string) => Effect.Effect<MatchmakingEstimate, MatchmakingError>;
+}
+
+declare type MatchmakingTicket = typeof MatchmakingTicketSchema.Type;
+
+declare const MatchmakingTicketSchema: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly queue: Schema.String;
+    readonly state: Schema.Literals<readonly ["open", "matched", "assigned", "cancelled", "expired"]>;
+    readonly members: Schema.$Array<Schema.String>;
+    readonly attributes: Schema.$Record<Schema.String, Schema.Unknown>;
+    readonly createdAt: Schema.Number;
+    readonly expiresAt: Schema.Number;
+    readonly closedAt: Schema.NullOr<Schema.Number>;
+    readonly metadata: Schema.$Record<Schema.String, Schema.Unknown>;
+}>;
+
+declare interface MatchOutput<A = Readonly<Record<string, unknown>>> {
+    readonly proposals: ReadonlyArray<MatchProposal<A>>;
+    readonly leftover: ReadonlyArray<MatchTicket<A>>;
+    /** Deterministic branch inspections, not a runtime or throughput measurement. */
+    readonly searchNodes: number;
+    readonly exhausted: boolean;
+}
+
+declare interface MatchProposal<A = Readonly<Record<string, unknown>>> {
+    readonly teams: ReadonlyArray<ReadonlyArray<MatchTicket<A>>>;
+    readonly quality: number;
+}
+
+declare interface MatchQueueRules {
+    readonly name: string;
+    readonly teams: {
+        readonly count: number;
+        readonly size: number;
+    };
+    readonly maxTickets: number;
+    readonly maxSearchNodes: number;
+    readonly maxAvoidPairs: number;
+    readonly maxAttributeBytes: number;
+    readonly minQuality: {
+        readonly initial: number;
+        readonly after: ReadonlyArray<readonly [number, number]>;
+    };
+}
+
+declare interface MatchTicket<A = Readonly<Record<string, unknown>>> {
+    readonly id: string;
+    readonly tenantId: string;
+    readonly queue: string;
+    readonly members: ReadonlyArray<string>;
+    readonly createdAt: number;
+    readonly attributes: A;
+}
+
+export declare const partyMembershipFakeLayer: Layer.Layer<PartyMembershipPort, never, never>;
+
+declare class PartyMembershipPort extends PartyMembershipPort_base {
+}
+
+declare const PartyMembershipPort_base: Context.ServiceClass<PartyMembershipPort, "@voltro/PartyMembershipPort", PartyMembershipService>;
+
+export declare const partyMembershipPortFixture: {
+    kind: "port";
+    tag: typeof PartyMembershipPort;
+    fakeLayer: Layer.Layer<PartyMembershipPort, never, never>;
+    probe: {
+        run: () => Effect.Effect<boolean, MatchmakingError, never>;
+        expected: boolean;
+    };
+};
+
+/** Chat and other plugins ask current party membership here, never party SQL. */
+declare interface PartyMembershipService {
+    readonly isMember: (subject: Subject, partyId: string) => Effect.Effect<boolean, MatchmakingError>;
+}
+
+/** A detached current SQL roster. It contains IDs, never inferred Subject kinds. */
+declare interface PartyRoster {
+    readonly tenantId: string;
+    readonly partyId: string;
+    readonly leaderId: string;
+    readonly memberIds: ReadonlyArray<string>;
+}
+
+export declare const partyRosterFakeLayer: Layer.Layer<PartyRosterPort, never, never>;
+
+declare class PartyRosterPort extends PartyRosterPort_base {
+}
+
+declare const PartyRosterPort_base: Context.ServiceClass<PartyRosterPort, "@voltro/PartyRosterPort", PartyRosterService>;
+
+export declare const partyRosterPortFixture: {
+    kind: "port";
+    tag: typeof PartyRosterPort;
+    fakeLayer: Layer.Layer<PartyRosterPort, never, never>;
+    probe: {
+        run: () => Effect.Effect<readonly string[], MatchmakingError, never>;
+        expected: string[];
+    };
+};
+
+/** Trusted server composition only. The caller must authorize the operation;
+ * this read is not a player route or authority to move the returned members. */
+declare interface PartyRosterService {
+    readonly read: (tenantId: string, partyId: string) => Effect.Effect<PartyRoster | null, MatchmakingError>;
+}
+
+declare interface SkillWindowOptions {
+    readonly initialWindow: number;
+    readonly growPerSecond: number;
+    readonly maxWindow: number;
+    readonly latencyMaxMs?: number;
+}
+
+export { }

package/dist/testing.js

@@ -0,0 +1,152 @@
+import { matchmakingError as e } from "./errors.js";
+import { captureMatchInput as t } from "./contract.js";
+import { defaultMatchmakingAvoidPairs as n } from "./avoidPairs.js";
+import { fifo as r, regionLatency as i, skillWindow as a } from "./strategies.js";
+import { defineQueue as o } from "./queue.js";
+import { MatchmakingDirectorPort as s, MatchmakingPort as c, PartyMembershipPort as l, PartyRosterPort as u } from "./port.js";
+import { resolveTicketAdmissionOptions as d } from "./service.js";
+import { Effect as f, Layer as p, Result as m, Schema as h } from "effect";
+//#region src/testing.ts
+var g = () => ({
+	now: 1e3,
+	queue: {
+		name: "fixture",
+		teams: {
+			count: 2,
+			size: 1
+		},
+		maxTickets: 100,
+		maxSearchNodes: 1e4,
+		maxAvoidPairs: 100,
+		maxAttributeBytes: 1024,
+		minQuality: {
+			initial: 0,
+			after: []
+		}
+	},
+	avoid: [],
+	tickets: ["a", "b"].map((e) => ({
+		id: e,
+		tenantId: "tenant",
+		queue: "fixture",
+		members: [e],
+		createdAt: 0,
+		attributes: {
+			skill: 100,
+			region: "eu",
+			latencies: { eu: 20 }
+		}
+	}))
+}), _ = {
+	fifo: r,
+	skillWindow: a,
+	regionLatency: i,
+	input: g
+}, v = (t = {}) => ({
+	enqueue: t.enqueue ?? (() => f.fail(e("unavailable"))),
+	cancel: t.cancel ?? (() => f.fail(e("unavailable"))),
+	status: t.status ?? (() => f.fail(e("unavailable"))),
+	estimate: t.estimate ?? (() => f.fail(e("unavailable")))
+}), y = (e = {}) => p.succeed(c, v(e)), b = (e) => {
+	let r = t(g());
+	return {
+		avoidPairs: n,
+		context: Object.freeze({
+			tenantId: "tenant",
+			queue: "fixture",
+			tickets: r.tickets,
+			maxPairs: r.queue.maxAvoidPairs,
+			query: e
+		})
+	};
+}, x = {
+	kind: "slot",
+	defaultImplementation: n,
+	defaultProbe: {
+		run: () => n(b(async () => []).context),
+		expected: []
+	},
+	overrideProbe: {
+		run: () => d({
+			queues: [o({
+				name: "fixture",
+				room: "arena",
+				ticket: h.Struct({}),
+				teams: {
+					count: 2,
+					size: 1
+				},
+				matchFunction: r()
+			})],
+			prepareTicket: () => f.succeed({}),
+			admit: () => f.void,
+			avoidPairs: () => f.succeed([["a", "b"]])
+		}).avoidPairs(b(async () => []).context),
+		expected: [["a", "b"]]
+	}
+}, S = y(), C = {
+	kind: "port",
+	tag: c,
+	fakeLayer: S,
+	probe: {
+		run: () => c.pipe(f.flatMap((e) => f.result(e.status({
+			type: "user",
+			id: "a",
+			tenantId: "tenant"
+		}, "ticket"))), f.map((e) => m.isFailure(e) ? e.failure.code : "succeeded"), f.provide(S)),
+		expected: "unavailable"
+	}
+}, w = (e = {}) => p.succeed(l, { isMember: (t, n) => f.succeed(t.type === "user" && (e[n] ?? []).includes(String(t.id))) }), T = w({ party: ["a"] }), E = {
+	kind: "port",
+	tag: l,
+	fakeLayer: T,
+	probe: {
+		run: () => l.pipe(f.flatMap((e) => e.isMember({
+			type: "user",
+			id: "a",
+			tenantId: "tenant"
+		}, "party")), f.provide(T)),
+		expected: !0
+	}
+}, D = (t = () => f.fail(e("unavailable"))) => p.succeed(u, { read: t }), O = D((e, t) => f.succeed(e === "tenant" && t === "party" ? Object.freeze({
+	tenantId: e,
+	partyId: t,
+	leaderId: "a",
+	memberIds: Object.freeze(["a", "b"])
+}) : null)), k = {
+	kind: "port",
+	tag: u,
+	fakeLayer: O,
+	probe: {
+		run: () => u.pipe(f.flatMap((e) => e.read("tenant", "party")), f.map((e) => e?.memberIds ?? []), f.provide(O)),
+		expected: ["a", "b"]
+	}
+}, A = (e = {
+	cycles: 0,
+	assigned: 0,
+	skipped: 0,
+	failed: 0
+}) => p.succeed(s, { run: () => f.succeed(e) }), j = A({
+	cycles: 1,
+	assigned: 1,
+	skipped: 0,
+	failed: 0
+}), M = {
+	kind: "port",
+	tag: s,
+	fakeLayer: j,
+	probe: {
+		run: () => s.pipe(f.flatMap((e) => e.run({
+			runKey: "fixture",
+			maxPairs: 1
+		})), f.provide(j)),
+		expected: {
+			cycles: 1,
+			assigned: 1,
+			skipped: 0,
+			failed: 0
+		}
+	}
+};
+//#endregion
+export { A as fakeMatchmakingDirectorLayer, y as fakeMatchmakingLayer, v as fakeMatchmakingService, w as fakePartyMembershipLayer, D as fakePartyRosterLayer, _ as matchFunctionFixture, b as matchmakingAvoidPairsFixture, x as matchmakingAvoidPairsSlotFixture, j as matchmakingDirectorFakeLayer, M as matchmakingDirectorPortFixture, S as matchmakingFakeLayer, g as matchmakingInputFixture, C as matchmakingPortFixture, T as partyMembershipFakeLayer, E as partyMembershipPortFixture, O as partyRosterFakeLayer, k as partyRosterPortFixture };

package/dist/ticketContract.d.ts

@@ -0,0 +1,52 @@
+import { Schema } from 'effect';
+
+export declare const ASSIGNMENTS_TABLE = "_voltro_mm_assignments";
+
+export declare const CLAIMS_TABLE = "_voltro_mm_subject_admission";
+
+/** Players send a queue preference intent; never skill, members, state or assignments. */
+export declare interface EnqueueIntent {
+    readonly queue: string;
+    readonly requestId: string;
+    readonly preferences: Readonly<Record<string, unknown>>;
+}
+
+export declare type MatchmakingAssignment = typeof MatchmakingAssignmentSchema.Type;
+
+export declare const MatchmakingAssignmentSchema: Schema.Struct<{
+    readonly ticketId: Schema.String;
+    readonly queue: Schema.String;
+    readonly roomId: Schema.String;
+    readonly sessionId: Schema.String;
+    readonly createdAt: Schema.Number;
+}>;
+
+export declare type MatchmakingEstimate = typeof MatchmakingEstimateSchema.Type;
+
+/** Expected wait in a queue: the median time recent searches of this tenant waited until matched, from up to
+ * `samples` searches matched in the last 30 minutes. `waitMs` is null with fewer than three such searches. */
+export declare const MatchmakingEstimateSchema: Schema.Struct<{
+    readonly queue: Schema.String;
+    readonly waitMs: Schema.NullOr<Schema.Number>;
+    readonly samples: Schema.Number;
+}>;
+
+export declare type MatchmakingTicket = typeof MatchmakingTicketSchema.Type;
+
+export declare const MatchmakingTicketSchema: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly queue: Schema.String;
+    readonly state: Schema.Literals<readonly ["open", "matched", "assigned", "cancelled", "expired"]>;
+    readonly members: Schema.$Array<Schema.String>;
+    readonly attributes: Schema.$Record<Schema.String, Schema.Unknown>;
+    readonly createdAt: Schema.Number;
+    readonly expiresAt: Schema.Number;
+    readonly closedAt: Schema.NullOr<Schema.Number>;
+    readonly metadata: Schema.$Record<Schema.String, Schema.Unknown>;
+}>;
+
+export declare const QUEUES_TABLE = "_voltro_mm_queue_admission";
+
+export declare const TICKETS_TABLE = "_voltro_mm_tickets";
+
+export { }

package/dist/ticketContract.js

@@ -0,0 +1,31 @@
+import { Schema as e } from "effect";
+//#region src/ticketContract.ts
+var t = "_voltro_mm_tickets", n = "_voltro_mm_subject_admission", r = "_voltro_mm_queue_admission", i = "_voltro_mm_assignments", a = e.Number.pipe(e.check(e.isInt()), e.check(e.isGreaterThanOrEqualTo(0))), o = e.Record(e.String, e.Unknown), s = e.Struct({
+	id: e.String,
+	queue: e.String,
+	state: e.Literals([
+		"open",
+		"matched",
+		"assigned",
+		"cancelled",
+		"expired"
+	]),
+	members: e.Array(e.String),
+	attributes: o,
+	createdAt: a,
+	expiresAt: a,
+	closedAt: e.NullOr(a),
+	metadata: o
+}), c = e.Struct({
+	queue: e.String,
+	waitMs: e.NullOr(e.Number),
+	samples: e.Number
+}), l = e.Struct({
+	ticketId: e.String,
+	queue: e.String,
+	roomId: e.String,
+	sessionId: e.String,
+	createdAt: a
+});
+//#endregion
+export { i as ASSIGNMENTS_TABLE, n as CLAIMS_TABLE, l as MatchmakingAssignmentSchema, c as MatchmakingEstimateSchema, s as MatchmakingTicketSchema, r as QUEUES_TABLE, t as TICKETS_TABLE };

package/dist/tickets.entity.js

@@ -0,0 +1,50 @@
+import { ASSIGNMENTS_TABLE as e, TICKETS_TABLE as t } from "./ticketContract.js";
+import { id as n, integer as r, json as i, table as a, text as o, timestamp as s } from "@voltro/database";
+//#region src/tickets.entity.ts
+var c = a(t, {
+	id: n({ prefix: "mmt" }),
+	tenantId: o().maxLength(256).externalId().sensitive("pii"),
+	subjectId: o().maxLength(256).externalId().sensitive("pii"),
+	queue: o().maxLength(256).safe(),
+	requestKey: o().maxLength(64).serverOnly(),
+	partyId: o().maxLength(64).nullable().safe(),
+	members: i().sensitive("pii"),
+	attributes: i().sensitive("pii"),
+	state: o().maxLength(16).oneOf([
+		"open",
+		"matched",
+		"assigned",
+		"cancelled",
+		"expired"
+	]).safe(),
+	attempts: r().default(0).safe(),
+	matchedAt: s().nullable().safe(),
+	createdAt: s().safe(),
+	expiresAt: s().safe(),
+	closedAt: s().nullable().safe(),
+	metadata: i().sensitive("pii")
+}).index([
+	"tenantId",
+	"queue",
+	"state",
+	"createdAt"
+]).index(["tenantId", "subjectId"]).index([
+	"tenantId",
+	"partyId",
+	"state"
+]), l = a(e, {
+	id: n({ prefix: "mma" }),
+	tenantId: o().maxLength(256).externalId().sensitive("pii"),
+	subjectId: o().maxLength(256).externalId().sensitive("pii"),
+	ticketId: o().maxLength(64).safe(),
+	queue: o().maxLength(256).safe(),
+	roomId: o().maxLength(191).safe(),
+	sessionId: o().maxLength(191).serverOnly(),
+	createdAt: s().safe()
+}).unique("byMatchmakingAssignmentSeat", ["ticketId", "subjectId"]).index([
+	"tenantId",
+	"subjectId",
+	"createdAt"
+]);
+//#endregion
+export { l as matchmakingAssignmentsTable, c as matchmakingTicketsTable };