@tribe-nest/forge 3.58.0 → 3.60.0

package/src/data/queries/useMembershipCalls.ts

@@ -1,12 +1,14 @@
 import { useQuery } from "@tanstack/react-query";
+import type { AxiosInstance } from "axios";
 import { useForge } from "../../provider/ForgeProvider";
+import { MissingCommunityProviderError, useOptionalCommunityContext } from "../../contexts/CommunityContext";
 
 /**
  * The viewer's own call calendar (`GET /public/scheduled-calls/mine`).
  *
  * Lives in Forge rather than in either app because BOTH rendering surfaces need
- * exactly this - the site-starter's `/i/members/calendar` and the client app's
- * `/i/members/calendar`, and now the classroom and cohort pages on both - and a
+ * exactly this - every community's calendar tab and the classroom and cohort
+ * pages - and a
  * second copy is how the two drift, as `useMyTickets` and `useMyBookings`
  * already document.
  *
@@ -37,6 +39,90 @@ import { useForge } from "../../provider/ForgeProvider";
 
 export type MembershipCallParticipation = "open" | "host_only";
 
+/** One speaker turn. Times are ms from the start of the recording, so they seek the video. */
+export interface MemberCallTranscriptSegment {
+  name: string;
+  startMs: number;
+  endMs: number;
+  text: string;
+}
+
+/**
+ * A recorded call's transcript, as a member sees it: the finished thing, or
+ * that it is being prepared. Never a failure: the member is shown nothing at
+ * all rather than a reason that is the business's to deal with. Null on the
+ * recording when there is nothing to show.
+ */
+export type MemberCallTranscript =
+  | { status: "processing" }
+  | {
+      status: "ready";
+      /** Null when the summary could not be written; the transcript still stands. */
+      summary: MemberCallTranscriptSummary | null;
+    };
+
+export interface MemberCallTranscriptSummary {
+  title: string;
+  summary: string;
+  decisions: string[];
+  actionItems: string[];
+}
+
+/**
+ * One finished transcript with every line. NOT on the calendar payload: a
+ * two-hour meeting is thousands of lines, so they are read one transcript at a
+ * time, when a member opens it or downloads it.
+ */
+export interface MemberCallTranscriptDetail {
+  recordingId: string;
+  callId: string;
+  title: string;
+  startsAt: string;
+  timezone: string | null;
+  durationSeconds: number | null;
+  /** Signed for SIXTY seconds. Refetch for a fresh one when playback fails. */
+  watchUrl: string | null;
+  transcript: {
+    status: "ready";
+    language: string | null;
+    segments: MemberCallTranscriptSegment[];
+    summary: MemberCallTranscriptSummary | null;
+  };
+}
+
+export const memberCallTranscriptKey = (profileId: string | undefined, recordingId: string) =>
+  ["membership-calls", "transcript", profileId, recordingId] as const;
+
+/** Read one transcript. Shared by the viewer and by Download, so both hit one cache entry. */
+export const fetchMemberCallTranscript = async (
+  client: AxiosInstance,
+  profileId: string | undefined,
+  recordingId: string,
+): Promise<MemberCallTranscriptDetail> => {
+  const res = await client.get(`/public/scheduled-calls/mine/recordings/${recordingId}/transcript`, {
+    params: { profileId },
+  });
+  return res.data as MemberCallTranscriptDetail;
+};
+
+/**
+ * One recording's transcript and a fresh video address, for the viewer.
+ *
+ * Never refetched in the background: the lines do not change, and a refetch
+ * would swap the video address under a playing player. The viewer refetches on
+ * purpose when the sixty-second address lapses.
+ */
+export function useMemberCallTranscript(recordingId: string | null) {
+  const { client, profileId } = useForge();
+  return useQuery<MemberCallTranscriptDetail>({
+    queryKey: memberCallTranscriptKey(profileId, recordingId ?? ""),
+    queryFn: () => fetchMemberCallTranscript(client, profileId, recordingId!),
+    enabled: !!profileId && !!client && !!recordingId,
+    staleTime: Infinity,
+    refetchOnWindowFocus: false,
+  });
+}
+
 export interface MyMembershipCall {
   id: string;
   title: string;
@@ -84,6 +170,8 @@ export interface MyMembershipCall {
     durationSeconds: number | null;
     /** Signed per request and short-lived. Null while `processing`. */
     watchUrl: string | null;
+    /** Who said what, and a summary. Same access rule as the video. */
+    transcript: MemberCallTranscript | null;
   } | null;
 }
 
@@ -91,6 +179,21 @@ export const membershipCallKeys = {
   mine: (profileId: string | undefined) => ["membership-calls", "mine", profileId] as const,
 };
 
+/**
+ * The community a call read is scoped to, or null for a course or cohort scope.
+ *
+ * A community calendar must come from `<CommunityProvider>`: a fan in two
+ * communities must never see one's calls on the other's calendar. A course or
+ * cohort scope names its own audience and belongs to no community, so it needs
+ * no provider. Anything else is a developer error, and it throws.
+ */
+function useCallScopeCommunity(hookName: string, courseScoped: boolean): string | null | undefined {
+  const community = useOptionalCommunityContext();
+  if (courseScoped) return null;
+  if (!community) throw new MissingCommunityProviderError(hookName);
+  return community.communityId;
+}
+
 /**
  * @param options.from Inclusive lower bound. Absent means "from now on", which is
  * what a caller wanting only the next few calls sends.
@@ -121,6 +224,8 @@ export function useMyMembershipCalls(options?: {
   const to = options?.to?.toISOString();
   const courseId = options?.courseId || undefined;
   const cohortId = options?.cohortId || undefined;
+  // null = a course or cohort scope; a string = this community; undefined = still resolving.
+  const communityId = useCallScopeCommunity("useMyMembershipCalls()", !!(courseId || cohortId));
   return useQuery<MyMembershipCall[]>({
     // The WINDOW is part of the key: paging back a month is a different question
     // with a different answer, and sharing one cache entry would show February's
@@ -134,14 +239,15 @@ export function useMyMembershipCalls(options?: {
       to ?? "open",
       courseId ?? "any-course",
       cohortId ?? "any-cohort",
+      communityId ?? "no-community",
     ],
     queryFn: async () => {
       const res = await client.get("/public/scheduled-calls/mine", {
-        params: { profileId, from, to, limit: options?.limit, courseId, cohortId },
+        params: { profileId, from, to, limit: options?.limit, courseId, cohortId, communityId: communityId ?? undefined },
       });
       return res.data;
     },
-    enabled: !!profileId && !!client && options?.enabled !== false,
+    enabled: !!profileId && !!client && communityId !== undefined && options?.enabled !== false,
     /**
      * A call opens fifteen minutes before it starts, and the member watching
      * this page is waiting for exactly that. Without a refetch the Join button
@@ -175,19 +281,22 @@ export interface MyMembershipCallRecording {
    * for long. Null while `status` is `processing`.
    */
   watchUrl: string | null;
+  /** Who said what, and a summary. Same access rule as the video. */
+  transcript: MemberCallTranscript | null;
 }
 
 export function useMyMembershipCallRecordings(options?: { limit?: number; enabled?: boolean }) {
   const { client, profileId } = useForge();
+  const communityId = useCallScopeCommunity("useMyMembershipCallRecordings()", false);
   return useQuery<MyMembershipCallRecording[]>({
-    queryKey: ["membership-calls", "recordings", profileId],
+    queryKey: ["membership-calls", "recordings", profileId, communityId],
     queryFn: async () => {
       const res = await client.get("/public/scheduled-calls/mine/recordings", {
-        params: { profileId, limit: options?.limit },
+        params: { profileId, communityId, limit: options?.limit },
       });
       return res.data;
     },
-    enabled: !!profileId && !!client && options?.enabled !== false,
+    enabled: !!profileId && !!communityId && !!client && options?.enabled !== false,
     /**
      * Slower than the upcoming list: nothing here changes on a fifteen-minute
      * boundary, and the only transition worth catching is `processing` ->

package/src/data/queries/usePostCollections.ts

@@ -1,5 +1,5 @@
 import type { IPublicPostCollection, PaginatedData } from "../../types/models";
-import { useForge } from "../../provider/ForgeProvider";
+import { useCommunityScope } from "../../contexts/CommunityContext";
 import { useQuery } from "@tanstack/react-query";
 
 export interface GetPostCollectionsParams {
@@ -8,14 +8,15 @@ export interface GetPostCollectionsParams {
 }
 
 export function useGetPostCollections(params?: GetPostCollectionsParams) {
-  const { client, profileId } = useForge();
+  const { client, profileId, communityId } = useCommunityScope("useGetPostCollections()");
 
   return useQuery<PaginatedData<IPublicPostCollection>>({
-    queryKey: ["post-collections", profileId, params],
+    queryKey: ["post-collections", communityId, params],
     queryFn: async () => {
       const res = await client.get("/public/post-collections", {
         params: {
-          profileId: profileId,
+          profileId,
+          communityId,
           page: params?.page || 1,
           limit: 10,
           filter: {
@@ -25,24 +26,35 @@ export function useGetPostCollections(params?: GetPostCollectionsParams) {
       });
       return res.data;
     },
-    enabled: !!profileId && !!client,
+    enabled: !!profileId && !!communityId && !!client,
   });
 }
 
+/**
+ * One collection, by id or slug. A collection that is missing, archived or in
+ * another community answers 404, which is an ANSWER, not a failure: this
+ * resolves `null` for it (and does not retry), so a page can say "not found"
+ * rather than falling over.
+ */
 export function useGetPostCollection(collectionId?: string) {
-  const { client, profileId } = useForge();
+  const { client, profileId, communityId } = useCommunityScope("useGetPostCollection()");
 
-  return useQuery<IPublicPostCollection>({
-    queryKey: ["post-collection", profileId, collectionId],
+  return useQuery<IPublicPostCollection | null>({
+    queryKey: ["post-collection", communityId, collectionId],
     queryFn: async () => {
-      const res = await client.get(`/public/post-collections/${collectionId}`, {
-        params: {
-          profileId: profileId,
-        },
-      });
-      return res.data;
+      try {
+        const res = await client.get(`/public/post-collections/${collectionId}`, {
+          params: {
+            profileId,
+            communityId,
+          },
+        });
+        return res.data ?? null;
+      } catch (error) {
+        if ((error as { response?: { status?: number } })?.response?.status === 404) return null;
+        throw error;
+      }
     },
-    enabled: !!profileId && !!client && !!collectionId,
+    enabled: !!profileId && !!communityId && !!client && !!collectionId,
   });
 }
-

package/src/data/queries/usePosts.ts

@@ -1,5 +1,5 @@
 import type { IPublicPost, PaginatedData } from "../../types/models";
-import { useForge } from "../../provider/ForgeProvider";
+import { useCommunityScope } from "../../contexts/CommunityContext";
 import { useInfiniteQuery, useQuery } from "@tanstack/react-query";
 
 export interface GetPostsParams {
@@ -10,14 +10,15 @@ export interface GetPostsParams {
 }
 
 export function useGetPosts(params?: GetPostsParams) {
-  const { client, profileId } = useForge();
+  const { client, profileId, communityId } = useCommunityScope("useGetPosts()");
 
   return useQuery<PaginatedData<IPublicPost>>({
-    queryKey: ["posts", profileId, params],
+    queryKey: ["posts", communityId, params],
     queryFn: async () => {
       const res = await client.get("/public/posts", {
         params: {
-          profileId: profileId,
+          profileId,
+          communityId,
           page: params?.page || 1,
           limit: 10,
           filter: {
@@ -29,7 +30,7 @@ export function useGetPosts(params?: GetPostsParams) {
       });
       return res.data;
     },
-    enabled: !!profileId && !!client,
+    enabled: !!profileId && !!communityId && !!client,
   });
 }
 
@@ -46,19 +47,20 @@ export interface GetPostsInfiniteParams {
  * ships media for locked posts, so paging is safe for any auth state.
  */
 export function useGetPostsInfinite(params?: GetPostsInfiniteParams) {
-  const { client, profileId } = useForge();
+  const { client, profileId, communityId } = useCommunityScope("useGetPostsInfinite()");
   const limit = params?.pageSize ?? 10;
 
   return useInfiniteQuery<PaginatedData<IPublicPost>>({
     queryKey: [
       "posts-infinite",
-      profileId,
+      communityId,
       { query: params?.query, type: params?.type, membershipTierId: params?.membershipTierId, limit },
     ],
     queryFn: async ({ pageParam = 1 }) => {
       const res = await client.get("/public/posts", {
         params: {
-          profileId: profileId,
+          profileId,
+          communityId,
           page: pageParam,
           limit,
           filter: {
@@ -72,23 +74,23 @@ export function useGetPostsInfinite(params?: GetPostsInfiniteParams) {
     },
     initialPageParam: 1,
     getNextPageParam: (lastPage) => (lastPage.hasNextPage ? (lastPage.nextPage ?? lastPage.page + 1) : undefined),
-    enabled: !!profileId && !!client,
+    enabled: !!profileId && !!communityId && !!client,
   });
 }
 
 /**
- * The member's saved posts (GET /public/posts/saved — requires auth). The
+ * The member's saved posts (GET /public/posts/saved: requires auth). The
  * endpoint returns a single `{ data, total }` page.
  */
 export function useGetSavedPosts(enabled = true) {
-  const { client, profileId } = useForge();
+  const { client, profileId, communityId } = useCommunityScope("useGetSavedPosts()");
 
   return useQuery<{ data: IPublicPost[]; total: number }>({
-    queryKey: ["posts-saved", profileId],
+    queryKey: ["posts-saved", communityId],
     queryFn: async () => {
-      const res = await client.get("/public/posts/saved", { params: { profileId } });
+      const res = await client.get("/public/posts/saved", { params: { profileId, communityId } });
       return res.data;
     },
-    enabled: !!profileId && !!client && enabled,
+    enabled: !!profileId && !!communityId && !!client && enabled,
   });
 }

package/src/data/queries/useSubscriptions.ts

@@ -1,4 +1,5 @@
 import { useForge } from "../../provider/ForgeProvider";
+import { useOptionalCommunityContext } from "../../contexts/CommunityContext";
 import { useMutation } from "@tanstack/react-query";
 import { usePublicAuth } from "../../contexts/PublicAuthContext";
 import type { QuestionnaireAnswer } from "../../types/models";
@@ -20,6 +21,8 @@ export type CreateSubscriptionInput = {
    * invite must be for the signed-in email); ignored on an open tier.
    */
   inviteToken?: string;
+  /** A shareable invite link token (`?join=`); opens an invite-only tier, still charges a paid one. */
+  joinToken?: string;
   /** Answers to the tier's questions. Required by the server when the tier has any. */
   questionnaire?: QuestionnaireAnswer[];
 };
@@ -55,6 +58,8 @@ export type CreateSubscriptionResult = {
    * charged today, and the first charge is on `endsAt`.
    */
   trial?: { days: number; endsAt: string } | null;
+  /** The slug of the community the tier belongs to, so the caller can land the fan inside it. */
+  communitySlug?: string;
 };
 
 /** Subscribe to a paid tier, or move an existing subscription onto another one. */
@@ -73,10 +78,12 @@ export function useCreateSubscription() {
 export function useCreateFreeSubscription() {
   const { client, profileId } = useForge();
 
-  return useMutation<unknown, unknown, {
+  return useMutation<{ communitySlug?: string } | undefined, unknown, {
       membershipTierId: string;
       attributionRefId?: string;
       inviteToken?: string;
+      /** A shareable invite link token (`?join=`). */
+      joinToken?: string;
       /** Answers to the tier's questions. Required by the server when the tier has any. */
       questionnaire?: QuestionnaireAnswer[];
     }>({
@@ -89,7 +96,7 @@ export function useCreateFreeSubscription() {
 
 export type CancelMembershipResult = {
   membershipId: string;
-  /** The status AFTER cancelling — still `active` while a paid period runs out. */
+  /** The status AFTER cancelling: still `active` while a paid period runs out. */
   status: string;
   /** True when the cancellation was scheduled rather than applied immediately. */
   cancelAtPeriodEnd: boolean;
@@ -104,7 +111,7 @@ export type CancelMembershipResult = {
  * schedules it for the end of the period they have already paid for and the
  * member keeps their benefits until `accessUntil`. Free tiers (and any
  * membership with nothing paid up) end immediately. Works for every membership
- * the member can still use — including one whose card is failing, which used to
+ * the member can still use: including one whose card is failing, which used to
  * be rejected with an error the UI never showed.
  */
 export function useCancelMembership() {
@@ -126,7 +133,7 @@ export function useCancelMembership() {
  *
  * Every membership-aware surface should use this instead of reading
  * `user.membership.status`. `access` answers "can they see it", `message`
- * answers "what do we tell them" — two different questions, and conflating
+ * answers "what do we tell them": two different questions, and conflating
  * them is what locked past_due members out while calling them "Cancelled".
  */
 export function useMembershipAccess(): {
@@ -143,12 +150,12 @@ export function useMembershipAccess(): {
  *
  * This is the other half of keeping access through `past_due`: the grace window
  * is only a recovery window if the member can actually fix their card inside
- * it. Nothing about the caller is sent — the server derives the provider
+ * it. Nothing about the caller is sent: the server derives the provider
  * customer from the session, because a customer id in a request body is a
  * cross-tenant leak waiting to happen.
  *
  * `returnUrl` defaults to the current page so the member lands back where they
- * were. The returned `url` is a one-time link — redirect, never render it.
+ * were. The returned `url` is a one-time link: redirect, never render it.
  */
 export function useOpenBillingPortal() {
   const { client, profileId } = useForge();
@@ -170,14 +177,21 @@ export function useOpenBillingPortal() {
 /**
  * Reconcile the most recent subscription after a checkout return.
  * Returns the latest subscription status (e.g. "active").
+ *
+ * A fan can subscribe in several communities of one creator, so "the latest"
+ * is the latest IN A COMMUNITY: pass `communityId`, or it is read from the
+ * surrounding `<CommunityProvider>`.
  */
 export function useConfirmLatestSubscription() {
   const { client, profileId } = useForge();
+  const contextCommunityId = useOptionalCommunityContext()?.communityId;
 
-  return useMutation<{ status: string }, unknown, void>({
-    mutationFn: async () => {
+  return useMutation<{ status: string }, unknown, { communityId?: string } | void>({
+    mutationFn: async (input) => {
+      const communityId = (input && input.communityId) || contextCommunityId;
       const res = await client.post("/public/payments/subscriptions/confirm-latest", {
         profileId,
+        ...(communityId ? { communityId } : {}),
       });
       return res.data;
     },

package/src/i18n/de.json

@@ -655,6 +655,118 @@
   "forge.cohort_page.date_range": "{start} bis {end}",
   "forge.cohort_page.date_tbd": "Noch offen",
   "forge.cohort_page.not_found": "Kohorte nicht gefunden.",
+  "forge.communities_list.empty": "Es gibt noch keine Communitys zum Beitreten.",
+  "forge.communities_list.heading": "Communitys",
+  "forge.communities_list.member_count": "{count} Mitglieder",
+  "forge.community_about.apply": "Beitritt beantragen",
+  "forge.community_about.current_tier": "Deine aktuelle Stufe",
+  "forge.community_about.go_inside": "Zur Community",
+  "forge.community_about.join": "Beitreten",
+  "forge.community_about.join_free": "Kostenlos beitreten",
+  "forge.community_about.join_from": "Beitreten ab {amount}/Monat",
+  "forge.community_about.join_from_yearly": "Beitreten ab {amount}/Jahr",
+  "forge.community_about.join_tier": "Beitreten",
+  "forge.community_about.member_count": "{count} Mitglieder",
+  "forge.community_about.not_found": "Diese Community wurde nicht gefunden.",
+  "forge.community_about.pending": "Dein Antrag wird geprüft.",
+  "forge.community_about.tiers_title": "Mitgliedschaftsstufen",
+  "forge.community_about.view_application": "Deinen Antrag ansehen",
+  "forge.community_home.confirming": "Deine Mitgliedschaft wird bestätigt...",
+  "forge.community_home.dismiss": "Schließen",
+  "forge.community_home.join": "Beitreten",
+  "forge.community_home.membership": "Mitgliedschaft",
+  "forge.community_home.not_found": "Diese Community wurde nicht gefunden.",
+  "forge.community_home.upgrade": "Upgrade",
+  "forge.community_home.welcome": "Willkommen bei {community_name}!",
+  "forge.community_join_sheet.accept_terms": "Ich akzeptiere die AGB und die Datenschutzerklärung",
+  "forge.community_join_sheet.already_member": "Du bist bereits Mitglied.",
+  "forge.community_join_sheet.amount_below_minimum": "Der Mindestbetrag ist {minimum}.",
+  "forge.community_join_sheet.amount_label": "Wähle deinen Betrag (mindestens {minimum})",
+  "forge.community_join_sheet.amount_not_positive": "Gib einen Betrag über null ein.",
+  "forge.community_join_sheet.answer_required": "Bitte beantworte: {question}",
+  "forge.community_join_sheet.apply": "Beitritt beantragen",
+  "forge.community_join_sheet.aria_close": "Schließen",
+  "forge.community_join_sheet.back": "Zurück",
+  "forge.community_join_sheet.billing_cycle": "Abrechnungszeitraum",
+  "forge.community_join_sheet.card_application": "Karte für deinen Antrag hinterlegen",
+  "forge.community_join_sheet.card_application_help": "Deine Karte wird gespeichert, nicht belastet. Sie wird nur belastet, wenn dein Antrag angenommen wird.",
+  "forge.community_join_sheet.card_application_help_label": "Wann wird meine Karte belastet?",
+  "forge.community_join_sheet.card_payment": "{amount} bezahlen",
+  "forge.community_join_sheet.card_trial": "Karte hinterlegen und kostenlose Testphase starten",
+  "forge.community_join_sheet.change_tier": "Stufe wechseln",
+  "forge.community_join_sheet.choose_tier": "Wähle eine Stufe",
+  "forge.community_join_sheet.code": "6-stelliger Code",
+  "forge.community_join_sheet.code_sent": "Wir haben einen 6-stelligen Code an {email} gesendet.",
+  "forge.community_join_sheet.continue": "Weiter",
+  "forge.community_join_sheet.email": "E-Mail",
+  "forge.community_join_sheet.email_mismatch": "Diese Einladung gilt für {email}. Du bist als {signed_in_email} angemeldet.",
+  "forge.community_join_sheet.first_name": "Vorname",
+  "forge.community_join_sheet.invite_expired": "Diese Einladung ist abgelaufen. Du kannst unten trotzdem beitreten.",
+  "forge.community_join_sheet.invite_not_found": "Dieser Einladungslink ist ungültig. Du kannst unten trotzdem beitreten.",
+  "forge.community_join_sheet.invite_revoked": "Diese Einladung wurde zurückgezogen. Du kannst unten trotzdem beitreten.",
+  "forge.community_join_sheet.invite_used": "Diese Einladung wurde bereits verwendet. Du kannst unten trotzdem beitreten.",
+  "forge.community_join_sheet.invite_used_up": "Für diesen Einladungslink sind keine Plätze mehr frei. Du kannst unten trotzdem beitreten.",
+  "forge.community_join_sheet.join_for": "Für {amount} beitreten",
+  "forge.community_join_sheet.join_free": "Kostenlos beitreten",
+  "forge.community_join_sheet.joined_title": "Du bist dabei!",
+  "forge.community_join_sheet.joining": "Beitritt läuft...",
+  "forge.community_join_sheet.last_name": "Nachname",
+  "forge.community_join_sheet.mode_signin": "Anmelden",
+  "forge.community_join_sheet.mode_signup": "Konto erstellen",
+  "forge.community_join_sheet.monthly": "Monatlich",
+  "forge.community_join_sheet.monthly_price": "Monatlich, {amount}",
+  "forge.community_join_sheet.password": "Passwort",
+  "forge.community_join_sheet.pay": "{amount} bezahlen",
+  "forge.community_join_sheet.pending_body": "Dein Antrag wird geprüft. Wir melden uns, sobald entschieden ist.",
+  "forge.community_join_sheet.pending_title": "Antrag gesendet",
+  "forge.community_join_sheet.resend": "Code erneut senden",
+  "forge.community_join_sheet.select_placeholder": "Auswählen...",
+  "forge.community_join_sheet.sign_in_as": "Als {email} anmelden",
+  "forge.community_join_sheet.start_trial": "Kostenlose Testphase starten",
+  "forge.community_join_sheet.taking_you_inside": "Wir bringen dich hinein...",
+  "forge.community_join_sheet.title": "{community_name} beitreten",
+  "forge.community_join_sheet.title_plain": "Beitreten",
+  "forge.community_join_sheet.trial_line": "{days} Tage kostenlos testen, erste Abbuchung am {date}",
+  "forge.community_join_sheet.verify": "Bestätigen",
+  "forge.community_join_sheet.working": "Bitte warten...",
+  "forge.community_join_sheet.yearly": "Jährlich",
+  "forge.community_join_sheet.yearly_price": "Jährlich, {amount}",
+  "forge.community_membership_menu.aria_close": "Schließen",
+  "forge.community_membership_menu.cancel": "Mitgliedschaft kündigen",
+  "forge.community_membership_menu.cancel_confirm": "Mitgliedschaft kündigen",
+  "forge.community_membership_menu.cancel_confirm_now": "Deine Mitgliedschaft endet sofort.",
+  "forge.community_membership_menu.cancel_confirm_title": "Mitgliedschaft kündigen?",
+  "forge.community_membership_menu.cancel_confirm_until": "Du behältst den Zugang bis {date}. Sie wird nicht verlängert.",
+  "forge.community_membership_menu.cancel_keep": "Mitgliedschaft behalten",
+  "forge.community_membership_menu.downgrade_to": "Zur Verlängerung zu {tier_name} wechseln",
+  "forge.community_membership_menu.ending": "Endet",
+  "forge.community_membership_menu.ends_on": "Endet am {date}",
+  "forge.community_membership_menu.payment_failed": "Zahlung fehlgeschlagen",
+  "forge.community_membership_menu.pending_downgrade": "Wechsel zu {tier_name} am {date}.",
+  "forge.community_membership_menu.renews_on": "Verlängert sich am {date}",
+  "forge.community_membership_menu.title": "Deine Mitgliedschaft",
+  "forge.community_membership_menu.trigger": "Mitgliedschaft",
+  "forge.community_membership_menu.undo_downgrade": "Aktuelle Stufe behalten",
+  "forge.community_membership_menu.update_card": "Zahlungsmethode aktualisieren",
+  "forge.community_membership_menu.upgrade": "Upgrade",
+  "forge.community_pending.body": "Dein Antrag wird geprüft. Du erhältst Zugang, sobald er angenommen ist.",
+  "forge.community_pending.body_since": "Du hast am {date} beantragt. Du erhältst Zugang, sobald der Antrag angenommen ist.",
+  "forge.community_pending.title": "Dein Antrag wird geprüft",
+  "forge.community_upgrade_sheet.aria_close": "Schließen",
+  "forge.community_upgrade_sheet.back": "Zurück",
+  "forge.community_upgrade_sheet.charge_now": "Du zahlst jetzt {amount}.",
+  "forge.community_upgrade_sheet.charge_prorated": "Du zahlst jetzt {amount} für den Rest dieses Zeitraums.",
+  "forge.community_upgrade_sheet.confirm": "Jetzt upgraden",
+  "forge.community_upgrade_sheet.continue_to_card": "Weiter zur Karte",
+  "forge.community_upgrade_sheet.current": "Du bist auf {tier_name}.",
+  "forge.community_upgrade_sheet.done": "Upgrade abgeschlossen!",
+  "forge.community_upgrade_sheet.none": "Du bist bereits auf der höchsten Stufe.",
+  "forge.community_upgrade_sheet.pay": "Bezahlen und upgraden",
+  "forge.community_upgrade_sheet.price_monthly": "{amount}/Monat",
+  "forge.community_upgrade_sheet.price_yearly": "{amount}/Jahr",
+  "forge.community_upgrade_sheet.requires_card": "Beim Upgrade gibst du deine Karte erneut ein und dein aktuelles Abo wird ersetzt.",
+  "forge.community_upgrade_sheet.title": "Upgrade",
+  "forge.community_upgrade_sheet.unlock_with": "Mit {tier_name} freischalten",
   "forge.confirm_subscription.back_to_site": "Zurück zur Seite",
   "forge.confirm_subscription.expired_body": "Dieser Bestätigungslink gilt nicht mehr. Melde dich einfach noch einmal an.",
   "forge.confirm_subscription.expired_title": "Link abgelaufen",
@@ -1167,6 +1279,19 @@
   "forge.login_form.verify_submit": "Bestätigen & anmelden",
   "forge.login_form.verify_title": "Bestätige deine E-Mail",
   "forge.login_form.verifying": "Wird geprüft…",
+  "forge.member_home_layout.nav_label": "Community",
+  "forge.member_home_layout.tab_calendar": "Kalender",
+  "forge.member_home_layout.tab_chat": "Chat",
+  "forge.member_home_layout.tab_collections": "Sammlungen",
+  "forge.member_home_layout.tab_leaderboard": "Bestenliste",
+  "forge.member_home_layout.tab_notifications": "Benachrichtigungen",
+  "forge.member_home_layout.tab_posts": "Beiträge",
+  "forge.member_home_layout.tab_spaces": "Bereiche",
+  "forge.member_post_card.locked_body": "Tritt bei, um diesen Inhalt zu sehen",
+  "forge.member_post_card.locked_body_tier": "Mit {tier_name} freischalten, um diesen Inhalt zu sehen",
+  "forge.member_post_card.locked_title": "Inhalt gesperrt",
+  "forge.member_post_card.unlock": "Freischalten",
+  "forge.member_post_card.unlock_with": "Mit {tier_name} freischalten",
   "forge.membership_checkout.accept_invite": "Einladung annehmen",
   "forge.membership_checkout.amount_below_minimum": "Bitte {minimum} oder mehr eingeben.",
   "forge.membership_checkout.amount_not_positive": "Bitte einen Betrag größer als null eingeben.",
@@ -1203,7 +1328,7 @@
   "forge.membership_checkout.empty_title": "Keine Mitgliedschaften verfügbar",
   "forge.membership_checkout.field_required": "Dieses Feld ist erforderlich",
   "forge.membership_checkout.free": "Kostenlos",
-  "forge.membership_checkout.go_to_account": "Zu deinem Konto",
+  "forge.membership_checkout.go_to_community": "Zur Community",
   "forge.membership_checkout.invite_dead_body": "Sie ist vielleicht abgelaufen, wurde schon verwendet oder durch eine neuere Einladung ersetzt. Frag uns nach einer neuen.",
   "forge.membership_checkout.invite_dead_title": "Diese Einladung ist nicht mehr gültig",
   "forge.membership_checkout.invite_email_mismatch": "Du bist als {signed_in_email} angemeldet. Melde dich mit {email} an, um diese Einladung anzunehmen.",
@@ -1235,6 +1360,7 @@
   "forge.membership_tier_callout.invite_for_email": "Diese Einladung gilt für {email}. Melde dich mit dieser Adresse an oder erstelle damit ein Konto.",
   "forge.membership_tier_callout.join_title": "{tier_name} beitreten",
   "forge.membership_tier_callout.more_benefits": "+{count} weitere Vorteile",
+  "forge.membership_tier_callout.view_community": "Teil von {community_name}",
   "forge.membership_tiers.accept_invite": "Einladung annehmen",
   "forge.membership_tiers.application_approved": "Angenommen, wird eingerichtet",
   "forge.membership_tiers.application_declined": "Nicht angenommen",
@@ -1255,6 +1381,14 @@
   "forge.membership_tiers.withdraw": "Bewerbung zurückziehen",
   "forge.membership_tiers.withdraw_error": "Wir konnten deine Bewerbung nicht zurückziehen. Bitte versuche es erneut.",
   "forge.membership_tiers.withdrawing": "Wird zurückgezogen…",
+  "forge.my_memberships_list.cycle_month": "Monat",
+  "forge.my_memberships_list.cycle_year": "Jahr",
+  "forge.my_memberships_list.empty": "Du bist noch in keiner Community Mitglied.",
+  "forge.my_memberships_list.ends_on": "Endet am {date}",
+  "forge.my_memberships_list.open": "Community öffnen",
+  "forge.my_memberships_list.price": "{amount} pro {cycle}",
+  "forge.my_memberships_list.renews_on": "Verlängert sich am {date}",
+  "forge.my_memberships_list.trial_until": "Kostenlose Testphase bis {date}",
   "forge.offer_button.buy_now": "Jetzt kaufen",
   "forge.offer_button.confirm_email": "E-Mail bestätigen",
   "forge.offer_button.continue_to_payment": "Weiter zur Zahlung",
@@ -1310,6 +1444,16 @@
   "forge.podcast_show.empty_title": "Noch keine Folgen.",
   "forge.podcast_show.not_found": "Podcast nicht gefunden.",
   "forge.podcast_show.now_playing": "Läuft gerade",
+  "forge.post_collection_detail.locked_body": "Tritt bei, um diesen Inhalt zu sehen",
+  "forge.post_collection_detail.locked_body_tier": "Mit {tier_name} freischalten, um diesen Inhalt zu sehen",
+  "forge.post_collection_detail.locked_title": "Inhalt gesperrt",
+  "forge.post_collection_detail.unlock": "Freischalten",
+  "forge.post_collection_detail.unlock_with": "Mit {tier_name} freischalten",
+  "forge.post_collections_grid.locked_body": "Tritt bei, um diesen Inhalt zu sehen",
+  "forge.post_collections_grid.locked_body_tier": "Mit {tier_name} freischalten, um diesen Inhalt zu sehen",
+  "forge.post_collections_grid.locked_title": "Inhalt gesperrt",
+  "forge.post_collections_grid.unlock": "Freischalten",
+  "forge.post_collections_grid.unlock_with": "Mit {tier_name} freischalten",
   "forge.posts_feed.empty_body": "Noch keine Beiträge.",
   "forge.presale_code.checking": "Wird geprüft…",
   "forge.presale_code.input_placeholder": "Code eingeben",