@burdenoff/be-sdk 2026.510.79

package/dist/graphql-BAVrUgBF.d.ts

@@ -0,0 +1,22 @@
+import { Variables } from 'graphql-request';
+import { a as SDKConfig, S as SDKContext } from './index-CHbVw5M7.js';
+
+declare class BurdenoffGraphQLClient {
+    private workspacesClient;
+    private tenantClient?;
+    private config;
+    private defaultContext;
+    constructor(config: SDKConfig, defaultContext?: SDKContext);
+    private getHeaders;
+    updateContext(context: Partial<SDKContext>): void;
+    query<T>(query: string, variables?: Variables, context?: SDKContext): Promise<T>;
+    tenantQuery<T>(query: string, variables?: Variables, context?: SDKContext): Promise<T>;
+    private executeQuery;
+    private executeWithRetry;
+    private shouldRetry;
+    private handleError;
+    private sleep;
+    getContext(): SDKContext;
+}
+
+export { BurdenoffGraphQLClient as B };

package/dist/i18n/index.d.ts

@@ -0,0 +1,2 @@
+export { F as FlatTranslationMap, d as I18n, c as I18nConfig, I as I18nContext, e as II18n, a as LanguageCode, f as LanguageInfo, L as LocaleCode, P as ParsedLocale, g as PluralForms, h as PluralTranslateFunction, R as RTL_LANGUAGES, i as TextDirection, j as TranslateFunction, b as TranslationDictionary, T as TranslationVariables, k as createI18n, l as getI18n, m as getTextDirection, n as initializeI18n } from '../i18n-DA6IPnYy.js';
+export { D as DEFAULT_I18N_CONFIG, I as I18nCapableContext, L as Locales, T as Translator, b as clearTranslationCache, c as createTranslator, d as discoverLocales, e as extractLocaleFromRequest, f as findBestMatch, j as flattenDictionary, k as getCachedTranslations, g as getLanguage, l as getLanguageFromLocale, a as getLocale, m as getRegionFromLocale, h as hasI18n, n as loadTranslationFile, o as loadTranslationsForLocale, p as normalizeLocale, q as parseAcceptLanguage, r as parseLocaleString, s as preloadAllTranslations, u as setCachedTranslations, t } from '../index-BV3G48cH.js';

package/dist/i18n/index.js

@@ -0,0 +1,5 @@
+export { DEFAULT_I18N_CONFIG, I18n, Locales, RTL_LANGUAGES, clearTranslationCache, createI18n, createTranslator, discoverLocales, extractLocaleFromRequest, findBestMatch, flattenDictionary, getCachedTranslations, getI18n, getLanguage, getLanguageFromLocale, getLocale, getRegionFromLocale, getTextDirection, hasI18n, initializeI18n, loadTranslationFile, loadTranslationsForLocale, normalizeLocale, parseAcceptLanguage, parseLocaleString, preloadAllTranslations, setCachedTranslations, t } from '../chunk-IYE2NTRX.js';
+import '../chunk-CBZNP6RF.js';
+import '../chunk-XE4OXN2W.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/i18n/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/dist/i18n-DA6IPnYy.d.ts

@@ -0,0 +1,101 @@
+type LocaleCode = 'en-US' | 'en-GB' | 'en-AU' | 'en-CA' | 'en-IN' | 'es-ES' | 'es-MX' | 'es-AR' | 'fr-FR' | 'fr-CA' | 'fr-BE' | 'de-DE' | 'de-AT' | 'de-CH' | 'it-IT' | 'pt-PT' | 'pt-BR' | 'ru-RU' | 'zh-CN' | 'zh-TW' | 'zh-HK' | 'ja-JP' | 'ko-KR' | 'ar-SA' | 'ar-AE' | 'ar-EG' | 'hi-IN' | 'bn-IN' | 'bn-BD' | 'ta-IN' | 'te-IN' | 'ml-IN' | 'nl-NL' | 'nl-BE' | 'pl-PL' | 'tr-TR' | 'vi-VN' | 'th-TH' | 'id-ID' | 'ms-MY' | 'sv-SE' | 'nb-NO' | 'da-DK' | 'fi-FI' | 'el-GR' | 'cs-CZ' | 'ro-RO' | 'hu-HU' | 'he-IL' | 'uk-UA' | string;
+type LanguageCode = 'en' | 'es' | 'fr' | 'de' | 'it' | 'pt' | 'ru' | 'zh' | 'ja' | 'ko' | 'ar' | 'hi' | 'bn' | 'ta' | 'te' | 'ml' | 'nl' | 'pl' | 'tr' | 'vi' | 'th' | 'id' | 'ms' | 'sv' | 'nb' | 'da' | 'fi' | 'el' | 'cs' | 'ro' | 'hu' | 'he' | 'uk' | string;
+type TranslationDictionary = {
+    [key: string]: string | TranslationDictionary | null;
+};
+type FlatTranslationMap = Record<string, string>;
+type TranslationVariables = Record<string, string | number | boolean>;
+interface PluralForms {
+    zero?: string;
+    one: string;
+    two?: string;
+    few?: string;
+    many?: string;
+    other: string;
+}
+type TranslateFunction = (key: string, variables?: TranslationVariables, defaultValue?: string) => string;
+type PluralTranslateFunction = (key: string, count: number, variables?: TranslationVariables) => string;
+interface I18nConfig {
+    defaultLocale: LocaleCode;
+    fallbackLocale?: LocaleCode;
+    localesPath: string;
+    supportedLocales?: LocaleCode[];
+    lazyLoad?: boolean;
+    enableCache?: boolean;
+    namespace?: string;
+    logMissing?: boolean;
+    returnKeyOnMissing?: boolean;
+}
+interface ParsedLocale {
+    locale: LocaleCode;
+    language: LanguageCode;
+    region?: string;
+    quality: number;
+}
+interface I18nContext {
+    locale: LocaleCode;
+    language: LanguageCode;
+    region?: string;
+    country?: string;
+    currency?: string;
+    timezone?: string;
+    t: TranslateFunction;
+    tp: PluralTranslateFunction;
+    formatNumber: (value: number, options?: Intl.NumberFormatOptions) => string;
+    formatCurrency: (value: number, currency: string) => string;
+    formatDate: (date: Date | string, options?: Intl.DateTimeFormatOptions) => string;
+    formatRelativeTime: (value: number, unit: Intl.RelativeTimeFormatUnit) => string;
+}
+interface II18n {
+    getLocale(): LocaleCode;
+    setLocale(locale: LocaleCode): void;
+    getSupportedLocales(): LocaleCode[];
+    isSupported(locale: LocaleCode): boolean;
+    t: TranslateFunction;
+    tp: PluralTranslateFunction;
+    createContext(locale: LocaleCode): I18nContext;
+    loadLocale(locale: LocaleCode): Promise<void>;
+    getTranslations(locale: LocaleCode): FlatTranslationMap | undefined;
+}
+type TextDirection = 'ltr' | 'rtl';
+interface LanguageInfo {
+    code: LanguageCode;
+    name: string;
+    nativeName: string;
+    direction: TextDirection;
+    locales: LocaleCode[];
+}
+declare const RTL_LANGUAGES: LanguageCode[];
+declare function getTextDirection(language: LanguageCode): TextDirection;
+
+declare class I18n implements II18n {
+    private config;
+    private currentLocale;
+    private supportedLocales;
+    private initialized;
+    constructor(config: I18nConfig);
+    initialize(): Promise<void>;
+    getLocale(): LocaleCode;
+    setLocale(locale: LocaleCode): void;
+    getSupportedLocales(): LocaleCode[];
+    isSupported(locale: LocaleCode): boolean;
+    loadLocale(locale: LocaleCode): Promise<void>;
+    getTranslations(locale: LocaleCode): FlatTranslationMap | undefined;
+    t: TranslateFunction;
+    tp: PluralTranslateFunction;
+    private translate;
+    private translatePlural;
+    createContext(locale: LocaleCode): I18nContext;
+    createContextFromRequest(request: Request): I18nContext;
+    getLanguageInfo(locale: LocaleCode): {
+        code: LanguageCode;
+        direction: 'ltr' | 'rtl';
+        locale: LocaleCode;
+        region?: string;
+    };
+}
+declare function initializeI18n(config: I18nConfig): Promise<I18n>;
+declare function getI18n(): I18n | null;
+declare function createI18n(config: I18nConfig): I18n;
+
+export { type FlatTranslationMap as F, type I18nContext as I, type LocaleCode as L, type ParsedLocale as P, RTL_LANGUAGES as R, type TranslationVariables as T, type LanguageCode as a, type TranslationDictionary as b, type I18nConfig as c, I18n as d, type II18n as e, type LanguageInfo as f, type PluralForms as g, type PluralTranslateFunction as h, type TextDirection as i, type TranslateFunction as j, createI18n as k, getI18n as l, getTextDirection as m, initializeI18n as n };

package/dist/index-4gKQKZ2B.d.ts

@@ -0,0 +1,71 @@
+import { AnyElysia } from 'elysia';
+import { M as MetricsMiddlewareConfig } from './types-Bo2wkjSP.js';
+
+interface Metrics {
+    avgResponseTime: number;
+    errorRate: number;
+    totalRequests: number;
+    requestsLastHour: number;
+    errorsLastHour: number;
+}
+declare class MetricsCollector {
+    private static instance;
+    private requests;
+    private readonly MAX_REQUESTS;
+    private totalRequests;
+    private totalErrors;
+    private totalResponseTime;
+    private cleanupInterval;
+    private readonly CLEANUP_INTERVAL_MS;
+    private readonly DATA_RETENTION_MS;
+    private constructor();
+    static getInstance(): MetricsCollector;
+    recordRequest(responseTimeMs: number, isError: boolean): void;
+    getMetrics(): Metrics;
+    getMetricsForWindow(windowMs: number): Metrics;
+    reset(): void;
+    private startCleanupTimer;
+    stopCleanupTimer(): void;
+    private cleanup;
+    getStatistics(): {
+        bufferSize: number;
+        oldestMetricAge: number;
+        newestMetricAge: number;
+        globalStats: {
+            totalRequests: number;
+            totalErrors: number;
+            avgResponseTime: number;
+            errorRate: number;
+        };
+    };
+}
+declare const metricsCollector: MetricsCollector;
+
+declare function createMetricsPlugin(config?: MetricsMiddlewareConfig): AnyElysia;
+declare function getCurrentMetrics(): {
+    avgResponseTime: number;
+    errorRate: number;
+    totalRequests: number;
+    requestsLastHour: number;
+    errorsLastHour: number;
+};
+declare function getMetricsForWindow(windowMs: number): {
+    avgResponseTime: number;
+    errorRate: number;
+    totalRequests: number;
+    requestsLastHour: number;
+    errorsLastHour: number;
+};
+
+type index_Metrics = Metrics;
+type index_MetricsCollector = MetricsCollector;
+declare const index_MetricsCollector: typeof MetricsCollector;
+declare const index_createMetricsPlugin: typeof createMetricsPlugin;
+declare const index_getCurrentMetrics: typeof getCurrentMetrics;
+declare const index_getMetricsForWindow: typeof getMetricsForWindow;
+declare const index_metricsCollector: typeof metricsCollector;
+declare namespace index {
+  export { type index_Metrics as Metrics, index_MetricsCollector as MetricsCollector, index_createMetricsPlugin as createMetricsPlugin, index_getCurrentMetrics as getCurrentMetrics, index_getMetricsForWindow as getMetricsForWindow, index_metricsCollector as metricsCollector };
+}
+
+export { type Metrics as M, MetricsCollector as a, getMetricsForWindow as b, createMetricsPlugin as c, getCurrentMetrics as g, index as i, metricsCollector as m };

package/dist/index-B18rrFru.d.ts

@@ -0,0 +1,42 @@
+import { DatabaseService, Logger, PrismaTransactionClient, createDatabaseService } from './graphql/services/index.js';
+
+interface MessageSerializer {
+    stringify: (data: unknown) => string | Promise<string>;
+    parse: (message: string) => unknown | Promise<unknown>;
+}
+interface NatsEventTargetOptions {
+    natsUrl: string | string[];
+    connectionOptions?: {
+        name?: string;
+        maxReconnectAttempts?: number;
+        reconnectTimeWait?: number;
+        pingInterval?: number;
+        maxPingOut?: number;
+        timeout?: number;
+    };
+    serializer?: MessageSerializer;
+    subjectPrefix?: string;
+}
+type EventListener = (event: Event) => void;
+interface NatsEventTarget {
+    addEventListener(type: string, listener: EventListener): void;
+    removeEventListener(type: string, listener: EventListener): void;
+    dispatchEvent(event: Event): boolean;
+    close(): Promise<void>;
+    isHealthy(): boolean;
+}
+declare function createNatsEventTarget(options: NatsEventTargetOptions): Promise<NatsEventTarget>;
+
+declare const index_DatabaseService: typeof DatabaseService;
+declare const index_Logger: typeof Logger;
+type index_MessageSerializer = MessageSerializer;
+type index_NatsEventTarget = NatsEventTarget;
+type index_NatsEventTargetOptions = NatsEventTargetOptions;
+declare const index_PrismaTransactionClient: typeof PrismaTransactionClient;
+declare const index_createDatabaseService: typeof createDatabaseService;
+declare const index_createNatsEventTarget: typeof createNatsEventTarget;
+declare namespace index {
+  export { index_DatabaseService as DatabaseService, index_Logger as Logger, type index_MessageSerializer as MessageSerializer, type index_NatsEventTarget as NatsEventTarget, type index_NatsEventTargetOptions as NatsEventTargetOptions, index_PrismaTransactionClient as PrismaTransactionClient, index_createDatabaseService as createDatabaseService, index_createNatsEventTarget as createNatsEventTarget };
+}
+
+export { type MessageSerializer as M, type NatsEventTarget as N, type NatsEventTargetOptions as a, createNatsEventTarget as c, index as i };

package/dist/index-B70b5mYS.d.ts

@@ -0,0 +1,33 @@
+declare function isCaptchaEnabled(): boolean;
+interface VerifyCaptchaInput {
+    token: string;
+    secretKey?: string;
+    remoteIp?: string;
+    expectedAction?: string;
+    minScore?: number;
+}
+interface VerifyCaptchaResult {
+    success: boolean;
+    score?: number;
+    action?: string;
+    hostname?: string;
+    challengeTs?: string;
+    errorCodes?: string[];
+}
+declare function verifyCaptcha(input: VerifyCaptchaInput): Promise<VerifyCaptchaResult>;
+type RecaptchaVerifyOptions = VerifyCaptchaInput;
+type RecaptchaVerifyResult = VerifyCaptchaResult;
+declare function verifyCaptchaIfEnabled(input: VerifyCaptchaInput): Promise<VerifyCaptchaResult>;
+
+type index_RecaptchaVerifyOptions = RecaptchaVerifyOptions;
+type index_RecaptchaVerifyResult = RecaptchaVerifyResult;
+type index_VerifyCaptchaInput = VerifyCaptchaInput;
+type index_VerifyCaptchaResult = VerifyCaptchaResult;
+declare const index_isCaptchaEnabled: typeof isCaptchaEnabled;
+declare const index_verifyCaptcha: typeof verifyCaptcha;
+declare const index_verifyCaptchaIfEnabled: typeof verifyCaptchaIfEnabled;
+declare namespace index {
+  export { type index_RecaptchaVerifyOptions as RecaptchaVerifyOptions, type index_RecaptchaVerifyResult as RecaptchaVerifyResult, type index_VerifyCaptchaInput as VerifyCaptchaInput, type index_VerifyCaptchaResult as VerifyCaptchaResult, index_isCaptchaEnabled as isCaptchaEnabled, index_verifyCaptcha as verifyCaptcha, index_verifyCaptchaIfEnabled as verifyCaptchaIfEnabled };
+}
+
+export { type RecaptchaVerifyOptions as R, type VerifyCaptchaInput as V, type RecaptchaVerifyResult as a, isCaptchaEnabled as b, verifyCaptchaIfEnabled as c, type VerifyCaptchaResult as d, index as i, verifyCaptcha as v };

package/dist/index-BMq3lFjj.d.ts

@@ -0,0 +1,247 @@
+import { S as ServiceLayer } from './layer-DDip18KY.js';
+
+type ExportFormat = 'csv' | 'json' | 'xlsx' | 'pdf';
+declare enum ExportFormatEnum {
+    CSV = "CSV",
+    JSON = "JSON",
+    EXCEL = "EXCEL",
+    PDF = "PDF"
+}
+interface ExportConfig {
+    format: ExportFormat;
+    fields?: string[];
+    filters?: Record<string, unknown>;
+    sortBy?: string;
+    sortOrder?: 'asc' | 'desc';
+}
+interface ExportOptions {
+    format: 'csv' | 'json' | 'xlsx';
+    filters?: Record<string, unknown>;
+    fields?: string[];
+    pagination?: {
+        page: number;
+        pageSize: number;
+    };
+}
+type ExportJobStatus = 'pending' | 'processing' | 'completed' | 'failed' | 'expired';
+interface ExportJob {
+    id: string;
+    status: ExportJobStatus;
+    config: ExportConfig;
+    result?: string;
+    error?: string;
+    createdAt: Date;
+    completedAt?: Date;
+}
+interface ExportProgress {
+    status: ExportJobStatus;
+    percentage: number;
+    recordsProcessed: number;
+    totalRecords: number;
+    error?: string;
+    startedAt?: Date;
+    completedAt?: Date;
+}
+interface ExportResult {
+    jobId?: string;
+    downloadUrl?: string;
+    fileName?: string;
+    fileSize?: number;
+    mimeType?: string;
+    expiresAt?: Date;
+    progress?: ExportProgress;
+    data?: unknown[];
+    totalCount?: number;
+    format?: string;
+}
+interface ExportFetchOptions {
+    pageSize?: number;
+    cursor?: string;
+    fields?: string[];
+    filters?: Record<string, unknown>;
+    sortBy?: string;
+    sortOrder?: 'asc' | 'desc';
+    includeRelations?: boolean;
+    limit?: number;
+    workspaceId?: string;
+    userId?: string;
+    dateFrom?: Date;
+    dateTo?: Date;
+    excludeFields?: string[];
+}
+interface ExportFetchResult<T> {
+    data: T[];
+    totalCount: number;
+    hasMore: boolean;
+    nextCursor?: string;
+}
+interface PaginationParams {
+    page?: number;
+    pageSize?: number;
+    cursor?: string;
+}
+interface PaginatedResult<T> {
+    items: T[];
+    totalCount: number;
+    pageInfo: {
+        hasNextPage: boolean;
+        hasPreviousPage: boolean;
+        startCursor?: string;
+        endCursor?: string;
+    };
+}
+interface PaginatedQueryOptions {
+    limit?: number;
+    initialCursor?: string;
+}
+interface PaginateResult<T> {
+    data: T[];
+    total: number;
+    hasMore: boolean;
+    nextCursor?: string;
+}
+type PaginateQueryFn<T> = (params: {
+    skip: number;
+    take: number;
+}) => Promise<{
+    items: T[];
+    total: number;
+}>;
+interface ExportableModule {
+    exportData(config: ExportConfig): Promise<unknown[]>;
+    getSupportedFields(): string[];
+}
+interface CSVConversionOptions {
+    delimiter?: string;
+    includeHeaders?: boolean;
+    dateFormat?: string;
+    flattenFields?: boolean;
+    maxFlattenDepth?: number;
+}
+
+declare abstract class BaseModuleExporter<T = unknown> {
+    moduleKey?: string;
+    displayName?: string;
+    description?: string;
+    defaultExcludeFields?: string[];
+    supportedProducts?: string[];
+    protected modelName?: string;
+    export?(options: ExportOptions): Promise<ExportResult>;
+    protected filterFields(entity: T | Record<string, unknown>, excludeFields?: string[]): Record<string, unknown>;
+    protected filterFieldsMany(entities: (T | Record<string, unknown>)[], excludeFields?: string[]): Record<string, unknown>[];
+    protected paginate(queryFn: PaginateQueryFn<T>, page?: number, pageSize?: number): Promise<PaginateResult<T>>;
+    protected fetchAll(fetchBatch: (cursor?: string) => Promise<(T & {
+        id: string;
+    })[]>, batchSize?: number): Promise<T[]>;
+    protected transformForExport(entity: T, excludeFields?: string[]): Record<string, unknown>;
+    protected validateOptions(options: ExportOptions): void;
+    getSupportedFormats(): string[];
+    getMetadata(): {
+        moduleKey?: string;
+        displayName?: string;
+        description?: string;
+        supportedProducts?: string[];
+        supportedFormats: string[];
+    };
+}
+
+declare class PaginationService {
+    static paginate<T>(items: T[], params: PaginationParams): PaginatedResult<T>;
+    static calculatePagination(totalCount: number, page: number, pageSize: number): {
+        hasNextPage: boolean;
+        hasPreviousPage: boolean;
+        totalPages: number;
+        currentPage: number;
+        pageSize: number;
+        startIndex: number;
+        endIndex: number;
+    };
+    static paginatedQuery<T extends {
+        id: string;
+    }>(fetchFn: (cursor?: string) => Promise<T[]>, options?: PaginatedQueryOptions): AsyncGenerator<T, void, unknown>;
+    static collectPaginatedQuery<T extends {
+        id: string;
+    }>(fetchFn: (cursor?: string) => Promise<T[]>, options?: PaginatedQueryOptions): Promise<T[]>;
+    static createPrismaFetchFn<T extends {
+        id: string;
+    }>(queryFn: (cursor?: string) => Promise<T[]>, _batchSize?: number): (cursor?: string) => Promise<T[]>;
+    static calculateOffset(page: number, pageSize: number): number;
+    static parseCursor<T = Record<string, unknown>>(cursor: string): T | null;
+    static createCursor(data: Record<string, unknown>): string;
+}
+
+declare function convertToCSV(data: unknown[], options?: CSVConversionOptions): string;
+declare function parseCSV(csv: string, options?: {
+    delimiter?: string;
+    hasHeaders?: boolean;
+}): Record<string, string>[];
+declare function csvToJSON(csv: string, options?: {
+    delimiter?: string;
+    hasHeaders?: boolean;
+    pretty?: boolean;
+}): string;
+declare function getCSVHeaders(data: unknown[], flattenFields?: boolean): string[];
+declare function estimateCSVSize(data: unknown[], sampleSize?: number): number;
+
+type ExportActorType = 'user' | 'app' | 'service' | 'super_admin';
+type ExportFormatGql = 'JSON' | 'CSV';
+interface TriggerExportJobParams {
+    serviceName: string;
+    layer?: ServiceLayer;
+    workspaceId: string;
+    name: string;
+    entityTypes: string[];
+    format: ExportFormatGql;
+    actorId: string;
+    actorType: ExportActorType;
+    includeMetadata?: boolean;
+    dateRangeStart?: string;
+    dateRangeEnd?: string;
+}
+interface ExportJobResult {
+    id: string;
+    status: string;
+    workspaceId: string;
+    entityTypes: string[];
+    format: string;
+    createdAt: string;
+}
+declare function triggerExportJob(params: TriggerExportJobParams): Promise<ExportJobResult>;
+
+type index_BaseModuleExporter<T = unknown> = BaseModuleExporter<T>;
+declare const index_BaseModuleExporter: typeof BaseModuleExporter;
+type index_CSVConversionOptions = CSVConversionOptions;
+type index_ExportActorType = ExportActorType;
+type index_ExportConfig = ExportConfig;
+type index_ExportFetchOptions = ExportFetchOptions;
+type index_ExportFetchResult<T> = ExportFetchResult<T>;
+type index_ExportFormat = ExportFormat;
+type index_ExportFormatEnum = ExportFormatEnum;
+declare const index_ExportFormatEnum: typeof ExportFormatEnum;
+type index_ExportFormatGql = ExportFormatGql;
+type index_ExportJob = ExportJob;
+type index_ExportJobResult = ExportJobResult;
+type index_ExportJobStatus = ExportJobStatus;
+type index_ExportOptions = ExportOptions;
+type index_ExportProgress = ExportProgress;
+type index_ExportResult = ExportResult;
+type index_ExportableModule = ExportableModule;
+type index_PaginateQueryFn<T> = PaginateQueryFn<T>;
+type index_PaginateResult<T> = PaginateResult<T>;
+type index_PaginatedQueryOptions = PaginatedQueryOptions;
+type index_PaginatedResult<T> = PaginatedResult<T>;
+type index_PaginationParams = PaginationParams;
+type index_PaginationService = PaginationService;
+declare const index_PaginationService: typeof PaginationService;
+type index_TriggerExportJobParams = TriggerExportJobParams;
+declare const index_convertToCSV: typeof convertToCSV;
+declare const index_csvToJSON: typeof csvToJSON;
+declare const index_estimateCSVSize: typeof estimateCSVSize;
+declare const index_getCSVHeaders: typeof getCSVHeaders;
+declare const index_parseCSV: typeof parseCSV;
+declare const index_triggerExportJob: typeof triggerExportJob;
+declare namespace index {
+  export { index_BaseModuleExporter as BaseModuleExporter, type index_CSVConversionOptions as CSVConversionOptions, type index_ExportActorType as ExportActorType, type index_ExportConfig as ExportConfig, type index_ExportFetchOptions as ExportFetchOptions, type index_ExportFetchResult as ExportFetchResult, type index_ExportFormat as ExportFormat, index_ExportFormatEnum as ExportFormatEnum, type index_ExportFormatGql as ExportFormatGql, type index_ExportJob as ExportJob, type index_ExportJobResult as ExportJobResult, type index_ExportJobStatus as ExportJobStatus, type index_ExportOptions as ExportOptions, type index_ExportProgress as ExportProgress, type index_ExportResult as ExportResult, type index_ExportableModule as ExportableModule, type index_PaginateQueryFn as PaginateQueryFn, type index_PaginateResult as PaginateResult, type index_PaginatedQueryOptions as PaginatedQueryOptions, type index_PaginatedResult as PaginatedResult, type index_PaginationParams as PaginationParams, index_PaginationService as PaginationService, type index_TriggerExportJobParams as TriggerExportJobParams, index_convertToCSV as convertToCSV, index_csvToJSON as csvToJSON, index_estimateCSVSize as estimateCSVSize, index_getCSVHeaders as getCSVHeaders, index_parseCSV as parseCSV, index_triggerExportJob as triggerExportJob };
+}
+
+export { BaseModuleExporter as B, type CSVConversionOptions as C, type ExportActorType as E, type PaginateQueryFn as P, type TriggerExportJobParams as T, type ExportConfig as a, type ExportFetchOptions as b, type ExportFetchResult as c, type ExportFormat as d, ExportFormatEnum as e, type ExportFormatGql as f, type ExportJob as g, type ExportJobResult as h, index as i, type ExportJobStatus as j, type ExportOptions as k, type ExportProgress as l, type ExportResult as m, type ExportableModule as n, type PaginateResult as o, type PaginatedQueryOptions as p, type PaginatedResult as q, type PaginationParams as r, PaginationService as s, convertToCSV as t, csvToJSON as u, estimateCSVSize as v, getCSVHeaders as w, parseCSV as x, triggerExportJob as y };