import { A as ApiData } from '../ApiData-DPKNfY-9.mjs';
import { A as ApiDataInterface, J as JsonApiHydratedDataInterface } from '../ApiDataInterface-BcZeXy5X.mjs';
import { A as ApiRequestDataTypeInterface, F as FieldSelector } from '../ApiRequestDataTypeInterface-CYEcRUrh.mjs';
export { G as GetterKeys, c as createJsonApiInclusion } from '../ApiRequestDataTypeInterface-CYEcRUrh.mjs';
import { A as ApiResponseInterface } from '../ApiResponseInterface-rsXRL_Hn.mjs';
import { A as AbstractApiData } from '../AbstractApiData-XLhBP5Tl.mjs';
import { A as AbstractService, N as NextRef, P as PreviousRef } from '../AbstractService-B0T7h8fX.mjs';
export { H as HttpMethod, S as SelfRef, T as TotalRef, b as clearLastApiMeta, c as clearLastApiTotal, d as getGlobalErrorHandler, a as getLastApiMeta, g as getLastApiTotal, s as setGlobalErrorHandler } from '../AbstractService-B0T7h8fX.mjs';
import { M as ModuleWithPermissions, g as PermissionUser, A as Action, f as PermissionModule, a as ModuleFactory } from '../types-Bq_UA8Lg.mjs';
export { d as ModuleDefinition, c as ModulePermissionDefinition, P as PageUrl, b as PermissionCheck, e as PermissionConfig } from '../types-Bq_UA8Lg.mjs';
import { a as HowToInterface, H as HowToInput, d as AssistantMessageInterface, A as AssistantMessageRole, e as ChunkInterface, C as ChunkRelationshipMeta, b as AssistantMessageType, c as AssistantMessageInput } from '../AssistantMessageInterface-ddyG114R.mjs';
export { B as BreadcrumbItemData } from '../AssistantMessageInterface-ddyG114R.mjs';
export { C as ContentFields, D as D3Link, a as D3Node, R as RoleFields, U as UserFields } from '../content.fields-1AlHDtDb.mjs';
import { ClassValue } from 'clsx';
export { ClassValue } from 'clsx';
import * as React from 'react';
import { ReactElement, ReactNode, JSXElementConstructor } from 'react';
import { z } from 'zod';
import { T as TotpAuthenticatorInterface, P as PasskeyInterface } from '../ai-connection.module-28f-hux0.mjs';
export { h as AiConnection, l as AiConnectionEnvDefaults, i as AiConnectionFields, n as AiConnectionInput, m as AiConnectionInterface, p as AiConnectionModule, o as AiConnectionService, j as AiProviderFieldDescriptor, k as AiProviderRegistry, A as AuthComponent, b as getIcon, a as getIconByModule, c as getIconByModuleName, g as getInitials, d as getLucideIcon, e as getLucideIconByModule, f as getLucideIconByModuleName } from '../ai-connection.module-28f-hux0.mjs';
import { PartialBlock } from '@blocknote/core';
import { ExternalToast } from 'sonner';
import { e as RoleInterface, R as RoleInput, U as UserInterface, c as CompanyInterface, f as UserInput, b as CompanyInput, C as ContentInterface, a as ContentInput, N as NotificationInterface, d as NotificationInput } from '../notification.interface-BWOCvKRP.mjs';
import { b as AuthInterface, A as AuthInput } from '../auth.interface-jYD8Gc4P.mjs';
export { a as AuthQuery } from '../auth.interface-jYD8Gc4P.mjs';
import { T as TwoFactorChallengeInterface, c as S3Interface, b as S3Input } from '../s3.service-D_dswjgz.mjs';
export { A as AuthService, C as CompanyService, a as ContentService, F as FeatureService, N as NotificationService, P as PushService, R as RoleService, S as S3Service, U as UserService } from '../s3.service-D_dswjgz.mjs';
import { PublicKeyCredentialCreationOptionsJSON, RegistrationResponseJSON, PublicKeyCredentialRequestOptionsJSON, AuthenticationResponseJSON } from '@simplewebauthn/browser';
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, q as PromotionCodeValidationResult } from '../stripe-promotion-code.interface-ClZ7DxS9.mjs';
export { c as ProrationLineItem, l as StripeSubscriptionCreateMeta, p as UsageRecordInterface } from '../stripe-promotion-code.interface-ClZ7DxS9.mjs';
import { M as ModuleInterface, F as FeatureInterface } from '../feature.interface-CXb1-vNq.mjs';
import { a as AssistantInterface, A as AssistantInput } from '../AssistantInterface-DMh-zApr.mjs';
import { O as OAuthClientInterface, a as OAuthClientInput, b as OAuthClientCreateRequest, c as OAuthClientCreateResponse, d as OAuthConsentRequest, f as OAuthConsentInfo } from '../oauth.interface-DRE3NAKc.mjs';
export { A as AVAILABLE_OAUTH_SCOPES, D as DEFAULT_GRANT_TYPES, g as OAUTH_SCOPE_DISPLAY, e as OAuthScopeInfo } from '../oauth.interface-DRE3NAKc.mjs';
export { b as TokenUsageAdminBreakdownModule, T as TokenUsageAdminSummaryModule, a as TokenUsageAdminTimelineModule, c as configureTokenUsage, g as getTokenUsageCurrency, t as tokenUsageModules } from '../config-n-ZpPmOL.mjs';
import 'lucide-react';
import 'd3';

/**
 * The single place in this package that reads `process.env`.
 *
 * Everything else imports {@link ENV}. Centralising the reads keeps every
 * default in one place — the same contract `base.config.ts` provides on the
 * NestJS side — instead of scattering `process.env.X || "…"` across hooks,
 * clients and components where the fallbacks silently drift apart.
 *
 * WHY THE READS MUST STAY LITERAL: Next.js inlines `NEXT_PUBLIC_*` by textual
 * substitution at build time, replacing the exact expression
 * `process.env.NEXT_PUBLIC_FOO` with a string literal. A computed lookup
 * (`process.env[key]`) is NOT substituted and reads as `undefined` in the
 * browser bundle. Every entry below therefore spells its variable out in full,
 * and new entries must do the same.
 *
 * WHY GETTERS AND NOT PLAIN PROPERTIES: every call site this replaced read
 * `process.env` at CALL time, not at import time. A plain property would freeze
 * the value when the module is first imported, which breaks any consumer that
 * assigns the variable after boot — the package's own tests do exactly that.
 * Getters keep the read lazy while leaving the expression literal, so the build
 * time substitution still applies.
 *
 * Because that substitution happens before the code runs, no reference to
 * `process` survives into the client bundle — so this module is safe to import
 * from client components, server components, route handlers and middleware
 * alike. It deliberately carries no `"use client"` directive for that reason.
 *
 * Values are normalised (empty string rather than `undefined`, booleans rather
 * than string comparisons) so callers never repeat the parsing. Callers that
 * must distinguish "unset" from "set to empty" — the URL getters, which throw a
 * configuration error — check for an empty string.
 */
declare const ENV: {
    /** Public API base URL (NEXT_PUBLIC_API_URL). Empty when unset. */
    readonly API_URL: string;
    /** Public app base URL (NEXT_PUBLIC_ADDRESS). Empty when unset. */
    readonly APP_URL: string;
    /**
     * Alternative app base URL (NEXT_PUBLIC_APP_URL), used only by
     * `client/config.ts`'s `getAppUrl()` before it falls back to
     * `window.location.origin`. Empty when unset.
     */
    readonly APP_URL_ALTERNATE: string;
    /** Web-push VAPID public key (NEXT_PUBLIC_VAPID_PUBLIC_KEY). Empty when unset. */
    readonly VAPID_PUBLIC_KEY: string;
    /** Google Maps JS key (NEXT_PUBLIC_GOOGLE_MAPS_API_KEY). Empty disables autocomplete. */
    readonly GOOGLE_MAPS_API_KEY: string;
    /**
     * NEXT_PUBLIC_PRIVATE_INSTALLATION === "true", case-insensitively
     * (default false). A private installation is a single-tenant deployment.
     */
    readonly PRIVATE_INSTALLATION: boolean;
    /** NODE_ENV === "production" — set by the Next build, not by `.env`. */
    readonly IS_PRODUCTION: boolean;
    /** NODE_ENV === "development" — gates verbose client-side diagnostics. */
    readonly IS_DEVELOPMENT: boolean;
};

declare enum ClientHttpMethod {
    GET = "GET",
    POST = "POST",
    PUT = "PUT",
    PATCH = "PATCH",
    DELETE = "DELETE"
}
interface ClientNextRef {
    next?: string;
}
interface ClientPreviousRef {
    previous?: string;
}
interface ClientSelfRef {
    self?: string;
}
interface ClientTotalRef {
    total?: number;
}
/**
 * Set a global error handler for API errors (client-side only).
 * This handler will be called instead of throwing errors.
 */
declare function setClientGlobalErrorHandler(handler: (status: number, message: string) => void): void;
/**
 * Get the current global error handler.
 */
declare function getClientGlobalErrorHandler(): ((status: number, message: string) => void) | null;
/**
 * Client-side abstract base class for services that interact with the JSON:API.
 * Use this for client components.
 */
declare abstract class ClientAbstractService {
    /**
     * Extract locale from client-side URL pathname
     * URL structure: /{locale}/route-path (e.g., /it/accounts)
     * Fallback chain: URL locale → navigator.language → "en"
     */
    private static getClientLocale;
    /**
     * Fetch the next page of results.
     */
    static next<T>(params: {
        type: ApiRequestDataTypeInterface;
        endpoint: string;
        next?: ClientNextRef;
        previous?: ClientPreviousRef;
        self?: ClientSelfRef;
        total?: ClientTotalRef;
    }): Promise<T>;
    /**
     * Fetch the previous page of results.
     */
    static previous<T>(params: {
        type: ApiRequestDataTypeInterface;
        endpoint: string;
        next?: ClientNextRef;
        previous?: ClientPreviousRef;
        self?: ClientSelfRef;
        total?: ClientTotalRef;
    }): Promise<T>;
    /**
     * Make a client-side API call.
     */
    protected static callApi<T>(params: {
        type: ApiRequestDataTypeInterface;
        method: ClientHttpMethod;
        endpoint: string;
        companyId?: string;
        input?: any;
        overridesJsonApiCreation?: boolean;
        next?: ClientNextRef;
        previous?: ClientPreviousRef;
        self?: ClientSelfRef;
        total?: ClientTotalRef;
        responseType?: ApiRequestDataTypeInterface;
        files?: {
            [key: string]: File | Blob;
        } | File | Blob;
        /**
         * Per-call override of the API base URL (mirrors `AbstractService.callApi`'s `baseUrl`).
         * Omitted => existing global `NEXT_PUBLIC_API_URL` resolution, unchanged.
         */
        baseUrl?: string;
    }): Promise<T>;
    /**
     * Get raw JSON:API response data without deserialization.
     */
    protected static getRawData(params: {
        type: ApiRequestDataTypeInterface;
        method: ClientHttpMethod;
        endpoint: string;
        companyId?: string;
    }): Promise<any>;
}

declare class JsonApiDataFactory {
    static create(classKey: ApiRequestDataTypeInterface, data: any): any;
}

declare class RehydrationFactory {
    static rehydrate<T extends ApiDataInterface>(classKey: ApiRequestDataTypeInterface, data: JsonApiHydratedDataInterface): T;
    static rehydrateList<T extends ApiDataInterface>(classKey: ApiRequestDataTypeInterface, data: JsonApiHydratedDataInterface[]): T[];
}

declare class DataClassRegistry {
    private static _map;
    static registerObjectClass(key: ApiRequestDataTypeInterface, classConstructor: {
        new (): ApiDataInterface;
    }): void;
    static get(classKey: ApiRequestDataTypeInterface): {
        new (): ApiDataInterface;
    };
    /**
     * Get class constructor by JSON:API type name.
     * Used for polymorphic rehydration where the type is determined at runtime.
     */
    static getByJsonApiType(typeName: string): {
        new (): ApiDataInterface;
    } | undefined;
    /**
     * Bootstrap the registry with all modules.
     * This is a convenience method for apps to register all their modules at once.
     *
     * @param modules - An object with module definitions (like the app's Modules class)
     */
    static bootstrap(modules: Record<string, ApiRequestDataTypeInterface>): void;
    /**
     * Clear all registered classes. Useful for testing.
     */
    static clear(): void;
}

/**
 * Helper class to bootstrap the registry from a Modules-style class.
 * This supports the pattern where modules are defined as static getters.
 */
declare class ModuleRegistrar {
    private static _isBootstrapped;
    /**
     * Bootstrap the registry from a Modules class.
     * Automatically detects static getters and registers their models.
     *
     * @param modulesClass - The Modules class with static getters
     */
    static bootstrap<T extends object>(modulesClass: T): void;
    /**
     * Reset the bootstrapped state. Useful for testing.
     */
    static reset(): void;
}

interface FoundationModuleDefinitions {
    S3: ModuleWithPermissions;
    Auth: ModuleWithPermissions;
    User: ModuleWithPermissions;
    Author: ModuleWithPermissions;
    Company: ModuleWithPermissions;
    Role: ModuleWithPermissions;
    Notification: ModuleWithPermissions;
    Push: ModuleWithPermissions;
    Feature: ModuleWithPermissions;
    Module: ModuleWithPermissions;
    Content: ModuleWithPermissions;
    HowTo: ModuleWithPermissions;
    Assistant: ModuleWithPermissions;
    AssistantMessage: ModuleWithPermissions;
    AssistantAction: ModuleWithPermissions;
    Chunk: ModuleWithPermissions;
    Billing: ModuleWithPermissions;
    StripeCustomer: ModuleWithPermissions;
    StripePaymentMethod: ModuleWithPermissions;
    StripeSubscription: ModuleWithPermissions;
    StripeInvoice: ModuleWithPermissions;
    StripeProduct: ModuleWithPermissions;
    StripePrice: ModuleWithPermissions;
    StripeUsage: ModuleWithPermissions;
    StripePromotionCode: ModuleWithPermissions;
    AiConnection: ModuleWithPermissions;
    OAuth: ModuleWithPermissions;
    Waitlist: ModuleWithPermissions;
    WaitlistStats: ModuleWithPermissions;
    Referral: ModuleWithPermissions;
    ReferralStats: ModuleWithPermissions;
    TotpAuthenticator: ModuleWithPermissions;
    TotpSetup: ModuleWithPermissions;
    TotpVerify: ModuleWithPermissions;
    TotpVerifyLogin: ModuleWithPermissions;
    Passkey: ModuleWithPermissions;
    PasskeyRegistrationOptions: ModuleWithPermissions;
    PasskeyRegistrationVerify: ModuleWithPermissions;
    PasskeyRename: ModuleWithPermissions;
    PasskeyVerifyLogin: ModuleWithPermissions;
    PasskeyAuthenticationOptions: ModuleWithPermissions;
    TwoFactorEnable: ModuleWithPermissions;
    TwoFactorChallenge: ModuleWithPermissions;
    TwoFactorStatus: ModuleWithPermissions;
    BackupCodeVerify: ModuleWithPermissions;
    PermissionMapping: ModuleWithPermissions;
    ModulePaths: ModuleWithPermissions;
    RbacMatrix: ModuleWithPermissions;
    AuditLog: ModuleWithPermissions;
    TokenUsageAdminSummary: ModuleWithPermissions;
    TokenUsageAdminTimeline: ModuleWithPermissions;
    TokenUsageAdminBreakdown: ModuleWithPermissions;
    TokenUsageReportSummary: ModuleWithPermissions;
    TokenUsageReportTimeline: ModuleWithPermissions;
    TokenUsageReportBreakdown: ModuleWithPermissions;
}
interface AppModuleDefinitions {
}
type ModuleDefinitions = FoundationModuleDefinitions & AppModuleDefinitions;
declare class ModuleRegistryClass {
    private get _modules();
    register<K extends string>(name: K, module: ApiRequestDataTypeInterface): void;
    get<K extends keyof ModuleDefinitions>(name: K): ModuleDefinitions[K];
    findByName(moduleName: string): ModuleWithPermissions;
    getAllPageUrls(): {
        id: string;
        text: string;
    }[];
    findByModelName(modelName: string): ModuleWithPermissions;
    findByFeature(feature: string): ModuleWithPermissions[];
    getAll(): ApiRequestDataTypeInterface[];
}
declare const ModuleRegistry: ModuleRegistryClass;
declare const Modules: ModuleDefinitions & {
    findByName: (name: string) => ModuleWithPermissions;
    findByModelName: (name: string) => ModuleWithPermissions;
    findByFeature: (feature: string) => ModuleWithPermissions[];
};

/**
 * Centralized bootstrap store accessible from ModuleRegistry.
 * This file has NO external dependencies to avoid circular imports.
 *
 * The bootstrap store allows ModuleRegistry to call the app's bootstrapper
 * when modules are accessed before bootstrap() was called, providing
 * self-healing behavior for module evaluation order issues.
 *
 * IMPORTANT: We use globalThis to persist state across HMR/Turbopack
 * module re-evaluations in development mode. Without this, the bootstrapper
 * reference would be lost when modules are hot-reloaded, causing
 * "Module not registered" errors during navigation.
 */
type BootstrapperFn = () => void;
/**
 * Register the bootstrapper function.
 * Called by configureJsonApi() from client/config, client/JsonApiClient, or unified/JsonApiRequest.
 */
declare function setBootstrapper(fn: BootstrapperFn): void;
/**
 * Get the registered bootstrapper function.
 * Returns null if no bootstrapper has been registered.
 */
declare function getBootstrapper(): BootstrapperFn | null;
/**
 * Attempt to run the bootstrapper if one is registered.
 * Returns true if bootstrapper was executed, false if not available.
 * Safe to call multiple times - bootstrapper is expected to be idempotent.
 */
declare function tryBootstrap(): boolean;
/**
 * Check if a bootstrapper has been registered.
 */
declare function hasBootstrapper(): boolean;
/**
 * Reset the bootstrap store. Useful for testing.
 */
declare function resetBootstrapStore(): void;

type EndpointQuery = {
    endpoint: ApiRequestDataTypeInterface | string;
    id?: string;
    childEndpoint?: ApiRequestDataTypeInterface | string;
    childId?: string;
    additionalParams?: {
        key: string;
        value: string | string[];
    }[];
};
declare class EndpointCreator {
    private _endpoint;
    constructor(params: {
        endpoint: ApiRequestDataTypeInterface | string;
        id?: string;
        childEndpoint?: ApiRequestDataTypeInterface | string;
        childId?: string;
        additionalParams?: {
            key: string;
            value: string;
        }[];
    });
    endpoint(value: ApiRequestDataTypeInterface | string): EndpointCreator;
    id(value: string): EndpointCreator;
    childEndpoint(value: ApiRequestDataTypeInterface | string): EndpointCreator;
    childId(value: string): EndpointCreator;
    set additionalParams(value: {
        key: string;
        value: string;
    }[]);
    addAdditionalParam(key: string, value: string | string[]): EndpointCreator;
    limitToType(selectors: string[]): this;
    limitToFields(selectors: FieldSelector<any>[]): this;
    generate(): string;
}

/**
 * Translates raw JSON:API data into typed objects.
 * Does not require API response metadata.
 */
declare function translateData<T extends ApiDataInterface>(params: {
    classKey: ApiRequestDataTypeInterface;
    data: any;
}): T | T[];
/**
 * Translates a full API response into a typed ApiResponseInterface.
 * Includes pagination support.
 */
declare function translateResponse<T extends ApiDataInterface>(params: {
    classKey: ApiRequestDataTypeInterface;
    apiResponse: ApiData;
    companyId?: string;
    language: string;
    paginationHandler?: (endpoint: string) => Promise<ApiResponseInterface>;
}): Promise<ApiResponseInterface>;

/**
 * Rehydrate a single dehydrated object back into its typed class instance.
 */
declare function rehydrate<T extends ApiDataInterface>(classKey: ApiRequestDataTypeInterface, data: JsonApiHydratedDataInterface): T;
/**
 * Rehydrate a list of dehydrated objects back into typed class instances.
 */
declare function rehydrateList<T extends ApiDataInterface>(classKey: ApiRequestDataTypeInterface, data: JsonApiHydratedDataInterface[]): T[];

declare function cn(...inputs: ClassValue[]): string;

type PossibleRef<T> = React.Ref<T> | undefined;
/**
 * A utility to compose multiple refs together
 * Accepts callback refs and RefObject(s)
 */
declare function composeRefs<T>(...refs: PossibleRef<T>[]): React.RefCallback<T>;
/**
 * A custom hook that composes multiple refs
 * Accepts callback refs and RefObject(s)
 */
declare function useComposedRefs<T>(...refs: PossibleRef<T>[]): React.RefCallback<T>;

declare const MOBILE_BREAKPOINT = 768;
declare const VIEWPORT_COOKIE_NAME = "viewport_mobile";
declare function useIsMobile(): boolean;

type FormatOption = "date" | "time" | "dateTime" | "timeSince" | "default";
/**
 * Format a `Date` as `YYYY-MM-DD` using the value's local-time components.
 *
 * Use for JSON:API attributes whose backend field type is `"date"` (calendar
 * date with no time component). `JSON.stringify(new Date(...))` would call
 * `.toISOString()`, which UTC-shifts and can lose a day west of UTC; this
 * helper avoids that by emitting the local-date components verbatim.
 *
 * For `"datetime"` fields use `.toISOString()` instead — those represent an
 * instant in time and the UTC shift is correct.
 */
declare const formatLocalDate: (d: Date) => string;
declare const formatDate: (eventDate: Date, formatOption: FormatOption, locale?: string) => string;

declare const exists: <T>(itemOrArray: T | T[] | null | undefined) => boolean;

/**
 * Check if a user has permission to perform an action on a module.
 *
 * @param module - The module to check permissions for
 * @param action - The action to check (read, create, update, delete)
 * @param user - The user with their modules and permissions
 * @param data - Optional data object for path-based permission checks
 */
declare function checkPermissions<T extends PermissionUser>(params: {
    module: ModuleWithPermissions;
    action: Action;
    user: T;
    data?: any;
}): boolean;
/**
 * Check permissions from server context where user object is not fully available.
 *
 * @param module - The module to check permissions for
 * @param action - The action to check
 * @param userId - The user's ID
 * @param selectedModule - The selected module with its permissions
 * @param data - Optional data object for path-based permission checks
 */
declare function checkPermissionsFromServer(params: {
    module: ModuleWithPermissions;
    action: Action;
    userId: string;
    selectedModule?: PermissionModule;
    data?: any;
}): boolean;
/**
 * Traverse an object path and check if the value matches the user ID.
 * Handles nested objects, arrays, and various data structures.
 */
declare function getValueFromPath(obj: any, path: string, userId: string): any;

declare class TableOptions {
    private _components;
    private _hasPermissionToModule;
    constructor(hasPermissionToModule: <M extends ModuleWithPermissions>(params: {
        module: M;
        action: Action;
        data?: any;
    }) => boolean);
    addOption<M extends ModuleWithPermissions>(component: ReactElement<any> | null, module?: M, action?: Action): void;
    getComponents(): ReactElement<any>[];
    getOptions(): ReactElement<any> | null;
}
declare function getTableOptions(params: {
    hasPermissionToModule: <M extends ModuleWithPermissions>(params: {
        module: M;
        action: Action;
        data?: any;
    }) => boolean;
    options: {
        component: ReactElement<any> | null;
        module?: ModuleWithPermissions;
        action?: Action;
    }[];
}): ReactElement<any> | null;
declare function getTableComponents(params: {
    hasPermissionToModule: <M extends ModuleWithPermissions>(params: {
        module: M;
        action: Action;
        data?: any;
    }) => boolean;
    options: {
        component: ReactElement<any> | null;
        module?: ModuleWithPermissions;
        action?: Action;
    }[];
}): ReactElement<any>[];

declare const userObjectSchema: z.ZodObject<{
    id: z.ZodString;
    name: z.ZodString;
    avatar: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
type UserObject = z.infer<typeof userObjectSchema>;

declare const entityObjectSchema: z.ZodObject<{
    id: z.ZodUUID;
    name: z.ZodString;
}, z.core.$strip>;
type EntityObject = z.infer<typeof entityObjectSchema>;

/**
 * True when an image src is an absolute remote URL.
 *
 * `next/image` THROWS when it is given an absolute URL whose hostname is not
 * listed in `images.remotePatterns`, which takes down the whole page through
 * the nearest error boundary. Avatars can come from OAuth providers
 * (Discord, Google, ...), so their hostname is user-controlled and can never
 * be reliably enumerated in config. Pass `unoptimized` for these srcs.
 *
 * `blob:` and `data:` srcs are excluded: `next/image` already marks those
 * unoptimized on its own.
 */
declare function isRemoteImageSrc(src?: string | null): boolean;

declare function validatePartitaIva(partitaIva: string): boolean;
type CodiceFiscaleValidationOptions = {
    /** When true, a valid Partita IVA is also accepted as a valid value. */
    allowPartitaIva?: boolean;
};
declare function validateCodiceFiscale(codiceFiscale: string, options?: CodiceFiscaleValidationOptions): boolean;
declare function validateItalianTaxCode(value: string, type: "partitaIva" | "codiceFiscale", options?: CodiceFiscaleValidationOptions): boolean;
declare function formatPartitaIva(partitaIva: string): string;
declare function formatCodiceFiscale(codiceFiscale: string): string;

interface WordDiff {
    type: "added" | "removed" | "unchanged";
    text: string;
    diffId: string;
    accepted?: boolean;
    rejected?: boolean;
}
interface DiffBlock {
    id?: string;
    type?: string;
    props?: any;
    content?: any;
    children?: DiffBlock[];
    diffType?: "added" | "removed" | "modified" | "unchanged";
    originalContent?: any;
    diffId?: string;
    wordDiffs?: WordDiff[];
    accepted?: boolean;
    rejected?: boolean;
}
interface DiffResult {
    blocks: DiffBlock[];
    hasChanges: boolean;
}
interface BlockDiffOptions {
    ignoreIds?: boolean;
    compareContent?: boolean;
    similarityThreshold?: number;
}
/**
 * BlockNote Diff Utility
 * Implements a sophisticated diff algorithm for BlockNote document structures
 */
declare class BlockNoteDiffUtil {
    private static readonly DEFAULT_OPTIONS;
    /**
     * Compare two BlockNote documents and return diff result
     */
    static diff(originalBlocks?: PartialBlock[], newBlocks?: PartialBlock[], options?: BlockDiffOptions): DiffResult;
    /**
     * Compare two blocks for equality
     */
    private static areBlocksEqual;
    /**
     * Deep equality comparison for objects
     */
    private static deepEqual;
    /**
     * Sort diff blocks to maintain logical order
     */
    private static sortDiffBlocks;
    /**
     * Calculate similarity between two text contents
     */
    private static calculateSimilarity;
    /**
     * Extract plain text from BlockNote content array
     */
    private static extractTextFromContent;
    /**
     * Calculate Levenshtein distance between two strings
     */
    private static levenshteinDistance;
    /**
     * Generate word-level diffs between two content arrays
     */
    static generateWordDiffs(originalContent: any, newContent: any, blockId: string): WordDiff[];
    /**
     * Perform word-level diff using word-only approach (no space tokenization)
     */
    private static diffWords; /**
     * Improved diff algorithm that better handles word insertions
     * Uses a combination of LCS and heuristics to minimize false changes
     */
    private static myersDiff;
    /**
     * Compute edit script using dynamic programming
     */
    private static computeEditScript;
    /**
     * Reconstruct the actual diff from the DP table
     */
    private static reconstructDiff;
    /**
     * Consolidate adjacent changes to reduce fragmentation
     * e.g., if we have: delete "Key", insert "Key!", delete "Challenges"
     * We can consolidate this into: replace ["Key", "Challenges"] with ["Key!"]
     */
    private static consolidateAdjacentChanges;
    /**
     * Determine if a sequence of changes should be consolidated
     */
    private static shouldConsolidateChanges;
    /**
     * Check if two words are similar enough to be considered a replacement
     */
    private static areWordsSimilar;
}

declare class BlockNoteWordDiffRendererUtil {
    static renderWordDiffs(diffBlocks: DiffBlock[], onAcceptChange?: (diffId: string) => void, onRejectChange?: (diffId: string) => void, acceptedChanges?: Set<string>, rejectedChanges?: Set<string>): PartialBlock[];
    private static updateWordDiffStates;
    private static renderDiffBlock;
    private static renderBlockLevelDiff;
    private static renderWordLevelDiff;
    private static groupAndRenderWordDiffs;
    private static cleanupSpaces;
    private static isLastDiffInGroup;
    private static createTextContent;
    private static getBlockProps;
    static generateChangeSummary(diffBlocks: DiffBlock[]): {
        totalWords: number;
        addedWords: number;
        removedWords: number;
        acceptedChanges: number;
        rejectedChanges: number;
        pendingChanges: number;
    };
}

type ToastOptions = {
    description?: ReactNode;
    duration?: number;
    id?: string;
    onDismiss?: () => void;
    action?: ExternalToast["action"];
    dismissible?: boolean;
};
/** Standard toast - neutral/white */
declare function showToast(message: string, options?: ToastOptions): string | number;
/** Error toast - destructive red */
declare function showError(message: string, options?: ToastOptions): string | number;
/** Dismiss toast(s) */
declare function dismissToast(toastId?: string | number): string | number;
/** Custom toast - ONLY for complex UI like upload progress */
declare function showCustomToast(render: (id: string | number) => ReactElement<unknown, string | JSXElementConstructor<unknown>>, options?: {
    id?: string | number;
    duration?: number;
    dismissible?: boolean;
    onDismiss?: () => void;
}): string | number;

declare const AuthModule: (factory: ModuleFactory) => ModuleWithPermissions;

declare const TotpAuthenticatorModule: (factory: ModuleFactory) => ModuleWithPermissions;

declare const TotpSetupModule: (factory: ModuleFactory) => ModuleWithPermissions;

declare const TotpVerifyModule: (factory: ModuleFactory) => ModuleWithPermissions;

declare const TotpVerifyLoginModule: (factory: ModuleFactory) => ModuleWithPermissions;

declare const PasskeyModule: (factory: ModuleFactory) => ModuleWithPermissions;

declare const PasskeyRegistrationOptionsModule: (factory: ModuleFactory) => ModuleWithPermissions;

declare const PasskeyRegistrationVerifyModule: (factory: ModuleFactory) => ModuleWithPermissions;

declare const PasskeyRenameModule: (factory: ModuleFactory) => ModuleWithPermissions;

declare const PasskeyVerifyLoginModule: (factory: ModuleFactory) => ModuleWithPermissions;

declare const PasskeyAuthenticationOptionsModule: (factory: ModuleFactory) => ModuleWithPermissions;

declare const TwoFactorEnableModule: (factory: ModuleFactory) => ModuleWithPermissions;

declare const TwoFactorChallengeModule: (factory: ModuleFactory) => ModuleWithPermissions;

declare const TwoFactorStatusModule: (factory: ModuleFactory) => ModuleWithPermissions;

declare const BackupCodeVerifyModule: (factory: ModuleFactory) => ModuleWithPermissions;

declare const ModuleModule: (factory: ModuleFactory) => ModuleWithPermissions;

declare class Module extends AbstractApiData implements ModuleInterface {
    private _name?;
    private _permissions?;
    get name(): string;
    get permissions(): {
        create: boolean | string;
        read: boolean | string;
        update: boolean | string;
        delete: boolean | string;
    };
    rehydrate(data: JsonApiHydratedDataInterface): this;
}

declare const FeatureModule: (factory: ModuleFactory) => ModuleWithPermissions;

declare class Feature extends AbstractApiData implements FeatureInterface {
    private _name?;
    private _isCore?;
    private _modules;
    get name(): string;
    get isCore(): boolean;
    get modules(): ModuleInterface[];
    rehydrate(data: JsonApiHydratedDataInterface): this;
}

declare const AuthorModule: (factory: ModuleFactory) => ModuleWithPermissions;

declare class Role extends AbstractApiData implements RoleInterface {
    private _name?;
    private _description?;
    private _isSelectable?;
    private _requiredFeature?;
    get name(): string;
    get description(): string;
    get isSelectable(): boolean;
    get requiredFeature(): FeatureInterface | undefined;
    rehydrate(data: JsonApiHydratedDataInterface): this;
    createJsonApi(data: RoleInput): any;
}

declare const RoleModule: (factory: ModuleFactory) => ModuleWithPermissions;

interface SearchResultInterface {
    get searchResult(): string;
}

declare class User extends AbstractApiData implements UserInterface, SearchResultInterface {
    private _name?;
    private _email?;
    private _title?;
    private _bio?;
    private _avatar?;
    private _avatarUrl?;
    private _phone?;
    private _rate?;
    private _isActivated?;
    private _isDeleted?;
    private _twoFactorEnabled;
    private _lastLogin?;
    private _relevance?;
    private _roles;
    private _company?;
    private _modules;
    get searchResult(): string;
    get name(): string;
    get email(): string;
    get title(): string;
    get bio(): string;
    get avatar(): string | undefined;
    get avatarUrl(): string | undefined;
    get phone(): string | undefined;
    get rate(): number | undefined;
    get relevance(): number | undefined;
    get isActivated(): boolean;
    get isDeleted(): boolean;
    get twoFactorEnabled(): boolean;
    get lastLogin(): Date | undefined;
    get roles(): RoleInterface[];
    get company(): CompanyInterface | undefined;
    get modules(): ModuleInterface[];
    rehydrate(data: JsonApiHydratedDataInterface): this;
    createJsonApi(data: UserInput): any;
}

/**
 * localStorage key backing the `CurrentUserProvider` atom.
 *
 * Owned by this library, not by the apps that consume it: `<Logout />` clears
 * it on every sign-out. Kept in its own module so both the provider that writes
 * it and the component that clears it can reference the same constant without
 * importing each other.
 */
declare const CURRENT_USER_STORAGE_KEY = "user";

declare const UserModule: (factory: ModuleFactory) => ModuleWithPermissions;

declare class Auth extends AbstractApiData implements AuthInterface {
    private _token?;
    private _refreshToken?;
    private _user?;
    get token(): string;
    get refreshToken(): string;
    get user(): UserInterface;
    rehydrate(data: JsonApiHydratedDataInterface): this;
    createJsonApi(data: AuthInput): any;
}

interface TwoFactorStatusInterface extends ApiDataInterface {
    get isEnabled(): boolean;
    get preferredMethod(): "totp" | "passkey" | undefined;
    get totpAuthenticators(): TotpAuthenticatorInterface[];
    get passkeys(): PasskeyInterface[];
    get backupCodesCount(): number;
}

declare class TwoFactorStatus extends AbstractApiData implements TwoFactorStatusInterface {
    private _isEnabled;
    private _preferredMethod?;
    private _totpAuthenticators;
    private _passkeys;
    private _backupCodesCount;
    get isEnabled(): boolean;
    get preferredMethod(): "totp" | "passkey" | undefined;
    get totpAuthenticators(): TotpAuthenticatorInterface[];
    get passkeys(): PasskeyInterface[];
    get backupCodesCount(): number;
    rehydrate(data: JsonApiHydratedDataInterface): this;
}

declare class TotpAuthenticator extends AbstractApiData implements TotpAuthenticatorInterface {
    private _name;
    private _verified;
    private _lastUsedAt?;
    get name(): string;
    get verified(): boolean;
    get lastUsedAt(): Date | undefined;
    rehydrate(data: JsonApiHydratedDataInterface): this;
}

interface TotpSetupInterface {
    get secret(): string;
    get qrCodeUri(): string;
    get authenticatorId(): string;
}

type TotpSetupInput = {
    id: string;
    name: string;
    accountName: string;
};
declare class TotpSetup extends AbstractApiData implements TotpSetupInterface {
    private _qrCodeUri;
    private _secret;
    private _authenticatorId;
    get qrCodeUri(): string;
    get secret(): string;
    get authenticatorId(): string;
    rehydrate(data: JsonApiHydratedDataInterface): this;
    createJsonApi(data: TotpSetupInput): {
        data: {
            type: string;
            id: string;
            attributes: {
                name: string;
                accountName: string;
            };
        };
    };
}

declare class Passkey extends AbstractApiData implements PasskeyInterface {
    private _name;
    private _credentialId;
    private _deviceType;
    private _backedUp;
    private _lastUsedAt?;
    get name(): string;
    get credentialId(): string;
    get deviceType(): string;
    get backedUp(): boolean;
    get lastUsedAt(): Date | undefined;
    rehydrate(data: JsonApiHydratedDataInterface): this;
}

type PasskeyRegistrationOptionsInput = {
    id: string;
    userName: string;
    userDisplayName?: string;
};
interface PasskeyRegistrationOptionsInterface {
    pendingId: string;
    options: PublicKeyCredentialCreationOptionsJSON;
}
declare class PasskeyRegistrationOptions extends AbstractApiData implements PasskeyRegistrationOptionsInterface {
    private _pendingId;
    private _options;
    get pendingId(): string;
    get options(): PublicKeyCredentialCreationOptionsJSON;
    rehydrate(data: JsonApiHydratedDataInterface): this;
    createJsonApi(data: PasskeyRegistrationOptionsInput): {
        data: {
            type: string;
            id: string;
            attributes: {
                userName: string;
                userDisplayName: string | undefined;
            };
        };
    };
}

type PasskeyRegistrationVerifyInput = {
    id: string;
    pendingId: string;
    name: string;
    response: RegistrationResponseJSON;
};
declare class PasskeyRegistrationVerify extends AbstractApiData implements PasskeyInterface {
    private _name;
    private _credentialId;
    private _deviceType;
    private _backedUp;
    private _lastUsedAt?;
    get name(): string;
    get credentialId(): string;
    get deviceType(): string;
    get backedUp(): boolean;
    get lastUsedAt(): Date | undefined;
    rehydrate(data: JsonApiHydratedDataInterface): this;
    createJsonApi(data: PasskeyRegistrationVerifyInput): {
        data: {
            type: string;
            id: string;
            attributes: {
                pendingId: string;
                name: string;
                response: RegistrationResponseJSON;
            };
        };
    };
}

interface PasskeyAuthenticationOptionsInterface extends ApiDataInterface {
    get pendingId(): string;
    get options(): PublicKeyCredentialRequestOptionsJSON;
}

type PasskeyAuthenticationOptionsInput = {
    id: string;
};
declare class PasskeyAuthenticationOptions extends AbstractApiData implements PasskeyAuthenticationOptionsInterface {
    private _pendingId;
    private _options;
    get pendingId(): string;
    get options(): PublicKeyCredentialRequestOptionsJSON;
    rehydrate(data: JsonApiHydratedDataInterface): this;
    createJsonApi(data: PasskeyAuthenticationOptionsInput): {
        data: {
            type: string;
            id: string;
            attributes: {};
        };
    };
}

declare class TwoFactorService extends AbstractService {
    static getStatus(): Promise<TwoFactorStatusInterface>;
    static enable(params: {
        id: string;
        preferredMethod: "totp" | "passkey";
    }): Promise<void>;
    static disable(params: {
        code: string;
    }): Promise<void>;
    static setupTotp(params: {
        id: string;
        name: string;
        accountName: string;
    }): Promise<TotpSetupInterface>;
    static verifyTotpSetup(params: {
        id: string;
        authenticatorId: string;
        code: string;
    }): Promise<void>;
    static listTotpAuthenticators(): Promise<TotpAuthenticatorInterface[]>;
    static deleteTotpAuthenticator(params: {
        id: string;
    }): Promise<void>;
    static getPasskeyRegistrationOptions(params: {
        id: string;
        userName: string;
        userDisplayName?: string;
    }): Promise<PasskeyRegistrationOptionsInterface>;
    static verifyPasskeyRegistration(params: {
        id: string;
        pendingId: string;
        name: string;
        response: RegistrationResponseJSON;
    }): Promise<PasskeyInterface>;
    static listPasskeys(): Promise<PasskeyInterface[]>;
    static deletePasskey(params: {
        id: string;
    }): Promise<void>;
    static renamePasskey(params: {
        id: string;
        name: string;
    }): Promise<PasskeyInterface>;
    static generateBackupCodes(): Promise<string[]>;
    static getBackupCodesCount(): Promise<number>;
    private static handleSuccessfulAuth;
    static getChallenge(params: {
        id: string;
        pendingToken: string;
        method: "totp" | "passkey" | "backup";
    }): Promise<TwoFactorChallengeInterface>;
    static verifyTotp(params: {
        id: string;
        pendingToken: string;
        code: string;
    }): Promise<AuthInterface>;
    static getPasskeyAuthOptions(params: {
        pendingToken: string;
    }): Promise<PasskeyAuthenticationOptionsInterface>;
    static verifyPasskey(params: {
        id: string;
        pendingToken: string;
        pendingId: string;
        credential: AuthenticationResponseJSON;
    }): Promise<AuthInterface>;
    static verifyBackupCode(params: {
        id: string;
        pendingToken: string;
        code: string;
    }): Promise<AuthInterface>;
}

type TotpVerifyInput = {
    id: string;
    authenticatorId: string;
    code: string;
};
declare class TotpVerify extends AbstractApiData {
    createJsonApi(data: TotpVerifyInput): {
        data: {
            type: string;
            id: string;
            attributes: {
                authenticatorId: string;
                code: string;
            };
        };
    };
}

type TotpVerifyLoginInput = {
    id: string;
    code: string;
};
declare class TotpVerifyLogin extends AbstractApiData {
    createJsonApi(data: TotpVerifyLoginInput): {
        data: {
            type: string;
            id: string;
            attributes: {
                code: string;
            };
        };
    };
}

type PasskeyRenameInput = {
    id: string;
    name: string;
};
declare class PasskeyRename extends AbstractApiData {
    createJsonApi(data: PasskeyRenameInput): {
        data: {
            type: string;
            id: string;
            attributes: {
                name: string;
            };
        };
    };
}

type PasskeyVerifyLoginInput = {
    id: string;
    pendingId: string;
    response: AuthenticationResponseJSON;
};
declare class PasskeyVerifyLogin extends AbstractApiData {
    createJsonApi(data: PasskeyVerifyLoginInput): {
        data: {
            type: string;
            id: string;
            attributes: {
                pendingId: string;
                response: AuthenticationResponseJSON;
            };
        };
    };
}

type TwoFactorEnableInput = {
    id: string;
    preferredMethod: "totp" | "passkey";
};
declare class TwoFactorEnable extends AbstractApiData {
    createJsonApi(data: TwoFactorEnableInput): {
        data: {
            type: string;
            id: string;
            attributes: {
                preferredMethod: "totp" | "passkey";
            };
        };
    };
}

type TwoFactorChallengeInput = {
    id: string;
    method: "totp" | "passkey" | "backup";
};
declare class TwoFactorChallenge extends AbstractApiData implements TwoFactorChallengeInterface {
    private _pendingToken;
    private _availableMethods;
    private _expiresAt;
    get pendingToken(): string;
    get availableMethods(): ("totp" | "passkey" | "backup")[];
    get expiresAt(): Date;
    rehydrate(data: JsonApiHydratedDataInterface): this;
    createJsonApi(data: TwoFactorChallengeInput): {
        data: {
            type: string;
            id: string;
            attributes: {
                method: "totp" | "passkey" | "backup";
            };
        };
    };
}

type BackupCodeVerifyInput = {
    id: string;
    code: string;
};
declare class BackupCodeVerify extends AbstractApiData {
    createJsonApi(data: BackupCodeVerifyInput): {
        data: {
            type: string;
            id: string;
            attributes: {
                code: string;
            };
        };
    };
}

/**
 * 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 enum StripeProductFields {
    stripeProductId = "stripeProductId",
    name = "name",
    status = "status",
    prices = "prices"
}

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?;
    private _token?;
    private _isTrial?;
    private _priceFeatures;
    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;
    get token(): number | undefined;
    get isTrial(): boolean | undefined;
    get priceFeatures(): FeatureInterface[];
    rehydrate(data: JsonApiHydratedDataInterface): this;
    createJsonApi(data: StripePriceInput): any;
}

declare enum StripePriceFields {
    stripePriceId = "stripePriceId",
    nickname = "nickname",
    amount = "amount",
    interval = "interval",
    token = "token",
    status = "status"
}

/**
 * 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;

/**
 * Service for validating Stripe promotion codes
 */
declare class StripePromotionCodeService {
    /**
     * Validate a promotion code against Stripe
     *
     * @param params.code - The promotion code to validate (e.g., "SAVE20")
     * @param params.stripePriceId - Optional price ID to check product restrictions
     * @param params.language - Language code for the request
     * @returns Validation result with discount details if valid
     */
    static validatePromotionCode(params: {
        code: string;
        stripePriceId?: string;
        language?: string;
    }): Promise<PromotionCodeValidationResult>;
}

declare class StripePromotionCode extends AbstractApiData implements PromotionCodeValidationResult {
    private _valid;
    private _promotionCodeId?;
    private _code;
    private _discountType?;
    private _discountValue?;
    private _currency?;
    private _duration?;
    private _durationInMonths?;
    private _errorMessage?;
    get valid(): boolean;
    get promotionCodeId(): string | undefined;
    get code(): string;
    get discountType(): "percent_off" | "amount_off" | undefined;
    get discountValue(): number | undefined;
    get currency(): string | undefined;
    get duration(): "forever" | "once" | "repeating" | undefined;
    get durationInMonths(): number | undefined;
    get errorMessage(): string | undefined;
    rehydrate(data: JsonApiHydratedDataInterface): this;
}

declare const StripePromotionCodeModule: (factory: ModuleFactory) => ModuleWithPermissions;

declare const CompanyModule: (factory: ModuleFactory) => ModuleWithPermissions;

declare class Company extends AbstractApiData implements CompanyInterface {
    private _name?;
    private _logo?;
    private _logoUrl?;
    private _configurations?;
    private _isActiveSubscription;
    private _monthlyCredits;
    private _availableMonthlyCredits;
    private _availableExtraCredits;
    private _aiEnabled?;
    private _features?;
    private _modules?;
    private _legal_address?;
    private _street_number?;
    private _street?;
    private _city?;
    private _province?;
    private _region?;
    private _postcode?;
    private _country?;
    private _country_code?;
    private _fiscal_data?;
    get name(): string;
    get logo(): string | undefined;
    get logoUrl(): string | undefined;
    get isActiveSubscription(): boolean;
    get monthlyCredits(): number;
    get availableMonthlyCredits(): number;
    get availableExtraCredits(): number;
    get aiEnabled(): boolean;
    get features(): FeatureInterface[];
    get modules(): ModuleInterface[];
    get configurations(): any | undefined;
    get legal_address(): string | undefined;
    get street_number(): string | undefined;
    get street(): string | undefined;
    get city(): string | undefined;
    get province(): string | undefined;
    get region(): string | undefined;
    get postcode(): string | undefined;
    get country(): string | undefined;
    get country_code(): string | undefined;
    get fiscal_data(): string | undefined;
    rehydrate(data: JsonApiHydratedDataInterface): this;
    createJsonApi(data: CompanyInput): any;
}

declare enum CompanyFields {
    companyId = "companyId",
    name = "name",
    createdAt = "createdAt",
    updatedAt = "updatedAt"
}

declare const EntityAiStatus: {
    readonly Pending: "Pending";
    readonly Summarising: "Summarising";
    readonly Completed: "Completed";
    readonly Failed: "Failed";
    readonly PendingCredits: "PendingCredits";
    readonly Discarded: "Discarded";
};
type EntityAiStatus = (typeof EntityAiStatus)[keyof typeof EntityAiStatus];

declare const ContentModule: (factory: ModuleFactory) => ModuleWithPermissions;

declare class Content extends AbstractApiData implements ContentInterface, SearchResultInterface {
    private _contentType?;
    private _name?;
    private _abstract?;
    private _tldr?;
    private _aiStatus?;
    private _relevance?;
    private _author?;
    private _editors?;
    get searchResult(): string;
    get contentType(): string | undefined;
    get name(): string;
    get abstract(): string | undefined;
    get tldr(): string | undefined;
    get aiStatus(): string;
    get relevance(): number | undefined;
    get author(): UserInterface;
    get editors(): UserInterface[];
    rehydrate(data: JsonApiHydratedDataInterface): this;
    protected addContentInput(response: any, data: ContentInput): void;
}

declare const HowToModule: (factory: ModuleFactory) => ModuleWithPermissions;

declare class HowTo extends Content implements HowToInterface {
    private _description?;
    private _pages?;
    private _howToType?;
    private _slug?;
    private _order?;
    private _summary?;
    private _tags?;
    private _contextualKeys?;
    private _draft?;
    /**
     * Parse pages from backend JSON string (handles legacy single string + JSON array)
     */
    static parsePagesFromString(pagesStr?: string): string[];
    /**
     * Serialize pages array to JSON string for backend
     */
    static serializePagesToString(pages: string[]): string | undefined;
    get description(): any;
    get pages(): string | undefined;
    get howToType(): string | undefined;
    get slug(): string | undefined;
    get order(): number | undefined;
    get summary(): string | undefined;
    get tags(): string[];
    get contextualKeys(): string[];
    get draft(): boolean;
    rehydrate(data: JsonApiHydratedDataInterface): this;
    createJsonApi(data: HowToInput): any;
}

declare enum HowToFields {
    howToId = "howToId",
    name = "name",
    description = "description",
    pages = "pages",
    createdAt = "createdAt",
    updatedAt = "updatedAt"
}

declare class HowToService extends AbstractService {
    static findOne(params: {
        id: string;
    }): Promise<HowToInterface>;
    static findMany(params?: {
        search?: string;
        fetchAll?: boolean;
        next?: NextRef;
        prev?: PreviousRef;
    }): Promise<HowToInterface[]>;
    static create(params: HowToInput): Promise<HowToInterface>;
    static update(params: HowToInput): Promise<HowToInterface>;
    static delete(params: {
        howToId: string;
    }): Promise<void>;
    static findPublished(params?: {
        howToType?: string;
    }): Promise<HowToInterface[]>;
    static findPublishedArticle(params: {
        howToType: string;
        slug: string;
    }): Promise<HowToInterface>;
    static findRelated(params: {
        howToType: string;
        slug: string;
    }): Promise<HowToInterface[]>;
    static addRelated(params: {
        howToId: string;
        relatedId: string;
    }): Promise<HowToInterface>;
    static removeRelated(params: {
        howToId: string;
        relatedId: string;
    }): Promise<void>;
}

declare const AssistantModule: (factory: ModuleFactory) => ModuleWithPermissions;

declare class Assistant extends AbstractApiData implements AssistantInterface {
    private _title?;
    private _messageCount?;
    private _engine?;
    private _boundContentType?;
    private _boundContentId?;
    get title(): string;
    get messageCount(): number;
    get engine(): string | undefined;
    get boundContentType(): string | undefined;
    get boundContentId(): string | undefined;
    rehydrate(data: JsonApiHydratedDataInterface): this;
    createJsonApi(data: AssistantInput): {
        data: {
            relationships?: {
                content: {
                    data: {
                        type: string;
                        id: string;
                    };
                };
            } | undefined;
            type: string;
            attributes: {
                limitToHowToId?: string | undefined;
                howToMode?: boolean | undefined;
                title?: string | undefined;
                content: string;
            };
        };
        included: never[];
    };
}

declare class AssistantService extends AbstractService {
    static findOne(params: {
        id: string;
    }): Promise<AssistantInterface>;
    /**
     * Lists threads. `boundType`/`boundId` narrow the list to the threads bound
     * to one resource (e.g. a campaign), so a scoped surface never shows the
     * user's unrelated threads.
     */
    static findMany(params?: {
        fetchAll?: boolean;
        boundType?: string;
        boundId?: string;
    }): Promise<AssistantInterface[]>;
    static create(params: AssistantInput): Promise<AssistantInterface>;
    /**
     * Creates an assistant whose first turn runs on the operator engine
     * (durable checkpointing + approval gates). Mirrors `create()` against the
     * standalone operator module's create route (`POST operator`).
     */
    static createOperator(params: AssistantInput): Promise<AssistantInterface>;
    /**
     * Sends a new user message to an existing assistant thread. The agent turn
     * runs synchronously; the response is a two-element list: [user, assistant].
     *
     * Uses the dedicated AssistantMessage.createAppendMessageJsonApi method to
     * build the JSON:API envelope; this is the architecture-compliant pairing
     * with `overridesJsonApiCreation: true`.
     */
    static appendMessage(params: {
        assistantId: string;
        content: string;
        howToMode?: boolean;
        limitToHowToId?: string;
        /** BlockNote document. Serialised by the model into `content`; never its own attribute. */
        contentBlocks?: unknown[];
    }): Promise<AssistantMessageInterface[]>;
    /**
     * Operator-engine variant of `appendMessage()`. Targets
     * `POST operator/:assistantId/assistant-messages`; the turn may freeze on a
     * destructive tool call, in which case the returned list ends with an
     * `approval-request` assistant message linked to a pending AssistantAction.
     */
    static appendMessageOperator(params: {
        assistantId: string;
        content: string;
        /** BlockNote document. Serialised by the model into `content`; never its own attribute. */
        contentBlocks?: unknown[];
    }): Promise<AssistantMessageInterface[]>;
    static rename(params: {
        id: string;
        title: string;
    }): Promise<void>;
    static delete(params: {
        id: string;
    }): Promise<void>;
}

declare const AssistantMessageModule: (factory: ModuleFactory) => ModuleWithPermissions;

declare class AssistantMessage extends AbstractApiData implements AssistantMessageInterface {
    private _role?;
    private _content?;
    private _position?;
    private _suggestedQuestions?;
    private _inputTokens?;
    private _outputTokens?;
    private _references?;
    private _citations?;
    private _isOptimistic;
    private _messageType?;
    private _actionId?;
    get role(): AssistantMessageRole;
    get content(): string;
    get position(): number;
    get suggestedQuestions(): string[];
    get inputTokens(): number | undefined;
    get outputTokens(): number | undefined;
    get references(): ApiDataInterface[];
    get citations(): (ChunkInterface & ChunkRelationshipMeta)[];
    get isOptimistic(): boolean;
    get messageType(): AssistantMessageType;
    get actionId(): string | undefined;
    rehydrate(data: JsonApiHydratedDataInterface): this;
    createJsonApi(data: AssistantMessageInput): {
        data: {
            type: string;
            id: string;
            attributes: {
                role: AssistantMessageRole;
                content: string;
                position: number;
            };
            relationships: {
                assistant: {
                    data: {
                        type: string;
                        id: string;
                    };
                };
            };
        };
        included: never[];
    };
    /**
     * JSON:API envelope for POST /assistants/:id/assistant-messages.
     * Different from `createJsonApi` (which expects a full message with role/position/assistant ref);
     * the append-to-thread endpoint derives those server-side, so we only send `content` and
     * the optional retrieval-mode flags.
     */
    createAppendMessageJsonApi(params: {
        content: string;
        howToMode?: boolean;
        limitToHowToId?: string;
        contentBlocks?: unknown[];
    }): {
        data: {
            type: string;
            attributes: {
                limitToHowToId?: string | undefined;
                howToMode?: boolean | undefined;
                content: string;
            };
        };
    };
    static buildOptimistic(params: {
        content: string;
        position: number;
        assistantId?: string;
    }): AssistantMessage;
}

declare class AssistantMessageService extends AbstractService {
    static findByAssistant(params: {
        assistantId: string;
        next?: NextRef;
    }): Promise<AssistantMessageInterface[]>;
    static findOne(params: {
        id: string;
    }): Promise<AssistantMessageInterface>;
    static delete(params: {
        id: string;
    }): Promise<void>;
}

declare const AssistantActionModule: (factory: ModuleFactory) => ModuleWithPermissions;

/**
 * Lifecycle of a destructive tool call the operator engine paused on.
 * Only `pending` is actionable from the UI.
 */
type AssistantActionStatus = "pending" | "approved" | "denied" | "expired" | "executed" | "failed";
/**
 * The frontend never creates assistant actions — the operator engine does.
 * The input therefore carries the id alone, so `createJsonApi()` can emit a
 * well-formed (if minimal) JSON:API resource object.
 */
type AssistantActionInput = {
    id: string;
};
interface AssistantActionInterface extends ApiDataInterface {
    get status(): AssistantActionStatus;
    get toolName(): string;
    get summary(): string;
    get resolvedAt(): Date | undefined;
    get expiresAt(): Date | undefined;
}

declare class AssistantAction extends AbstractApiData implements AssistantActionInterface {
    private _status?;
    private _toolName?;
    private _summary?;
    private _resolvedAt?;
    private _expiresAt?;
    get status(): AssistantActionStatus;
    get toolName(): string;
    get summary(): string;
    get resolvedAt(): Date | undefined;
    get expiresAt(): Date | undefined;
    rehydrate(data: JsonApiHydratedDataInterface): this;
    /**
     * Minimal payload (id only): the frontend never POSTs assistant actions —
     * approve/deny are body-less POSTs handled by AssistantActionService.
     */
    createJsonApi(data: AssistantActionInput): {
        data: {
            type: string;
            id: string;
            attributes: {};
        };
        included: never[];
    };
}

declare class AssistantActionService extends AbstractService {
    /**
     * GET single assistant action by ID
     */
    static findOne(params: {
        id: string;
    }): Promise<AssistantActionInterface>;
    /**
     * POST (body-less) approve action — resumes the paused run and
     * returns the resumed assistant message.
     */
    static approve(params: {
        id: string;
    }): Promise<AssistantMessageInterface>;
    /**
     * POST (body-less) deny action — resumes the paused run with a denial and
     * returns the resumed assistant message.
     */
    static deny(params: {
        id: string;
    }): Promise<AssistantMessageInterface>;
}

declare const ChunkModule: (factory: ModuleFactory) => ModuleWithPermissions;

declare class Chunk extends AbstractApiData implements ChunkInterface {
    private _content?;
    private _nodeId?;
    private _nodeType?;
    private _imagePath?;
    private _source?;
    get content(): string;
    get nodeId(): string | undefined;
    get nodeType(): string | undefined;
    get imagePath(): string | undefined;
    get source(): ApiDataInterface | undefined;
    rehydrate(data: JsonApiHydratedDataInterface): this;
    createJsonApi(): {
        data: {
            type: string;
            id: string;
            attributes: {};
            relationships: {};
        };
        included: never[];
    };
}

type ChunkInput = {
    id: string;
};

declare class Notification extends AbstractApiData implements NotificationInterface {
    private _notificationType?;
    private _isRead?;
    private _message?;
    private _actionUrl?;
    private _actor?;
    private _subject?;
    get notificationType(): string;
    get isRead(): boolean;
    get message(): string | undefined;
    get actionUrl(): string | undefined;
    get actor(): ApiDataInterface | undefined;
    get subject(): ApiDataInterface | undefined;
    rehydrate(data: JsonApiHydratedDataInterface): this;
    createJsonApi(data: NotificationInput): any;
}

declare enum NotificationFields {
    notificationId = "notificationId",
    name = "name",
    createdAt = "createdAt",
    updatedAt = "updatedAt"
}

declare const NotificationModule: (factory: ModuleFactory) => ModuleWithPermissions;

type PushInput = {
    key: string;
    contentType?: string;
};
interface PushInterface extends ApiDataInterface {
}

declare class Push extends AbstractApiData implements PushInterface {
    createJsonApi(data: PushInput): any;
}

declare const PushModule: (factory: ModuleFactory) => ModuleWithPermissions;

declare const S3Module: (factory: ModuleFactory) => ModuleWithPermissions;

declare class S3 extends AbstractApiData implements S3Interface {
    private _url?;
    private _storageType?;
    private _contentType?;
    private _blobType?;
    private _acl?;
    get url(): string;
    get headers(): Record<string, string>;
    rehydrate(data: JsonApiHydratedDataInterface): this;
    createJsonApi(data: S3Input): any;
}

declare const OAuthModule: (factory: ModuleFactory) => ModuleWithPermissions;

/**
 * OAuth client data model
 * Represents a registered OAuth application that can request access tokens
 */
declare class OAuthClient extends AbstractApiData implements OAuthClientInterface {
    private _clientId?;
    private _name?;
    private _description?;
    private _redirectUris;
    private _allowedScopes;
    private _allowedGrantTypes;
    private _isConfidential;
    private _isActive;
    get clientId(): string;
    get name(): string;
    get description(): string | undefined;
    get redirectUris(): string[];
    get allowedScopes(): string[];
    get allowedGrantTypes(): string[];
    get isConfidential(): boolean;
    get isActive(): boolean;
    rehydrate(data: JsonApiHydratedDataInterface): this;
    createJsonApi(data: OAuthClientInput): any;
}

/**
 * Service for OAuth client management and authorization consent flow.
 *
 * Client Management endpoints:
 * - GET /oauth/clients - List all clients for current user
 * - GET /oauth/clients/:clientId - Get single client
 * - POST /oauth/clients - Create new client (returns secret once)
 * - PATCH /oauth/clients/:clientId - Update client
 * - DELETE /oauth/clients/:clientId - Delete client
 * - POST /oauth/clients/:clientId/regenerate-secret - Regenerate client secret
 *
 * Consent Flow endpoints:
 * - GET /oauth/authorize/info - Get client info for consent screen
 * - POST /oauth/authorize/approve - Approve authorization
 * - POST /oauth/authorize/deny - Deny authorization
 */
declare class OAuthService extends AbstractService {
    /**
     * List all OAuth clients for the current user
     */
    static listClients(params?: {
        next?: NextRef;
    }): Promise<OAuthClientInterface[]>;
    /**
     * Get a single OAuth client by ID
     */
    static getClient(params: {
        clientId: string;
    }): Promise<OAuthClientInterface>;
    /**
     * Create a new OAuth client
     * @returns The created client AND the client secret (shown only once!)
     */
    static createClient(data: OAuthClientCreateRequest): Promise<OAuthClientCreateResponse>;
    /**
     * Update an existing OAuth client
     */
    static updateClient(params: {
        clientId: string;
        data: Partial<OAuthClientInput>;
    }): Promise<OAuthClientInterface>;
    /**
     * Delete an OAuth client
     */
    static deleteClient(params: {
        clientId: string;
    }): Promise<void>;
    /**
     * Regenerate the client secret
     * @returns The new client secret (shown only once!)
     */
    static regenerateSecret(params: {
        clientId: string;
    }): Promise<{
        clientSecret: string;
    }>;
    /**
     * Get client information for the consent screen
     * Called when user is redirected to /oauth/authorize
     */
    static getAuthorizationInfo(params: OAuthConsentRequest): Promise<OAuthConsentInfo>;
    /**
     * Approve the authorization request
     * @returns Redirect URL with authorization code
     */
    static approveAuthorization(params: OAuthConsentRequest): Promise<{
        redirectUrl: string;
    }>;
    /**
     * Deny the authorization request
     * @returns Redirect URL with error=access_denied
     */
    static denyAuthorization(params: OAuthConsentRequest): Promise<{
        redirectUrl: string;
    }>;
}

type WaitlistStatus = "pending" | "confirmed" | "invited" | "registered";
type WaitlistInput = {
    id: string;
    email: string;
    gdprConsent: boolean;
    gdprConsentAt: string;
    marketingConsent?: boolean;
    marketingConsentAt?: string;
    questionnaire?: Record<string, any>;
};
interface WaitlistInterface extends ApiDataInterface {
    get email(): string;
    get gdprConsent(): boolean;
    get gdprConsentAt(): string;
    get marketingConsent(): boolean | undefined;
    get marketingConsentAt(): string | undefined;
    get questionnaire(): string | undefined;
    get status(): WaitlistStatus;
    get confirmedAt(): string | undefined;
    get invitedAt(): string | undefined;
    get registeredAt(): string | undefined;
}
interface InviteValidation {
    email: string;
    valid: boolean;
}

declare class Waitlist extends AbstractApiData implements WaitlistInterface {
    private _email?;
    private _gdprConsent;
    private _gdprConsentAt?;
    private _marketingConsent?;
    private _marketingConsentAt?;
    private _questionnaire?;
    private _status;
    private _confirmedAt?;
    private _invitedAt?;
    private _registeredAt?;
    get email(): string;
    get gdprConsent(): boolean;
    get gdprConsentAt(): string;
    get marketingConsent(): boolean | undefined;
    get marketingConsentAt(): string | undefined;
    get questionnaire(): string | undefined;
    get status(): WaitlistStatus;
    get confirmedAt(): string | undefined;
    get invitedAt(): string | undefined;
    get registeredAt(): string | undefined;
    rehydrate(data: JsonApiHydratedDataInterface): this;
    createJsonApi(data: WaitlistInput): any;
}

interface WaitlistStatsInterface extends ApiDataInterface {
    get pending(): number;
    get confirmed(): number;
    get invited(): number;
    get registered(): number;
    get total(): number;
}

declare class WaitlistService extends AbstractService {
    /**
     * Submit to waitlist (public)
     * Uses Waitlist.createJsonApi() to transform WaitlistInput to JSON:API format
     */
    static submit(params: WaitlistInput): Promise<WaitlistInterface>;
    /**
     * Confirm email (public)
     */
    static confirm(code: string): Promise<WaitlistInterface>;
    /**
     * List all waitlist entries (admin)
     * Uses cursor-based pagination with NextRef/PreviousRef
     */
    static findMany(params?: {
        status?: string;
        search?: string;
        fetchAll?: boolean;
        next?: NextRef;
        prev?: PreviousRef;
    }): Promise<WaitlistInterface[]>;
    /**
     * Send invite (admin)
     */
    static invite(id: string): Promise<WaitlistInterface>;
    /**
     * Batch invite (admin)
     * Non-standard batch operation - uses custom JSON:API format
     */
    static inviteBatch(ids: string[]): Promise<{
        invited: number;
        failed: number;
    }>;
    /**
     * Get statistics (admin)
     */
    static getStats(): Promise<WaitlistStatsInterface>;
    /**
     * Validate invite code (public) - calls auth endpoint
     */
    static validateInvite(code: string): Promise<InviteValidation | null>;
}

declare class WaitlistStats extends AbstractApiData implements WaitlistStatsInterface {
    private _pending;
    private _confirmed;
    private _invited;
    private _registered;
    private _total;
    get pending(): number;
    get confirmed(): number;
    get invited(): number;
    get registered(): number;
    get total(): number;
    rehydrate(data: JsonApiHydratedDataInterface): this;
    createJsonApi(_data?: any): any;
}

declare const WaitlistModule: (factory: ModuleFactory) => ModuleWithPermissions;

declare const WaitlistStatsModule: (factory: ModuleFactory) => ModuleWithPermissions;

declare const PermissionMappingModule: (factory: ModuleFactory) => ModuleWithPermissions;
declare const ModulePathsModule: (factory: ModuleFactory) => ModuleWithPermissions;
/**
 * Dev-only matrix module. The `name` is the URL path of the dev singleton
 * endpoint (`GET|PUT _dev/rbac/matrix`), NOT a plural resource collection.
 * This module is only useful when the backend is running with `devMode: true`
 * on `RbacModule.register`.
 */
declare const RbacMatrixModule: (factory: ModuleFactory) => ModuleWithPermissions;

interface ReferralStatsInterface {
    referralCode: string;
    completedReferrals: number;
    totalTokensEarned: number;
}

declare class ReferralStats extends AbstractApiData implements ReferralStatsInterface {
    private _referralCode?;
    private _completedReferrals?;
    private _totalTokensEarned?;
    get referralCode(): string;
    get completedReferrals(): number;
    get totalTokensEarned(): number;
    rehydrate(data: JsonApiHydratedDataInterface): this;
    createJsonApi(): {};
}

declare class ReferralService extends AbstractService {
    /**
     * Get referral stats for the current company.
     * Returns deserialized attributes from JSON:API response.
     */
    static getMyReferralStats(): Promise<ReferralStatsInterface>;
    /**
     * Send a referral invitation email.
     * Uses overridesJsonApiCreation since the endpoint accepts a simple JSON body, not JSON:API format.
     * Returns 204 No Content on success.
     */
    static sendReferralEmail(email: string): Promise<void>;
}

declare const ReferralModule: (factory: ModuleFactory) => ModuleWithPermissions;

declare const ReferralStatsModule: (factory: ModuleFactory) => ModuleWithPermissions;

interface AuditLogInterface extends ApiDataInterface {
    get kind(): "audit" | "comment";
    get action(): string | undefined;
    get fieldName(): string | undefined;
    get oldValue(): string | undefined;
    get newValue(): string | undefined;
    get content(): string | undefined;
    get annotationId(): string | undefined;
    get user(): UserInterface | undefined;
}

declare class AuditLog extends AbstractApiData implements AuditLogInterface {
    private _kind;
    private _action?;
    private _fieldName?;
    private _oldValue?;
    private _newValue?;
    private _content?;
    private _annotationId?;
    private _user?;
    get kind(): "audit" | "comment";
    get action(): string | undefined;
    get fieldName(): string | undefined;
    get oldValue(): string | undefined;
    get newValue(): string | undefined;
    get content(): string | undefined;
    get annotationId(): string | undefined;
    get user(): UserInterface | undefined;
    rehydrate(data: JsonApiHydratedDataInterface): this;
    createJsonApi(): any;
}

declare class AuditLogService extends AbstractService {
    static findActivityByEntity(params: {
        entityType: string;
        entityId: string;
        next?: NextRef;
    }): Promise<AuditLogInterface[]>;
}

declare const AuditLogModule: (factory: ModuleFactory) => ModuleWithPermissions;

export { AbstractApiData, AbstractService, Action, ApiData, ApiDataInterface, ApiRequestDataTypeInterface, ApiResponseInterface, type AppModuleDefinitions, Assistant, AssistantAction, type AssistantActionInput, type AssistantActionInterface, AssistantActionModule, AssistantActionService, type AssistantActionStatus, AssistantInput, AssistantInterface, AssistantMessage, AssistantMessageInput, AssistantMessageInterface, AssistantMessageModule, AssistantMessageRole, AssistantMessageService, AssistantMessageType, AssistantModule, AssistantService, AuditLog, type AuditLogInterface, AuditLogModule, AuditLogService, Auth, AuthInput, AuthInterface, AuthModule, AuthorModule, BackupCodeVerify, type BackupCodeVerifyInput, BackupCodeVerifyModule, Billing, BillingModule, BillingService, type BlockDiffOptions, BlockNoteDiffUtil, BlockNoteWordDiffRendererUtil, CURRENT_USER_STORAGE_KEY, Chunk, type ChunkInput, ChunkInterface, ChunkModule, ChunkRelationshipMeta, ClientAbstractService, ClientHttpMethod, type ClientNextRef, type ClientPreviousRef, type ClientSelfRef, type ClientTotalRef, type CodiceFiscaleValidationOptions, Company, CompanyFields, CompanyInput, CompanyInterface, CompanyModule, Content, ContentInput, ContentInterface, ContentModule, DataClassRegistry as DataClass, DataClassRegistry, type DiffBlock, type DiffResult, ENV, EndpointCreator, type EndpointQuery, EntityAiStatus, type EntityObject, Feature, FeatureInterface, FeatureModule, FieldSelector, type FormatOption, type FoundationModuleDefinitions, HowTo, HowToFields, HowToInput, HowToInterface, HowToModule, HowToService, type InviteValidation, InvoiceStatus, JsonApiDataFactory, JsonApiHydratedDataInterface, MOBILE_BREAKPOINT, MeterInterface, MeterSummaryInterface, Module, type ModuleDefinitions, ModuleFactory, ModuleInterface, ModuleModule, ModulePathsModule, ModuleRegistrar, ModuleRegistry, ModuleWithPermissions, Modules, NextRef, Notification, NotificationFields, NotificationInput, NotificationInterface, NotificationModule, OAuthClient, OAuthClientCreateRequest, OAuthClientCreateResponse, OAuthClientInput, OAuthClientInterface, OAuthConsentInfo, OAuthConsentRequest, OAuthModule, OAuthService, Passkey, PasskeyAuthenticationOptions, type PasskeyAuthenticationOptionsInput, type PasskeyAuthenticationOptionsInterface, PasskeyAuthenticationOptionsModule, PasskeyInterface, PasskeyModule, PasskeyRegistrationOptions, type PasskeyRegistrationOptionsInput, type PasskeyRegistrationOptionsInterface, PasskeyRegistrationOptionsModule, PasskeyRegistrationVerify, type PasskeyRegistrationVerifyInput, PasskeyRegistrationVerifyModule, PasskeyRename, type PasskeyRenameInput, PasskeyRenameModule, PasskeyVerifyLogin, type PasskeyVerifyLoginInput, PasskeyVerifyLoginModule, PaymentMethod, PaymentMethodInterface, PermissionMappingModule, PermissionModule, PermissionUser, PreviousRef, PriceRecurring, PromotionCodeValidationResult, ProrationPreviewInterface, Push, type PushInput, type PushInterface, PushModule, RbacMatrixModule, ReferralModule, ReferralService, ReferralStats, ReferralStatsModule, RehydrationFactory, ReportUsageInput, Role, RoleInput, RoleInterface, RoleModule, S3, S3Input, S3Interface, S3Module, type SearchResultInterface, StripeCustomer, StripeCustomerInterface, StripeCustomerModule, StripeCustomerService, StripeInvoice, StripeInvoiceInterface, StripeInvoiceModule, StripeInvoiceService, StripePaymentMethodModule, StripePrice, StripePriceFields, StripePriceInput, StripePriceInterface, StripePriceModule, StripePriceService, StripeProduct, StripeProductFields, StripeProductInput, StripeProductInterface, StripeProductModule, StripeProductService, StripePromotionCode, StripePromotionCodeModule, StripePromotionCodeService, StripeSubscription, StripeSubscriptionCreateResponse, StripeSubscriptionInput, StripeSubscriptionInterface, StripeSubscriptionModule, StripeSubscriptionService, StripeUsage, StripeUsageInterface, StripeUsageModule, StripeUsageService, SubscriptionStatus, TableOptions, type ToastOptions, TotpAuthenticator, TotpAuthenticatorInterface, TotpAuthenticatorModule, TotpSetup, type TotpSetupInput, type TotpSetupInterface, TotpSetupModule, TotpVerify, type TotpVerifyInput, TotpVerifyLogin, type TotpVerifyLoginInput, TotpVerifyLoginModule, TotpVerifyModule, TwoFactorChallenge, type TwoFactorChallengeInput, TwoFactorChallengeInterface, TwoFactorChallengeModule, TwoFactorEnable, type TwoFactorEnableInput, TwoFactorEnableModule, TwoFactorService, TwoFactorStatus, type TwoFactorStatusInterface, TwoFactorStatusModule, UsageSummaryInterface, User, UserInput, UserInterface, UserModule, type UserObject, VIEWPORT_COOKIE_NAME, Waitlist, type WaitlistInput, type WaitlistInterface, WaitlistModule, WaitlistService, WaitlistStats, type WaitlistStatsInterface, WaitlistStatsModule, type WaitlistStatus, type WordDiff, checkPermissions, checkPermissionsFromServer, cn, composeRefs, dismissToast, entityObjectSchema, exists, formatCodiceFiscale, formatDate, formatLocalDate, formatPartitaIva, getBootstrapper, getClientGlobalErrorHandler, getTableComponents, getTableOptions, getValueFromPath, hasBootstrapper, isRemoteImageSrc, rehydrate, rehydrateList, resetBootstrapStore, setBootstrapper, setClientGlobalErrorHandler, showCustomToast, showError, showToast, translateData, translateResponse, tryBootstrap, useComposedRefs, useIsMobile, userObjectSchema, validateCodiceFiscale, validateItalianTaxCode, validatePartitaIva };