@lootlog/sdk 0.1.0

package/dist/realtime.js

@@ -0,0 +1,1443 @@
+import { Result, Schema, SchemaTransformation } from "effect";
+import * as Schema$1 from "effect/Schema";
+import { TaggedError } from "effect/Schema";
+import { decode, encode } from "@msgpack/msgpack";
+//#region ../schema/src/npc-type.ts
+const NpcTypeEnum = {
+	COMMON: "COMMON",
+	ELITE: "ELITE",
+	ELITE2: "ELITE2",
+	ELITE3: "ELITE3",
+	HERO: "HERO",
+	EVENT_HERO: "EVENT_HERO",
+	COLOSSUS: "COLOSSUS",
+	TITAN: "TITAN",
+	NPC: "NPC"
+};
+const NpcTypeSchema = Schema.Literals([
+	NpcTypeEnum.COMMON,
+	NpcTypeEnum.ELITE,
+	NpcTypeEnum.ELITE2,
+	NpcTypeEnum.ELITE3,
+	NpcTypeEnum.HERO,
+	NpcTypeEnum.EVENT_HERO,
+	NpcTypeEnum.COLOSSUS,
+	NpcTypeEnum.TITAN,
+	NpcTypeEnum.NPC
+]);
+//#endregion
+//#region ../schema/src/permissions.ts
+const Capability = {
+	OWNER: "OWNER",
+	ADMIN: "ADMIN",
+	LOOTLOG_MANAGE: "LOOTLOG_MANAGE",
+	LOOTLOG_ACCESS: "LOOTLOG_ACCESS",
+	LOOTLOG_LOOTS_READ: "LOOTLOG_LOOTS_READ",
+	LOOTLOG_LOOTS_WRITE: "LOOTLOG_LOOTS_WRITE",
+	LOOTLOG_LOOTS_ARCHIVE: "LOOTLOG_LOOTS_ARCHIVE",
+	LOOTLOG_LOOTS_TITANS_READ: "LOOTLOG_LOOTS_TITANS_READ",
+	LOOTLOG_LOOTS_HEROES_READ: "LOOTLOG_LOOTS_HEROES_READ",
+	LOOTLOG_TIMERS_READ: "LOOTLOG_TIMERS_READ",
+	LOOTLOG_TIMERS_WRITE: "LOOTLOG_TIMERS_WRITE",
+	LOOTLOG_TIMERS_RESET: "LOOTLOG_TIMERS_RESET",
+	LOOTLOG_TIMERS_DELETE: "LOOTLOG_TIMERS_DELETE",
+	LOOTLOG_TIMERS_TITANS_READ: "LOOTLOG_TIMERS_TITANS_READ",
+	LOOTLOG_TIMERS_HEROES_READ: "LOOTLOG_TIMERS_HEROES_READ",
+	LOOTLOG_RESERVATIONS_READ: "LOOTLOG_RESERVATIONS_READ",
+	LOOTLOG_RESERVATIONS_WRITE: "LOOTLOG_RESERVATIONS_WRITE",
+	LOOTLOG_MEMBERS_READ: "LOOTLOG_MEMBERS_READ",
+	LOOTLOG_ONLINE_PLAYERS_READ: "LOOTLOG_ONLINE_PLAYERS_READ",
+	LOOTLOG_PRESENCE_LOCATION_READ: "LOOTLOG_PRESENCE_LOCATION_READ",
+	LOOTLOG_CHAT_READ: "LOOTLOG_CHAT_READ",
+	LOOTLOG_CHAT_WRITE: "LOOTLOG_CHAT_WRITE",
+	LOOTLOG_CHAT_TITANS_READ: "LOOTLOG_CHAT_TITANS_READ",
+	LOOTLOG_CHAT_HEROES_READ: "LOOTLOG_CHAT_HEROES_READ",
+	LOOTLOG_NOTIFICATIONS_READ: "LOOTLOG_NOTIFICATIONS_READ",
+	LOOTLOG_NOTIFICATIONS_SEND: "LOOTLOG_NOTIFICATIONS_SEND",
+	LOOTLOG_NOTIFICATIONS_TITANS_READ: "LOOTLOG_NOTIFICATIONS_TITANS_READ",
+	LOOTLOG_NOTIFICATIONS_HEROES_READ: "LOOTLOG_NOTIFICATIONS_HEROES_READ",
+	LOOTLOG_EVENTS_MANAGE: "LOOTLOG_EVENTS_MANAGE",
+	LOOTLOG_EVENTS_READ: "LOOTLOG_EVENTS_READ",
+	LOOTLOG_EVENTS_WRITE: "LOOTLOG_EVENTS_WRITE",
+	LOOTLOG_DOCS_READ: "LOOTLOG_DOCS_READ",
+	LOOTLOG_DOCS_WRITE: "LOOTLOG_DOCS_WRITE"
+};
+const Permission = Capability;
+const PermissionSchema = Schema.Literals(Object.values(Capability));
+const UserGuildPermissionsRoleSchema = Schema.Struct({
+	id: Schema.NonEmptyString,
+	lvlRangeFrom: Schema.Int,
+	lvlRangeTo: Schema.Int,
+	permissions: Schema.Array(PermissionSchema)
+});
+const UserGuildPermissionsGuildSchema = Schema.Struct({
+	id: Schema.NonEmptyString,
+	ownerId: Schema.NonEmptyString
+});
+Schema.Struct({
+	guild: UserGuildPermissionsGuildSchema,
+	roles: Schema.Array(UserGuildPermissionsRoleSchema)
+});
+//#endregion
+//#region ../protocol/src/realtime/access-policy.ts
+const LevelRange = Schema.Struct({
+	from: Schema.Int,
+	to: Schema.Int
+});
+const AccessPolicyArea = Schema.Literals([
+	"timers",
+	"chat",
+	"notifications",
+	"presence",
+	"reservations",
+	"loots",
+	"events",
+	"organization"
+]);
+const OrganizationAccessPolicy = Schema.Struct({
+	organizationId: Schema.NonEmptyString,
+	owner: Schema.Boolean,
+	permissions: Schema.Array(PermissionSchema),
+	grants: Schema.Array(Schema.Struct({
+		permission: PermissionSchema,
+		ranges: Schema.Array(LevelRange)
+	}))
+});
+const AccessPolicySnapshot = Schema.Struct({
+	version: Schema.NonEmptyString,
+	organizations: Schema.Array(OrganizationAccessPolicy)
+});
+Schema.is(AccessPolicySnapshot);
+const AccessPolicyChange = Schema.Struct({
+	organizationId: Schema.NonEmptyString,
+	areas: Schema.Array(AccessPolicyArea),
+	restricted: Schema.Boolean,
+	expanded: Schema.Boolean
+});
+const NPC_PERMISSIONS = {
+	timers: [
+		Permission.LOOTLOG_TIMERS_READ,
+		Permission.LOOTLOG_TIMERS_HEROES_READ,
+		Permission.LOOTLOG_TIMERS_TITANS_READ
+	],
+	chat: [
+		Permission.LOOTLOG_CHAT_READ,
+		Permission.LOOTLOG_CHAT_HEROES_READ,
+		Permission.LOOTLOG_CHAT_TITANS_READ
+	],
+	notifications: [
+		Permission.LOOTLOG_NOTIFICATIONS_READ,
+		Permission.LOOTLOG_NOTIFICATIONS_HEROES_READ,
+		Permission.LOOTLOG_NOTIFICATIONS_TITANS_READ
+	],
+	loots: [
+		Permission.LOOTLOG_LOOTS_READ,
+		Permission.LOOTLOG_LOOTS_HEROES_READ,
+		Permission.LOOTLOG_LOOTS_TITANS_READ
+	]
+};
+Object.values(NPC_PERMISSIONS).flat();
+new Set(NPC_PERMISSIONS.loots);
+Object.values(Permission).sort();
+new Set(Object.values(NpcTypeEnum));
+//#endregion
+//#region ../schema/src/item-rarity.ts
+const ItemRarityEnum = {
+	UNIQUE: "UNIQUE",
+	HEROIC: "HEROIC",
+	LEGENDARY: "LEGENDARY",
+	UPGRADED: "UPGRADED"
+};
+const ItemRaritySchema = Schema.Literals([
+	ItemRarityEnum.UNIQUE,
+	ItemRarityEnum.HEROIC,
+	ItemRarityEnum.LEGENDARY,
+	ItemRarityEnum.UPGRADED
+]);
+//#endregion
+//#region ../schema/src/loot.ts
+const LootSourceEnum = {
+	LOOTBOX: "LOOTBOX",
+	DIALOG: "DIALOG",
+	FIGHT: "FIGHT"
+};
+Schema.Literals([
+	LootSourceEnum.LOOTBOX,
+	LootSourceEnum.DIALOG,
+	LootSourceEnum.FIGHT
+]);
+const LootShareSourceEnum = {
+	NONE: "NONE",
+	ITEM_OWNER: "ITEM_OWNER",
+	CHAT_MESSAGE: "CHAT_MESSAGE"
+};
+Schema.Literals([
+	LootShareSourceEnum.NONE,
+	LootShareSourceEnum.ITEM_OWNER,
+	LootShareSourceEnum.CHAT_MESSAGE
+]);
+const ProfessionEnum = {
+	WARRIOR: "WARRIOR",
+	PALADIN: "PALADIN",
+	HUNTER: "HUNTER",
+	MAGE: "MAGE",
+	BLADE_DANCER: "BLADE_DANCER",
+	TRACKER: "TRACKER"
+};
+const ProfessionSchema = Schema.Literals([
+	ProfessionEnum.WARRIOR,
+	ProfessionEnum.PALADIN,
+	ProfessionEnum.HUNTER,
+	ProfessionEnum.MAGE,
+	ProfessionEnum.BLADE_DANCER,
+	ProfessionEnum.TRACKER
+]);
+const ItemTypeEnum = {
+	ONE_HAND_WEAPON: "ONE_HAND_WEAPON",
+	TWO_HAND_WEAPON: "TWO_HAND_WEAPON",
+	ONE_AND_HALF_HAND_WEAPON: "ONE_AND_HALF_HAND_WEAPON",
+	DISTANCE_WEAPON: "DISTANCE_WEAPON",
+	HELP_WEAPON: "HELP_WEAPON",
+	WAND_WEAPON: "WAND_WEAPON",
+	ORB_WEAPON: "ORB_WEAPON",
+	ARMOR: "ARMOR",
+	HELMET: "HELMET",
+	BOOTS: "BOOTS",
+	GLOVES: "GLOVES",
+	RING: "RING",
+	NECKLACE: "NECKLACE",
+	SHIELD: "SHIELD",
+	NEUTRAL: "NEUTRAL",
+	CONSUME: "CONSUME",
+	GOLD: "GOLD",
+	KEYS: "KEYS",
+	QUEST: "QUEST",
+	RENEWABLE: "RENEWABLE",
+	ARROWS: "ARROWS",
+	TALISMAN: "TALISMAN",
+	BOOK: "BOOK",
+	BAG: "BAG",
+	BLESS: "BLESS",
+	UPGRADE: "UPGRADE",
+	RECIPE: "RECIPE",
+	COINAGE: "COINAGE",
+	QUIVER: "QUIVER",
+	OUTFITS: "OUTFITS",
+	PETS: "PETS",
+	TELEPORTS: "TELEPORTS"
+};
+Schema.Literals([
+	ItemTypeEnum.ONE_HAND_WEAPON,
+	ItemTypeEnum.TWO_HAND_WEAPON,
+	ItemTypeEnum.ONE_AND_HALF_HAND_WEAPON,
+	ItemTypeEnum.DISTANCE_WEAPON,
+	ItemTypeEnum.HELP_WEAPON,
+	ItemTypeEnum.WAND_WEAPON,
+	ItemTypeEnum.ORB_WEAPON,
+	ItemTypeEnum.ARMOR,
+	ItemTypeEnum.HELMET,
+	ItemTypeEnum.BOOTS,
+	ItemTypeEnum.GLOVES,
+	ItemTypeEnum.RING,
+	ItemTypeEnum.NECKLACE,
+	ItemTypeEnum.SHIELD,
+	ItemTypeEnum.NEUTRAL,
+	ItemTypeEnum.CONSUME,
+	ItemTypeEnum.GOLD,
+	ItemTypeEnum.KEYS,
+	ItemTypeEnum.QUEST,
+	ItemTypeEnum.RENEWABLE,
+	ItemTypeEnum.ARROWS,
+	ItemTypeEnum.TALISMAN,
+	ItemTypeEnum.BOOK,
+	ItemTypeEnum.BAG,
+	ItemTypeEnum.BLESS,
+	ItemTypeEnum.UPGRADE,
+	ItemTypeEnum.RECIPE,
+	ItemTypeEnum.COINAGE,
+	ItemTypeEnum.QUIVER,
+	ItemTypeEnum.OUTFITS,
+	ItemTypeEnum.PETS,
+	ItemTypeEnum.TELEPORTS
+]);
+//#endregion
+//#region ../schema/src/http-scalars.ts
+const FiniteNumber = Schema$1.Number.check(Schema$1.isFinite().annotate({ expected: "a finite number" }));
+const dateTimeString = (pattern) => Schema$1.String.annotate({ format: "date-time" }).check(Schema$1.isPattern(new RegExp(pattern)).annotate({ expected: `a string matching the RegExp ${pattern}` }));
+dateTimeString("^(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))T(?:(?:[01]\\d|2[0-3]):[0-5]\\d(?::[0-5]\\d(?:\\.\\d+)?)?(?:Z))$");
+const DateTimeWithOffsetString = dateTimeString("^(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))T(?:(?:[01]\\d|2[0-3]):[0-5]\\d(?::[0-5]\\d(?:\\.\\d+)?)?(?:Z|([+-](?:[01]\\d|2[0-3]):[0-5]\\d)))$");
+Schema$1.String.check(Schema$1.isMinLength(1).annotate({ expected: "a value with a length of at least 1" }));
+Schema$1.Json.annotate({ expected: "JSON value" });
+Schema$1.Number.check(Schema$1.isInt().annotate({ expected: "an integer" })).check(Schema$1.isGreaterThanOrEqualTo(-9007199254740991).annotate({ expected: "a value greater than or equal to -9007199254740991" })).check(Schema$1.isLessThanOrEqualTo(9007199254740991).annotate({ expected: "a value less than or equal to 9007199254740991" }));
+const PositiveSafeInteger = Schema$1.Number.check(Schema$1.isInt().annotate({ expected: "an integer" })).check(Schema$1.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" })).check(Schema$1.isLessThanOrEqualTo(9007199254740991).annotate({ expected: "a value less than or equal to 9007199254740991" }));
+Schema$1.Number.check(Schema$1.isInt().annotate({ expected: "an integer" })).check(Schema$1.isGreaterThanOrEqualTo(0).annotate({ expected: "a value greater than or equal to 0" })).check(Schema$1.isLessThanOrEqualTo(9007199254740991).annotate({ expected: "a value less than or equal to 9007199254740991" }));
+Schema$1.Number.check(Schema$1.isInt().annotate({ expected: "an integer" })).check(Schema$1.isGreaterThanOrEqualTo(0).annotate({ expected: "a value greater than or equal to 0" })).check(Schema$1.isLessThanOrEqualTo(500).annotate({ expected: "a value less than or equal to 500" }));
+Schema$1.Number.check(Schema$1.isInt().annotate({ expected: "an integer" })).check(Schema$1.isGreaterThanOrEqualTo(1).annotate({ expected: "a value greater than or equal to 1" })).check(Schema$1.isLessThanOrEqualTo(100).annotate({ expected: "a value less than or equal to 100" }));
+//#endregion
+//#region ../protocol/src/loot-summary.ts
+const LootItemResponse = Schema.Struct({
+	id: FiniteNumber,
+	hid: Schema.String,
+	name: Schema.String,
+	icon: Schema.String,
+	stat: Schema.String,
+	type: Schema.NullOr(Schema.String),
+	rarity: Schema.NullOr(ItemRaritySchema),
+	lvl: FiniteNumber,
+	prof: Schema.Array(ProfessionSchema)
+});
+const LootPlayerResponse = Schema.Struct({
+	id: Schema.Union([Schema.String, FiniteNumber]),
+	name: Schema.String,
+	lvl: Schema.NullOr(FiniteNumber),
+	prof: Schema.NullOr(ProfessionSchema),
+	icon: Schema.NullOr(Schema.String),
+	characterId: Schema.NullOr(FiniteNumber),
+	accountId: Schema.NullOr(FiniteNumber),
+	hpp: Schema.NullOr(FiniteNumber)
+});
+const LootNpcResponse = Schema.Struct({
+	id: FiniteNumber,
+	name: Schema.String,
+	wt: Schema.NullOr(FiniteNumber),
+	lvl: Schema.NullOr(FiniteNumber),
+	prof: Schema.NullOr(ProfessionSchema),
+	icon: Schema.NullOr(Schema.String),
+	type: Schema.NullOr(NpcTypeSchema),
+	margonemType: Schema.NullOr(FiniteNumber)
+});
+const LootShareResponse = Schema.Record(Schema.String, Schema.Array(Schema.String));
+const LootSummary = Schema.Struct({
+	items: Schema.Array(LootItemResponse),
+	players: Schema.Array(LootPlayerResponse),
+	npcs: Schema.Array(LootNpcResponse),
+	lootShare: LootShareResponse,
+	location: Schema.String
+});
+//#endregion
+//#region ../protocol/src/feed.ts
+const FeedNpc = Schema.Struct({
+	id: FiniteNumber,
+	name: Schema.String,
+	type: Schema.NullOr(Schema.String),
+	lvl: Schema.NullOr(FiniteNumber),
+	icon: Schema.NullOr(Schema.String),
+	prof: Schema.optionalKey(Schema.NullOr(Schema.String))
+});
+const common = {
+	id: Schema.String,
+	version: PositiveSafeInteger,
+	groupKey: Schema.optionalKey(Schema.String),
+	occurredAt: Schema.String,
+	world: Schema.String,
+	guild: Schema.Struct({
+		id: Schema.String,
+		name: Schema.String,
+		vanityUrl: Schema.NullOr(Schema.String)
+	}),
+	npc: Schema.NullOr(FeedNpc)
+};
+const UserFeedItem = Schema.Union([Schema.Struct({
+	...common,
+	type: Schema.Literal("kill"),
+	npc: FeedNpc,
+	count: PositiveSafeInteger
+}), Schema.Struct({
+	...common,
+	type: Schema.Literal("loot"),
+	lootId: PositiveSafeInteger,
+	summary: Schema.optionalKey(LootSummary),
+	additionalItemsCount: FiniteNumber,
+	items: Schema.Array(Schema.Struct({
+		id: FiniteNumber,
+		name: Schema.String,
+		icon: Schema.String,
+		rarity: Schema.NullOr(Schema.String),
+		stat: Schema.optionalKey(Schema.String),
+		type: Schema.optionalKey(Schema.NullOr(Schema.String)),
+		lvl: Schema.optionalKey(Schema.NullOr(FiniteNumber))
+	}))
+})]);
+//#endregion
+//#region ../schema/src/primitives.ts
+const NonEmptyString = Schema.NonEmptyString;
+const NonNegativeInt = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0));
+Schema.String.annotate({ format: "date-time" }).pipe(Schema.check(Schema.isPattern(/^(?:(?:\d\d[2468][048]|\d\d[13579][26]|\d\d0[48]|[02468][048]00|[13579][26]00)-02-29|\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\d|30)|(?:02)-(?:0[1-9]|1\d|2[0-8])))T(?:(?:[01]\d|2[0-3]):[0-5]\d(?::[0-5]\d(?:\.\d+)?)?(?:Z))$/)), Schema.decodeTo(Schema.Date, SchemaTransformation.dateFromString));
+//#endregion
+//#region ../schema/src/air-tag.ts
+const AIR_TAG_RELATIONS = [
+	1,
+	2,
+	3,
+	4,
+	5,
+	6,
+	7,
+	8
+];
+const AIR_TAG_MAX_COORDINATE = 65535;
+const ShortString = Schema.NonEmptyString.check(Schema.isMaxLength(64));
+const GuildId = Schema.NonEmptyString.check(Schema.isMaxLength(128));
+const SafeNatural = Schema.Int.check(Schema.isBetween({
+	minimum: 0,
+	maximum: Number.MAX_SAFE_INTEGER
+}));
+const Coordinate = Schema.Int.check(Schema.isBetween({
+	minimum: 0,
+	maximum: AIR_TAG_MAX_COORDINATE
+}));
+const AirTagRelationSchema = Schema.Literals(AIR_TAG_RELATIONS);
+const AirTagClanSchema = Schema.Struct({
+	id: SafeNatural,
+	name: ShortString
+});
+const AirTagObservationSchema = Schema.Struct({
+	targetId: ShortString,
+	nickname: ShortString,
+	clan: Schema.optionalKey(AirTagClanSchema),
+	relation: AirTagRelationSchema,
+	x: Coordinate,
+	y: Coordinate
+});
+const AirTagObservationBatchSchema = Schema.Struct({
+	expectedMapId: Coordinate,
+	observations: Schema.Array(AirTagObservationSchema)
+});
+Schema.Struct({
+	requestId: ShortString,
+	enabled: Schema.Boolean,
+	expectedMapId: Schema.optionalKey(Coordinate)
+});
+const AirTagTargetSchema = Schema.Struct({
+	targetId: ShortString,
+	nickname: ShortString,
+	clan: Schema.optionalKey(AirTagClanSchema),
+	relation: AirTagRelationSchema,
+	x: Coordinate,
+	y: Coordinate,
+	observedAt: SafeNatural,
+	enemyObservedAt: Schema.optionalKey(SafeNatural),
+	clanEnemyObservedAt: Schema.optionalKey(SafeNatural)
+});
+const AirTagScopeIdentityFields = {
+	guildId: GuildId,
+	world: ShortString,
+	mapId: Coordinate,
+	epochId: ShortString,
+	epochStartedAt: SafeNatural,
+	revision: SafeNatural
+};
+const AirTagScopeSnapshotSchema = Schema.Struct({
+	...AirTagScopeIdentityFields,
+	targets: Schema.Array(AirTagTargetSchema)
+});
+const AirTagUpdateEventSchema = Schema.Struct({
+	...AirTagScopeIdentityFields,
+	target: AirTagTargetSchema
+});
+Schema.is(AirTagRelationSchema);
+Schema.is(AirTagObservationSchema);
+Schema.is(AirTagTargetSchema);
+Schema.is(AirTagScopeSnapshotSchema);
+Schema.is(AirTagUpdateEventSchema);
+const MapPingTypeSchema = Schema.Literals([
+	"attention",
+	"enemy",
+	"regroup",
+	"avoid"
+]);
+const MapPingRejectCodeSchema = Schema.Literals([
+	"forbidden",
+	"invalid-context",
+	"invalid-payload",
+	"rate-limited",
+	"temporarily-unavailable"
+]);
+Schema.is(MapPingTypeSchema);
+const MapPingSendPayloadSchema = Schema.Struct({
+	expectedMapId: NonNegativeInt,
+	type: MapPingTypeSchema,
+	x: NonNegativeInt,
+	y: NonNegativeInt
+});
+const MapPingAckSchema = Schema.Union([Schema.Struct({
+	status: Schema.Literal("accepted"),
+	pingId: Schema.NonEmptyString
+}), Schema.Struct({
+	status: Schema.Literal("rejected"),
+	code: MapPingRejectCodeSchema,
+	retryAfterMs: Schema.optionalKey(NonNegativeInt)
+})]);
+const MapPingEventSchema = Schema.Struct({
+	pingId: Schema.NonEmptyString,
+	world: Schema.NonEmptyString,
+	mapId: NonNegativeInt,
+	type: MapPingTypeSchema,
+	x: NonNegativeInt,
+	y: NonNegativeInt,
+	sender: Schema.Struct({
+		characterId: Schema.NonEmptyString,
+		name: Schema.NonEmptyString
+	}),
+	createdAt: NonNegativeInt
+});
+//#endregion
+//#region ../schema/src/discord.ts
+const discordPermissionFields = {
+	hasRequiredPermissions: Schema.Boolean,
+	requiredPermissions: Schema.Array(Schema.String),
+	grantedPermissions: Schema.Array(Schema.String),
+	missingPermissions: Schema.Array(Schema.String)
+};
+const DiscordGuildSyncStatus = Schema.Literals([
+	"SYNCED",
+	"SYNCING",
+	"FAILED",
+	"STALE",
+	"NOT_FOUND"
+]);
+//#endregion
+//#region ../protocol/src/rabbit/topology.ts
+const RabbitExchange = {
+	DEFAULT: "default",
+	DEAD_LETTER: "dlx",
+	RETRY: "retry"
+};
+const RabbitExchangeName = Schema.Literals([
+	RabbitExchange.DEFAULT,
+	RabbitExchange.DEAD_LETTER,
+	RabbitExchange.RETRY
+]);
+const RabbitRoutingKey = {
+	USERS_ONLINE_CHECKPOINT_V1: "users.online.checkpoint.v1",
+	USERS_ONLINE_CHECKPOINT_V1_RETRY: "users.online.checkpoint.v1.retry",
+	USERS_ONLINE_CHECKPOINT_V1_DLQ: "users.online.checkpoint.v1.dlq",
+	ACTIVITY_LOG_CREATE: "activity.log.create",
+	ACTIVITY_LOG_CREATE_DLQ: "activity.log.create.dlq",
+	ACTIVITY_LOG_CREATE_RETRY: "activity.log.create.retry",
+	DISCORD_GUILD_CHANNEL_DELETED: "discord.guild.channel.deleted",
+	DISCORD_GUILD_CHANNEL_UPSERTED: "discord.guild.channel.upserted",
+	DISCORD_GUILD_CHANNELS_SYNC_FAILED: "discord.guild.channels.sync.failed",
+	DISCORD_GUILD_CHANNELS_SYNCED: "discord.guild.channels.synced",
+	DISCORD_GUILD_SYNC_STATE_UPDATED: "discord.guild.sync-state.updated",
+	EVENT_HERO_KILLED: "event.hero.killed",
+	EVENT_MAP_STATUS_UPDATE: "event.map-status.update",
+	EVENT_RANKING_UPDATE: "event.ranking.update",
+	EVENT_RESPAWN_WINDOW_CLOSED: "event.respawn-window.closed",
+	EVENT_RESPAWN_WINDOW_OPENED: "event.respawn-window.opened",
+	GUILDS_CLEAR_MESSAGES: "guilds.clear.messages",
+	GUILDS_CREATE: "guilds.create",
+	GUILDS_CREATE_DLQ: "guilds.create.dlq",
+	GUILDS_CREATE_RETRY: "guilds.create.retry",
+	GUILDS_CREATE_ROLE: "guilds.create.role",
+	GUILDS_CREATE_ROLE_DLQ: "guilds.create.role.dlq",
+	GUILDS_CREATE_ROLE_RETRY: "guilds.create.role.retry",
+	GUILDS_DELETE: "guilds.delete",
+	GUILDS_DELETE_DLQ: "guilds.delete.dlq",
+	GUILDS_DELETE_MESSAGE: "guilds.delete.message",
+	GUILDS_DELETE_RETRY: "guilds.delete.retry",
+	GUILDS_DELETE_ROLE: "guilds.delete.role",
+	GUILDS_DELETE_ROLE_DLQ: "guilds.delete.role.dlq",
+	GUILDS_DELETE_ROLE_RETRY: "guilds.delete.role.retry",
+	GUILDS_INITIALIZE: "guilds.initialize",
+	GUILDS_INITIALIZE_BOT: "guilds.initialize-bot",
+	GUILDS_INITIALIZE_DLQ: "guilds.initialize.dlq",
+	GUILDS_INITIALIZE_RETRY: "guilds.initialize.retry",
+	GUILDS_KILLS_ACCEPTED_V1: "guilds.kills.accepted.v1",
+	GUILDS_KILLS_ACCEPTED_V1_RETRY: "guilds.kills.accepted.v1.retry",
+	GUILDS_KILLS_ACCEPTED_V1_DLQ: "guilds.kills.accepted.v1.dlq",
+	GUILDS_LOOTS_CREATE: "guilds.loots.create",
+	GUILDS_LOOTS_CREATE_DLQ: "guilds.loots.create.dlq",
+	GUILDS_LOOTS_CREATE_RETRY: "guilds.loots.create.retry",
+	GUILDS_LOOTS_DELETE: "guilds.loots.delete",
+	GUILDS_LOOTS_SHARE_UPDATE: "guilds.loots.share.update",
+	GUILDS_LOOTS_SHARE_UPDATE_DLQ: "guilds.loots.share.update.dlq",
+	GUILDS_LOOTS_SHARE_UPDATE_RETRY: "guilds.loots.share.update.retry",
+	GUILDS_LOOTS_UPDATE: "guilds.loots.update",
+	GUILDS_MEMBERS_ADD: "guilds.members.add",
+	GUILDS_MEMBERS_ADD_DLQ: "guilds.members.add.dlq",
+	GUILDS_MEMBERS_ADD_RETRY: "guilds.members.add.retry",
+	GUILDS_MEMBERS_ADD_ROLE: "guilds.members.add.role",
+	GUILDS_MEMBERS_ADD_ROLE_DLQ: "guilds.members.add.role.dlq",
+	GUILDS_MEMBERS_ADD_ROLE_RETRY: "guilds.members.add.role.retry",
+	GUILDS_MEMBERS_REFRESH_JOB_UPDATE: "guilds.members.refresh.job.update",
+	GUILDS_MEMBERS_REMOVE: "guilds.members.remove",
+	GUILDS_MEMBERS_REMOVE_DLQ: "guilds.members.remove.dlq",
+	GUILDS_MEMBERS_REMOVE_RETRY: "guilds.members.remove.retry",
+	GUILDS_MEMBERS_REMOVE_ROLE: "guilds.members.remove.role",
+	GUILDS_MEMBERS_REMOVE_ROLE_DLQ: "guilds.members.remove.role.dlq",
+	GUILDS_MEMBERS_REMOVE_ROLE_RETRY: "guilds.members.remove.role.retry",
+	GUILDS_MEMBERS_UPDATE: "guilds.members.update",
+	GUILDS_MEMBERS_UPDATE_DLQ: "guilds.members.update.dlq",
+	GUILDS_MEMBERS_UPDATE_RETRY: "guilds.members.update.retry",
+	GUILDS_NOTIFICATIONS_SEND: "guilds.notifications.send",
+	GUILDS_NOTIFICATIONS_SEND_DLQ: "guilds.notifications.send.dlq",
+	GUILDS_NOTIFICATIONS_SEND_RETRY: "guilds.notifications.send.retry",
+	GUILDS_NOTIFICATIONS_VOLUNTEER: "guilds.notifications.volunteer",
+	GUILDS_NOTIFICATIONS_VOLUNTEER_DLQ: "guilds.notifications.volunteer.dlq",
+	GUILDS_NOTIFICATIONS_VOLUNTEER_RETRY: "guilds.notifications.volunteer.retry",
+	GUILDS_PARTY_GATHERING: "guilds.party-gathering",
+	GUILDS_PARTY_GATHERING_CANCEL: "guilds.party-gathering.cancel",
+	GUILDS_PARTY_GATHERING_DLQ: "guilds.party-gathering.dlq",
+	GUILDS_PARTY_GATHERING_RETRY: "guilds.party-gathering.retry",
+	GUILDS_RESERVATIONS_CHANGED_V2: "guilds.reservations.v2.changed",
+	GUILDS_RESERVATIONS_CHANGED_V2_DLQ: "guilds.reservations.v2.changed.dlq",
+	GUILDS_RESERVATIONS_CHANGED_V2_RETRY: "guilds.reservations.v2.changed.retry",
+	GUILDS_RESERVATIONS_CREATE: "guilds.reservations.create",
+	GUILDS_RESERVATIONS_CREATE_DLQ: "guilds.reservations.create.dlq",
+	GUILDS_RESERVATIONS_CREATE_RETRY: "guilds.reservations.create.retry",
+	GUILDS_RESERVATIONS_DELETE: "guilds.reservations.delete",
+	GUILDS_RESERVATIONS_DELETE_DLQ: "guilds.reservations.delete.dlq",
+	GUILDS_RESERVATIONS_DELETE_RETRY: "guilds.reservations.delete.retry",
+	GUILDS_SEND_MESSAGE: "guilds.send.message",
+	GUILDS_SEND_MESSAGE_DLQ: "guilds.send.message.dlq",
+	GUILDS_SEND_MESSAGE_RETRY: "guilds.send.message.retry",
+	GUILDS_SYNC: "guilds.sync",
+	GUILDS_SYNC_TRIGGER: "guilds.sync.trigger",
+	GUILDS_TIMERS_DELETE: "guilds.timers.delete",
+	GUILDS_TIMERS_DELETE_DLQ: "guilds.timers.delete.dlq",
+	GUILDS_TIMERS_DELETE_RETRY: "guilds.timers.delete.retry",
+	GUILDS_TIMERS_UPDATE: "guilds.timers.update",
+	GUILDS_TIMERS_UPDATE_DLQ: "guilds.timers.update.dlq",
+	GUILDS_TIMERS_UPDATE_RETRY: "guilds.timers.update.retry",
+	GUILDS_UPDATE: "guilds.update",
+	GUILDS_UPDATE_DLQ: "guilds.update.dlq",
+	GUILDS_UPDATE_MESSAGE: "guilds.update.message",
+	GUILDS_UPDATE_RETRY: "guilds.update.retry",
+	GUILDS_UPDATE_ROLE: "guilds.update.role",
+	GUILDS_UPDATE_ROLE_DLQ: "guilds.update.role.dlq",
+	GUILDS_UPDATE_ROLE_RETRY: "guilds.update.role.retry",
+	NOTIFICATIONS_DELIVERY_RESULT: "notifications.delivery.result",
+	NOTIFICATIONS_DISCORD_SEND: "notifications.discord.send",
+	NOTIFICATIONS_LOOT_CREATED: "notifications.loot.created",
+	NOTIFICATIONS_TIMER_DELETED: "notifications.timer.deleted",
+	NOTIFICATIONS_TIMER_UPDATED: "notifications.timer.updated",
+	GAME_CHARACTER_OFFLINE: "game.character.offline",
+	PRESENCE_CHECK_REQUEST: "presence.check.request",
+	PRESENCE_COVERAGE_CHECK: "presence.coverage.check",
+	SEARCH_ITEMS_INDEX: "search.items.index",
+	SEARCH_NPCS_INDEX: "search.npcs.index",
+	SEARCH_PLAYERS_INDEX: "search.players.index",
+	USERS_PARTY_READY_ROOM_UPDATED: "users.party-ready-room.updated",
+	USERS_PARTY_READY_ROOM_UPDATED_DLQ: "users.party-ready-room.updated.dlq",
+	USERS_PARTY_READY_ROOM_UPDATED_RETRY: "users.party-ready-room.updated.retry"
+};
+const RabbitRoutingKeyName = Schema.Literals(Object.values(RabbitRoutingKey));
+Schema.Struct({
+	name: RabbitExchangeName,
+	type: Schema.Literal("topic"),
+	durable: Schema.Boolean
+});
+Schema.Struct({
+	name: Schema.String,
+	exchange: RabbitExchangeName,
+	routingKey: RabbitRoutingKeyName,
+	durable: Schema.Boolean,
+	messageTtl: Schema.optional(Schema.Int),
+	singleActiveConsumer: Schema.optional(Schema.Boolean),
+	deadLetterExchange: Schema.optional(RabbitExchangeName),
+	deadLetterRoutingKey: Schema.optional(RabbitRoutingKeyName)
+});
+RabbitExchange.DEFAULT, RabbitExchange.RETRY, RabbitExchange.DEAD_LETTER;
+Schema.Struct({
+	userId: NonEmptyString,
+	discordId: NonEmptyString,
+	world: NonEmptyString,
+	characterId: NonEmptyString,
+	organizationIds: Schema.Array(NonEmptyString),
+	disconnectedAt: NonNegativeInt
+});
+const NullableString = Schema.NullOr(Schema.String);
+const NullableNumber = Schema.NullOr(Schema.Number);
+const GuildRole = Schema.Struct({
+	id: NonEmptyString,
+	name: NonEmptyString,
+	color: Schema.Number,
+	admin: Schema.Boolean,
+	position: Schema.Number
+});
+Schema.Struct({
+	guildId: NonEmptyString,
+	name: NonEmptyString,
+	icon: NullableString,
+	ownerId: NonEmptyString,
+	roles: Schema.Array(GuildRole)
+});
+Schema.Struct({
+	guildId: NonEmptyString,
+	name: NonEmptyString,
+	icon: NullableString,
+	ownerId: NonEmptyString
+});
+Schema.Struct({ guildId: NonEmptyString });
+Schema.Struct({
+	guildId: NonEmptyString,
+	...GuildRole.fields
+});
+Schema.Struct({
+	guildId: NonEmptyString,
+	id: NonEmptyString
+});
+Schema.Struct({
+	guildId: NonEmptyString,
+	discordId: NonEmptyString,
+	userId: NonEmptyString
+});
+Schema.Struct({
+	guildId: NonEmptyString,
+	mapName: NonEmptyString
+});
+Schema.Struct({
+	guildId: NonEmptyString,
+	mapName: NonEmptyString,
+	discordId: NonEmptyString,
+	hasPlayer: Schema.Boolean,
+	isAfk: Schema.optional(Schema.Boolean)
+});
+const DiscordGuildChannel = Schema.Struct({
+	guildId: NonEmptyString,
+	channelId: NonEmptyString,
+	name: NonEmptyString,
+	channelType: NonEmptyString,
+	parentId: NullableString,
+	position: Schema.Number,
+	active: Schema.Boolean,
+	canView: Schema.Boolean,
+	canSend: Schema.Boolean,
+	...discordPermissionFields,
+	lastSyncedAt: NonEmptyString
+});
+const DiscordGuildSyncState = Schema.Struct({
+	guildId: NonEmptyString,
+	status: DiscordGuildSyncStatus,
+	...discordPermissionFields,
+	channelCount: NonNegativeInt,
+	selectableChannelCount: NonNegativeInt,
+	lastAttemptAt: NullableString,
+	lastSuccessAt: NullableString,
+	lastError: NullableString,
+	updatedAt: NonEmptyString
+});
+Schema.Struct({
+	guildId: NonEmptyString,
+	channels: Schema.Array(DiscordGuildChannel),
+	syncState: DiscordGuildSyncState
+});
+Schema.Struct({
+	guildId: NonEmptyString,
+	channel: DiscordGuildChannel,
+	syncState: DiscordGuildSyncState
+});
+Schema.Struct({
+	guildId: NonEmptyString,
+	status: DiscordGuildSyncStatus,
+	lastAttemptAt: NonEmptyString,
+	lastError: NonEmptyString
+});
+Schema.Struct({
+	guildId: NonEmptyString,
+	syncState: DiscordGuildSyncState
+});
+Schema.Union([Schema.Struct({ guildId: NonEmptyString }), Schema.Struct({ organizationId: NonEmptyString })]);
+Schema.Struct({
+	recipientDiscordId: NonEmptyString,
+	eligibleGuildIds: Schema.Array(NonEmptyString),
+	update: Schema.Unknown
+});
+Schema.Struct({
+	notificationId: NonEmptyString,
+	targetDiscordId: NonEmptyString,
+	volunteerDiscordId: NonEmptyString,
+	world: NonEmptyString,
+	character: Schema.Unknown
+});
+const GuildLootEventNpc = Schema.Struct({
+	lvl: Schema.optional(NullableNumber),
+	prof: Schema.optional(NullableString),
+	type: Schema.optional(Schema.NullOr(Schema.Union([Schema.Number, Schema.String]))),
+	wt: Schema.optional(Schema.NullOr(Schema.Union([Schema.Number, Schema.String])))
+});
+Schema.Struct({
+	sourceNpcs: Schema.optional(Schema.Array(Schema.Struct({
+		level: NonNegativeInt,
+		type: NpcTypeSchema
+	}))),
+	feedEntry: Schema.optional(UserFeedItem),
+	version: Schema.Literal(1),
+	guildId: NonEmptyString,
+	world: NonEmptyString,
+	npc: Schema.Struct({
+		type: NpcTypeSchema,
+		lvl: NonNegativeInt
+	})
+});
+const GuildLootCreatedEventV2 = Schema.Struct({
+	feedEntry: Schema.optional(UserFeedItem),
+	version: Schema.Literal(2),
+	guildId: NonEmptyString,
+	lootId: NonNegativeInt,
+	npcs: Schema.Array(GuildLootEventNpc)
+});
+const GuildLootShareUpdatedEventV2 = Schema.Struct({
+	...GuildLootCreatedEventV2.fields,
+	lootShare: Schema.Record(Schema.String, Schema.Array(Schema.String))
+});
+const ReservationChangedEventV2 = Schema.Struct({
+	version: Schema.Literal(2),
+	action: Schema.Literals([
+		"created",
+		"updated",
+		"deleted",
+		"sharing-changed"
+	]),
+	sourceGuildId: NonEmptyString,
+	audienceGuildIds: Schema.Array(NonEmptyString),
+	reservationId: Schema.NullOr(NonNegativeInt),
+	spotId: Schema.NullOr(Schema.String)
+});
+const EventScope = Schema.Struct({
+	guildId: NonEmptyString,
+	eventId: NonEmptyString
+});
+Schema.Struct({
+	...EventScope.fields,
+	heroNpcLvl: Schema.optional(Schema.NullOr(NonNegativeInt)),
+	mapId: NonEmptyString,
+	reason: Schema.optional(Schema.String)
+});
+Schema.Struct({
+	...EventScope.fields,
+	heroNpcLvl: Schema.optional(Schema.NullOr(NonNegativeInt)),
+	heroId: Schema.optional(NonEmptyString)
+});
+Schema.Struct({
+	...EventScope.fields,
+	heroNpcLvl: Schema.optional(Schema.NullOr(NonNegativeInt)),
+	heroId: NonEmptyString
+});
+Schema.Struct({
+	userId: NonEmptyString,
+	guildId: Schema.optional(NonEmptyString),
+	action: NonEmptyString,
+	entityType: Schema.optional(NonEmptyString),
+	entityId: Schema.optional(Schema.Union([Schema.String, Schema.Number])),
+	metadata: Schema.optional(Schema.Record(Schema.String, Schema.Unknown))
+});
+Schema.Struct({
+	guildId: NonEmptyString,
+	world: NonEmptyString,
+	npcId: NonNegativeInt,
+	timerKey: NonEmptyString,
+	minSpawnTime: NonEmptyString,
+	maxSpawnTime: NonEmptyString,
+	npc: Schema.optional(Schema.NullOr(Schema.Struct({ name: Schema.optional(Schema.String) })))
+});
+Schema.Struct({
+	guildId: NonEmptyString,
+	world: NonEmptyString,
+	timerKey: NonEmptyString,
+	npcId: Schema.optional(NonNegativeInt)
+});
+Schema.Struct({
+	version: Schema.Literal(2),
+	lootId: NonNegativeInt,
+	world: NonEmptyString,
+	guildIds: Schema.Array(NonEmptyString),
+	itemIds: Schema.Array(NonNegativeInt),
+	itemNames: Schema.Array(Schema.String),
+	npcs: Schema.Array(Schema.Struct({
+		type: NullableString,
+		lvl: NullableNumber
+	}))
+});
+Schema.Struct({
+	notificationJobId: NonEmptyString,
+	success: Schema.Boolean,
+	retryable: Schema.Boolean,
+	providerMessageId: Schema.optional(NullableString),
+	errorCode: Schema.optional(NullableString),
+	errorMessage: Schema.optional(NullableString),
+	deliveredAt: NonEmptyString
+});
+Schema.Struct({
+	guildId: NonEmptyString,
+	channelId: NonEmptyString,
+	syncState: DiscordGuildSyncState
+});
+/** Cumulative confirmed game presence. A gap starts a new segment; retries never extend it. */
+const UserOnlineCheckpointV1 = Schema.Struct({
+	version: Schema.Literal(1),
+	type: Schema.Literal("checkpoint"),
+	userId: NonEmptyString,
+	sessionId: NonEmptyString,
+	segmentId: NonEmptyString,
+	world: Schema.optional(NonEmptyString),
+	startedAt: DateTimeWithOffsetString,
+	endedAt: DateTimeWithOffsetString,
+	observedAt: DateTimeWithOffsetString
+}).check(Schema.makeFilter((event) => Date.parse(event.startedAt) <= Date.parse(event.endedAt) && Date.parse(event.endedAt) <= Date.parse(event.observedAt), { expected: "ordered confirmed interval timestamps" }));
+/** Published only after the durable publisher has drained its pending checkpoints. */
+const UserOnlineHealthV1 = Schema.Struct({
+	version: Schema.Literal(1),
+	type: Schema.Literal("collector"),
+	observedAt: DateTimeWithOffsetString,
+	status: Schema.Literals(["healthy", "degraded"])
+});
+Schema.Union([UserOnlineCheckpointV1, UserOnlineHealthV1]);
+RabbitRoutingKey.GAME_CHARACTER_OFFLINE, RabbitRoutingKey.GUILDS_KILLS_ACCEPTED_V1, RabbitRoutingKey.USERS_ONLINE_CHECKPOINT_V1, RabbitRoutingKey.ACTIVITY_LOG_CREATE, RabbitRoutingKey.DISCORD_GUILD_CHANNEL_DELETED, RabbitRoutingKey.DISCORD_GUILD_CHANNEL_UPSERTED, RabbitRoutingKey.DISCORD_GUILD_CHANNELS_SYNC_FAILED, RabbitRoutingKey.DISCORD_GUILD_CHANNELS_SYNCED, RabbitRoutingKey.DISCORD_GUILD_SYNC_STATE_UPDATED, RabbitRoutingKey.EVENT_HERO_KILLED, RabbitRoutingKey.EVENT_MAP_STATUS_UPDATE, RabbitRoutingKey.EVENT_RANKING_UPDATE, RabbitRoutingKey.EVENT_RESPAWN_WINDOW_CLOSED, RabbitRoutingKey.EVENT_RESPAWN_WINDOW_OPENED, RabbitRoutingKey.GUILDS_LOOTS_CREATE, RabbitRoutingKey.GUILDS_LOOTS_SHARE_UPDATE, RabbitRoutingKey.GUILDS_CREATE, RabbitRoutingKey.GUILDS_DELETE, RabbitRoutingKey.GUILDS_UPDATE, RabbitRoutingKey.GUILDS_CREATE_ROLE, RabbitRoutingKey.GUILDS_DELETE_ROLE, RabbitRoutingKey.GUILDS_UPDATE_ROLE, RabbitRoutingKey.GUILDS_MEMBERS_ADD, RabbitRoutingKey.GUILDS_MEMBERS_ADD_ROLE, RabbitRoutingKey.GUILDS_MEMBERS_REMOVE, RabbitRoutingKey.GUILDS_MEMBERS_REMOVE_ROLE, RabbitRoutingKey.GUILDS_MEMBERS_UPDATE, RabbitRoutingKey.GUILDS_TIMERS_UPDATE, RabbitRoutingKey.GUILDS_TIMERS_DELETE, RabbitRoutingKey.GUILDS_RESERVATIONS_CREATE, RabbitRoutingKey.GUILDS_RESERVATIONS_DELETE, RabbitRoutingKey.GUILDS_SEND_MESSAGE, RabbitRoutingKey.GUILDS_UPDATE_MESSAGE, RabbitRoutingKey.GUILDS_DELETE_MESSAGE, RabbitRoutingKey.GUILDS_CLEAR_MESSAGES, RabbitRoutingKey.GUILDS_NOTIFICATIONS_SEND, RabbitRoutingKey.GUILDS_NOTIFICATIONS_VOLUNTEER, RabbitRoutingKey.GUILDS_PARTY_GATHERING, RabbitRoutingKey.GUILDS_PARTY_GATHERING_CANCEL, RabbitRoutingKey.GUILDS_MEMBERS_REFRESH_JOB_UPDATE, RabbitRoutingKey.GUILDS_RESERVATIONS_CHANGED_V2, RabbitRoutingKey.NOTIFICATIONS_DELIVERY_RESULT, RabbitRoutingKey.NOTIFICATIONS_LOOT_CREATED, RabbitRoutingKey.NOTIFICATIONS_TIMER_DELETED, RabbitRoutingKey.NOTIFICATIONS_TIMER_UPDATED, RabbitRoutingKey.PRESENCE_CHECK_REQUEST, RabbitRoutingKey.PRESENCE_COVERAGE_CHECK, RabbitRoutingKey.USERS_PARTY_READY_ROOM_UPDATED;
+const REALTIME_SUBPROTOCOL = "lootlog.realtime.v1";
+const REALTIME_JSON_SUBPROTOCOL = "lootlog.realtime.json.v1";
+const PRESENCE_HEARTBEAT_INTERVAL_MS = 25e3;
+const RequestId = NonEmptyString;
+const Revision = NonNegativeInt;
+const Timestamp = NonNegativeInt;
+const RealtimeLogicalTopic = Schema.Literals([
+	"organization.activity",
+	"organization.chat",
+	"organization.loots",
+	"organization.members",
+	"organization.notifications",
+	"organization.presence",
+	"organization.reservations",
+	"organization.timers",
+	"event.coordination",
+	"map.air-tags",
+	"map.pings",
+	"party.ready-room"
+]);
+const SubscriptionScope = Schema.Struct({
+	topic: RealtimeLogicalTopic,
+	organizationId: Schema.optional(NonEmptyString),
+	eventId: Schema.optional(NonEmptyString),
+	world: Schema.optional(NonEmptyString),
+	mapId: Schema.optional(NonNegativeInt)
+});
+const PresencePlatform = Schema.Literals(["game", "web-app"]);
+const PresenceStatus = Schema.Literals(["online", "offline"]);
+const PresenceConfidence = Schema.Literals(["verified", "reported"]);
+const PresenceClan = Schema.Struct({
+	id: Schema.optional(NonNegativeInt),
+	name: Schema.optional(Schema.String),
+	rank: Schema.optional(Schema.Int)
+});
+const PresenceCharacter = Schema.Struct({
+	world: NonEmptyString,
+	name: NonEmptyString,
+	lvl: NonNegativeInt,
+	icon: Schema.String,
+	characterId: NonEmptyString,
+	accountId: NonEmptyString,
+	prof: Schema.String,
+	clan: Schema.optional(PresenceClan)
+});
+const PrecisePresenceLocation = Schema.Struct({
+	mapId: Schema.optional(NonNegativeInt),
+	map: NonEmptyString,
+	x: Schema.optional(NonNegativeInt),
+	y: Schema.optional(NonNegativeInt)
+});
+const BasicPresence = Schema.Struct({
+	userId: NonEmptyString,
+	discordId: Schema.optional(NonEmptyString),
+	sessionId: NonEmptyString,
+	organizationIds: Schema.Array(NonEmptyString),
+	platform: PresencePlatform,
+	status: PresenceStatus,
+	confidence: PresenceConfidence,
+	isAfk: Schema.Boolean,
+	lastSeen: Timestamp,
+	character: Schema.optional(PresenceCharacter)
+});
+const PresenceWithLocation = Schema.Struct({
+	...BasicPresence.fields,
+	location: PrecisePresenceLocation
+});
+const PublishedPresence = Schema.Struct({
+	organizationIds: Schema.Array(NonEmptyString),
+	isAfk: Schema.optional(Schema.Boolean),
+	character: Schema.optional(PresenceCharacter),
+	location: Schema.optional(PrecisePresenceLocation),
+	clientObservedAt: Schema.optional(Timestamp)
+});
+const PresenceSnapshot = Schema.Struct({
+	organizationId: NonEmptyString,
+	world: Schema.optional(NonEmptyString),
+	revision: Revision,
+	presences: Schema.Array(Schema.Union([PresenceWithLocation, BasicPresence]))
+});
+const PresenceDelta = Schema.Struct({
+	organizationId: NonEmptyString,
+	revision: Revision,
+	changes: Schema.Array(Schema.Union([Schema.Struct({
+		action: Schema.Literal("upsert"),
+		presence: Schema.Union([PresenceWithLocation, BasicPresence])
+	}), Schema.Struct({
+		action: Schema.Literal("remove"),
+		userId: NonEmptyString,
+		discordId: Schema.optional(NonEmptyString),
+		sessionId: NonEmptyString
+	})]))
+});
+const command = (type, data) => Schema.Struct({
+	v: Schema.Literal(1),
+	type: Schema.Literal(type),
+	requestId: Schema.optional(RequestId),
+	data
+});
+const SessionJoinCommand = command("session.join", Schema.Struct({
+	world: Schema.optional(NonEmptyString),
+	character: Schema.optional(PresenceCharacter),
+	margonemAccountProof: Schema.optional(Schema.Unknown)
+}));
+const HeartbeatCommand = command("presence.heartbeat", Schema.Struct({ sessionId: NonEmptyString }));
+const PresencePublishCommand = command("presence.publish", PublishedPresence);
+const PresenceFetchCommand = command("presence.fetch", Schema.Struct({
+	organizationId: NonEmptyString,
+	world: Schema.optional(NonEmptyString)
+}));
+const SubscribeCommand = command("subscription.subscribe", SubscriptionScope);
+const UnsubscribeCommand = command("subscription.unsubscribe", SubscriptionScope);
+const MapPingCommand = command("map-ping.send", MapPingSendPayloadSchema);
+const AirTagSubscriptionCommand = command("air-tag.subscription", Schema.Struct({
+	requestId: RequestId,
+	enabled: Schema.Boolean,
+	expectedMapId: Schema.optional(NonNegativeInt)
+}));
+const AirTagObservationCommand = command("air-tag.observation", AirTagObservationBatchSchema);
+const AirTagRejectCode = Schema.Literals([
+	"forbidden",
+	"invalid-context",
+	"invalid-payload",
+	"rate-limited",
+	"temporarily-unavailable"
+]);
+const AirTagSubscriptionAck = Schema.Union([Schema.Struct({
+	status: Schema.Literal("accepted"),
+	requestId: RequestId,
+	scopes: Schema.Array(AirTagScopeSnapshotSchema)
+}), Schema.Struct({
+	status: Schema.Literal("rejected"),
+	requestId: RequestId,
+	code: AirTagRejectCode
+})]);
+const AirTagObservationAck = Schema.Union([Schema.Struct({
+	status: Schema.Literal("accepted"),
+	acceptedScopes: NonNegativeInt,
+	acceptedTargets: NonNegativeInt
+}), Schema.Struct({
+	status: Schema.Literal("rejected"),
+	code: AirTagRejectCode,
+	retryAfterMs: Schema.optional(NonNegativeInt)
+})]);
+const ClientCommand = Schema.Union([
+	SessionJoinCommand,
+	HeartbeatCommand,
+	PresencePublishCommand,
+	PresenceFetchCommand,
+	SubscribeCommand,
+	UnsubscribeCommand,
+	MapPingCommand,
+	AirTagSubscriptionCommand,
+	AirTagObservationCommand
+]);
+const RealtimeError = Schema.Struct({
+	code: NonEmptyString,
+	message: NonEmptyString,
+	retryable: Schema.Boolean,
+	retryAfterMs: Schema.optional(NonNegativeInt),
+	details: Schema.optional(Schema.Record(Schema.String, Schema.Unknown))
+});
+const Response = Schema.Union([Schema.Struct({
+	v: Schema.Literal(1),
+	requestId: RequestId,
+	status: Schema.Literal("success"),
+	data: Schema.optional(Schema.Unknown)
+}), Schema.Struct({
+	v: Schema.Literal(1),
+	requestId: RequestId,
+	status: Schema.Literal("error"),
+	error: RealtimeError
+})]);
+const serverEvent = (type, data) => Schema.Struct({
+	v: Schema.Literal(1),
+	type: Schema.Literal(type),
+	sequence: Schema.optional(Revision),
+	data
+});
+const OrganizationEvent = Schema.Struct({
+	organizationId: NonEmptyString,
+	payload: Schema.Unknown
+});
+const ServerEvent = Schema.Union([
+	serverEvent("session.joined", Schema.Struct({
+		connectionId: NonEmptyString,
+		organizationIds: Schema.Array(NonEmptyString),
+		subscriptionScopes: Schema.Array(SubscriptionScope),
+		accessPolicy: Schema.optional(AccessPolicySnapshot)
+	})),
+	serverEvent("permissions.updated", Schema.Struct({
+		changes: Schema.optional(Schema.Array(AccessPolicyChange)),
+		organizationIds: Schema.Array(NonEmptyString),
+		subscriptionScopes: Schema.Array(SubscriptionScope),
+		accessPolicy: Schema.optional(AccessPolicySnapshot)
+	})),
+	serverEvent("presence.snapshot", PresenceSnapshot),
+	serverEvent("presence.delta", PresenceDelta),
+	serverEvent("chat.created", OrganizationEvent),
+	serverEvent("chat.updated", OrganizationEvent),
+	serverEvent("chat.deleted", OrganizationEvent),
+	serverEvent("chat.cleared", OrganizationEvent),
+	serverEvent("feed.entry", UserFeedItem),
+	serverEvent("kills.changed", Schema.Struct({ guildId: NonEmptyString })),
+	serverEvent("loot.created", GuildLootCreatedEventV2),
+	serverEvent("loot.share-updated", GuildLootShareUpdatedEventV2),
+	serverEvent("timer.created", OrganizationEvent),
+	serverEvent("timer.deleted", OrganizationEvent),
+	serverEvent("reservation.created", OrganizationEvent),
+	serverEvent("reservation.deleted", OrganizationEvent),
+	serverEvent("reservation.changed", ReservationChangedEventV2),
+	serverEvent("notification.sent", OrganizationEvent),
+	serverEvent("member-refresh.updated", OrganizationEvent),
+	serverEvent("party-gathering.updated", OrganizationEvent),
+	serverEvent("party-gathering.cancelled", OrganizationEvent),
+	serverEvent("party-ready-room.updated", OrganizationEvent),
+	serverEvent("map-ping.received", MapPingEventSchema),
+	serverEvent("air-tag.updated", AirTagUpdateEventSchema),
+	serverEvent("event.map-status-updated", OrganizationEvent),
+	serverEvent("event.hero-killed", OrganizationEvent),
+	serverEvent("event.ranking-updated", OrganizationEvent),
+	serverEvent("event.respawn-window-opened", OrganizationEvent),
+	serverEvent("event.respawn-window-closed", OrganizationEvent),
+	serverEvent("notification.volunteer", Schema.Struct({
+		notificationId: NonEmptyString,
+		volunteer: Schema.StructWithRest(Schema.Struct({
+			discordId: NonEmptyString,
+			world: NonEmptyString
+		}), [Schema.Record(Schema.String, Schema.Unknown)])
+	}))
+]);
+const RealtimeFrame = Schema.Union([
+	ClientCommand,
+	Response,
+	ServerEvent
+]);
+Schema.decodeUnknownSync(ClientCommand);
+Schema.decodeUnknownSync(Response);
+Schema.decodeUnknownSync(ServerEvent);
+const decodeRealtimeFrame = Schema.decodeUnknownSync(RealtimeFrame);
+const serverEventTypes = new Set(ServerEvent.members.map((member) => member.fields.type.literal));
+const isServerEventFrame = (frame) => "type" in frame && serverEventTypes.has(frame.type);
+//#endregion
+//#region ../protocol/src/realtime/codec.ts
+var RealtimeCodecError = class extends TaggedError()("RealtimeCodecError", {
+	operation: Schema.Literals(["decode", "encode"]),
+	message: Schema.String,
+	cause: Schema.Defect()
+}) {};
+const getErrorMessage = (cause) => cause instanceof Error ? cause.message : String(cause);
+const tryEncodeFrame = (frame) => Result.try({
+	try: () => {
+		const validated = Schema.encodeUnknownSync(RealtimeFrame)(frame);
+		return {
+			frame: validated,
+			bytes: encode(validated, { ignoreUndefined: true })
+		};
+	},
+	catch: (error) => new RealtimeCodecError({
+		operation: "encode",
+		message: getErrorMessage(error),
+		cause: error
+	})
+});
+const tryEncodeRealtimeFrame = (frame) => Result.map(tryEncodeFrame(frame), ({ bytes }) => bytes);
+const encodeRealtimeFrame = (frame) => Result.getOrThrow(tryEncodeRealtimeFrame(frame));
+const tryDecodeRealtimeFrame = (bytes) => Result.try({
+	try: () => {
+		const input = bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes);
+		return Schema.decodeUnknownSync(RealtimeFrame)(decode(input));
+	},
+	catch: (error) => new RealtimeCodecError({
+		operation: "decode",
+		message: getErrorMessage(error),
+		cause: error
+	})
+});
+Schema.decodeUnknownSync(PresenceSnapshot);
+Schema.is(MapPingAckSchema);
+Schema.is(AirTagSubscriptionAck);
+Schema.is(AirTagObservationAck);
+Schema.is(Schema.Struct({ presences: Schema.optional(PresenceSnapshot.fields.presences) }));
+//#endregion
+//#region ../client/src/realtime/realtime-client.ts
+var RealtimeRequestError = class extends Error {
+	code;
+	retryable;
+	retryAfterMs;
+	constructor(code, message, retryable, retryAfterMs) {
+		super(message);
+		this.code = code;
+		this.retryable = retryable;
+		this.retryAfterMs = retryAfterMs;
+		this.name = "RealtimeRequestError";
+	}
+};
+const normalizeUrl = (baseUrl, path) => {
+	const fallbackBase = typeof globalThis.location === "undefined" ? "http://localhost" : globalThis.location.href;
+	const url = new URL(baseUrl, fallbackBase);
+	if (url.protocol === "http:") url.protocol = "ws:";
+	if (url.protocol === "https:") url.protocol = "wss:";
+	url.pathname = path.startsWith("/") ? path : `/${path}`;
+	url.search = "";
+	url.hash = "";
+	return url.toString();
+};
+const nativeWebSocketFactory = (url, protocols) => new WebSocket(url, protocols);
+const WEBSOCKET_OPEN = 1;
+const scopeKey = (scope) => JSON.stringify([
+	scope.topic,
+	scope.organizationId ?? null,
+	scope.eventId ?? null,
+	scope.world ?? null,
+	scope.mapId ?? null
+]);
+const toBytes = async (data) => {
+	if (data instanceof Uint8Array) return data;
+	if (data instanceof ArrayBuffer) return new Uint8Array(data);
+	if (data instanceof Blob) return new Uint8Array(await data.arrayBuffer());
+	throw new Error("Gateway returned a non-binary realtime frame");
+};
+const getPresenceSessionId = (data) => {
+	if (!data || typeof data !== "object" || !("sessionId" in data)) return null;
+	return typeof data.sessionId === "string" ? data.sessionId : null;
+};
+var RealtimeClient = class {
+	url;
+	protocols;
+	requestTimeoutMs;
+	reconnectBaseDelayMs;
+	reconnectMaxDelayMs;
+	random;
+	webSocketFactory;
+	frameEncoding;
+	eventListeners = /* @__PURE__ */ new Set();
+	stateListeners = /* @__PURE__ */ new Set();
+	pending = /* @__PURE__ */ new Map();
+	subscriptions = /* @__PURE__ */ new Map();
+	socket = null;
+	stateValue = "disconnected";
+	joinData = null;
+	reconnectAttempt = 0;
+	reconnectTimeout = null;
+	heartbeatTimeout = null;
+	presenceSessionId = null;
+	manuallyClosed = false;
+	messageChain = Promise.resolve();
+	rejoinHandler = null;
+	constructor(options) {
+		this.url = normalizeUrl(options.url, options.path ?? "/ws");
+		this.protocols = options.protocols ? [...options.protocols] : void 0;
+		this.requestTimeoutMs = options.requestTimeoutMs ?? 2e4;
+		this.reconnectBaseDelayMs = options.reconnectBaseDelayMs ?? 1e3;
+		this.reconnectMaxDelayMs = options.reconnectMaxDelayMs ?? 3e4;
+		this.random = options.random ?? Math.random;
+		this.webSocketFactory = options.webSocketFactory ?? nativeWebSocketFactory;
+		this.frameEncoding = options.frameEncoding ?? "messagepack";
+	}
+	get state() {
+		return this.stateValue;
+	}
+	get connected() {
+		return this.socket?.readyState === WEBSOCKET_OPEN;
+	}
+	connect() {
+		if (this.socket && this.socket.readyState <= WEBSOCKET_OPEN) return;
+		this.manuallyClosed = false;
+		this.clearReconnect();
+		this.open(this.reconnectAttempt > 0 ? "reconnecting" : "connecting");
+	}
+	disconnect() {
+		this.manuallyClosed = true;
+		this.clearReconnect();
+		this.clearHeartbeat();
+		this.rejectPending(/* @__PURE__ */ new Error("Realtime client disconnected"));
+		const activeSocket = this.socket;
+		this.socket = null;
+		activeSocket?.close(1e3, "client disconnect");
+		this.setState("disconnected");
+	}
+	subscribe(listener) {
+		this.eventListeners.add(listener);
+		return () => this.eventListeners.delete(listener);
+	}
+	subscribeState(listener) {
+		this.stateListeners.add(listener);
+		listener(this.stateValue);
+		return () => this.stateListeners.delete(listener);
+	}
+	setReconnectHandler(handler) {
+		this.rejoinHandler = handler;
+	}
+	join(data) {
+		this.joinData = data;
+		return this.performJoin();
+	}
+	subscribeScope(scope) {
+		this.subscriptions.set(scopeKey(scope), scope);
+		if (!this.connected || this.stateValue !== "ready") return Promise.resolve(void 0);
+		return this.request("subscription.subscribe", scope);
+	}
+	unsubscribeScope(scope) {
+		this.subscriptions.delete(scopeKey(scope));
+		if (!this.connected || this.stateValue !== "ready") return Promise.resolve(void 0);
+		return this.request("subscription.unsubscribe", scope);
+	}
+	request(type, data) {
+		const activeSocket = this.socket;
+		if (!activeSocket || activeSocket.readyState !== WEBSOCKET_OPEN) return Promise.reject(/* @__PURE__ */ new Error("Realtime connection is not open"));
+		const requestId = crypto.randomUUID();
+		return new Promise((resolve, reject) => {
+			const timeout = setTimeout(() => {
+				this.pending.delete(requestId);
+				reject(/* @__PURE__ */ new Error(`Realtime request timed out: ${type}`));
+			}, this.requestTimeoutMs);
+			this.pending.set(requestId, {
+				type,
+				resolve,
+				reject,
+				timeout
+			});
+			try {
+				activeSocket.send(this.encodeFrame({
+					v: 1,
+					type,
+					requestId,
+					data
+				}));
+			} catch (error) {
+				clearTimeout(timeout);
+				this.pending.delete(requestId);
+				reject(error instanceof Error ? error : new Error(String(error)));
+			}
+		});
+	}
+	send(type, data) {
+		const activeSocket = this.socket;
+		if (!activeSocket || activeSocket.readyState !== WEBSOCKET_OPEN) return;
+		activeSocket.send(this.encodeFrame({
+			v: 1,
+			type,
+			data
+		}));
+	}
+	open(state) {
+		this.setState(state);
+		if (this.manuallyClosed) return;
+		const socket = this.webSocketFactory(this.url, this.protocols);
+		socket.binaryType = "arraybuffer";
+		this.socket = socket;
+		socket.addEventListener("open", () => {
+			if (this.socket !== socket) return;
+			this.setState("connected");
+			if (this.joinData) (this.rejoinHandler ?? (() => this.performJoin().then(() => void 0)))().catch(() => socket.close(4008, "session rejoin failed"));
+		});
+		socket.addEventListener("message", (event) => {
+			this.messageChain = this.messageChain.then(() => this.handleMessage(event.data)).catch(() => socket.close(4007, "malformed realtime frame"));
+		});
+		socket.addEventListener("error", () => {
+			if (this.socket === socket) socket.close();
+		});
+		socket.addEventListener("close", () => {
+			if (this.socket !== socket) return;
+			this.socket = null;
+			this.clearHeartbeat();
+			this.rejectPending(/* @__PURE__ */ new Error("Realtime connection closed"));
+			this.setState("disconnected");
+			if (!this.manuallyClosed) this.scheduleReconnect();
+		});
+	}
+	async performJoin() {
+		if (!this.joinData || !this.connected) return void 0;
+		this.setState("joining");
+		try {
+			const result = await this.request("session.join", this.joinData);
+			await Promise.all([...this.subscriptions.values()].map((scope) => this.request("subscription.subscribe", scope)));
+			this.reconnectAttempt = 0;
+			this.setState("ready");
+			return result;
+		} catch (error) {
+			if (this.connected) this.socket?.close(4008, "session join failed");
+			throw error;
+		}
+	}
+	async handleMessage(data) {
+		const frame = await this.decodeFrame(data);
+		if ("status" in frame) {
+			const pending = this.pending.get(frame.requestId);
+			if (!pending) return;
+			clearTimeout(pending.timeout);
+			this.pending.delete(frame.requestId);
+			if (frame.status === "success") {
+				if (pending.type === "presence.publish") {
+					this.presenceSessionId = getPresenceSessionId(frame.data);
+					this.scheduleHeartbeat();
+				}
+				pending.resolve(frame.data);
+			} else pending.reject(new RealtimeRequestError(frame.error.code, frame.error.message, frame.error.retryable, frame.error.retryAfterMs));
+			return;
+		}
+		if (!isServerEventFrame(frame)) return;
+		for (const listener of this.eventListeners) listener(frame);
+	}
+	encodeFrame(frame) {
+		return this.frameEncoding === "json" ? JSON.stringify(frame) : encodeRealtimeFrame(frame);
+	}
+	async decodeFrame(data) {
+		if (this.frameEncoding === "json") {
+			if (typeof data !== "string") throw new Error("Gateway returned a non-text realtime frame");
+			return decodeRealtimeFrame(JSON.parse(data));
+		}
+		const decoded = tryDecodeRealtimeFrame(await toBytes(data));
+		if (Result.isFailure(decoded)) throw decoded.failure;
+		return decoded.success;
+	}
+	scheduleReconnect() {
+		this.reconnectAttempt += 1;
+		const exponential = Math.min(this.reconnectMaxDelayMs, this.reconnectBaseDelayMs * 2 ** (this.reconnectAttempt - 1));
+		const jittered = Math.round(exponential * (.5 + this.random()));
+		this.setState("reconnecting");
+		this.reconnectTimeout = setTimeout(() => this.open("reconnecting"), jittered);
+	}
+	scheduleHeartbeat() {
+		this.clearHeartbeat();
+		if (!this.presenceSessionId || !this.connected) return;
+		this.heartbeatTimeout = setTimeout(() => {
+			const sessionId = this.presenceSessionId;
+			if (!sessionId) return;
+			this.request("presence.heartbeat", { sessionId }).then(() => this.scheduleHeartbeat()).catch(() => this.socket?.close());
+		}, PRESENCE_HEARTBEAT_INTERVAL_MS);
+	}
+	rejectPending(error) {
+		for (const pending of this.pending.values()) {
+			clearTimeout(pending.timeout);
+			pending.reject(error);
+		}
+		this.pending.clear();
+	}
+	setState(state) {
+		if (this.stateValue === state) return;
+		this.stateValue = state;
+		for (const listener of this.stateListeners) listener(state);
+	}
+	clearReconnect() {
+		if (this.reconnectTimeout) clearTimeout(this.reconnectTimeout);
+		this.reconnectTimeout = null;
+	}
+	clearHeartbeat() {
+		if (this.heartbeatTimeout) clearTimeout(this.heartbeatTimeout);
+		this.heartbeatTimeout = null;
+	}
+};
+//#endregion
+export { REALTIME_JSON_SUBPROTOCOL, REALTIME_SUBPROTOCOL, RealtimeClient, RealtimeRequestError };
+
+//# sourceMappingURL=realtime.js.map