No OneTemporary
Actions

Size

62 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/keyserver/src/fetchers/community-fetchers.js b/keyserver/src/fetchers/community-fetchers.js
	index 6c52e997a..d7e29f66d 100644
	--- a/keyserver/src/fetchers/community-fetchers.js
	+++ b/keyserver/src/fetchers/community-fetchers.js
	@@ -1,108 +1,118 @@
	// @flow

	import type {
	ServerCommunityInfo,
	ServerCommunityInfoWithCommunityName,
	} from 'lib/types/community-types.js';

	+import { fetchPrivilegedThreadInfos } from './thread-fetchers.js';
	import { dbQuery, SQL, mergeAndConditions } from '../database/database.js';
	import { Viewer } from '../session/viewer.js';

	type ServerCommunityInfoWithHolder = $ReadOnly<{
	...ServerCommunityInfo,
	+blobHolder: ?string,
	}>;

	async function fetchCommunityInfos(
	viewer: Viewer,
	communityIDs?: $ReadOnlyArray<string>,
	): Promise<$ReadOnlyArray<ServerCommunityInfoWithHolder>> {
	if (!viewer.loggedIn) {
	return [];
	}

	const query = SQL`
	SELECT c.id, c.farcaster_channel_id as farcasterChannelID,
	c.blob_holder as blobHolder
	FROM communities c
	`;
	if (!viewer.isScriptViewer) {
	query.append(SQL`
	INNER JOIN memberships m
	ON c.id = m.thread AND m.user = ${viewer.userID}
	`);
	}

	const conditions = [];
	if (!viewer.isScriptViewer) {
	conditions.push(SQL`m.role > 0`);
	}
	if (communityIDs && communityIDs.length > 0) {
	conditions.push(SQL`
	c.id IN (${communityIDs})
	`);
	}
	if (conditions.length > 0) {
	const clause = mergeAndConditions(conditions);
	query.append(SQL`WHERE `);
	query.append(clause);
	}

	const [result] = await dbQuery(query);

	const communityInfos = result.map(row => ({
	id: row.id.toString(),
	farcasterChannelID: row.farcasterChannelID,
	blobHolder: row.blobHolder,
	}));

	return communityInfos;
	}

	async function fetchCommunityFarcasterChannelTag(
	viewer: Viewer,
	communityID: string,
	): Promise<?string> {
	if (!viewer.loggedIn) {
	return null;
	}

	const query = SQL`
	SELECT c.farcaster_channel_id as farcasterChannelID
	FROM communities c
	WHERE c.id = ${communityID}
	`;

	const [result] = await dbQuery(query);

	const communityInfo = result[0];

	return communityInfo?.farcasterChannelID;
	}

	-async function fetchAllCommunityInfosWithNames(): Promise<
	- $ReadOnlyArray<ServerCommunityInfoWithCommunityName>,
	-> {
	+async function fetchAllCommunityInfosWithNames(
	+ viewer: Viewer,
	+): Promise<$ReadOnlyArray<ServerCommunityInfoWithCommunityName>> {
	const query = SQL`
	SELECT c.id, t.name as communityName,
	c.farcaster_channel_id as farcasterChannelID
	FROM communities c
	INNER JOIN threads t ON c.id = t.id
	`;

	const [result] = await dbQuery(query);

	- const communityInfos = result.map(row => ({
	- id: row.id.toString(),
	- farcasterChannelID: row.farcasterChannelID,
	- communityName: row.communityName,
	- }));
	+ const threadIDs = new Set(result.map(row => row.id.toString()));
	+
	+ const threadInfosResult = await fetchPrivilegedThreadInfos(viewer, {
	+ threadIDs,
	+ });
	+
	+ const communityInfos = result.map(
	+ (row): ServerCommunityInfoWithCommunityName => ({
	+ id: row.id.toString(),
	+ farcasterChannelID: row.farcasterChannelID,
	+ communityName: row.communityName,
	+ threadInfo: threadInfosResult.threadInfos[row.id.toString()] ?? null,
	+ }),
	+ );

	return communityInfos;
	}

	export {
	fetchCommunityInfos,
	fetchCommunityFarcasterChannelTag,
	fetchAllCommunityInfosWithNames,
	};
	diff --git a/keyserver/src/responders/community-responders.js b/keyserver/src/responders/community-responders.js
	index dc8fde021..17dfe5f35 100644
	--- a/keyserver/src/responders/community-responders.js
	+++ b/keyserver/src/responders/community-responders.js
	@@ -1,42 +1,43 @@
	// @flow

	import type {
	FetchCommunityInfosResponse,
	- FetchAllCommunityInfosWithNamesResponse,
	+ ServerFetchAllCommunityInfosWithNamesResponse,
	} from 'lib/types/community-types.js';

	import {
	fetchCommunityInfos,
	fetchAllCommunityInfosWithNames,
	} from '../fetchers/community-fetchers.js';
	import { Viewer } from '../session/viewer.js';

	async function fetchCommunityInfosResponder(
	viewer: Viewer,
	): Promise<FetchCommunityInfosResponse> {
	const fetchedCommunities = await fetchCommunityInfos(viewer);

	const communityInfos = fetchedCommunities.map(community => ({
	id: community.id,
	farcasterChannelID: community.farcasterChannelID,
	}));

	return { communityInfos };
	}

	async function fetchAllCommunityInfosWithNamesResponder(
	viewer: Viewer,
	-): Promise<FetchAllCommunityInfosWithNamesResponse> {
	+): Promise<ServerFetchAllCommunityInfosWithNamesResponse> {
	if (!viewer.loggedIn) {
	return { allCommunityInfosWithNames: [] };
	}

	- const allCommunityInfosWithNames = await fetchAllCommunityInfosWithNames();
	+ const allCommunityInfosWithNames =
	+ await fetchAllCommunityInfosWithNames(viewer);

	return { allCommunityInfosWithNames };
	}

	export {
	fetchCommunityInfosResponder,
	fetchAllCommunityInfosWithNamesResponder,
	};
	diff --git a/keyserver/src/scripts/delete-all-fc-channel-tags.js b/keyserver/src/scripts/delete-all-fc-channel-tags.js
	index d09b689b1..eb7d92157 100644
	--- a/keyserver/src/scripts/delete-all-fc-channel-tags.js
	+++ b/keyserver/src/scripts/delete-all-fc-channel-tags.js
	@@ -1,29 +1,30 @@
	// @flow

	import { main } from './utils.js';
	import { deleteFarcasterChannelTag } from '../deleters/farcaster-channel-tag-deleters.js';
	import { fetchAllCommunityInfosWithNames } from '../fetchers/community-fetchers.js';
	import { createScriptViewer } from '../session/scripts.js';
	import { thisKeyserverAdmin } from '../user/identity.js';

	async function deleteAllFCChannelTags() {
	const admin = await thisKeyserverAdmin();
	const adminViewer = createScriptViewer(admin.id);

	- const allCommunityInfosWithNames = await fetchAllCommunityInfosWithNames();
	+ const allCommunityInfosWithNames =
	+ await fetchAllCommunityInfosWithNames(adminViewer);

	const deleteFarcasterChannelTagPromises = allCommunityInfosWithNames
	.map(communityInfoWithName => {
	if (!communityInfoWithName.farcasterChannelID) {
	return null;
	}
	return deleteFarcasterChannelTag(adminViewer, {
	commCommunityID: communityInfoWithName.id,
	farcasterChannelID: communityInfoWithName.farcasterChannelID,
	});
	})
	.filter(Boolean);
	await Promise.all(deleteFarcasterChannelTagPromises);
	}

	main([deleteAllFCChannelTags]);
	diff --git a/lib/actions/community-actions.js b/lib/actions/community-actions.js
	index ec19de1e3..636e41220 100644
	--- a/lib/actions/community-actions.js
	+++ b/lib/actions/community-actions.js
	@@ -1,166 +1,166 @@
	// @flow

	import type { CallSingleKeyserverEndpoint } from '../keyserver-conn/call-single-keyserver-endpoint.js';
	import { extractKeyserverIDFromID } from '../keyserver-conn/keyserver-call-utils.js';
	import { useKeyserverCall } from '../keyserver-conn/keyserver-call.js';
	import type { CallKeyserverEndpoint } from '../keyserver-conn/keyserver-conn-types.js';
	import type {
	ServerCommunityInfo,
	FetchCommunityInfosResponse,
	- FetchAllCommunityInfosWithNamesResponse,
	+ ClientFetchAllCommunityInfosWithNamesResponse,
	CreateOrUpdateFarcasterChannelTagRequest,
	CreateOrUpdateFarcasterChannelTagResponse,
	DeleteFarcasterChannelTagRequest,
	DeleteFarcasterChannelTagPayload,
	} from '../types/community-types.js';

	const updateCalendarCommunityFilter = 'UPDATE_CALENDAR_COMMUNITY_FILTER';
	const clearCalendarCommunityFilter = 'CLEAR_CALENDAR_COMMUNITY_FILTER';
	const updateChatCommunityFilter = 'UPDATE_CHAT_COMMUNITY_FILTER';
	const clearChatCommunityFilter = 'CLEAR_CHAT_COMMUNITY_FILTER';

	const addCommunityActionType = 'ADD_COMMUNITY';

	const fetchCommunityInfosActionTypes = Object.freeze({
	started: 'FETCH_COMMUNITY_INFOS_STARTED',
	success: 'FETCH_COMMUNITY_INFOS_SUCCESS',
	failed: 'FETCH_COMMUNITY_INFOS_FAILED',
	});

	const fetchCommunityInfos =
	(
	callKeyserverEndpoint: CallKeyserverEndpoint,
	allKeyserverIDs: $ReadOnlyArray<string>,
	): (() => Promise<FetchCommunityInfosResponse>) =>
	async () => {
	const requests: { [string]: void } = {};

	for (const keyserverID of allKeyserverIDs) {
	requests[keyserverID] = undefined;
	}

	const responses = await callKeyserverEndpoint(
	'fetch_community_infos',
	requests,
	);

	let communityInfos: $ReadOnlyArray<ServerCommunityInfo> = [];

	for (const keyserverID in responses) {
	communityInfos = communityInfos.concat(
	responses[keyserverID].communityInfos,
	);
	}

	return {
	communityInfos,
	};
	};

	function useFetchCommunityInfos(): () => Promise<FetchCommunityInfosResponse> {
	return useKeyserverCall(fetchCommunityInfos);
	}

	const fetchAllCommunityInfosWithNamesActionTypes = Object.freeze({
	started: 'FETCH_ALL_COMMUNITY_INFOS_WITH_NAMES_STARTED',
	success: 'FETCH_ALL_COMMUNITY_INFOS_WITH_NAMES_SUCCESS',
	failed: 'FETCH_ALL_COMMUNITY_INFOS_WITH_NAMES_FAILED',
	});
	const fetchAllCommunityInfosWithNames =
	(
	callSingleKeyserverEndpoint: CallSingleKeyserverEndpoint,
	- ): (() => Promise<FetchAllCommunityInfosWithNamesResponse>) =>
	+ ): (() => Promise<ClientFetchAllCommunityInfosWithNamesResponse>) =>
	() =>
	callSingleKeyserverEndpoint('fetch_all_community_infos_with_names');
	const createOrUpdateFarcasterChannelTagActionTypes = Object.freeze({
	started: 'CREATE_OR_UPDATE_FARCASTER_CHANNEL_TAG_STARTED',
	success: 'CREATE_OR_UPDATE_FARCASTER_CHANNEL_TAG_SUCCESS',
	failed: 'CREATE_OR_UPDATE_FARCASTER_CHANNEL_TAG_FAILED',
	});

	const createOrUpdateFarcasterChannelTag =
	(
	callKeyserverEndpoint: CallKeyserverEndpoint,
	): ((
	input: CreateOrUpdateFarcasterChannelTagRequest,
	) => Promise<CreateOrUpdateFarcasterChannelTagResponse>) =>
	async input => {
	const keyserverID = extractKeyserverIDFromID(input.commCommunityID);

	const requests = {
	[keyserverID]: {
	commCommunityID: input.commCommunityID,
	farcasterChannelID: input.farcasterChannelID,
	},
	};

	const responses = await callKeyserverEndpoint(
	'create_or_update_farcaster_channel_tag',
	requests,
	);

	return responses[keyserverID];
	};

	function useCreateOrUpdateFarcasterChannelTag(): (
	input: CreateOrUpdateFarcasterChannelTagRequest,
	) => Promise<CreateOrUpdateFarcasterChannelTagResponse> {
	return useKeyserverCall(createOrUpdateFarcasterChannelTag);
	}

	const deleteFarcasterChannelTagActionTypes = Object.freeze({
	started: 'DELETE_FARCASTER_CHANNEL_TAG_STARTED',
	success: 'DELETE_FARCASTER_CHANNEL_TAG_SUCCESS',
	failed: 'DELETE_FARCASTER_CHANNEL_TAG_FAILED',
	});

	const deleteFarcasterChannelTag =
	(
	callKeyserverEndpoint: CallKeyserverEndpoint,
	): ((
	input: DeleteFarcasterChannelTagRequest,
	) => Promise<DeleteFarcasterChannelTagPayload>) =>
	async input => {
	const keyserverID = extractKeyserverIDFromID(input.commCommunityID);

	const requests = {
	[keyserverID]: {
	commCommunityID: input.commCommunityID,
	farcasterChannelID: input.farcasterChannelID,
	},
	};

	const responses = await callKeyserverEndpoint(
	'delete_farcaster_channel_tag',
	requests,
	);

	const response = responses[keyserverID];

	return {
	commCommunityID: input.commCommunityID,
	...response,
	};
	};

	function useDeleteFarcasterChannelTag(): (
	input: DeleteFarcasterChannelTagRequest,
	) => Promise<DeleteFarcasterChannelTagPayload> {
	return useKeyserverCall(deleteFarcasterChannelTag);
	}

	export {
	updateCalendarCommunityFilter,
	clearCalendarCommunityFilter,
	updateChatCommunityFilter,
	clearChatCommunityFilter,
	addCommunityActionType,
	fetchCommunityInfosActionTypes,
	useFetchCommunityInfos,
	fetchAllCommunityInfosWithNamesActionTypes,
	fetchAllCommunityInfosWithNames,
	createOrUpdateFarcasterChannelTagActionTypes,
	useCreateOrUpdateFarcasterChannelTag,
	deleteFarcasterChannelTagActionTypes,
	useDeleteFarcasterChannelTag,
	};
	diff --git a/lib/types/community-types.js b/lib/types/community-types.js
	index 7b0d94f1b..537f408df 100644
	--- a/lib/types/community-types.js
	+++ b/lib/types/community-types.js
	@@ -1,98 +1,115 @@
	// @flow

	import t, { type TInterface } from 'tcomb';

	import type { RawMessageInfo } from './message-types.js';
	-import type { ChangeThreadSettingsResult } from './thread-types.js';
	+import type { ThinRawThreadInfo } from './minimally-encoded-thread-permissions-types.js';
	+import type {
	+ ChangeThreadSettingsResult,
	+ LegacyThinRawThreadInfo,
	+} from './thread-types.js';
	import type { ServerUpdateInfo } from './update-types.js';
	+import { thinRawThreadInfoValidator } from '../permissions/minimally-encoded-raw-thread-info-validators.js';
	import { tID, tShape } from '../utils/validation-utils.js';

	export type CommunityInfo = {
	+farcasterChannelID: ?string,
	};

	export type CommunityInfos = { +[threadID: string]: CommunityInfo };

	export type CommunityStore = {
	+communityInfos: CommunityInfos,
	};

	export type AddCommunityPayload = {
	+id: string,
	+newCommunityInfo: CommunityInfo,
	};

	export type ServerCommunityInfo = {
	+id: string,
	+farcasterChannelID: ?string,
	};

	export const serverCommunityInfoValidator: TInterface<ServerCommunityInfo> =
	tShape<ServerCommunityInfo>({
	id: tID,
	farcasterChannelID: t.maybe(t.String),
	});

	export type ServerCommunityInfoWithCommunityName = $ReadOnly<{
	...ServerCommunityInfo,
	+communityName: string,
	+ +threadInfo: LegacyThinRawThreadInfo \| ThinRawThreadInfo \| null,
	}>;

	-export const serverCommunityInfoWithCommunityNameValidator: TInterface<ServerCommunityInfoWithCommunityName> =
	- tShape<ServerCommunityInfoWithCommunityName>({
	+export type ClientCommunityInfoWithCommunityName = $ReadOnly<{
	+ ...ServerCommunityInfo,
	+ +communityName: string,
	+ +threadInfo: ThinRawThreadInfo \| null,
	+}>;
	+
	+export const clientCommunityInfoWithCommunityNameValidator: TInterface<ClientCommunityInfoWithCommunityName> =
	+ tShape<ClientCommunityInfoWithCommunityName>({
	id: tID,
	farcasterChannelID: t.maybe(t.String),
	communityName: t.String,
	+ threadInfo: t.maybe(thinRawThreadInfoValidator),
	});

	export type FetchCommunityInfosResponse = {
	+communityInfos: $ReadOnlyArray<ServerCommunityInfo>,
	};

	-export type FetchAllCommunityInfosWithNamesResponse = {
	+export type ServerFetchAllCommunityInfosWithNamesResponse = {
	+allCommunityInfosWithNames: $ReadOnlyArray<ServerCommunityInfoWithCommunityName>,
	};

	+export type ClientFetchAllCommunityInfosWithNamesResponse = {
	+ +allCommunityInfosWithNames: $ReadOnlyArray<ClientCommunityInfoWithCommunityName>,
	+};
	+
	export type CreateOrUpdateFarcasterChannelTagRequest = {
	+commCommunityID: string,
	+farcasterChannelID: string,
	};

	export type CreateOrUpdateFarcasterChannelTagResponse = {
	+commCommunityID: string,
	+farcasterChannelID: string,
	+updatesResult?: ?{
	+newUpdates: $ReadOnlyArray<ServerUpdateInfo>,
	},
	+newMessageInfos?: ?$ReadOnlyArray<RawMessageInfo>,
	};

	export type DeleteFarcasterChannelTagRequest = {
	+commCommunityID: string,
	+farcasterChannelID: string,
	};

	export type DeleteFarcasterChannelTagResponse = ChangeThreadSettingsResult;

	export type DeleteFarcasterChannelTagPayload = {
	+commCommunityID: string,
	+updatesResult?: ?{
	+newUpdates: $ReadOnlyArray<ServerUpdateInfo>,
	},
	+newMessageInfos?: ?$ReadOnlyArray<RawMessageInfo>,
	};

	export type OngoingJoinCommunityData = {
	+resolve: () => mixed,
	+reject: () => mixed,
	+communityID: string,
	+threadID: ?string,
	};

	export type JoinCommunityStep =
	\| 'inactive'
	\| 'add_keyserver'
	\| 'auth_to_keyserver'
	\| 'join_community'
	\| 'join_thread'
	\| 'finished';
	diff --git a/lib/types/redux-types.js b/lib/types/redux-types.js
	index 032c51907..ee4a0f556 100644
	--- a/lib/types/redux-types.js
	+++ b/lib/types/redux-types.js
	@@ -1,1680 +1,1680 @@
	// @flow

	import type { PersistState } from 'redux-persist/es/types';

	import type {
	LogOutResult,
	KeyserverLogOutResult,
	LegacyLogInStartingPayload,
	LegacyLogInResult,
	LegacyRegisterResult,
	DefaultNotificationPayload,
	ClaimUsernameResponse,
	KeyserverAuthResult,
	} from './account-types.js';
	import type {
	ActivityUpdateSuccessPayload,
	QueueActivityUpdatesPayload,
	SetThreadUnreadStatusPayload,
	} from './activity-types.js';
	import type { AlertStore, RecordAlertActionPayload } from './alert-types.js';
	import type {
	AuxUserStore,
	SetAuxUserFIDsPayload,
	AddAuxUserFIDsPayload,
	RemovePeerUsersPayload,
	SetPeerDeviceListsPayload,
	SetMissingDeviceListsPayload,
	} from './aux-user-types.js';
	import type {
	UpdateUserAvatarRequest,
	UpdateUserAvatarResponse,
	} from './avatar-types.js';
	import type {
	CommunityStore,
	AddCommunityPayload,
	FetchCommunityInfosResponse,
	- FetchAllCommunityInfosWithNamesResponse,
	+ ClientFetchAllCommunityInfosWithNamesResponse,
	CreateOrUpdateFarcasterChannelTagResponse,
	DeleteFarcasterChannelTagPayload,
	} from './community-types.js';
	import type { DBOpsStore } from './db-ops-types.js';
	import type {
	GetVersionActionPayload,
	LastCommunicatedPlatformDetails,
	} from './device-types.js';
	import type {
	ProcessDMOpsPayload,
	QueuedDMOperations,
	QueueDMOpsPayload,
	PruneDMOpsQueuePayload,
	ClearQueuedThreadDMOpsPayload,
	ClearQueuedMessageDMOpsPayload,
	ClearQueuedEntryDMOpsPayload,
	ClearQueuedMembershipDMOpsPayload,
	} from './dm-ops.js';
	import type { DraftStore } from './draft-types.js';
	import type { EnabledApps, SupportedApps } from './enabled-apps.js';
	import type {
	RawEntryInfo,
	EntryStore,
	SaveEntryPayload,
	CreateEntryPayload,
	DeleteEntryResult,
	RestoreEntryPayload,
	FetchEntryInfosResult,
	CalendarQueryUpdateResult,
	CalendarQueryUpdateStartingPayload,
	FetchRevisionsForEntryPayload,
	} from './entry-types.js';
	import type {
	CalendarFilter,
	CalendarThreadFilter,
	SetCalendarDeletedFilterPayload,
	} from './filter-types.js';
	import type { HolderStore, BlobHashAndHolder } from './holder-types.js';
	import type { IdentityAuthResult } from './identity-service-types';
	import type { IntegrityStore } from './integrity-types.js';
	import type {
	KeyserverStore,
	AddKeyserverPayload,
	RemoveKeyserverPayload,
	} from './keyserver-types.js';
	import type { LifecycleState } from './lifecycle-state-types.js';
	import type {
	FetchInviteLinksResponse,
	InviteLink,
	InviteLinksStore,
	InviteLinkVerificationResponse,
	DisableInviteLinkPayload,
	} from './link-types.js';
	import type { LoadingStatus, LoadingInfo } from './loading-types.js';
	import type { UpdateMultimediaMessageMediaPayload } from './media-types.js';
	import type { MessageReportCreationResult } from './message-report-types.js';
	import type {
	MessageStore,
	RawMultimediaMessageInfo,
	FetchMessageInfosPayload,
	SendMessagePayload,
	EditMessagePayload,
	SaveMessagesPayload,
	NewMessagesPayload,
	MessageStorePrunePayload,
	LocallyComposedMessageInfo,
	SimpleMessagesPayload,
	FetchPinnedMessagesResult,
	SearchMessagesResponse,
	} from './message-types.js';
	import type { RawReactionMessageInfo } from './messages/reaction.js';
	import type { RawTextMessageInfo } from './messages/text.js';
	import type { BaseNavInfo, WebNavInfo } from './nav-types.js';
	import type { GetOlmSessionInitializationDataResponse } from './olm-session-types.js';
	import {
	type ForcePolicyAcknowledgmentPayload,
	type PolicyAcknowledgmentPayload,
	type UserPolicies,
	} from './policy-types.js';
	import type { RelationshipErrors } from './relationship-types.js';
	import type {
	EnabledReports,
	ClearDeliveredReportsPayload,
	QueueReportsPayload,
	ReportStore,
	} from './report-types.js';
	import type { ProcessServerRequestAction } from './request-types.js';
	import type {
	UserSearchResult,
	ExactUserSearchResult,
	} from './search-types.js';
	import type { SetSessionPayload } from './session-types.js';
	import type {
	ConnectionIssue,
	StateSyncFullActionPayload,
	StateSyncIncrementalActionPayload,
	SetActiveSessionRecoveryPayload,
	ClientStateSyncSocketResult,
	} from './socket-types.js';
	import { type ClientStore } from './store-ops-types.js';
	import type { SubscriptionUpdateResult } from './subscription-types.js';
	import type {
	SyncedMetadataStore,
	SetSyncedMetadataEntryPayload,
	ClearSyncedMetadataEntryPayload,
	} from './synced-metadata-types.js';
	import type { GlobalThemeInfo } from './theme-types.js';
	import type { ThreadActivityStore } from './thread-activity-types.js';
	import type {
	ThreadStore,
	ChangeThreadSettingsPayload,
	LeaveThreadPayload,
	NewThreadResult,
	ThreadJoinPayload,
	ToggleMessagePinResult,
	LegacyThreadStore,
	RoleModificationPayload,
	RoleDeletionPayload,
	} from './thread-types.js';
	import type { TunnelbrokerDeviceToken } from './tunnelbroker-device-token-types.js';
	import type { ClientUpdatesResultWithUserInfos } from './update-types.js';
	import type {
	CurrentUserInfo,
	UserInfos,
	UserStore,
	UserInfo,
	} from './user-types.js';
	import type {
	SetDeviceTokenActionPayload,
	SetDeviceTokenStartedPayload,
	} from '../actions/device-actions.js';
	import type {
	ProcessHoldersStartedPayload,
	ProcessHoldersFailedPayload,
	ProcessHoldersFinishedPayload,
	} from '../actions/holder-actions.js';
	import type {
	UpdateConnectionStatusPayload,
	SetLateResponsePayload,
	UpdateKeyserverReachabilityPayload,
	} from '../keyserver-conn/keyserver-conn-types.js';
	import type { SendMessageError } from '../utils/errors.js';

	export type BaseAppState<NavInfo: BaseNavInfo = BaseNavInfo> = {
	+navInfo: NavInfo,
	+currentUserInfo: ?CurrentUserInfo,
	+draftStore: DraftStore,
	+entryStore: EntryStore,
	+threadStore: ThreadStore,
	+userStore: UserStore,
	+messageStore: MessageStore,
	+loadingStatuses: { [key: string]: { [idx: number]: LoadingStatus } },
	+calendarFilters: $ReadOnlyArray<CalendarFilter>,
	+alertStore: AlertStore,
	+watchedThreadIDs: $ReadOnlyArray<string>,
	+lifecycleState: LifecycleState,
	+enabledApps: EnabledApps,
	+reportStore: ReportStore,
	+dataLoaded: boolean,
	+userPolicies: UserPolicies,
	+commServicesAccessToken: ?string,
	+inviteLinksStore: InviteLinksStore,
	+keyserverStore: KeyserverStore,
	+threadActivityStore: ThreadActivityStore,
	+integrityStore: IntegrityStore,
	+globalThemeInfo: GlobalThemeInfo,
	+customServer: ?string,
	+communityStore: CommunityStore,
	+dbOpsStore: DBOpsStore,
	+syncedMetadataStore: SyncedMetadataStore,
	+auxUserStore: AuxUserStore,
	+tunnelbrokerDeviceToken: TunnelbrokerDeviceToken,
	+_persist: ?PersistState,
	+queuedDMOperations: QueuedDMOperations,
	+holderStore: HolderStore,
	+initialStateLoaded: boolean,
	...
	};

	export type NativeAppState = BaseAppState<>;
	export type WebAppState = BaseAppState<> & {
	+pushApiPublicKey: ?string,
	...
	};
	export type AppState = NativeAppState \| WebAppState;

	export type ClientWebInitialReduxStateResponse = {
	+navInfo: WebNavInfo,
	+currentUserInfo: CurrentUserInfo,
	+entryStore: EntryStore,
	+threadStore: ThreadStore,
	+userInfos: UserInfos,
	+messageStore: MessageStore,
	+pushApiPublicKey: ?string,
	+inviteLinksStore: InviteLinksStore,
	+keyserverInfo: WebInitialKeyserverInfo,
	};
	export type ServerWebInitialReduxStateResponse = {
	+navInfo: WebNavInfo,
	+currentUserInfo: CurrentUserInfo,
	+entryStore: EntryStore,
	+threadStore: LegacyThreadStore,
	+userInfos: UserInfos,
	+messageStore: MessageStore,
	+pushApiPublicKey: ?string,
	+inviteLinksStore: InviteLinksStore,
	+keyserverInfo: WebInitialKeyserverInfo,
	};
	export type WebInitialKeyserverInfo = {
	+sessionID: ?string,
	+updatesCurrentAsOf: number,
	};

	export type BaseAction = $ReadOnly<{
	+dispatchMetadata?: DispatchMetadata,
	...
	\| {
	+type: '@@redux/INIT',
	+payload?: void,
	}
	\| {
	+type: 'FETCH_ENTRIES_STARTED',
	+payload?: void,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'FETCH_ENTRIES_FAILED',
	+error: true,
	+payload: Error,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'FETCH_ENTRIES_SUCCESS',
	+payload: FetchEntryInfosResult,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'LOG_OUT_STARTED',
	+payload?: void,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'LOG_OUT_FAILED',
	+error: true,
	+payload: Error,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'LOG_OUT_SUCCESS',
	+payload: LogOutResult,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'CLAIM_USERNAME_STARTED',
	+payload?: void,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'CLAIM_USERNAME_FAILED',
	+error: true,
	+payload: Error,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'CLAIM_USERNAME_SUCCESS',
	+payload: ClaimUsernameResponse,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'DELETE_KEYSERVER_ACCOUNT_STARTED',
	+payload?: void,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'DELETE_KEYSERVER_ACCOUNT_FAILED',
	+error: true,
	+payload: Error,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'DELETE_KEYSERVER_ACCOUNT_SUCCESS',
	+payload: KeyserverLogOutResult,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'DELETE_ACCOUNT_STARTED',
	+payload?: void,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'DELETE_ACCOUNT_FAILED',
	+error: true,
	+payload: Error,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'DELETE_ACCOUNT_SUCCESS',
	+payload: LogOutResult,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'CREATE_LOCAL_ENTRY',
	+payload: RawEntryInfo,
	}
	\| {
	+type: 'CREATE_ENTRY_STARTED',
	+payload?: void,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'CREATE_ENTRY_FAILED',
	+error: true,
	+payload: Error,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'CREATE_ENTRY_SUCCESS',
	+payload: CreateEntryPayload,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'SAVE_ENTRY_STARTED',
	+payload?: void,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'SAVE_ENTRY_FAILED',
	+error: true,
	+payload: Error,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'SAVE_ENTRY_SUCCESS',
	+payload: SaveEntryPayload,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'CONCURRENT_MODIFICATION_RESET',
	+payload: {
	+id: string,
	+dbText: string,
	},
	}
	\| {
	+type: 'DELETE_ENTRY_STARTED',
	+loadingInfo: LoadingInfo,
	+payload: {
	+localID: ?string,
	+serverID: ?string,
	},
	}
	\| {
	+type: 'DELETE_ENTRY_FAILED',
	+error: true,
	+payload: Error,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'DELETE_ENTRY_SUCCESS',
	+payload: ?DeleteEntryResult,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'IDENTITY_LOG_IN_STARTED',
	+loadingInfo: LoadingInfo,
	+payload?: void,
	}
	\| {
	+type: 'IDENTITY_LOG_IN_FAILED',
	+error: true,
	+payload: Error,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'IDENTITY_LOG_IN_SUCCESS',
	+payload: IdentityAuthResult,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'KEYSERVER_AUTH_STARTED',
	+loadingInfo: LoadingInfo,
	+payload?: void,
	}
	\| {
	+type: 'KEYSERVER_AUTH_FAILED',
	+error: true,
	+payload: Error,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'KEYSERVER_AUTH_SUCCESS',
	+payload: KeyserverAuthResult,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'LEGACY_LOG_IN_STARTED',
	+loadingInfo: LoadingInfo,
	+payload: LegacyLogInStartingPayload,
	}
	\| {
	+type: 'LEGACY_LOG_IN_FAILED',
	+error: true,
	+payload: Error,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'LEGACY_LOG_IN_SUCCESS',
	+payload: LegacyLogInResult,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'LEGACY_KEYSERVER_REGISTER_STARTED',
	+loadingInfo: LoadingInfo,
	+payload: LegacyLogInStartingPayload,
	}
	\| {
	+type: 'LEGACY_KEYSERVER_REGISTER_FAILED',
	+error: true,
	+payload: Error,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'LEGACY_KEYSERVER_REGISTER_SUCCESS',
	+payload: LegacyRegisterResult,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'IDENTITY_REGISTER_STARTED',
	+payload?: void,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'IDENTITY_REGISTER_FAILED',
	+error: true,
	+payload: Error,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'IDENTITY_REGISTER_SUCCESS',
	+payload: IdentityAuthResult,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'IDENTITY_GENERATE_NONCE_STARTED',
	+payload?: void,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'IDENTITY_GENERATE_NONCE_FAILED',
	+error: true,
	+payload: Error,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'IDENTITY_GENERATE_NONCE_SUCCESS',
	+payload?: void,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'CHANGE_KEYSERVER_USER_PASSWORD_STARTED',
	+payload?: void,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'CHANGE_KEYSERVER_USER_PASSWORD_FAILED',
	+error: true,
	+payload: Error,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'CHANGE_KEYSERVER_USER_PASSWORD_SUCCESS',
	+payload?: void,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'CHANGE_IDENTITY_USER_PASSWORD_STARTED',
	+payload?: void,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'CHANGE_IDENTITY_USER_PASSWORD_FAILED',
	+error: true,
	+payload: Error,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'CHANGE_IDENTITY_USER_PASSWORD_SUCCESS',
	+payload?: void,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'CHANGE_THREAD_SETTINGS_STARTED',
	+payload?: void,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'CHANGE_THREAD_SETTINGS_FAILED',
	+error: true,
	+payload: Error,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'CHANGE_THREAD_SETTINGS_SUCCESS',
	+payload: ChangeThreadSettingsPayload,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'DELETE_THREAD_STARTED',
	+payload?: void,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'DELETE_THREAD_FAILED',
	+error: true,
	+payload: Error,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'DELETE_THREAD_SUCCESS',
	+payload: LeaveThreadPayload,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'NEW_THREAD_STARTED',
	+payload?: void,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'NEW_THREAD_FAILED',
	+error: true,
	+payload: Error,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'NEW_THREAD_SUCCESS',
	+payload: NewThreadResult,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'REMOVE_USERS_FROM_THREAD_STARTED',
	+payload?: void,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'REMOVE_USERS_FROM_THREAD_FAILED',
	+error: true,
	+payload: Error,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'REMOVE_USERS_FROM_THREAD_SUCCESS',
	+payload: ChangeThreadSettingsPayload,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'CHANGE_THREAD_MEMBER_ROLES_STARTED',
	+payload?: void,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'CHANGE_THREAD_MEMBER_ROLES_FAILED',
	+error: true,
	+payload: Error,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'CHANGE_THREAD_MEMBER_ROLES_SUCCESS',
	+payload: ChangeThreadSettingsPayload,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'FETCH_REVISIONS_FOR_ENTRY_STARTED',
	+payload?: void,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'FETCH_REVISIONS_FOR_ENTRY_FAILED',
	+error: true,
	+payload: Error,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'FETCH_REVISIONS_FOR_ENTRY_SUCCESS',
	+payload: FetchRevisionsForEntryPayload,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'RESTORE_ENTRY_STARTED',
	+payload?: void,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'RESTORE_ENTRY_FAILED',
	+error: true,
	+payload: Error,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'RESTORE_ENTRY_SUCCESS',
	+payload: RestoreEntryPayload,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'JOIN_THREAD_STARTED',
	+payload?: void,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'JOIN_THREAD_FAILED',
	+error: true,
	+payload: Error,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'JOIN_THREAD_SUCCESS',
	+payload: ThreadJoinPayload,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'LEAVE_THREAD_STARTED',
	+payload?: void,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'LEAVE_THREAD_FAILED',
	+error: true,
	+payload: Error,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'LEAVE_THREAD_SUCCESS',
	+payload: LeaveThreadPayload,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'SET_NEW_SESSION',
	+payload: SetSessionPayload,
	}
	\| {
	+type: 'persist/REHYDRATE',
	+payload: ?BaseAppState<>,
	}
	\| {
	+type: 'FETCH_MESSAGES_BEFORE_CURSOR_STARTED',
	+payload?: void,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'FETCH_MESSAGES_BEFORE_CURSOR_FAILED',
	+error: true,
	+payload: Error,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'FETCH_MESSAGES_BEFORE_CURSOR_SUCCESS',
	+payload: FetchMessageInfosPayload,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'FETCH_MOST_RECENT_MESSAGES_STARTED',
	+payload?: void,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'FETCH_MOST_RECENT_MESSAGES_FAILED',
	+error: true,
	+payload: Error,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'FETCH_MOST_RECENT_MESSAGES_SUCCESS',
	+payload: FetchMessageInfosPayload,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'FETCH_SINGLE_MOST_RECENT_MESSAGES_FROM_THREADS_STARTED',
	+payload?: void,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'FETCH_SINGLE_MOST_RECENT_MESSAGES_FROM_THREADS_FAILED',
	+error: true,
	+payload: Error,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'FETCH_SINGLE_MOST_RECENT_MESSAGES_FROM_THREADS_SUCCESS',
	+payload: SimpleMessagesPayload,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'SEND_TEXT_MESSAGE_STARTED',
	+loadingInfo?: LoadingInfo,
	+payload: RawTextMessageInfo,
	}
	\| {
	+type: 'SEND_TEXT_MESSAGE_FAILED',
	+error: true,
	+payload: SendMessageError,
	+loadingInfo?: LoadingInfo,
	}
	\| {
	+type: 'SEND_TEXT_MESSAGE_SUCCESS',
	+payload: SendMessagePayload,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'SEND_MULTIMEDIA_MESSAGE_STARTED',
	+loadingInfo?: LoadingInfo,
	+payload: RawMultimediaMessageInfo,
	}
	\| {
	+type: 'SEND_MULTIMEDIA_MESSAGE_FAILED',
	+error: true,
	+payload: SendMessageError,
	+loadingInfo?: LoadingInfo,
	}
	\| {
	+type: 'SEND_MULTIMEDIA_MESSAGE_SUCCESS',
	+payload: SendMessagePayload,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'SEND_REACTION_MESSAGE_STARTED',
	+loadingInfo?: LoadingInfo,
	+payload: RawReactionMessageInfo,
	}
	\| {
	+type: 'SEND_REACTION_MESSAGE_FAILED',
	+error: true,
	+payload: SendMessageError,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'SEND_REACTION_MESSAGE_SUCCESS',
	+payload: SendMessagePayload,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'SEARCH_USERS_STARTED',
	+payload?: void,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'SEARCH_USERS_FAILED',
	+error: true,
	+payload: Error,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'SEARCH_USERS_SUCCESS',
	+payload: UserSearchResult,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'EXACT_SEARCH_USER_STARTED',
	+payload?: void,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'EXACT_SEARCH_USER_FAILED',
	+error: true,
	+payload: Error,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'EXACT_SEARCH_USER_SUCCESS',
	+payload: ExactUserSearchResult,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'UPDATE_DRAFT',
	+payload: {
	+key: string,
	+text: string,
	},
	}
	\| {
	+type: 'MOVE_DRAFT',
	+payload: {
	+oldKey: string,
	+newKey: string,
	},
	}
	\| {
	+type: 'SET_CLIENT_DB_STORE',
	+payload: ClientStore,
	}
	\| {
	+type: 'UPDATE_ACTIVITY_STARTED',
	+payload?: void,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'UPDATE_ACTIVITY_FAILED',
	+error: true,
	+payload: Error,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'UPDATE_ACTIVITY_SUCCESS',
	+payload: ActivityUpdateSuccessPayload,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'SET_DEVICE_TOKEN_STARTED',
	+payload: SetDeviceTokenStartedPayload,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'SET_DEVICE_TOKEN_FAILED',
	+error: true,
	+payload: Error,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'SET_DEVICE_TOKEN_SUCCESS',
	+payload: SetDeviceTokenActionPayload,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'SEND_REPORT_STARTED',
	+payload?: void,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'SEND_REPORT_FAILED',
	+error: true,
	+payload: Error,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'SEND_REPORT_SUCCESS',
	+payload?: ClearDeliveredReportsPayload,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'SEND_REPORTS_STARTED',
	+payload?: void,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'SEND_REPORTS_FAILED',
	+error: true,
	+payload: Error,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'SEND_REPORTS_SUCCESS',
	+payload?: ClearDeliveredReportsPayload,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'QUEUE_REPORTS',
	+payload: QueueReportsPayload,
	}
	\| {
	+type: 'SET_URL_PREFIX',
	+payload: string,
	}
	\| {
	+type: 'SAVE_MESSAGES',
	+payload: SaveMessagesPayload,
	}
	\| {
	+type: 'UPDATE_CALENDAR_THREAD_FILTER',
	+payload: CalendarThreadFilter,
	}
	\| {
	+type: 'CLEAR_CALENDAR_THREAD_FILTER',
	+payload?: void,
	}
	\| {
	+type: 'SET_CALENDAR_DELETED_FILTER',
	+payload: SetCalendarDeletedFilterPayload,
	}
	\| {
	+type: 'UPDATE_SUBSCRIPTION_STARTED',
	+payload?: void,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'UPDATE_SUBSCRIPTION_FAILED',
	+error: true,
	+payload: Error,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'UPDATE_SUBSCRIPTION_SUCCESS',
	+payload: SubscriptionUpdateResult,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'UPDATE_CALENDAR_QUERY_STARTED',
	+loadingInfo: LoadingInfo,
	+payload?: CalendarQueryUpdateStartingPayload,
	}
	\| {
	+type: 'UPDATE_CALENDAR_QUERY_FAILED',
	+error: true,
	+payload: Error,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'UPDATE_CALENDAR_QUERY_SUCCESS',
	+payload: CalendarQueryUpdateResult,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'FULL_STATE_SYNC',
	+payload: StateSyncFullActionPayload,
	}
	\| {
	+type: 'INCREMENTAL_STATE_SYNC',
	+payload: StateSyncIncrementalActionPayload,
	}
	\| ProcessServerRequestAction
	\| {
	+type: 'UPDATE_CONNECTION_STATUS',
	+payload: UpdateConnectionStatusPayload,
	}
	\| {
	+type: 'QUEUE_ACTIVITY_UPDATES',
	+payload: QueueActivityUpdatesPayload,
	}
	\| {
	+type: 'UNSUPERVISED_BACKGROUND',
	+payload: { +keyserverID: string },
	}
	\| {
	+type: 'UPDATE_LIFECYCLE_STATE',
	+payload: LifecycleState,
	}
	\| {
	+type: 'ENABLE_APP',
	+payload: SupportedApps,
	}
	\| {
	+type: 'DISABLE_APP',
	+payload: SupportedApps,
	}
	\| {
	+type: 'UPDATE_REPORTS_ENABLED',
	+payload: Partial<EnabledReports>,
	}
	\| {
	+type: 'PROCESS_UPDATES',
	+payload: ClientUpdatesResultWithUserInfos,
	}
	\| {
	+type: 'PROCESS_MESSAGES',
	+payload: NewMessagesPayload,
	}
	\| {
	+type: 'MESSAGE_STORE_PRUNE',
	+payload: MessageStorePrunePayload,
	}
	\| {
	+type: 'SET_LATE_RESPONSE',
	+payload: SetLateResponsePayload,
	}
	\| {
	+type: 'UPDATE_KEYSERVER_REACHABILITY',
	+payload: UpdateKeyserverReachabilityPayload,
	}
	\| {
	+type: 'REQUEST_ACCESS_STARTED',
	+payload?: void,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'REQUEST_ACCESS_FAILED',
	+error: true,
	+payload: Error,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'REQUEST_ACCESS_SUCCESS',
	+payload?: void,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'UPDATE_MULTIMEDIA_MESSAGE_MEDIA',
	+payload: UpdateMultimediaMessageMediaPayload,
	}
	\| {
	+type: 'CREATE_LOCAL_MESSAGE',
	+payload: LocallyComposedMessageInfo,
	}
	\| {
	+type: 'UPDATE_RELATIONSHIPS_STARTED',
	+payload?: void,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'UPDATE_RELATIONSHIPS_FAILED',
	+error: true,
	+payload: Error,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'UPDATE_RELATIONSHIPS_SUCCESS',
	+payload: RelationshipErrors,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'SET_THREAD_UNREAD_STATUS_STARTED',
	+payload: {
	+threadID: string,
	+unread: boolean,
	},
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'SET_THREAD_UNREAD_STATUS_FAILED',
	+error: true,
	+payload: Error,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'SET_THREAD_UNREAD_STATUS_SUCCESS',
	+payload: SetThreadUnreadStatusPayload,
	}
	\| {
	+type: 'SET_USER_SETTINGS_STARTED',
	+payload?: void,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'SET_USER_SETTINGS_SUCCESS',
	+payload: DefaultNotificationPayload,
	}
	\| {
	+type: 'SET_USER_SETTINGS_FAILED',
	+payload: Error,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'SEND_MESSAGE_REPORT_STARTED',
	+payload?: void,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'SEND_MESSAGE_REPORT_SUCCESS',
	+payload: MessageReportCreationResult,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'SEND_MESSAGE_REPORT_FAILED',
	+error: true,
	+payload: Error,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'FORCE_POLICY_ACKNOWLEDGMENT',
	+payload: ForcePolicyAcknowledgmentPayload,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'POLICY_ACKNOWLEDGMENT_STARTED',
	+payload?: void,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'POLICY_ACKNOWLEDGMENT_SUCCESS',
	+payload: PolicyAcknowledgmentPayload,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'POLICY_ACKNOWLEDGMENT_FAILED',
	+error: true,
	+payload: Error,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'GET_SIWE_NONCE_STARTED',
	+payload?: void,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'GET_SIWE_NONCE_SUCCESS',
	+payload?: void,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'GET_SIWE_NONCE_FAILED',
	+error: true,
	+payload: Error,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'LEGACY_SIWE_AUTH_STARTED',
	+payload: LegacyLogInStartingPayload,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'LEGACY_SIWE_AUTH_SUCCESS',
	+payload: LegacyLogInResult,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'LEGACY_SIWE_AUTH_FAILED',
	+error: true,
	+payload: Error,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'RECORD_ALERT',
	+payload: RecordAlertActionPayload,
	}
	\| {
	+type: 'UPDATE_USER_AVATAR_STARTED',
	+payload: UpdateUserAvatarRequest,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'UPDATE_USER_AVATAR_SUCCESS',
	+payload: UpdateUserAvatarResponse,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'UPDATE_USER_AVATAR_FAILED',
	+error: true,
	+payload: Error,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'SEND_EDIT_MESSAGE_STARTED',
	+loadingInfo?: LoadingInfo,
	+payload?: void,
	}
	\| {
	+type: 'SEND_EDIT_MESSAGE_SUCCESS',
	+payload: EditMessagePayload,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'SEND_EDIT_MESSAGE_FAILED',
	+error: true,
	+payload: Error,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'TOGGLE_MESSAGE_PIN_STARTED',
	+loadingInfo?: LoadingInfo,
	+payload?: void,
	}
	\| {
	+type: 'TOGGLE_MESSAGE_PIN_SUCCESS',
	+payload: ToggleMessagePinResult,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'TOGGLE_MESSAGE_PIN_FAILED',
	+error: true,
	+payload: Error,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'FETCH_PINNED_MESSAGES_STARTED',
	+loadingInfo?: LoadingInfo,
	+payload?: void,
	}
	\| {
	+type: 'FETCH_PINNED_MESSAGES_SUCCESS',
	+payload: FetchPinnedMessagesResult,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'FETCH_PINNED_MESSAGES_FAILED',
	+error: true,
	+payload: Error,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'VERIFY_INVITE_LINK_STARTED',
	+loadingInfo?: LoadingInfo,
	+payload?: void,
	}
	\| {
	+type: 'VERIFY_INVITE_LINK_SUCCESS',
	+payload: InviteLinkVerificationResponse,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'VERIFY_INVITE_LINK_FAILED',
	+error: true,
	+payload: Error,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'FETCH_PRIMARY_INVITE_LINKS_STARTED',
	+loadingInfo?: LoadingInfo,
	+payload?: void,
	}
	\| {
	+type: 'FETCH_PRIMARY_INVITE_LINKS_SUCCESS',
	+payload: FetchInviteLinksResponse,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'FETCH_PRIMARY_INVITE_LINKS_FAILED',
	+error: true,
	+payload: Error,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'UPDATE_CALENDAR_COMMUNITY_FILTER',
	+payload: string,
	}
	\| {
	+type: 'CLEAR_CALENDAR_COMMUNITY_FILTER',
	+payload: void,
	}
	\| {
	+type: 'UPDATE_CHAT_COMMUNITY_FILTER',
	+payload: string,
	}
	\| {
	+type: 'CLEAR_CHAT_COMMUNITY_FILTER',
	+payload: void,
	}
	\| {
	+type: 'SEARCH_MESSAGES_STARTED',
	+payload: void,
	+loadingInfo?: LoadingInfo,
	}
	\| {
	+type: 'SEARCH_MESSAGES_SUCCESS',
	+payload: SearchMessagesResponse,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'SEARCH_MESSAGES_FAILED',
	+error: true,
	+payload: Error,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'CREATE_OR_UPDATE_PUBLIC_LINK_STARTED',
	+loadingInfo?: LoadingInfo,
	+payload?: void,
	}
	\| {
	+type: 'CREATE_OR_UPDATE_PUBLIC_LINK_SUCCESS',
	+payload: InviteLink,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'CREATE_OR_UPDATE_PUBLIC_LINK_FAILED',
	+error: true,
	+payload: Error,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'DISABLE_INVITE_LINK_STARTED',
	+loadingInfo?: LoadingInfo,
	+payload?: void,
	}
	\| {
	+type: 'DISABLE_INVITE_LINK_SUCCESS',
	+payload: DisableInviteLinkPayload,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'DISABLE_INVITE_LINK_FAILED',
	+error: true,
	+payload: Error,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'GET_OLM_SESSION_INITIALIZATION_DATA_STARTED',
	+loadingInfo?: LoadingInfo,
	+payload?: void,
	}
	\| {
	+type: 'GET_OLM_SESSION_INITIALIZATION_DATA_SUCCESS',
	+payload: GetOlmSessionInitializationDataResponse,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'GET_OLM_SESSION_INITIALIZATION_DATA_FAILED',
	+error: true,
	+payload: Error,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'SET_DATA_LOADED',
	+payload: {
	+dataLoaded: boolean,
	},
	}
	\| {
	+type: 'GET_VERSION_STARTED',
	+loadingInfo?: LoadingInfo,
	+payload?: void,
	}
	\| {
	+type: 'GET_VERSION_SUCCESS',
	+payload: GetVersionActionPayload,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'GET_VERSION_FAILED',
	+error: true,
	+payload: Error,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'UPDATE_LAST_COMMUNICATED_PLATFORM_DETAILS',
	+payload: LastCommunicatedPlatformDetails,
	}
	\| { +type: 'RESET_USER_STATE', +payload?: void }
	\| {
	+type: 'MODIFY_COMMUNITY_ROLE_STARTED',
	+loadingInfo?: LoadingInfo,
	+payload?: void,
	}
	\| {
	+type: 'MODIFY_COMMUNITY_ROLE_SUCCESS',
	+payload: RoleModificationPayload,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'MODIFY_COMMUNITY_ROLE_FAILED',
	+error: true,
	+payload: Error,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'DELETE_COMMUNITY_ROLE_STARTED',
	+loadingInfo?: LoadingInfo,
	+payload?: void,
	}
	\| {
	+type: 'DELETE_COMMUNITY_ROLE_SUCCESS',
	+payload: RoleDeletionPayload,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'DELETE_COMMUNITY_ROLE_FAILED',
	+error: true,
	+payload: Error,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'UPDATE_THREAD_LAST_NAVIGATED',
	+payload: { +threadID: string, +time: number },
	}
	\| {
	+type: 'UPDATE_INTEGRITY_STORE',
	+payload: {
	+threadIDsToHash?: $ReadOnlyArray<string>,
	+threadHashingStatus?: 'starting' \| 'running' \| 'completed',
	},
	}
	\| {
	+type: 'UPDATE_THEME_INFO',
	+payload: Partial<GlobalThemeInfo>,
	}
	\| {
	+type: 'ADD_KEYSERVER',
	+payload: AddKeyserverPayload,
	}
	\| {
	+type: 'REMOVE_KEYSERVER',
	+payload: RemoveKeyserverPayload,
	}
	\| {
	+type: 'SET_CUSTOM_SERVER',
	+payload: string,
	}
	\| {
	+type: 'SET_CONNECTION_ISSUE',
	+payload: { +connectionIssue: ?ConnectionIssue, +keyserverID: string },
	}
	\| {
	+type: 'ADD_COMMUNITY',
	+payload: AddCommunityPayload,
	}
	\| {
	+type: 'SET_SYNCED_METADATA_ENTRY',
	+payload: SetSyncedMetadataEntryPayload,
	}
	\| {
	+type: 'CLEAR_SYNCED_METADATA_ENTRY',
	+payload: ClearSyncedMetadataEntryPayload,
	}
	\| {
	+type: 'SET_ACTIVE_SESSION_RECOVERY',
	+payload: SetActiveSessionRecoveryPayload,
	}
	\| {
	+type: 'SET_AUX_USER_FIDS',
	+payload: SetAuxUserFIDsPayload,
	}
	\| {
	+type: 'ADD_AUX_USER_FIDS',
	+payload: AddAuxUserFIDsPayload,
	}
	\| {
	+type: 'CLEAR_AUX_USER_FIDS',
	+payload?: void,
	}
	\| {
	+type: 'REMOVE_PEER_USERS',
	+payload: RemovePeerUsersPayload,
	}
	\| {
	+type: 'SET_PEER_DEVICE_LISTS',
	+payload: SetPeerDeviceListsPayload,
	}
	\| {
	+type: 'OPS_PROCESSING_FINISHED_ACTION_TYPE',
	+payload?: void,
	}
	\| {
	+type: 'FETCH_COMMUNITY_INFOS_STARTED',
	+loadingInfo?: LoadingInfo,
	+payload?: void,
	}
	\| {
	+type: 'FETCH_COMMUNITY_INFOS_SUCCESS',
	+payload: FetchCommunityInfosResponse,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'FETCH_COMMUNITY_INFOS_FAILED',
	+error: true,
	+payload: Error,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'FETCH_ALL_COMMUNITY_INFOS_WITH_NAMES_STARTED',
	+loadingInfo?: LoadingInfo,
	+payload?: void,
	}
	\| {
	+type: 'FETCH_ALL_COMMUNITY_INFOS_WITH_NAMES_SUCCESS',
	- +payload: FetchAllCommunityInfosWithNamesResponse,
	+ +payload: ClientFetchAllCommunityInfosWithNamesResponse,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'FETCH_ALL_COMMUNITY_INFOS_WITH_NAMES_FAILED',
	+error: true,
	+payload: Error,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'CREATE_OR_UPDATE_FARCASTER_CHANNEL_TAG_STARTED',
	+loadingInfo?: LoadingInfo,
	+payload?: void,
	}
	\| {
	+type: 'CREATE_OR_UPDATE_FARCASTER_CHANNEL_TAG_SUCCESS',
	+payload: CreateOrUpdateFarcasterChannelTagResponse,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'CREATE_OR_UPDATE_FARCASTER_CHANNEL_TAG_FAILED',
	+error: true,
	+payload: Error,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'DELETE_FARCASTER_CHANNEL_TAG_STARTED',
	+loadingInfo?: LoadingInfo,
	+payload?: void,
	}
	\| {
	+type: 'DELETE_FARCASTER_CHANNEL_TAG_SUCCESS',
	+payload: DeleteFarcasterChannelTagPayload,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'DELETE_FARCASTER_CHANNEL_TAG_FAILED',
	+error: true,
	+payload: Error,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'PROCESS_NEW_USER_IDS',
	+payload: {
	+userIDs: $ReadOnlyArray<string>,
	},
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'FIND_USER_IDENTITIES_STARTED',
	+loadingInfo?: LoadingInfo,
	+payload?: void,
	}
	\| {
	+type: 'FIND_USER_IDENTITIES_SUCCESS',
	+payload: {
	+userInfos: $ReadOnlyArray<UserInfo>,
	},
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'FIND_USER_IDENTITIES_FAILED',
	+error: true,
	+payload: Error,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'VERSION_SUPPORTED_BY_IDENTITY_STARTED',
	+loadingInfo?: LoadingInfo,
	+payload?: void,
	}
	\| {
	+type: 'VERSION_SUPPORTED_BY_IDENTITY_SUCCESS',
	+payload: {
	+supported: boolean,
	},
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'VERSION_SUPPORTED_BY_IDENTITY_FAILED',
	+error: true,
	+payload: Error,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'FETCH_PENDING_UPDATES_STARTED',
	+loadingInfo?: LoadingInfo,
	+payload?: void,
	}
	\| {
	+type: 'FETCH_PENDING_UPDATES_SUCCESS',
	+payload: ClientStateSyncSocketResult,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'FETCH_PENDING_UPDATES_FAILED',
	+error: true,
	+payload: Error,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'SET_TB_DEVICE_TOKEN_STARTED',
	+loadingInfo?: LoadingInfo,
	+payload?: void,
	}
	\| {
	+type: 'SET_TB_DEVICE_TOKEN_SUCCESS',
	+payload: {
	+deviceToken: string,
	},
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'SET_TB_DEVICE_TOKEN_FAILED',
	+error: true,
	+payload: Error,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'PROCESS_DM_OPS',
	+payload: ProcessDMOpsPayload,
	}
	\| {
	+type: 'INVALIDATE_TUNNELBROKER_DEVICE_TOKEN',
	+payload: {
	+deviceToken: string,
	},
	}
	\| { +type: 'QUEUE_DM_OPS', +payload: QueueDMOpsPayload }
	\| { +type: 'PRUNE_DM_OPS_QUEUE', +payload: PruneDMOpsQueuePayload }
	\| {
	+type: 'CLEAR_QUEUED_THREAD_DM_OPS',
	+payload: ClearQueuedThreadDMOpsPayload,
	}
	\| {
	+type: 'CLEAR_QUEUED_MESSAGE_DM_OPS',
	+payload: ClearQueuedMessageDMOpsPayload,
	}
	\| {
	+type: 'CLEAR_QUEUED_ENTRY_DM_OPS',
	+payload: ClearQueuedEntryDMOpsPayload,
	}
	\| {
	+type: 'CLEAR_QUEUED_MEMBERSHIP_DM_OPS',
	+payload: ClearQueuedMembershipDMOpsPayload,
	}
	\| {
	+type: 'STORE_ESTABLISHED_HOLDER',
	+payload: BlobHashAndHolder,
	}
	\| {
	+type: 'PROCESS_HOLDERS_STARTED',
	+payload: ProcessHoldersStartedPayload,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'PROCESS_HOLDERS_FAILED',
	+error: true,
	+payload: Error & ProcessHoldersFailedPayload,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'PROCESS_HOLDERS_SUCCESS',
	+payload: ProcessHoldersFinishedPayload,
	+loadingInfo: LoadingInfo,
	}
	\| {
	+type: 'SET_MISSING_DEVICE_LISTS',
	+payload: SetMissingDeviceListsPayload,
	},
	}>;

	export type ActionPayload = ?(Object \| Array<> \| $ReadOnlyArray<> \| string);
	export type DispatchSource = 'tunnelbroker' \| 'tab-sync';
	// Data added when dispatching action as a result of message received
	// from other peer. It is used to send processing confirmation.
	export type InboundActionMetadata = {
	+messageID: string,
	+senderDeviceID: string,
	};
	// Data added when dispatching action triggered locally, used to resolve
	// promise associated with sending messages and track failed messages.
	export type OutboundActionMetadata = {
	+dmOpID: string,
	};
	export type DispatchMetadata = InboundActionMetadata \| OutboundActionMetadata;
	export type SuperAction = {
	+type: string,
	+payload?: ActionPayload,
	+loadingInfo?: LoadingInfo,
	+error?: boolean,
	+dispatchSource?: DispatchSource,
	+dispatchMetadata?: DispatchMetadata,
	};
	type ThunkedAction = (dispatch: Dispatch) => void;
	export type PromisedAction = (dispatch: Dispatch) => Promise<void>;
	export type Dispatch = ((promisedAction: PromisedAction) => Promise<void>) &
	((thunkedAction: ThunkedAction) => void) &
	((action: SuperAction) => boolean);

	// This is lifted from redux-persist/lib/constants.js
	// I don't want to add redux-persist to the web/server bundles...
	// import { REHYDRATE } from 'redux-persist';
	export const rehydrateActionType = 'persist/REHYDRATE';
	diff --git a/lib/types/validators/community-validators.js b/lib/types/validators/community-validators.js
	index 2c7507f4b..2ca39cf56 100644
	--- a/lib/types/validators/community-validators.js
	+++ b/lib/types/validators/community-validators.js
	@@ -1,28 +1,28 @@
	// @flow

	import t, { type TInterface } from 'tcomb';

	import { tShape } from '../../utils/validation-utils.js';
	import {
	serverCommunityInfoValidator,
	- serverCommunityInfoWithCommunityNameValidator,
	+ clientCommunityInfoWithCommunityNameValidator,
	type FetchCommunityInfosResponse,
	- type FetchAllCommunityInfosWithNamesResponse,
	+ type ClientFetchAllCommunityInfosWithNamesResponse,
	} from '../community-types.js';

	const fetchCommunityInfosResponseValidator: TInterface<FetchCommunityInfosResponse> =
	tShape({
	communityInfos: t.list(serverCommunityInfoValidator),
	});

	-const fetchAllCommunityInfosWithNamesResponseValidator: TInterface<FetchAllCommunityInfosWithNamesResponse> =
	+const fetchAllCommunityInfosWithNamesResponseValidator: TInterface<ClientFetchAllCommunityInfosWithNamesResponse> =
	tShape({
	allCommunityInfosWithNames: t.list(
	- serverCommunityInfoWithCommunityNameValidator,
	+ clientCommunityInfoWithCommunityNameValidator,
	),
	});

	export {
	fetchCommunityInfosResponseValidator,
	fetchAllCommunityInfosWithNamesResponseValidator,
	};

File Metadata

Mime Type: text/x-diff
Expires: Sat, Nov 23, 1:02 AM (1 d, 20 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 2553837
Default Alt Text: (62 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions