@burdenoff/be-sdk 2026.510.79

package/dist/index.d.ts

@@ -0,0 +1,584 @@
+import { S as SDKContext, a as SDKConfig, N as NatsHealthStatus, T as TemporalHealthStatus, b as SDKHealthStatus, c as SDKShutdownOptions } from './index-CHbVw5M7.js';
+export { L as LoggerConfig, d as LoggerTransport, e as NATSSDKConfig } from './index-CHbVw5M7.js';
+import { L as Logger } from './index-CrQgidpx.js';
+export { i as Logger } from './index-CrQgidpx.js';
+import { AuthModule } from './auth/index.js';
+import { T as TenantNotificationsModule, a as NotificationsModule } from './index-CyVEg86m.js';
+export { t as Notifications } from './index-CyVEg86m.js';
+import { RBACModule } from './rbac/index.js';
+export { LayerAwareRBACConfig, RBACDirectiveConfig, createRBACDirective, createRBACDirectiveForLayer, createRBACDirectiveFromEnv } from './rbac/index.js';
+import { A as ActivityModule, U as UsageModule, T as TrackerModule } from './index-KVWGHMbS.js';
+import { DatabaseConfig, DatabaseModule } from './database/index.js';
+import { E as EventsModule, I as IEventPublisher } from './index-Cq_xNjcv.js';
+export { i as EventQueue } from './index-Cq_xNjcv.js';
+import { G as GraphModule } from './index-BS2idbnr.js';
+export { i as Graph } from './index-BS2idbnr.js';
+import { B as BurdenoffGraphQLClient } from './graphql-BAVrUgBF.js';
+import { TemporalModule } from './temporal/index.js';
+export { TemporalClient, TemporalClientConfig, TemporalClientFactory, TemporalWorker, TemporalWorkerConfig, TemporalWorkerFactory, TemporalWorkerManager, WorkflowStartOptions } from './temporal/index.js';
+export { createInternalClient, createInternalClientForTenant, createInternalClientForWorkspaces } from './client/internal-client.js';
+export { i as Cache } from './index-BODgvRtL.js';
+export { i as Middleware } from './index-DSOpj8DI.js';
+export { i as Observability } from './index-4gKQKZ2B.js';
+export { i as GraphQL } from './index-B18rrFru.js';
+export { i as Prisma } from './index-Dtf6FBaD.js';
+export { i as Utils } from './index-PaojfSdd.js';
+export { i as I18n, I as I18nCapableContext, T as Translator, c as createTranslator, g as getLanguage, a as getLocale, h as hasI18n, t } from './index-BV3G48cH.js';
+export { i as Export } from './index-BMq3lFjj.js';
+export { i as Init } from './index-DOcBnmMe.js';
+export { i as DataLoader } from './index-DW9q22GH.js';
+export { a as Instrumentation } from './index-DoK0bjhH.js';
+export { i as Layer } from './index-DlFDFyWD.js';
+export { i as Crypto } from './index-e_18DzAg.js';
+export { i as Gateway } from './index-RU_M5c74.js';
+export { i as FeatureFlags } from './index-jOuh_TKn.js';
+export { i as Captcha, R as RecaptchaVerifyOptions, a as RecaptchaVerifyResult, b as isCaptchaEnabled, v as verifyCaptcha, c as verifyCaptchaIfEnabled } from './index-B70b5mYS.js';
+export { C as CircuitBreakerConfig, h as DEFAULT_CIRCUIT_BREAKER_CONFIG, i as DEFAULT_GATEWAY_RETRY_CONFIG, D as DEFAULT_GATEWAY_ROUTING, b as DEFAULT_LAYER_RESOURCES, c as DEFAULT_LAYER_STREAMS, f as GatewayRequestHeaders, g as GatewayRetryConfig, G as GatewayRoutingConfig, L as LayerConfig, a as LayerFullConfig, d as LayerGatewayConfig, e as LayerResourceUrls, S as ServiceLayer } from './layer-DDip18KY.js';
+import 'graphql-request';
+import '@envelop/core';
+import '@clickhouse/client';
+import './graph-emitter-Bk0FqD53.js';
+import './client-CSjIrYKS.js';
+import '@prisma/adapter-pg';
+import 'pg';
+import './prisma-extension-krXnYnrN.js';
+import '@temporalio/client';
+import '@temporalio/common';
+import 'elysia';
+import './types-Bo2wkjSP.js';
+import './graphql/services/index.js';
+import './i18n-DA6IPnYy.js';
+import './index-UhkH2eaB.js';
+import 'graphql-yoga';
+
+declare class ContextManager {
+    static getContext(): SDKContext | undefined;
+    static setContext(context: SDKContext): void;
+    static withContext<T>(context: SDKContext, fn: () => Promise<T>): Promise<T>;
+    static withContextSync<T>(context: SDKContext, fn: () => T): T;
+    static clearContext(): void;
+    static getActorId(): string | undefined;
+    static getUser(): string | undefined;
+    static getWorkspace(): string | undefined;
+    static getTenant(): string | undefined;
+    static getOrganization(): string | undefined;
+    static getProject(): string | undefined;
+    static getApp(): string | undefined;
+    static getToken(): string | undefined;
+    static getProduct(): string | undefined;
+    static updateContext(updates: Partial<SDKContext>): void;
+    static hasContext(): boolean;
+    static getCustomField(key: string): unknown;
+    static setCustomField(key: string, value: unknown): void;
+}
+
+interface SearchOptions {
+    query: string;
+    resourceTypes?: string[];
+    workspaceId?: string;
+    organizationId?: string;
+    projectId?: string;
+    fields?: string[];
+    fuzziness?: number;
+    boosts?: Record<string, number>;
+    filters?: SearchFilter[];
+    sort?: SearchSort[];
+    limit?: number;
+    offset?: number;
+    highlight?: boolean;
+}
+interface SearchFilter {
+    field: string;
+    operator: 'eq' | 'ne' | 'gt' | 'gte' | 'lt' | 'lte' | 'in' | 'range';
+    value: unknown;
+}
+interface SearchSort {
+    field: string;
+    order: 'asc' | 'desc';
+}
+interface SearchResult {
+    id: string;
+    type: string;
+    title: string;
+    description?: string;
+    data: Record<string, unknown>;
+    workspaceId?: string;
+    organizationId?: string;
+    projectId?: string;
+    score: number;
+    highlights?: Record<string, string[]>;
+    createdAt: string;
+    updatedAt: string;
+}
+interface SearchResponse {
+    results: SearchResult[];
+    total: number;
+    took: number;
+    aggregations?: Record<string, SearchAggregation>;
+}
+interface SearchAggregation {
+    buckets: Array<{
+        key: string;
+        count: number;
+    }>;
+}
+interface IndexDocumentOptions {
+    id: string;
+    type: string;
+    title: string;
+    description?: string;
+    content?: string;
+    data: Record<string, unknown>;
+    workspaceId?: string;
+    organizationId?: string;
+    projectId?: string;
+    tags?: string[];
+    metadata?: Record<string, unknown>;
+}
+declare class SearchModule {
+    private client;
+    private context;
+    constructor(client: BurdenoffGraphQLClient, context: SDKContext);
+    search(options: SearchOptions): Promise<SearchResponse>;
+    indexDocument(options: IndexDocumentOptions): Promise<{
+        id: string;
+        indexed: boolean;
+    }>;
+    removeDocument(id: string, type: string): Promise<boolean>;
+    updateDocument(id: string, type: string, updates: Partial<IndexDocumentOptions>): Promise<{
+        id: string;
+        updated: boolean;
+    }>;
+    indexDocumentsBulk(documents: IndexDocumentOptions[]): Promise<{
+        indexed: number;
+        failed: number;
+        errors: string[];
+    }>;
+    suggest(prefix: string, options?: {
+        resourceTypes?: string[];
+        limit?: number;
+    }): Promise<Array<{
+        text: string;
+        score: number;
+        type?: string;
+    }>>;
+    getRelated(documentId: string, options?: {
+        limit?: number;
+        minScore?: number;
+    }): Promise<SearchResult[]>;
+    aggregate(query: string, aggregations: Array<{
+        field: string;
+        type: 'terms' | 'date_histogram' | 'range';
+        size?: number;
+    }>): Promise<Record<string, SearchAggregation>>;
+    clearIndex(workspaceId?: string): Promise<{
+        deletedCount: number;
+    }>;
+    reindex(options?: {
+        workspaceId?: string;
+        resourceTypes?: string[];
+    }): Promise<{
+        indexed: number;
+        failed: number;
+    }>;
+}
+
+type SupportedLanguage = 'en' | 'es' | 'fr' | 'de' | 'it' | 'pt' | 'ru' | 'zh' | 'ja' | 'ko' | 'ar' | 'hi' | 'bn' | 'ta' | 'te' | 'ml';
+interface TranslationOptions {
+    text: string;
+    sourceLanguage?: SupportedLanguage;
+    targetLanguage: SupportedLanguage;
+    context?: string;
+    variables?: Record<string, string | number>;
+}
+interface Translation {
+    original: string;
+    translated: string;
+    sourceLanguage: string;
+    targetLanguage: string;
+    confidence?: number;
+}
+interface GetTranslationsOptions {
+    keys: string[];
+    language: SupportedLanguage;
+    namespace?: string;
+    fallbackLanguage?: SupportedLanguage;
+}
+interface TranslationKey {
+    key: string;
+    value: string;
+    language: SupportedLanguage;
+    namespace?: string;
+    description?: string;
+    variables?: string[];
+}
+interface SetTranslationOptions {
+    key: string;
+    value: string;
+    language: SupportedLanguage;
+    namespace?: string;
+    description?: string;
+    variables?: string[];
+}
+type TranslationExportFormat = 'JSON' | 'CSV' | 'XLSX' | 'PO' | 'XLIFF';
+interface ProductTranslationTree {
+    [key: string]: string | ProductTranslationTree;
+}
+interface ExportProductTranslationsOptions {
+    productId?: string;
+    productName?: string;
+    languageCode?: string;
+    format?: TranslationExportFormat;
+    decodeJson?: boolean;
+}
+interface ProductTranslationsExportResult {
+    format: TranslationExportFormat;
+    url: string;
+    translations?: Record<string, unknown>;
+}
+interface UpsertProductTranslationsOptions {
+    productId?: string;
+    productName?: string;
+    languageCode: string;
+    translations: Record<string, string> | ProductTranslationTree;
+    defaultValues?: Record<string, string> | ProductTranslationTree;
+    updateExisting?: boolean;
+    publish?: boolean;
+}
+interface UpsertProductTranslationsResult {
+    productId: string;
+    languageCode: string;
+    keysProcessed: number;
+    createdKeys: number;
+    updatedKeyDefaults: number;
+    createdTranslations: number;
+    updatedTranslations: number;
+}
+declare class TranslationModule {
+    private client;
+    private context;
+    constructor(client: BurdenoffGraphQLClient, context: SDKContext);
+    translate(options: TranslationOptions): Promise<Translation>;
+    getTranslations(options: GetTranslationsOptions): Promise<Record<string, string>>;
+    get(key: string, language: SupportedLanguage, variables?: Record<string, string | number>): Promise<string>;
+    setTranslation(options: SetTranslationOptions): Promise<TranslationKey>;
+    deleteTranslation(key: string, language: SupportedLanguage, namespace?: string): Promise<boolean>;
+    setTranslationsBatch(translations: SetTranslationOptions[]): Promise<TranslationKey[]>;
+    getAllTranslations(language: SupportedLanguage, namespace?: string): Promise<TranslationKey[]>;
+    detectLanguage(text: string): Promise<{
+        language: SupportedLanguage;
+        confidence: number;
+    }>;
+    getSupportedLanguages(): Promise<Array<{
+        code: SupportedLanguage;
+        name: string;
+        nativeName: string;
+    }>>;
+    importTranslations(language: SupportedLanguage, translations: Record<string, string>, namespace?: string): Promise<{
+        imported: number;
+        failed: number;
+    }>;
+    exportTranslations(language: SupportedLanguage, namespace?: string): Promise<Record<string, string>>;
+    exportProductTranslations(options: ExportProductTranslationsOptions): Promise<ProductTranslationsExportResult>;
+    upsertProductTranslations(options: UpsertProductTranslationsOptions): Promise<UpsertProductTranslationsResult>;
+    private flattenTranslationTree;
+    private decodeDataUrlJson;
+    private resolveProductId;
+    private findTranslationKeyByKey;
+    private createTranslationKey;
+    private updateTranslationKeyDefaultValue;
+    private findGlobalTranslation;
+    private createLanguageTranslation;
+    private updateLanguageTranslation;
+    private escapeRegex;
+    private interpolate;
+    formatPlural(_language: SupportedLanguage, count: number, translations: {
+        zero?: string;
+        one: string;
+        other: string;
+    }): string;
+    formatDateTime(date: Date | string, language: SupportedLanguage, options?: Intl.DateTimeFormatOptions): string;
+    formatNumber(number: number, language: SupportedLanguage, options?: Intl.NumberFormatOptions): string;
+    formatCurrency(amount: number, currency: string, language: SupportedLanguage): string;
+}
+
+declare enum PaymentStatus {
+    PENDING = "pending",
+    PROCESSING = "processing",
+    SUCCEEDED = "succeeded",
+    FAILED = "failed",
+    CANCELLED = "cancelled",
+    REFUNDED = "refunded"
+}
+declare enum PaymentMethod {
+    CREDIT_CARD = "credit_card",
+    DEBIT_CARD = "debit_card",
+    BANK_TRANSFER = "bank_transfer",
+    UPI = "upi",
+    WALLET = "wallet",
+    PAYPAL = "paypal",
+    STRIPE = "stripe"
+}
+declare enum SubscriptionStatus {
+    ACTIVE = "active",
+    INACTIVE = "inactive",
+    CANCELLED = "cancelled",
+    EXPIRED = "expired",
+    PAST_DUE = "past_due",
+    TRIALING = "trialing"
+}
+interface CreatePaymentOptions {
+    amount: number;
+    currency: string;
+    paymentMethod: PaymentMethod;
+    customerId: string;
+    description?: string;
+    metadata?: Record<string, unknown>;
+    workspaceId?: string;
+    organizationId?: string;
+}
+interface Payment {
+    id: string;
+    amount: number;
+    currency: string;
+    status: PaymentStatus;
+    paymentMethod: PaymentMethod;
+    customerId: string;
+    description?: string;
+    metadata?: Record<string, unknown>;
+    workspaceId?: string;
+    organizationId?: string;
+    transactionId?: string;
+    failureReason?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+interface CreateSubscriptionOptions {
+    customerId: string;
+    planId: string;
+    paymentMethod: PaymentMethod;
+    trialDays?: number;
+    metadata?: Record<string, unknown>;
+    workspaceId?: string;
+    organizationId?: string;
+}
+interface Subscription {
+    id: string;
+    customerId: string;
+    planId: string;
+    status: SubscriptionStatus;
+    currentPeriodStart: string;
+    currentPeriodEnd: string;
+    trialEnd?: string;
+    cancelledAt?: string;
+    endedAt?: string;
+    metadata?: Record<string, unknown>;
+    workspaceId?: string;
+    organizationId?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+interface Plan {
+    id: string;
+    name: string;
+    description?: string;
+    amount: number;
+    currency: string;
+    interval: 'day' | 'week' | 'month' | 'year';
+    intervalCount: number;
+    features?: string[];
+    metadata?: Record<string, unknown>;
+    active: boolean;
+    createdAt: string;
+}
+interface GetPaymentsOptions {
+    customerId?: string;
+    status?: PaymentStatus;
+    workspaceId?: string;
+    organizationId?: string;
+    startDate?: string;
+    endDate?: string;
+    limit?: number;
+    offset?: number;
+}
+declare class PaymentsModule {
+    private client;
+    private context;
+    constructor(client: BurdenoffGraphQLClient, context: SDKContext);
+    createPayment(options: CreatePaymentOptions): Promise<Payment>;
+    getPayment(paymentId: string): Promise<Payment>;
+    getPayments(options: GetPaymentsOptions): Promise<{
+        payments: Payment[];
+        total: number;
+    }>;
+    refundPayment(paymentId: string, amount?: number, reason?: string): Promise<Payment>;
+    verifyPayment(paymentId: string, verificationData: Record<string, unknown>): Promise<{
+        verified: boolean;
+        status: PaymentStatus;
+    }>;
+    createSubscription(options: CreateSubscriptionOptions): Promise<Subscription>;
+    getSubscription(subscriptionId: string): Promise<Subscription>;
+    cancelSubscription(subscriptionId: string, cancelAtPeriodEnd?: boolean): Promise<Subscription>;
+    getCustomerSubscriptions(customerId: string): Promise<Subscription[]>;
+    getPlans(activeOnly?: boolean): Promise<Plan[]>;
+    createPaymentIntent(options: {
+        amount: number;
+        currency: string;
+        customerId: string;
+        paymentMethod?: PaymentMethod;
+        metadata?: Record<string, unknown>;
+    }): Promise<{
+        clientSecret: string;
+        paymentIntentId: string;
+    }>;
+    getPaymentStats(options?: {
+        startDate?: string;
+        endDate?: string;
+        workspaceId?: string;
+    }): Promise<{
+        totalRevenue: number;
+        totalPayments: number;
+        successfulPayments: number;
+        failedPayments: number;
+        refundedAmount: number;
+        averagePaymentAmount: number;
+    }>;
+}
+
+type HeaderValue = string | string[] | undefined;
+interface BootstrapConfig extends SDKConfig {
+    database?: DatabaseConfig;
+    healthCheck?: boolean;
+    healthCheckInterval?: number;
+    modules?: string[];
+    environment?: 'development' | 'staging' | 'production';
+    serviceName?: string;
+    serviceVersion?: string;
+    healthCheckPort?: number;
+}
+interface BootstrapResult {
+    success: boolean;
+    serviceName: string;
+    serviceVersion: string;
+    environment: string;
+    startedAt: string;
+    modules: string[];
+    databaseConnected: boolean;
+    healthCheckEnabled: boolean;
+}
+interface BootstrapHealthCheckResult {
+    healthy: boolean;
+    checks: {
+        database?: boolean;
+        graphql?: boolean;
+        memory?: {
+            used: number;
+            total: number;
+            percentage: number;
+        };
+        uptime?: number;
+    };
+    timestamp: string;
+}
+declare class BootstrapModule {
+    private config;
+    private startTime;
+    private healthCheckInterval?;
+    constructor(config: BootstrapConfig);
+    bootstrap(): Promise<BootstrapResult>;
+    private validateConfiguration;
+    private connectDatabase;
+    private loadModules;
+    private setupHealthChecks;
+    performHealthCheck(): Promise<BootstrapHealthCheckResult>;
+    private setupSignalHandlers;
+    private cleanup;
+    getInfo(): {
+        serviceName: string;
+        serviceVersion: string;
+        environment: string;
+        uptime: number;
+        startedAt: string;
+    };
+    setupDefaultContext(context: SDKContext): void;
+    createContextMiddleware(): (req: {
+        headers: Record<string, HeaderValue>;
+        user?: unknown;
+    }, _res: unknown, next: () => void) => Promise<void>;
+    private extractContextFromRequest;
+    loadSchema(schemaPath: string): Promise<boolean>;
+    onShutdown(callback: () => Promise<void> | void): void;
+    isReady(): Promise<boolean>;
+    getMetrics(): {
+        memory: NodeJS.MemoryUsage;
+        uptime: number;
+        cpu: NodeJS.CpuUsage;
+    };
+}
+declare function createBootstrap(config: BootstrapConfig): BootstrapModule;
+
+interface TenantBackendClientConfig {
+    tenantBackendUrl: string;
+    workspacesBackendUrl?: string;
+    apiKey?: string;
+}
+declare class TenantBackendClient {
+    private graphqlClient;
+    private config;
+    readonly notifications: TenantNotificationsModule;
+    constructor(config: TenantBackendClientConfig);
+    setAuthToken(token: string): void;
+    query<T>(query: string, variables?: Record<string, unknown>): Promise<T>;
+    healthCheck(): Promise<boolean>;
+    getClient(): BurdenoffGraphQLClient;
+    getConfig(): TenantBackendClientConfig;
+}
+declare function createTenantBackendClient(config: TenantBackendClientConfig): TenantBackendClient;
+
+declare class BurdenoffSDK {
+    private client;
+    private defaultContext;
+    private natsPublisher;
+    private natsInitPromise;
+    private natsConfig;
+    private initializationPromise;
+    private isShuttingDown;
+    readonly auth: AuthModule;
+    readonly notifications: NotificationsModule;
+    readonly tenantNotifications: TenantNotificationsModule;
+    readonly rbac: RBACModule;
+    readonly activity: ActivityModule;
+    readonly usage: UsageModule;
+    readonly tracker: TrackerModule;
+    readonly database: typeof DatabaseModule;
+    readonly events: EventsModule;
+    readonly graph: GraphModule;
+    readonly search: SearchModule;
+    readonly translation: TranslationModule;
+    readonly payments: PaymentsModule;
+    private _temporal;
+    private _temporalPromise;
+    private _temporalConfig;
+    getTemporalModule(): Promise<TemporalModule>;
+    private loadTemporalModule;
+    readonly logger: Logger;
+    readonly context: typeof ContextManager;
+    constructor(config: SDKConfig, defaultContext?: SDKContext);
+    private scheduleBackgroundInit;
+    setContext(context: SDKContext): void;
+    getContext(): SDKContext | undefined;
+    withContext<T>(context: SDKContext, fn: () => Promise<T>): Promise<T>;
+    private initializeAsync;
+    private initializeNats;
+    getNatsPublisher(): Promise<IEventPublisher>;
+    waitForReady(): Promise<void>;
+    isNatsHealthy(): Promise<NatsHealthStatus>;
+    isTemporalHealthy(): Promise<TemporalHealthStatus>;
+    getHealthStatus(): Promise<SDKHealthStatus>;
+    shutdown(options?: SDKShutdownOptions): Promise<void>;
+    static createBootstrap(config: Parameters<typeof createBootstrap>[0]): BootstrapModule;
+}
+
+declare function createSDK(config: SDKConfig, context?: SDKContext): BurdenoffSDK;
+
+export { ActivityModule, AuthModule, BootstrapModule, BurdenoffGraphQLClient, BurdenoffSDK, ContextManager, DatabaseModule, EventsModule, type ExportProductTranslationsOptions, GraphModule, NatsHealthStatus, NotificationsModule, PaymentsModule, type ProductTranslationTree, type ProductTranslationsExportResult, RBACModule, SDKConfig, SDKContext, SDKHealthStatus, SDKShutdownOptions, SearchModule, TemporalHealthStatus, TemporalModule, TenantBackendClient, type TenantBackendClientConfig, TrackerModule, type TranslationExportFormat, TranslationModule, type UpsertProductTranslationsOptions, type UpsertProductTranslationsResult, UsageModule, createBootstrap, createSDK, createTenantBackendClient, BurdenoffSDK as default };