@carlonicora/nextjs-jsonapi 1.14.0 → 1.16.0

package/dist/core/index.d.ts

@@ -1,8 +1,8 @@
-import { A as ApiData, a as ApiResponseInterface } from '../ApiResponseInterface-QLDnxLA9.js';
-import { A as ApiDataInterface, J as JsonApiHydratedDataInterface, a as ApiRequestDataTypeInterface, M as ModuleWithPermissions, F as FieldSelector, i as PermissionUser, b as Action, h as PermissionModule, j as ModuleFactory, m as ModuleInterface, l as FeatureInterface, o as RoleInterface, R as RoleInput, k as CompanyInterface, C as CompanyInput, U as UserInterface, p as UserInput, N as NotificationInterface, n as NotificationInput } from '../notification.interface-lG6UpTpt.js';
-export { G as GetterKeys, f as ModuleDefinition, e as ModulePermissionDefinition, d as PageUrl, P as PermissionCheck, g as PermissionConfig, c as createJsonApiInclusion } from '../notification.interface-lG6UpTpt.js';
-import { c as AuthInterface, a as AuthInput, j as S3Interface, i as S3Input } from '../s3.service-Dq-PTUNa.js';
-export { A as AbstractService, b as AuthQuery, d as AuthService, C as CompanyService, e as ContentService, F as FeatureService, H as HttpMethod, N as NextRef, f as NotificationService, P as PreviousRef, h as PushService, R as RoleService, k as S3Service, S as SelfRef, U as UserService, g as getGlobalErrorHandler, s as setGlobalErrorHandler } from '../s3.service-Dq-PTUNa.js';
+import { A as ApiData, a as ApiResponseInterface } from '../ApiResponseInterface-BvWIeLkq.js';
+import { A as ApiDataInterface, J as JsonApiHydratedDataInterface, a as ApiRequestDataTypeInterface, M as ModuleWithPermissions, F as FieldSelector, i as PermissionUser, b as Action, h as PermissionModule, j as ModuleFactory, m as ModuleInterface, l as FeatureInterface, o as RoleInterface, R as RoleInput, k as CompanyInterface, C as CompanyInput, U as UserInterface, p as UserInput, N as NotificationInterface, n as NotificationInput } from '../notification.interface-BllkURRm.js';
+export { G as GetterKeys, f as ModuleDefinition, e as ModulePermissionDefinition, d as PageUrl, P as PermissionCheck, g as PermissionConfig, c as createJsonApiInclusion } from '../notification.interface-BllkURRm.js';
+import { c as AuthInterface, a as AuthInput, A as AbstractService, N as NextRef, P as PreviousRef, j as S3Interface, i as S3Input } from '../s3.service-BEfGqho0.js';
+export { b as AuthQuery, d as AuthService, C as CompanyService, e as ContentService, F as FeatureService, H as HttpMethod, f as NotificationService, h as PushService, R as RoleService, k as S3Service, S as SelfRef, U as UserService, g as getGlobalErrorHandler, s as setGlobalErrorHandler } from '../s3.service-BEfGqho0.js';
 export { B as BreadcrumbItemData } from '../breadcrumb.item.data.interface-CgB4_1EE.js';
 export { C as ContentFields, D as D3Link, a as D3Node, R as RoleFields, U as UserFields } from '../content.fields-Ck5lkQ5d.js';
 import { ClassValue } from 'clsx';
@@ -12,8 +12,9 @@ import { ReactElement, ReactNode } from 'react';
 import { z } from 'zod';
 import { PartialBlock } from '@blocknote/core';
 import { LucideIcon } from 'lucide-react';
-export { A as AuthComponent } from '../AuthComponent-hxOPs9o8.js';
-import { a as ContentInterface, C as ContentInput } from '../content.interface-TB2MfJGs.js';
+import { M as MeterInterface, o as MeterSummaryInterface, P as PaymentMethodInterface, S as StripeCustomerInterface, a as StripeInvoiceInterface, j as StripeSubscriptionInterface, I as InvoiceStatus, g as StripeProductInterface, d as StripePriceInterface, h as StripeProductInput, e as PriceRecurring, f as StripePriceInput, i as SubscriptionStatus, k as StripeSubscriptionInput, m as StripeSubscriptionCreateResponse, b as ProrationPreviewInterface, n as StripeUsageInterface, R as ReportUsageInput, U as UsageSummaryInterface } from '../stripe-subscription.interface-CUvNDvw5.js';
+export { A as AuthComponent, c as ProrationLineItem, l as StripeSubscriptionCreateMeta, p as UsageRecordInterface } from '../stripe-subscription.interface-CUvNDvw5.js';
+import { a as ContentInterface, C as ContentInput } from '../content.interface-D_4b4RQt.js';
 import 'd3';
 
 declare abstract class AbstractApiData implements ApiDataInterface {
@@ -37,14 +38,17 @@ declare abstract class AbstractApiData implements ApiDataInterface {
     protected _readIncluded<T extends ApiDataInterface>(data: JsonApiHydratedDataInterface, type: string, dataType: ApiRequestDataTypeInterface): T | T[] | undefined;
     /**
      * Read included relationship data and augment with relationship meta properties.
-     * Used for single relationships (one-to-one) that have edge properties.
+     * Handles both single relationships (one-to-one) and array relationships (one-to-many).
+     *
+     * For single relationships: meta is read from `relationships[type].meta`
+     * For array relationships: per-item meta is read from `relationships[type].data[].meta`
      *
      * @param data - Hydrated JSON:API data
-     * @param type - Relationship type key (e.g., "guide")
+     * @param type - Relationship type key (e.g., "guide", "persons")
      * @param dataType - Module reference for rehydration
-     * @returns Related object augmented with meta properties, or undefined
+     * @returns Related object(s) augmented with meta properties, or undefined
      */
-    protected _readIncludedWithMeta<T extends ApiDataInterface, M extends Record<string, any>>(data: JsonApiHydratedDataInterface, type: string, dataType: ApiRequestDataTypeInterface): (T & M) | undefined;
+    protected _readIncludedWithMeta<T extends ApiDataInterface, M extends Record<string, any>>(data: JsonApiHydratedDataInterface, type: string, dataType: ApiRequestDataTypeInterface): (T & M) | (T & M)[] | undefined;
     dehydrate(): JsonApiHydratedDataInterface;
     rehydrate(data: JsonApiHydratedDataInterface): this;
 }
@@ -197,6 +201,14 @@ interface FoundationModuleDefinitions {
     Content: ModuleWithPermissions;
     UserTopic: ModuleWithPermissions;
     UserExpertise: ModuleWithPermissions;
+    Billing: ModuleWithPermissions;
+    StripeCustomer: ModuleWithPermissions;
+    StripePaymentMethod: ModuleWithPermissions;
+    StripeSubscription: ModuleWithPermissions;
+    StripeInvoice: ModuleWithPermissions;
+    StripeProduct: ModuleWithPermissions;
+    StripePrice: ModuleWithPermissions;
+    StripeUsage: ModuleWithPermissions;
 }
 interface AppModuleDefinitions {
 }
@@ -254,7 +266,7 @@ declare function hasBootstrapper(): boolean;
 declare function resetBootstrapStore(): void;
 
 type EndpointQuery = {
-    endpoint: ApiRequestDataTypeInterface;
+    endpoint: ApiRequestDataTypeInterface | string;
     id?: string;
     childEndpoint?: ApiRequestDataTypeInterface | string;
     childId?: string;
@@ -266,7 +278,7 @@ type EndpointQuery = {
 declare class EndpointCreator {
     private _endpoint;
     constructor(params: {
-        endpoint: ApiRequestDataTypeInterface;
+        endpoint: ApiRequestDataTypeInterface | string;
         id?: string;
         childEndpoint?: ApiRequestDataTypeInterface | string;
         childId?: string;
@@ -275,7 +287,7 @@ declare class EndpointCreator {
             value: string;
         }[];
     });
-    endpoint(value: ApiRequestDataTypeInterface): EndpointCreator;
+    endpoint(value: ApiRequestDataTypeInterface | string): EndpointCreator;
     id(value: string): EndpointCreator;
     childEndpoint(value: ApiRequestDataTypeInterface | string): EndpointCreator;
     childId(value: string): EndpointCreator;
@@ -567,14 +579,14 @@ declare const getLucideIconByModuleName: (params: {
     name: string;
 }) => LucideIcon | null;
 
+declare const AuthModule: (factory: ModuleFactory) => ModuleWithPermissions;
+
 declare const ModuleModule: (factory: ModuleFactory) => ModuleWithPermissions;
 
 declare class Module extends AbstractApiData implements ModuleInterface {
     private _name?;
-    private _isCore?;
     private _permissions?;
     get name(): string;
-    get isCore(): boolean;
     get permissions(): {
         create: boolean | string;
         read: boolean | string;
@@ -588,10 +600,10 @@ declare const FeatureModule: (factory: ModuleFactory) => ModuleWithPermissions;
 
 declare class Feature extends AbstractApiData implements FeatureInterface {
     private _name?;
-    private _isProduction?;
+    private _isCore?;
     private _modules;
     get name(): string;
-    get isProduction(): boolean;
+    get isCore(): boolean;
     get modules(): ModuleInterface[];
     rehydrate(data: JsonApiHydratedDataInterface): this;
 }
@@ -694,7 +706,503 @@ declare class Auth extends AbstractApiData implements AuthInterface {
     createJsonApi(data: AuthInput): any;
 }
 
-declare const AuthModule: (factory: ModuleFactory) => ModuleWithPermissions;
+/**
+ * Legacy billing service - only contains meter methods
+ * @deprecated Use StripeUsageService for meter methods, StripeInvoiceService for invoices,
+ * StripeCustomerService for payment methods
+ */
+declare class BillingService extends AbstractService {
+    /**
+     * List all available usage meters
+     * @deprecated Use StripeUsageService.listMeters() instead
+     */
+    static listMeters(params?: {
+        next?: NextRef;
+        prev?: PreviousRef;
+    }): Promise<MeterInterface[]>;
+    /**
+     * Get meter summaries for a specific time period
+     * @deprecated Use StripeUsageService.getMeterSummaries() instead
+     */
+    static getMeterSummaries(params: {
+        meterId: string;
+        startTime: Date;
+        endTime: Date;
+    }): Promise<MeterSummaryInterface[]>;
+}
+
+/**
+ * Billing is a namespace module used for permissions and non-entity endpoints.
+ * It doesn't correspond to a specific backend entity but provides routing for
+ * meter-related endpoints and permission checks.
+ */
+declare class Billing extends AbstractApiData {
+    rehydrate(data: JsonApiHydratedDataInterface): this;
+    createJsonApi(_data?: any): any;
+}
+
+declare const BillingModule: (factory: ModuleFactory) => ModuleWithPermissions;
+
+/**
+ * PaymentMethod class for JSON:API rehydration
+ *
+ * Transforms flat JSON:API attributes into the nested PaymentMethodInterface structure
+ * expected by the frontend components.
+ */
+declare class PaymentMethod extends AbstractApiData implements PaymentMethodInterface {
+    private _paymentType?;
+    private _card?;
+    private _billingDetails?;
+    get type(): string;
+    get card(): {
+        brand: string;
+        last4: string;
+        expMonth: number;
+        expYear: number;
+    } | undefined;
+    get billingDetails(): {
+        name?: string;
+        email?: string;
+        phone?: string;
+        address?: {
+            city?: string;
+            country?: string;
+            line1?: string;
+            line2?: string;
+            postalCode?: string;
+            state?: string;
+        };
+    } | undefined;
+    rehydrate(data: JsonApiHydratedDataInterface): this;
+    createJsonApi(_data?: any): any;
+}
+
+declare class StripeCustomer extends AbstractApiData implements StripeCustomerInterface {
+    private _stripeCustomerId?;
+    private _email?;
+    private _name?;
+    private _defaultPaymentMethodId?;
+    private _currency?;
+    private _balance?;
+    private _delinquent;
+    private _metadata?;
+    get stripeCustomerId(): string;
+    get email(): string | undefined;
+    get name(): string | undefined;
+    get defaultPaymentMethodId(): string | undefined;
+    get currency(): string | undefined;
+    get balance(): number | undefined;
+    get delinquent(): boolean;
+    get metadata(): Record<string, any> | undefined;
+    rehydrate(data: JsonApiHydratedDataInterface): this;
+    createJsonApi(_data?: any): any;
+}
+
+/**
+ * Customer-facing billing service for managing subscriptions, payments, and usage
+ */
+declare class StripeCustomerService extends AbstractService {
+    /**
+     * Get the current user's billing customer record
+     */
+    static getCustomer(): Promise<StripeCustomerInterface>;
+    /**
+     * Create a billing customer for the current user
+     */
+    static createCustomer(): Promise<StripeCustomerInterface>;
+    /**
+     * Create a setup intent for adding payment methods
+     */
+    static createSetupIntent(): Promise<{
+        clientSecret: string;
+    }>;
+    /**
+     * Create a Stripe customer portal session URL
+     */
+    static createPortalSession(): Promise<{
+        url: string;
+    }>;
+    /**
+     * List all payment methods for the current user
+     */
+    static listPaymentMethods(params?: {
+        next?: NextRef;
+        prev?: PreviousRef;
+    }): Promise<PaymentMethodInterface[]>;
+    /**
+     * Set the default payment method for the current user
+     */
+    static setDefaultPaymentMethod(params: {
+        paymentMethodId: string;
+    }): Promise<StripeCustomerInterface>;
+    /**
+     * Remove a payment method
+     */
+    static removePaymentMethod(params: {
+        paymentMethodId: string;
+    }): Promise<void>;
+}
+
+declare const StripeCustomerModule: (factory: ModuleFactory) => ModuleWithPermissions;
+
+declare const StripePaymentMethodModule: (factory: ModuleFactory) => ModuleWithPermissions;
+
+declare class StripeInvoice extends AbstractApiData implements StripeInvoiceInterface {
+    private _stripeInvoiceId?;
+    private _stripeInvoiceNumber?;
+    private _customerId?;
+    private _subscriptionId?;
+    private _subscription?;
+    private _status?;
+    private _amountDue?;
+    private _amountPaid?;
+    private _amountRemaining?;
+    private _subtotal?;
+    private _total?;
+    private _tax?;
+    private _currency?;
+    private _periodStart?;
+    private _periodEnd?;
+    private _dueDate?;
+    private _paidAt?;
+    private _attemptCount;
+    private _attempted;
+    private _stripeHostedInvoiceUrl?;
+    private _stripePdfUrl?;
+    private _paid;
+    private _metadata?;
+    get stripeInvoiceId(): string;
+    get stripeInvoiceNumber(): string | undefined;
+    get customerId(): string | undefined;
+    get subscriptionId(): string | undefined;
+    get subscription(): StripeSubscriptionInterface | undefined;
+    get status(): InvoiceStatus;
+    get amountDue(): number;
+    get amountPaid(): number;
+    get amountRemaining(): number;
+    get subtotal(): number;
+    get total(): number;
+    get tax(): number | undefined;
+    get currency(): string;
+    get periodStart(): Date;
+    get periodEnd(): Date;
+    get dueDate(): Date | undefined;
+    get paidAt(): Date | undefined;
+    get attemptCount(): number;
+    get attempted(): boolean;
+    get stripeHostedInvoiceUrl(): string | undefined;
+    get stripePdfUrl(): string | undefined;
+    get paid(): boolean;
+    get metadata(): Record<string, any> | undefined;
+    rehydrate(data: JsonApiHydratedDataInterface): this;
+    createJsonApi(_data?: any): any;
+}
+
+/**
+ * Service for managing Stripe invoices
+ */
+declare class StripeInvoiceService extends AbstractService {
+    /**
+     * List all invoices for the current user
+     */
+    static listInvoices(params?: {
+        status?: string;
+        next?: NextRef;
+        prev?: PreviousRef;
+    }): Promise<StripeInvoiceInterface[]>;
+    /**
+     * Get a specific invoice by ID
+     */
+    static getInvoice(params: {
+        invoiceId: string;
+    }): Promise<StripeInvoiceInterface>;
+    /**
+     * Get the upcoming invoice for the current user
+     */
+    static getUpcomingInvoice(): Promise<StripeInvoiceInterface>;
+}
+
+declare const StripeInvoiceModule: (factory: ModuleFactory) => ModuleWithPermissions;
+
+declare class StripeProduct extends AbstractApiData implements StripeProductInterface {
+    private _stripeProductId?;
+    private _name?;
+    private _description?;
+    private _active;
+    private _metadata?;
+    private _stripePrices;
+    get stripeProductId(): string;
+    get name(): string;
+    get description(): string | undefined;
+    get active(): boolean;
+    get metadata(): Record<string, any> | undefined;
+    get stripePrices(): StripePriceInterface[];
+    rehydrate(data: JsonApiHydratedDataInterface): this;
+    createJsonApi(data: StripeProductInput): any;
+}
+
+declare class StripeProductService extends AbstractService {
+    /**
+     * List all products (admin)
+     */
+    static listProducts(params?: {
+        active?: boolean;
+        next?: NextRef;
+        prev?: PreviousRef;
+    }): Promise<StripeProductInterface[]>;
+    /**
+     * Get a specific product by ID (admin)
+     */
+    static getProduct(params: {
+        id: string;
+    }): Promise<StripeProductInterface>;
+    /**
+     * Create a new product (admin)
+     */
+    static createProduct(params: StripeProductInput): Promise<StripeProductInterface>;
+    /**
+     * Update an existing product (admin)
+     */
+    static updateProduct(params: StripeProductInput): Promise<StripeProductInterface>;
+    /**
+     * Archive a product (admin)
+     */
+    static archiveProduct(params: {
+        id: string;
+    }): Promise<StripeProductInterface>;
+    /**
+     * Reactivate a product (admin) - sets active to true
+     */
+    static reactivateProduct(params: {
+        id: string;
+    }): Promise<StripeProductInterface>;
+}
+
+declare const StripeProductModule: (factory: ModuleFactory) => ModuleWithPermissions;
+
+declare class StripePrice extends AbstractApiData implements StripePriceInterface {
+    private _stripePriceId?;
+    private _productId?;
+    private _product?;
+    private _active;
+    private _currency?;
+    private _unitAmount?;
+    private _recurring?;
+    private _priceType?;
+    private _nickname?;
+    private _lookupKey?;
+    private _metadata?;
+    private _description?;
+    private _features?;
+    get stripePriceId(): string;
+    get productId(): string;
+    get product(): StripeProductInterface | undefined;
+    get active(): boolean;
+    get currency(): string;
+    get unitAmount(): number | undefined;
+    get recurring(): PriceRecurring | undefined;
+    get priceType(): "one_time" | "recurring";
+    get nickname(): string | undefined;
+    get lookupKey(): string | undefined;
+    get metadata(): Record<string, any> | undefined;
+    get description(): string | undefined;
+    get features(): string[] | undefined;
+    rehydrate(data: JsonApiHydratedDataInterface): this;
+    createJsonApi(data: StripePriceInput): any;
+}
+
+/**
+ * Admin billing service for managing products and prices
+ */
+declare class StripePriceService extends AbstractService {
+    /**
+     * List all prices (admin)
+     */
+    static listPrices(params?: {
+        productId?: string;
+        active?: boolean;
+        next?: NextRef;
+        prev?: PreviousRef;
+    }): Promise<StripePriceInterface[]>;
+    /**
+     * Get a specific price by ID (admin)
+     */
+    static getPrice(params: {
+        id: string;
+    }): Promise<StripePriceInterface>;
+    /**
+     * Create a new price (admin)
+     */
+    static createPrice(params: StripePriceInput): Promise<StripePriceInterface>;
+    /**
+     * Update an existing price (admin)
+     */
+    static updatePrice(params: StripePriceInput): Promise<StripePriceInterface>;
+    /**
+     * Archive a price (admin)
+     *
+     * Sets the price as inactive. Archived prices cannot be used for new subscriptions.
+     */
+    static archivePrice(params: {
+        id: string;
+    }): Promise<void>;
+    /**
+     * Reactivate a price (admin)
+     *
+     * Sets the price as active. Active prices can be used for new subscriptions.
+     */
+    static reactivatePrice(params: {
+        id: string;
+    }): Promise<void>;
+}
+
+declare const StripePriceModule: (factory: ModuleFactory) => ModuleWithPermissions;
+
+declare class StripeSubscription extends AbstractApiData implements StripeSubscriptionInterface {
+    private _stripeSubscriptionId?;
+    private _status?;
+    private _currentPeriodStart?;
+    private _currentPeriodEnd?;
+    private _cancelAtPeriodEnd;
+    private _canceledAt?;
+    private _trialStart?;
+    private _trialEnd?;
+    private _price?;
+    get stripeSubscriptionId(): string;
+    get status(): SubscriptionStatus;
+    get currentPeriodStart(): Date;
+    get currentPeriodEnd(): Date;
+    get cancelAtPeriodEnd(): boolean;
+    get canceledAt(): Date | undefined;
+    get trialStart(): Date | undefined;
+    get trialEnd(): Date | undefined;
+    get price(): StripePriceInterface | undefined;
+    rehydrate(data: JsonApiHydratedDataInterface): this;
+    createJsonApi(data: StripeSubscriptionInput): any;
+}
+
+/**
+ * Customer-facing billing service for managing subscriptions, payments, and usage
+ */
+declare class StripeSubscriptionService extends AbstractService {
+    /**
+     * List all subscriptions for the current user
+     */
+    static listSubscriptions(params?: {
+        next?: NextRef;
+        prev?: PreviousRef;
+    }): Promise<StripeSubscriptionInterface[]>;
+    /**
+     * Get a specific subscription by ID
+     */
+    static getSubscription(params: {
+        subscriptionId: string;
+    }): Promise<StripeSubscriptionInterface>;
+    /**
+     * Create a new subscription
+     * Returns subscription data along with meta containing SCA payment confirmation details
+     */
+    static createSubscription(params: StripeSubscriptionInput): Promise<StripeSubscriptionCreateResponse>;
+    /**
+     * Change the plan of an existing subscription
+     */
+    static changePlan(params: StripeSubscriptionInput): Promise<StripeSubscriptionInterface>;
+    /**
+     * Get a proration preview for a plan change
+     */
+    static getProrationPreview(params: {
+        subscriptionId: string;
+        newPriceId: string;
+        quantity?: number;
+    }): Promise<ProrationPreviewInterface>;
+    /**
+     * Cancel a subscription
+     */
+    static cancelSubscription(params: StripeSubscriptionInput): Promise<StripeSubscriptionInterface>;
+    /**
+     * Pause a subscription
+     */
+    static pauseSubscription(params: {
+        subscriptionId: string;
+    }): Promise<StripeSubscriptionInterface>;
+    /**
+     * Resume a paused subscription
+     */
+    static resumeSubscription(params: {
+        subscriptionId: string;
+    }): Promise<StripeSubscriptionInterface>;
+    /**
+     * Sync a subscription with the latest data from Stripe
+     * This is useful after payment confirmation to get the updated status
+     */
+    static syncSubscription(params: {
+        subscriptionId: string;
+    }): Promise<StripeSubscriptionInterface>;
+}
+
+declare const StripeSubscriptionModule: (factory: ModuleFactory) => ModuleWithPermissions;
+
+declare class StripeUsage extends AbstractApiData implements StripeUsageInterface {
+    private _subscriptionId?;
+    private _meterId?;
+    private _meterEventName?;
+    private _stripeEventId?;
+    private _quantity?;
+    private _timestamp?;
+    get subscriptionId(): string;
+    get meterId(): string;
+    get meterEventName(): string;
+    get stripeEventId(): string;
+    get quantity(): number;
+    get timestamp(): Date | undefined;
+    rehydrate(data: JsonApiHydratedDataInterface): this;
+    createJsonApi(data: ReportUsageInput): any;
+}
+
+/**
+ * Service for managing Stripe usage tracking
+ */
+declare class StripeUsageService extends AbstractService {
+    /**
+     * List all available usage meters
+     */
+    static listMeters(params?: {
+        next?: NextRef;
+        prev?: PreviousRef;
+    }): Promise<MeterInterface[]>;
+    /**
+     * Get meter summaries for a specific time period
+     */
+    static getMeterSummaries(params: {
+        meterId: string;
+        startTime: Date;
+        endTime: Date;
+    }): Promise<MeterSummaryInterface[]>;
+    /**
+     * Report usage for a subscription item
+     */
+    static reportUsage(params: ReportUsageInput): Promise<StripeUsageInterface>;
+    /**
+     * List usage records for a subscription item
+     */
+    static listUsageRecords(params: {
+        subscriptionItemId: string;
+        next?: NextRef;
+        prev?: PreviousRef;
+    }): Promise<StripeUsageInterface[]>;
+    /**
+     * Get usage summary for a subscription item
+     */
+    static getUsageSummary(params: {
+        subscriptionItemId: string;
+        start?: Date;
+        end?: Date;
+    }): Promise<UsageSummaryInterface>;
+}
+
+declare const StripeUsageModule: (factory: ModuleFactory) => ModuleWithPermissions;
+
+declare const ContentModule: (factory: ModuleFactory) => ModuleWithPermissions;
 
 declare class Content extends AbstractApiData implements ContentInterface, SearchResultInterface {
     private _contentType?;
@@ -718,8 +1226,6 @@ declare class Content extends AbstractApiData implements ContentInterface, Searc
     protected addContentInput(response: any, data: ContentInput): void;
 }
 
-declare const ContentModule: (factory: ModuleFactory) => ModuleWithPermissions;
-
 declare class Notification extends AbstractApiData implements NotificationInterface {
     private _notificationType?;
     private _isRead?;
@@ -771,4 +1277,4 @@ declare class S3 extends AbstractApiData implements S3Interface {
     createJsonApi(data: S3Input): any;
 }
 
-export { AbstractApiData, Action, ApiData, ApiDataInterface, ApiRequestDataTypeInterface, ApiResponseInterface, type AppModuleDefinitions, Auth, AuthInput, AuthInterface, AuthModule, AuthorModule, type BlockDiffOptions, BlockNoteDiffUtil, BlockNoteWordDiffRendererUtil, ClientAbstractService, ClientHttpMethod, type ClientNextRef, type ClientPreviousRef, type ClientSelfRef, Company, CompanyFields, CompanyInput, CompanyInterface, CompanyModule, Content, ContentInput, ContentInterface, ContentModule, DataClassRegistry as DataClass, DataClassRegistry, type DiffBlock, type DiffResult, EndpointCreator, type EndpointQuery, type EntityObject, Feature, FeatureInterface, FeatureModule, FieldSelector, type FormatOption, type FoundationModuleDefinitions, JsonApiDataFactory, JsonApiHydratedDataInterface, Module, type ModuleDefinitions, ModuleFactory, ModuleInterface, ModuleModule, ModuleRegistrar, ModuleRegistry, ModuleWithPermissions, Modules, Notification, NotificationFields, NotificationInput, NotificationInterface, NotificationModule, PermissionModule, PermissionUser, Push, type PushInput, type PushInterface, PushModule, RehydrationFactory, Role, RoleInput, RoleInterface, RoleModule, S3, S3Input, S3Interface, S3Module, type SearchResultInterface, TableOptions, User, UserInput, UserInterface, UserModule, type UserObject, type WordDiff, checkPermissions, checkPermissionsFromServer, cn, composeRefs, entityObjectSchema, exists, formatDate, getBootstrapper, getClientGlobalErrorHandler, getIcon, getIconByModule, getIconByModuleName, getLucideIcon, getLucideIconByModule, getLucideIconByModuleName, getTableComponents, getTableOptions, getValueFromPath, hasBootstrapper, rehydrate, rehydrateList, resetBootstrapStore, setBootstrapper, setClientGlobalErrorHandler, translateData, translateResponse, tryBootstrap, useComposedRefs, useIsMobile, userObjectSchema };
+export { AbstractApiData, AbstractService, Action, ApiData, ApiDataInterface, ApiRequestDataTypeInterface, ApiResponseInterface, type AppModuleDefinitions, Auth, AuthInput, AuthInterface, AuthModule, AuthorModule, Billing, BillingModule, BillingService, type BlockDiffOptions, BlockNoteDiffUtil, BlockNoteWordDiffRendererUtil, ClientAbstractService, ClientHttpMethod, type ClientNextRef, type ClientPreviousRef, type ClientSelfRef, Company, CompanyFields, CompanyInput, CompanyInterface, CompanyModule, Content, ContentInput, ContentInterface, ContentModule, DataClassRegistry as DataClass, DataClassRegistry, type DiffBlock, type DiffResult, EndpointCreator, type EndpointQuery, type EntityObject, Feature, FeatureInterface, FeatureModule, FieldSelector, type FormatOption, type FoundationModuleDefinitions, InvoiceStatus, JsonApiDataFactory, JsonApiHydratedDataInterface, MeterInterface, MeterSummaryInterface, Module, type ModuleDefinitions, ModuleFactory, ModuleInterface, ModuleModule, ModuleRegistrar, ModuleRegistry, ModuleWithPermissions, Modules, NextRef, Notification, NotificationFields, NotificationInput, NotificationInterface, NotificationModule, PaymentMethod, PaymentMethodInterface, PermissionModule, PermissionUser, PreviousRef, PriceRecurring, ProrationPreviewInterface, Push, type PushInput, type PushInterface, PushModule, RehydrationFactory, ReportUsageInput, Role, RoleInput, RoleInterface, RoleModule, S3, S3Input, S3Interface, S3Module, type SearchResultInterface, StripeCustomer, StripeCustomerInterface, StripeCustomerModule, StripeCustomerService, StripeInvoice, StripeInvoiceInterface, StripeInvoiceModule, StripeInvoiceService, StripePaymentMethodModule, StripePrice, StripePriceInput, StripePriceInterface, StripePriceModule, StripePriceService, StripeProduct, StripeProductInput, StripeProductInterface, StripeProductModule, StripeProductService, StripeSubscription, StripeSubscriptionCreateResponse, StripeSubscriptionInput, StripeSubscriptionInterface, StripeSubscriptionModule, StripeSubscriptionService, StripeUsage, StripeUsageInterface, StripeUsageModule, StripeUsageService, SubscriptionStatus, TableOptions, UsageSummaryInterface, User, UserInput, UserInterface, UserModule, type UserObject, type WordDiff, checkPermissions, checkPermissionsFromServer, cn, composeRefs, entityObjectSchema, exists, formatDate, getBootstrapper, getClientGlobalErrorHandler, getIcon, getIconByModule, getIconByModuleName, getLucideIcon, getLucideIconByModule, getLucideIconByModuleName, getTableComponents, getTableOptions, getValueFromPath, hasBootstrapper, rehydrate, rehydrateList, resetBootstrapStore, setBootstrapper, setClientGlobalErrorHandler, translateData, translateResponse, tryBootstrap, useComposedRefs, useIsMobile, userObjectSchema };