@carlonicora/nextjs-jsonapi 1.141.3 → 1.143.0

package/src/features/tokenusage/contexts/TokenUsageAdminContext.tsx

@@ -0,0 +1,252 @@
+"use client";
+
+import { useTranslations } from "next-intl";
+import { createContext, ReactNode, useCallback, useContext, useEffect, useMemo, useState } from "react";
+import { SharedProvider } from "../../../contexts";
+import { usePageUrlGenerator } from "../../../hooks";
+import { BreadcrumbItemData } from "../../../interfaces";
+import { TokenUsageAdminFilterBar } from "../components/TokenUsageAdminFilterBar";
+import type { TokenUsageAdminBreakdownInterface } from "../data/tokenusage-admin-breakdown.interface";
+import type { TokenUsageAdminSummaryInterface } from "../data/tokenusage-admin-summary.interface";
+import type { TokenUsageAdminTimelineInterface } from "../data/tokenusage-admin-timeline.interface";
+import type { Granularity, Metric, StackBy } from "../data/tokenusage-admin.types";
+import { TokenUsageAdminService } from "../data/TokenUsageAdminService";
+
+/**
+ * Route the breadcrumb links back to. The page itself lives in the consuming
+ * app (a360ai mounts it at `/administration/token-usage`); the constant is here
+ * because the breadcrumb is built by this provider, not by the app.
+ */
+const TOKEN_USAGE_ADMIN_PAGE_URL = "/administration/token-usage";
+
+/** Rows kept per ranked panel before the repository folds the tail into "other". */
+const DEFAULT_TOP_N = 10;
+
+export type TokenUsageAdminFilterState = {
+  /** ISO 8601 instant. */
+  from: string;
+  /** ISO 8601 instant. */
+  to: string;
+  granularity: Granularity;
+  stackBy: StackBy;
+  companyId?: string;
+  metric: Metric;
+};
+
+export interface TokenUsageAdminContextType {
+  summary: TokenUsageAdminSummaryInterface[];
+  timeline: TokenUsageAdminTimelineInterface[];
+  byCompany: TokenUsageAdminBreakdownInterface[];
+  byUser: TokenUsageAdminBreakdownInterface[];
+  /** Platform-side spend split by operation. Always empty in single-customer mode. */
+  /** Platform spend by operation — empty in single-customer mode. */
+  byOperation: TokenUsageAdminBreakdownInterface[];
+  /** Customer spend by operation — the customer-side mirror of byOperation. */
+  byCustomerOperation: TokenUsageAdminBreakdownInterface[];
+  companies: { id: string; label: string }[];
+  filters: TokenUsageAdminFilterState;
+  /** Merges a partial patch into the current filters; every key is optional. */
+  setFilters: (next: Partial<TokenUsageAdminFilterState>) => void;
+  /** `true` once a company filter is applied — the platform panels are meaningless then. */
+  singleCustomerMode: boolean;
+  isLoading: boolean;
+  error: string | null;
+}
+
+const TokenUsageAdminContext = createContext<TokenUsageAdminContextType | undefined>(undefined);
+
+/** Current calendar month to now, which is the window the page opens on. */
+function defaultRange(): { from: string; to: string } {
+  const now = new Date();
+  const start = new Date(now.getFullYear(), now.getMonth(), 1, 0, 0, 0, 0);
+  return { from: start.toISOString(), to: now.toISOString() };
+}
+
+type TokenUsageAdminProviderProps = {
+  children: ReactNode;
+  /** Pre-select a company, which puts the page in single-customer mode from the first render. */
+  initialCompanyId?: string;
+  /** ISO 8601 instant. Defaults to the start of the current month. */
+  initialFrom?: string;
+  /** ISO 8601 instant. Defaults to now. */
+  initialTo?: string;
+  /** Rows per ranked panel. Defaults to 10. */
+  topN?: number;
+};
+
+/**
+ * Owns every filter the administrative token-usage page reads, fetches the five
+ * panels behind it, and publishes the filter bar into the page title bar.
+ *
+ * The filter bar is rendered into `title.functions` here — NOT in the container —
+ * because `RoundPageContainer`'s title bar reads `title.functions` from
+ * `SharedContext`, and a descendant cannot inject nodes into an ancestor's
+ * provider value. That is why the filter state lives at this level.
+ */
+export const TokenUsageAdminProvider = ({
+  children,
+  initialCompanyId,
+  initialFrom,
+  initialTo,
+  topN = DEFAULT_TOP_N,
+}: TokenUsageAdminProviderProps) => {
+  const t = useTranslations();
+  const generateUrl = usePageUrlGenerator();
+
+  const [filters, setFilterState] = useState<TokenUsageAdminFilterState>(() => {
+    const range = defaultRange();
+    return {
+      from: initialFrom ?? range.from,
+      to: initialTo ?? range.to,
+      granularity: "day",
+      stackBy: "scope",
+      companyId: initialCompanyId,
+      metric: "cost",
+    };
+  });
+
+  const [summary, setSummary] = useState<TokenUsageAdminSummaryInterface[]>([]);
+  const [timeline, setTimeline] = useState<TokenUsageAdminTimelineInterface[]>([]);
+  const [byCompany, setByCompany] = useState<TokenUsageAdminBreakdownInterface[]>([]);
+  const [byUser, setByUser] = useState<TokenUsageAdminBreakdownInterface[]>([]);
+  const [byOperation, setByOperation] = useState<TokenUsageAdminBreakdownInterface[]>([]);
+  const [byCustomerOperation, setByCustomerOperation] = useState<TokenUsageAdminBreakdownInterface[]>([]);
+  const [isLoading, setIsLoading] = useState(true);
+  const [error, setError] = useState<string | null>(null);
+
+  const { from, to, granularity, stackBy, companyId, metric } = filters;
+  const singleCustomerMode = Boolean(companyId);
+
+  useEffect(() => {
+    // `cancelled` is the out-of-order guard: a filter change fires a new request
+    // while the previous one is still in flight, and without this flag the slower
+    // (older) response would land last and overwrite the fresher state.
+    let cancelled = false;
+
+    setIsLoading(true);
+    setError(null);
+
+    const base = { from, to, companyId };
+
+    Promise.all([
+      TokenUsageAdminService.getSummary(base),
+      TokenUsageAdminService.getTimeline({ ...base, granularity, stackBy }),
+      TokenUsageAdminService.getBreakdown({ ...base, dimension: "company", scope: "customer", limit: topN }),
+      TokenUsageAdminService.getBreakdown({ ...base, dimension: "user", scope: "customer", limit: topN }),
+      // Platform spend is, by definition, the usage with no owning company, so
+      // filtering it by one is meaningless — the call is skipped entirely rather
+      // than issued and discarded.
+      companyId
+        ? Promise.resolve<TokenUsageAdminBreakdownInterface[]>([])
+        : TokenUsageAdminService.getBreakdown({ ...base, dimension: "operation", scope: "platform", limit: topN }),
+      // Customer spend by operation — unlike the platform panel this one IS
+      // meaningful under a company filter, so it is always requested.
+      TokenUsageAdminService.getBreakdown({ ...base, dimension: "operation", scope: "customer", limit: topN }),
+    ])
+      .then(([nextSummary, nextTimeline, nextByCompany, nextByUser, nextByOperation, nextByCustomerOperation]) => {
+        if (cancelled) return;
+        setSummary(nextSummary ?? []);
+        setTimeline(nextTimeline ?? []);
+        setByCompany(nextByCompany ?? []);
+        setByUser(nextByUser ?? []);
+        setByOperation(nextByOperation ?? []);
+        setByCustomerOperation(nextByCustomerOperation ?? []);
+      })
+      .catch((err) => {
+        if (cancelled) return;
+        console.error("Failed to load administrative token usage:", err);
+        setError(err instanceof Error ? err.message : String(err));
+      })
+      .finally(() => {
+        if (cancelled) return;
+        setIsLoading(false);
+      });
+
+    return () => {
+      cancelled = true;
+    };
+  }, [from, to, granularity, stackBy, companyId, topN]);
+
+  const setFilters = useCallback((next: Partial<TokenUsageAdminFilterState>) => {
+    setFilterState((prev) => ({ ...prev, ...next }));
+  }, []);
+
+  /**
+   * Derived from the company breakdown, per the page design. Note the
+   * consequence: once a company filter is applied the breakdown returns that
+   * company alone, so the selector narrows to it — clearing the filter restores
+   * the full list.
+   */
+  const companies = useMemo(
+    () => byCompany.filter((row) => row.id !== "other").map((row) => ({ id: row.id, label: row.label })),
+    [byCompany],
+  );
+
+  const breadcrumb = (): BreadcrumbItemData[] => [
+    {
+      name: t("token_usage.admin.title"),
+      href: generateUrl({ page: TOKEN_USAGE_ADMIN_PAGE_URL }),
+    },
+  ];
+
+  const title = () => ({
+    type: t("token_usage.admin.title"),
+    functions: (
+      <TokenUsageAdminFilterBar
+        key="tokenUsageAdminFilterBar"
+        from={from}
+        to={to}
+        granularity={granularity}
+        companyId={companyId}
+        metric={metric}
+        companies={companies}
+        onChange={setFilters}
+      />
+    ),
+  });
+
+  const contextValue = useMemo<TokenUsageAdminContextType>(
+    () => ({
+      summary,
+      timeline,
+      byCompany,
+      byUser,
+      byOperation,
+      byCustomerOperation,
+      companies,
+      filters,
+      setFilters,
+      singleCustomerMode,
+      isLoading,
+      error,
+    }),
+    [
+      summary,
+      timeline,
+      byCompany,
+      byUser,
+      byOperation,
+      byCustomerOperation,
+      companies,
+      filters,
+      setFilters,
+      singleCustomerMode,
+      isLoading,
+      error,
+    ],
+  );
+
+  return (
+    <SharedProvider value={{ breadcrumbs: breadcrumb(), title: title() }}>
+      <TokenUsageAdminContext.Provider value={contextValue}>{children}</TokenUsageAdminContext.Provider>
+    </SharedProvider>
+  );
+};
+
+export const useTokenUsageAdmin = (): TokenUsageAdminContextType => {
+  const ctx = useContext(TokenUsageAdminContext);
+  if (!ctx) {
+    throw new Error("useTokenUsageAdmin() called outside <TokenUsageAdminProvider>.");
+  }
+  return ctx;
+};

package/src/features/tokenusage/contexts/__tests__/TokenUsageAdminContext.spec.tsx

@@ -0,0 +1,80 @@
+import { render, screen, waitFor } from "@testing-library/react";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { TokenUsageAdminService } from "../../data/TokenUsageAdminService";
+import { TokenUsageAdminProvider, useTokenUsageAdmin } from "../TokenUsageAdminContext";
+
+vi.mock("../../data/TokenUsageAdminService", () => ({
+  TokenUsageAdminService: {
+    getSummary: vi.fn(async () => []),
+    getTimeline: vi.fn(async () => []),
+    getBreakdown: vi.fn(async () => []),
+  },
+}));
+
+function Probe() {
+  const ctx = useTokenUsageAdmin();
+  return <span data-testid="mode">{String(ctx.singleCustomerMode)}</span>;
+}
+
+describe("TokenUsageAdminContext", () => {
+  // The mocked service is module-level, so its call counts survive across tests.
+  // Without this reset the per-test `toHaveBeenCalledTimes` assertions would
+  // measure the whole file rather than one render.
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("throws when used outside its provider", () => {
+    expect(() => render(<Probe />)).toThrow();
+  });
+
+  it("requests every panel on mount and reports not-single-customer by default", async () => {
+    render(
+      <TokenUsageAdminProvider>
+        <Probe />
+      </TokenUsageAdminProvider>,
+    );
+
+    await waitFor(() => expect(TokenUsageAdminService.getSummary).toHaveBeenCalled());
+
+    // Four ranked panels: company, user, customer-by-operation, platform-by-operation.
+    // Asserted by dimension+scope rather than by count alone, so a wrong pairing
+    // fails here instead of silently rendering the wrong data.
+    const calls = (TokenUsageAdminService.getBreakdown as ReturnType<typeof vi.fn>).mock.calls.map(([args]) => [
+      args.dimension,
+      args.scope,
+    ]);
+    expect(calls).toEqual(
+      expect.arrayContaining([
+        ["company", "customer"],
+        ["user", "customer"],
+        ["operation", "customer"],
+        ["operation", "platform"],
+      ]),
+    );
+    expect(calls).toHaveLength(4);
+    expect(screen.getByTestId("mode")).toHaveTextContent("false");
+  });
+
+  it("skips only the PLATFORM operation breakdown once a company filter is applied", async () => {
+    render(
+      <TokenUsageAdminProvider initialCompanyId="c1">
+        <Probe />
+      </TokenUsageAdminProvider>,
+    );
+
+    await waitFor(() => expect(TokenUsageAdminService.getSummary).toHaveBeenCalled());
+
+    const calls = (TokenUsageAdminService.getBreakdown as ReturnType<typeof vi.fn>).mock.calls.map(([args]) => [
+      args.dimension,
+      args.scope,
+    ]);
+    // Platform spend has no owning company, so filtering it is meaningless and
+    // the call is skipped. The CUSTOMER operation panel is still meaningful and
+    // must survive — that distinction is the point of this test.
+    expect(calls).toContainEqual(["operation", "customer"]);
+    expect(calls).not.toContainEqual(["operation", "platform"]);
+    expect(calls).toHaveLength(3);
+    expect(screen.getByTestId("mode")).toHaveTextContent("true");
+  });
+});

package/src/features/tokenusage/data/TokenUsageAdminService.ts

@@ -0,0 +1,54 @@
+import { AbstractService, EndpointCreator, HttpMethod, Modules } from "../../../core";
+import { TokenUsageAdminBreakdownInterface } from "./tokenusage-admin-breakdown.interface";
+import { TokenUsageAdminSummaryInterface } from "./tokenusage-admin-summary.interface";
+import { TokenUsageAdminTimelineInterface } from "./tokenusage-admin-timeline.interface";
+import { Dimension, Granularity, Scope, StackBy, TokenUsageAdminFilters } from "./tokenusage-admin.types";
+
+function withFilters(endpoint: EndpointCreator, filters: TokenUsageAdminFilters): EndpointCreator {
+  endpoint.addAdditionalParam("from", filters.from);
+  endpoint.addAdditionalParam("to", filters.to);
+  if (filters.companyId) endpoint.addAdditionalParam("companyId", filters.companyId);
+  return endpoint;
+}
+
+export class TokenUsageAdminService extends AbstractService {
+  /** Six rows: {customer, platform, total} × {current, previous}. */
+  static async getSummary(filters: TokenUsageAdminFilters): Promise<TokenUsageAdminSummaryInterface[]> {
+    const endpoint = withFilters(new EndpointCreator({ endpoint: Modules.TokenUsageAdminSummary }), filters);
+
+    return this.callApi<TokenUsageAdminSummaryInterface[]>({
+      type: Modules.TokenUsageAdminSummary,
+      method: HttpMethod.GET,
+      endpoint: endpoint.generate(),
+    });
+  }
+
+  static async getTimeline(
+    params: TokenUsageAdminFilters & { granularity: Granularity; stackBy: StackBy },
+  ): Promise<TokenUsageAdminTimelineInterface[]> {
+    const endpoint = withFilters(new EndpointCreator({ endpoint: Modules.TokenUsageAdminTimeline }), params);
+    endpoint.addAdditionalParam("granularity", params.granularity);
+    endpoint.addAdditionalParam("stackBy", params.stackBy);
+
+    return this.callApi<TokenUsageAdminTimelineInterface[]>({
+      type: Modules.TokenUsageAdminTimeline,
+      method: HttpMethod.GET,
+      endpoint: endpoint.generate(),
+    });
+  }
+
+  static async getBreakdown(
+    params: TokenUsageAdminFilters & { dimension: Dimension; scope: Scope; limit?: number },
+  ): Promise<TokenUsageAdminBreakdownInterface[]> {
+    const endpoint = withFilters(new EndpointCreator({ endpoint: Modules.TokenUsageAdminBreakdown }), params);
+    endpoint.addAdditionalParam("dimension", params.dimension);
+    endpoint.addAdditionalParam("scope", params.scope);
+    if (params.limit !== undefined) endpoint.addAdditionalParam("limit", String(params.limit));
+
+    return this.callApi<TokenUsageAdminBreakdownInterface[]>({
+      type: Modules.TokenUsageAdminBreakdown,
+      method: HttpMethod.GET,
+      endpoint: endpoint.generate(),
+    });
+  }
+}

package/src/features/tokenusage/data/__tests__/tokenusage-admin-models.spec.ts

@@ -0,0 +1,147 @@
+import { beforeAll, describe, expect, it } from "vitest";
+import { ModuleFactory, ModuleWithPermissions } from "../../../../permissions/types";
+import { ModuleRegistry } from "../../../../core/registry/ModuleRegistry";
+import {
+  TokenUsageAdminBreakdownModule,
+  TokenUsageAdminSummaryModule,
+  TokenUsageAdminTimelineModule,
+} from "../../tokenusage-admin.module";
+import { TokenUsageAdminBreakdown } from "../tokenusage-admin-breakdown";
+import { TokenUsageAdminSummary } from "../tokenusage-admin-summary";
+import { TokenUsageAdminTimeline } from "../tokenusage-admin-timeline";
+
+// createJsonApi reads Modules.X.name (resolved lazily via ModuleRegistry), so
+// the modules must be registered before a model serialises — mirrors the
+// HowTo.spec / AssistantMessage.spec setup convention in this package.
+const moduleFactory: ModuleFactory = (params) =>
+  ({
+    pageUrl: params.pageUrl,
+    name: params.name,
+    model: params.model,
+  }) as ModuleWithPermissions;
+
+beforeAll(() => {
+  ModuleRegistry.register("TokenUsageAdminSummary", TokenUsageAdminSummaryModule(moduleFactory));
+  ModuleRegistry.register("TokenUsageAdminTimeline", TokenUsageAdminTimelineModule(moduleFactory));
+  ModuleRegistry.register("TokenUsageAdminBreakdown", TokenUsageAdminBreakdownModule(moduleFactory));
+});
+
+const hydrate = (attributes: Record<string, unknown>) =>
+  ({ jsonApi: { id: "x", type: "t", attributes }, included: [] }) as any;
+
+describe("token usage admin models", () => {
+  it("rehydrates every summary attribute", () => {
+    const m = new TokenUsageAdminSummary().rehydrate(
+      hydrate({
+        scope: "customer",
+        window: "current",
+        cost: 9.46,
+        credits: 3394,
+        tokensIn: 49244143,
+        tokensOut: 12,
+        cached: 75752,
+        calls: 2956,
+      }),
+    );
+    expect(m.scope).toBe("customer");
+    expect(m.window).toBe("current");
+    expect(m.cost).toBe(9.46);
+    expect(m.credits).toBe(3394);
+    expect(m.tokensIn).toBe(49244143);
+    expect(m.tokensOut).toBe(12);
+    expect(m.cached).toBe(75752);
+    expect(m.calls).toBe(2956);
+  });
+
+  it("parses the timeline bucket into a Date, not the wire string", () => {
+    const m = new TokenUsageAdminTimeline().rehydrate(
+      hydrate({
+        bucket: "2026-08-01",
+        series: "customer",
+        cost: 1,
+        credits: 1,
+        tokensIn: 1,
+        tokensOut: 1,
+        cached: 0,
+        calls: 1,
+      }),
+    );
+    expect(m.bucket).toBeInstanceOf(Date);
+    expect(m.bucket.toISOString().slice(0, 10)).toBe("2026-08-01");
+    expect(m.series).toBe("customer");
+  });
+
+  it("leaves company-only breakdown fields undefined on other dimensions", () => {
+    const m = new TokenUsageAdminBreakdown().rehydrate(
+      hydrate({
+        label: "m.rossi",
+        sublabel: "Studio Rossi",
+        cost: 3.74,
+        credits: 900,
+        tokensIn: 1,
+        tokensOut: 1,
+        cached: 0,
+        calls: 4,
+      }),
+    );
+    expect(m.label).toBe("m.rossi");
+    expect(m.sublabel).toBe("Studio Rossi");
+    expect(m.activeUsers).toBeUndefined();
+    expect(m.monthlyCredits).toBeUndefined();
+    expect(m.availableMonthlyCredits).toBeUndefined();
+  });
+
+  it("serialises a summary back to a JSON:API resource object", () => {
+    const doc = new TokenUsageAdminSummary().createJsonApi({
+      id: "customer|current",
+      scope: "customer",
+      window: "current",
+      cost: 9.46,
+      credits: 3394,
+      tokensIn: 1,
+      tokensOut: 2,
+      cached: 3,
+      calls: 4,
+    });
+
+    expect(doc.data.type).toBe("tokenusages/administration/summary");
+    expect(doc.data.id).toBe("customer|current");
+    expect(doc.data.attributes).toMatchObject({ scope: "customer", window: "current", cost: 9.46, calls: 4 });
+  });
+
+  it("emits the timeline bucket as YYYY-MM-DD via formatLocalDate, never a raw Date", () => {
+    const doc = new TokenUsageAdminTimeline().createJsonApi({
+      id: "2026-08-01|customer",
+      bucket: new Date(2026, 7, 1),
+      series: "customer",
+      cost: 1,
+      credits: 1,
+      tokensIn: 1,
+      tokensOut: 1,
+      cached: 0,
+      calls: 1,
+    });
+
+    expect(doc.data.attributes.bucket).toBe("2026-08-01");
+    expect(typeof doc.data.attributes.bucket).toBe("string");
+    // A raw Date would survive JSON.stringify as an ISO instant and UTC-shift.
+    expect(JSON.parse(JSON.stringify(doc)).data.attributes.bucket).toBe("2026-08-01");
+  });
+
+  it("omits absent optional breakdown attributes rather than emitting undefined", () => {
+    const doc = new TokenUsageAdminBreakdown().createJsonApi({
+      id: "u1",
+      label: "m.rossi",
+      cost: 1,
+      credits: 1,
+      tokensIn: 1,
+      tokensOut: 1,
+      cached: 0,
+      calls: 1,
+    });
+
+    expect(doc.data.attributes.label).toBe("m.rossi");
+    expect("sublabel" in doc.data.attributes).toBe(false);
+    expect("activeUsers" in doc.data.attributes).toBe(false);
+  });
+});

package/src/features/tokenusage/data/index.ts

@@ -0,0 +1,8 @@
+export * from "./tokenusage-admin.types";
+export { TokenUsageAdminSummary } from "./tokenusage-admin-summary";
+export type { TokenUsageAdminSummaryInterface } from "./tokenusage-admin-summary.interface";
+export { TokenUsageAdminTimeline } from "./tokenusage-admin-timeline";
+export type { TokenUsageAdminTimelineInterface } from "./tokenusage-admin-timeline.interface";
+export { TokenUsageAdminBreakdown } from "./tokenusage-admin-breakdown";
+export type { TokenUsageAdminBreakdownInterface } from "./tokenusage-admin-breakdown.interface";
+export { TokenUsageAdminService } from "./TokenUsageAdminService";

package/src/features/tokenusage/data/tokenusage-admin-breakdown.interface.ts

@@ -0,0 +1,18 @@
+import { ApiDataInterface } from "../../../core";
+
+export interface TokenUsageAdminBreakdownInterface extends ApiDataInterface {
+  get label(): string;
+  get sublabel(): string | undefined;
+  get cost(): number;
+  get credits(): number;
+  get tokensIn(): number;
+  get tokensOut(): number;
+  get cached(): number;
+  get calls(): number;
+  /** Company dimension only. */
+  get activeUsers(): number | undefined;
+  /** Company dimension only. */
+  get monthlyCredits(): number | undefined;
+  /** Company dimension only. */
+  get availableMonthlyCredits(): number | undefined;
+}

package/src/features/tokenusage/data/tokenusage-admin-breakdown.ts

@@ -0,0 +1,115 @@
+import { AbstractApiData, JsonApiHydratedDataInterface, Modules } from "../../../core";
+import { TokenUsageAdminBreakdownInterface } from "./tokenusage-admin-breakdown.interface";
+import { TokenUsageAdminBreakdownInput } from "./tokenusage-admin.types";
+
+/**
+ * One ranked row of a breakdown. The same shape serves all three dimensions —
+ * company, user and operation — which is why the three "by-X" views collapse
+ * into a single `breakdown?dimension=` call.
+ *
+ * `activeUsers` / `monthlyCredits` / `availableMonthlyCredits` are populated only
+ * for `dimension=company`; they are absent on user and operation rows.
+ */
+export class TokenUsageAdminBreakdown extends AbstractApiData implements TokenUsageAdminBreakdownInterface {
+  private _label: string = "";
+  private _sublabel?: string;
+  private _cost: number = 0;
+  private _credits: number = 0;
+  private _tokensIn: number = 0;
+  private _tokensOut: number = 0;
+  private _cached: number = 0;
+  private _calls: number = 0;
+  private _activeUsers?: number;
+  private _monthlyCredits?: number;
+  private _availableMonthlyCredits?: number;
+
+  get label(): string {
+    return this._label;
+  }
+
+  get sublabel(): string | undefined {
+    return this._sublabel;
+  }
+
+  get cost(): number {
+    return this._cost;
+  }
+
+  get credits(): number {
+    return this._credits;
+  }
+
+  get tokensIn(): number {
+    return this._tokensIn;
+  }
+
+  get tokensOut(): number {
+    return this._tokensOut;
+  }
+
+  get cached(): number {
+    return this._cached;
+  }
+
+  get calls(): number {
+    return this._calls;
+  }
+
+  get activeUsers(): number | undefined {
+    return this._activeUsers;
+  }
+
+  get monthlyCredits(): number | undefined {
+    return this._monthlyCredits;
+  }
+
+  get availableMonthlyCredits(): number | undefined {
+    return this._availableMonthlyCredits;
+  }
+
+  rehydrate(data: JsonApiHydratedDataInterface): this {
+    super.rehydrate(data);
+
+    const attrs = data.jsonApi.attributes;
+    this._label = attrs.label ?? "";
+    this._sublabel = attrs.sublabel ?? undefined;
+    this._cost = attrs.cost ?? 0;
+    this._credits = attrs.credits ?? 0;
+    this._tokensIn = attrs.tokensIn ?? 0;
+    this._tokensOut = attrs.tokensOut ?? 0;
+    this._cached = attrs.cached ?? 0;
+    this._calls = attrs.calls ?? 0;
+    this._activeUsers = attrs.activeUsers ?? undefined;
+    this._monthlyCredits = attrs.monthlyCredits ?? undefined;
+    this._availableMonthlyCredits = attrs.availableMonthlyCredits ?? undefined;
+
+    return this;
+  }
+
+  createJsonApi(data: TokenUsageAdminBreakdownInput) {
+    const response: any = {
+      data: {
+        type: Modules.TokenUsageAdminBreakdown.name,
+        id: data.id,
+        attributes: {},
+        relationships: {},
+      },
+      included: [],
+    };
+
+    if (data.label !== undefined) response.data.attributes.label = data.label;
+    if (data.sublabel !== undefined) response.data.attributes.sublabel = data.sublabel;
+    if (data.cost !== undefined) response.data.attributes.cost = data.cost;
+    if (data.credits !== undefined) response.data.attributes.credits = data.credits;
+    if (data.tokensIn !== undefined) response.data.attributes.tokensIn = data.tokensIn;
+    if (data.tokensOut !== undefined) response.data.attributes.tokensOut = data.tokensOut;
+    if (data.cached !== undefined) response.data.attributes.cached = data.cached;
+    if (data.calls !== undefined) response.data.attributes.calls = data.calls;
+    if (data.activeUsers !== undefined) response.data.attributes.activeUsers = data.activeUsers;
+    if (data.monthlyCredits !== undefined) response.data.attributes.monthlyCredits = data.monthlyCredits;
+    if (data.availableMonthlyCredits !== undefined)
+      response.data.attributes.availableMonthlyCredits = data.availableMonthlyCredits;
+
+    return response;
+  }
+}