@burdenoff/be-sdk 2026.510.79

package/dist/index-Dtf6FBaD.d.ts

@@ -0,0 +1,199 @@
+import { P as PrismaClientBase, b as PrismaClientWrapper, c as PrismaClientConfig, a as PrismaClientConstructorOptions, D as DatabaseReturnType, d as DatabaseHealth, C as ConnectionState, e as PrismaEvent, f as PrismaLogDefinition, g as PrismaLogEvent, h as PrismaLogLevel, i as PrismaQueryEvent, j as PrismaTransactionOptions, k as configurePrismaLogging, l as createConnectionPool, m as createPrismaAdapter, n as createPrismaClient } from './client-CSjIrYKS.js';
+import { G as GraphEventEmitter } from './prisma-extension-krXnYnrN.js';
+
+interface WorkspaceContext {
+    workspaceId?: string;
+    tenantId?: string;
+    actorId?: string;
+    actorType?: string;
+    organizationId?: string;
+    projectId?: string;
+    appId?: string;
+    onBehalfOf?: string;
+}
+declare function setWorkspaceContext(context: WorkspaceContext): void;
+declare function getWorkspaceContext(): WorkspaceContext | undefined;
+declare function withWorkspaceContext<T>(context: WorkspaceContext, fn: () => Promise<T>): Promise<T>;
+declare function withWorkspaceContextSync<T>(context: WorkspaceContext, fn: () => T): T;
+interface WorkspaceExtensionConfig {
+    enabled?: boolean;
+    enableReadIsolation?: boolean;
+    enableDeleteIsolation?: boolean;
+    enableUpdateWhereIsolation?: boolean;
+    populateContextJson?: boolean;
+    populateCreatedBy?: boolean;
+    populateUpdatedBy?: boolean;
+    populateTenantId?: boolean;
+    excludeModels?: string[];
+    excludeModelsFromReadIsolation?: string[];
+    strictMode?: boolean;
+    allowedUnguardedOperations?: string[];
+    debug?: boolean;
+}
+declare function injectWhereWorkspaceId(where: Record<string, unknown> | undefined, wsCtx?: WorkspaceContext): Record<string, unknown> | undefined;
+declare function addWorkspaceExtension<T>(baseClient: T, config?: WorkspaceExtensionConfig): T;
+
+interface DatabaseClientConfig extends PrismaClientConfig {
+    productName: string;
+    enableGraphExtension?: boolean;
+    graphEventEmitter?: GraphEventEmitter;
+    enableWorkspaceExtension?: boolean;
+    workspaceExtensionConfig?: WorkspaceExtensionConfig;
+    registerShutdownHandlers?: boolean;
+}
+interface DatabaseClient<T extends PrismaClientBase> {
+    db: T & {
+        client: T;
+    };
+    wrapper: PrismaClientWrapper<T>;
+    connect: (retries?: number, delay?: number) => Promise<void>;
+    disconnect: () => Promise<void>;
+}
+declare function createDatabaseClient<T extends PrismaClientBase>(PrismaClientConstructor: new (options: PrismaClientConstructorOptions) => T, config: DatabaseClientConfig): DatabaseClient<T>;
+declare function createDatabaseClientFromEnv<T extends PrismaClientBase>(PrismaClientConstructor: new (options: PrismaClientConstructorOptions) => T, productName: string, overrides?: Partial<DatabaseClientConfig>): DatabaseClient<T>;
+
+declare function initializeDatabase<T extends PrismaClientBase>(PrismaClientConstructor: new (options: PrismaClientConstructorOptions) => T, productName: string, config?: Partial<DatabaseClientConfig>): DatabaseClient<T>;
+declare function initializeDatabaseWithConfig<T extends PrismaClientBase>(PrismaClientConstructor: new (options: PrismaClientConstructorOptions) => T, config: DatabaseClientConfig): DatabaseClient<T>;
+declare function getDb<T extends PrismaClientBase = PrismaClientBase>(): DatabaseReturnType<T>;
+declare function getDatabaseManager<T extends PrismaClientBase = PrismaClientBase>(): DatabaseClient<T>;
+declare function isDatabaseInitialized(): boolean;
+declare function getDatabaseProductName(): string | null;
+declare function resetDatabaseManager(): Promise<void>;
+
+declare function checkDatabaseHealth<T extends PrismaClientBase>(client: T): Promise<DatabaseHealth>;
+declare function testConnection<T extends PrismaClientBase>(client: T): Promise<boolean>;
+declare function getDatabaseVersion<T extends PrismaClientBase>(client: T): Promise<string | null>;
+declare function getDatabaseStats<T extends PrismaClientBase>(client: T): Promise<{
+    health: DatabaseHealth;
+    version: string | null;
+    timestamp: Date;
+}>;
+
+interface FieldExtractionOptions {
+    excludeFields?: string[];
+    includeRelations?: boolean;
+    customFilter?: (field: {
+        name: string;
+        type: string;
+        isRelation: boolean;
+    }) => boolean;
+}
+interface FieldExtractionResult {
+    fields: string[];
+    metadata: {
+        totalFields: number;
+        excludedCount: number;
+        excludedFields: string[];
+        relationFields: number;
+    };
+}
+type ModelFieldsMap = Record<string, {
+    fields: string[];
+    relations: string[];
+}>;
+declare function loadGeneratedFields(generatedFieldsPath: string): ModelFieldsMap;
+declare function extractFieldsFromModel(modelName: string, modelFieldsMap: ModelFieldsMap, options?: FieldExtractionOptions): FieldExtractionResult;
+declare function getModelFields(modelName: string, modelFieldsMap: ModelFieldsMap, includeRelations?: boolean): string[];
+declare function hasModel(modelName: string, modelFieldsMap: ModelFieldsMap): boolean;
+declare function getAllModelNames(modelFieldsMap: ModelFieldsMap): string[];
+
+interface ContextFilterInput {
+    workspaceId?: string | null;
+    userId?: string | null;
+    projectId?: string | null;
+    appId?: string | null;
+    productId?: string | null;
+    organizationId?: string | null;
+}
+interface OperationContext extends ContextFilterInput {
+    custom?: Record<string, unknown> | null;
+}
+type PrismaJsonFilter = Record<string, unknown>;
+type JsonValue = string | number | boolean | null | {
+    [key: string]: JsonValue;
+} | JsonValue[];
+type InputJsonValue = string | number | boolean | {
+    [key: string]: InputJsonValue;
+} | InputJsonValue[];
+declare function buildContextWhereClause(contextFilter: ContextFilterInput | null | undefined): PrismaJsonFilter | undefined;
+declare function buildContextWhereConditions(contextFilter: ContextFilterInput | null | undefined): Array<{
+    context: PrismaJsonFilter;
+}>;
+declare function toContextJson(contextInput: OperationContext | null | undefined): InputJsonValue | undefined;
+declare function mergeContext(existingContext: JsonValue | null | undefined, newContext: OperationContext | null | undefined): InputJsonValue | undefined;
+declare function parseContext(contextJson: JsonValue | null | undefined): OperationContext | null;
+declare function contextMatches(context: OperationContext | null | undefined, filter: ContextFilterInput): boolean;
+declare function createContextFromSDK(sdkContext: {
+    workspaceId?: string;
+    userId?: string;
+    projectId?: string;
+    appId?: string;
+    productId?: string;
+    organizationId?: string;
+}): OperationContext;
+
+declare const index_ConnectionState: typeof ConnectionState;
+type index_ContextFilterInput = ContextFilterInput;
+type index_DatabaseClient<T extends PrismaClientBase> = DatabaseClient<T>;
+type index_DatabaseClientConfig = DatabaseClientConfig;
+declare const index_DatabaseHealth: typeof DatabaseHealth;
+declare const index_DatabaseReturnType: typeof DatabaseReturnType;
+type index_FieldExtractionOptions = FieldExtractionOptions;
+type index_FieldExtractionResult = FieldExtractionResult;
+type index_InputJsonValue = InputJsonValue;
+type index_JsonValue = JsonValue;
+type index_ModelFieldsMap = ModelFieldsMap;
+type index_OperationContext = OperationContext;
+declare const index_PrismaClientBase: typeof PrismaClientBase;
+declare const index_PrismaClientConfig: typeof PrismaClientConfig;
+declare const index_PrismaClientConstructorOptions: typeof PrismaClientConstructorOptions;
+declare const index_PrismaClientWrapper: typeof PrismaClientWrapper;
+declare const index_PrismaEvent: typeof PrismaEvent;
+type index_PrismaJsonFilter = PrismaJsonFilter;
+declare const index_PrismaLogDefinition: typeof PrismaLogDefinition;
+declare const index_PrismaLogEvent: typeof PrismaLogEvent;
+declare const index_PrismaLogLevel: typeof PrismaLogLevel;
+declare const index_PrismaQueryEvent: typeof PrismaQueryEvent;
+declare const index_PrismaTransactionOptions: typeof PrismaTransactionOptions;
+type index_WorkspaceContext = WorkspaceContext;
+type index_WorkspaceExtensionConfig = WorkspaceExtensionConfig;
+declare const index_addWorkspaceExtension: typeof addWorkspaceExtension;
+declare const index_buildContextWhereClause: typeof buildContextWhereClause;
+declare const index_buildContextWhereConditions: typeof buildContextWhereConditions;
+declare const index_checkDatabaseHealth: typeof checkDatabaseHealth;
+declare const index_configurePrismaLogging: typeof configurePrismaLogging;
+declare const index_contextMatches: typeof contextMatches;
+declare const index_createConnectionPool: typeof createConnectionPool;
+declare const index_createContextFromSDK: typeof createContextFromSDK;
+declare const index_createDatabaseClient: typeof createDatabaseClient;
+declare const index_createDatabaseClientFromEnv: typeof createDatabaseClientFromEnv;
+declare const index_createPrismaAdapter: typeof createPrismaAdapter;
+declare const index_createPrismaClient: typeof createPrismaClient;
+declare const index_extractFieldsFromModel: typeof extractFieldsFromModel;
+declare const index_getAllModelNames: typeof getAllModelNames;
+declare const index_getDatabaseManager: typeof getDatabaseManager;
+declare const index_getDatabaseProductName: typeof getDatabaseProductName;
+declare const index_getDatabaseStats: typeof getDatabaseStats;
+declare const index_getDatabaseVersion: typeof getDatabaseVersion;
+declare const index_getDb: typeof getDb;
+declare const index_getModelFields: typeof getModelFields;
+declare const index_getWorkspaceContext: typeof getWorkspaceContext;
+declare const index_hasModel: typeof hasModel;
+declare const index_initializeDatabase: typeof initializeDatabase;
+declare const index_initializeDatabaseWithConfig: typeof initializeDatabaseWithConfig;
+declare const index_injectWhereWorkspaceId: typeof injectWhereWorkspaceId;
+declare const index_isDatabaseInitialized: typeof isDatabaseInitialized;
+declare const index_loadGeneratedFields: typeof loadGeneratedFields;
+declare const index_mergeContext: typeof mergeContext;
+declare const index_parseContext: typeof parseContext;
+declare const index_resetDatabaseManager: typeof resetDatabaseManager;
+declare const index_setWorkspaceContext: typeof setWorkspaceContext;
+declare const index_testConnection: typeof testConnection;
+declare const index_toContextJson: typeof toContextJson;
+declare const index_withWorkspaceContext: typeof withWorkspaceContext;
+declare const index_withWorkspaceContextSync: typeof withWorkspaceContextSync;
+declare namespace index {
+  export { index_ConnectionState as ConnectionState, type index_ContextFilterInput as ContextFilterInput, type index_DatabaseClient as DatabaseClient, type index_DatabaseClientConfig as DatabaseClientConfig, index_DatabaseHealth as DatabaseHealth, index_DatabaseReturnType as DatabaseReturnType, type index_FieldExtractionOptions as FieldExtractionOptions, type index_FieldExtractionResult as FieldExtractionResult, type index_InputJsonValue as InputJsonValue, type index_JsonValue as JsonValue, type index_ModelFieldsMap as ModelFieldsMap, type index_OperationContext as OperationContext, index_PrismaClientBase as PrismaClientBase, index_PrismaClientConfig as PrismaClientConfig, index_PrismaClientConstructorOptions as PrismaClientConstructorOptions, index_PrismaClientWrapper as PrismaClientWrapper, index_PrismaEvent as PrismaEvent, type index_PrismaJsonFilter as PrismaJsonFilter, index_PrismaLogDefinition as PrismaLogDefinition, index_PrismaLogEvent as PrismaLogEvent, index_PrismaLogLevel as PrismaLogLevel, index_PrismaQueryEvent as PrismaQueryEvent, index_PrismaTransactionOptions as PrismaTransactionOptions, type index_WorkspaceContext as WorkspaceContext, type index_WorkspaceExtensionConfig as WorkspaceExtensionConfig, index_addWorkspaceExtension as addWorkspaceExtension, index_buildContextWhereClause as buildContextWhereClause, index_buildContextWhereConditions as buildContextWhereConditions, index_checkDatabaseHealth as checkDatabaseHealth, index_configurePrismaLogging as configurePrismaLogging, index_contextMatches as contextMatches, index_createConnectionPool as createConnectionPool, index_createContextFromSDK as createContextFromSDK, index_createDatabaseClient as createDatabaseClient, index_createDatabaseClientFromEnv as createDatabaseClientFromEnv, index_createPrismaAdapter as createPrismaAdapter, index_createPrismaClient as createPrismaClient, index_extractFieldsFromModel as extractFieldsFromModel, index_getAllModelNames as getAllModelNames, index_getDatabaseManager as getDatabaseManager, index_getDatabaseProductName as getDatabaseProductName, index_getDatabaseStats as getDatabaseStats, index_getDatabaseVersion as getDatabaseVersion, index_getDb as getDb, index_getModelFields as getModelFields, index_getWorkspaceContext as getWorkspaceContext, index_hasModel as hasModel, index_initializeDatabase as initializeDatabase, index_initializeDatabaseWithConfig as initializeDatabaseWithConfig, index_injectWhereWorkspaceId as injectWhereWorkspaceId, index_isDatabaseInitialized as isDatabaseInitialized, index_loadGeneratedFields as loadGeneratedFields, index_mergeContext as mergeContext, index_parseContext as parseContext, index_resetDatabaseManager as resetDatabaseManager, index_setWorkspaceContext as setWorkspaceContext, index_testConnection as testConnection, index_toContextJson as toContextJson, index_withWorkspaceContext as withWorkspaceContext, index_withWorkspaceContextSync as withWorkspaceContextSync };
+}
+
+export { loadGeneratedFields as A, mergeContext as B, type ContextFilterInput as C, type DatabaseClient as D, parseContext as E, type FieldExtractionOptions as F, resetDatabaseManager as G, setWorkspaceContext as H, type InputJsonValue as I, type JsonValue as J, testConnection as K, toContextJson as L, type ModelFieldsMap as M, withWorkspaceContext as N, type OperationContext as O, type PrismaJsonFilter as P, withWorkspaceContextSync as Q, type WorkspaceContext as W, type DatabaseClientConfig as a, type FieldExtractionResult as b, type WorkspaceExtensionConfig as c, addWorkspaceExtension as d, buildContextWhereClause as e, buildContextWhereConditions as f, checkDatabaseHealth as g, contextMatches as h, index as i, createContextFromSDK as j, createDatabaseClient as k, createDatabaseClientFromEnv as l, extractFieldsFromModel as m, getAllModelNames as n, getDatabaseManager as o, getDatabaseProductName as p, getDatabaseStats as q, getDatabaseVersion as r, getDb as s, getModelFields as t, getWorkspaceContext as u, hasModel as v, initializeDatabase as w, initializeDatabaseWithConfig as x, injectWhereWorkspaceId as y, isDatabaseInitialized as z };

package/dist/index-KVWGHMbS.d.ts

@@ -0,0 +1,415 @@
+import { B as BurdenoffGraphQLClient } from './graphql-BAVrUgBF.js';
+import { S as SDKContext } from './index-CHbVw5M7.js';
+import { N as NotificationType } from './index-CyVEg86m.js';
+
+declare enum ActivityType {
+    CREATE = "create",
+    READ = "read",
+    UPDATE = "update",
+    DELETE = "delete",
+    LOGIN = "login",
+    LOGOUT = "logout",
+    EXPORT = "export",
+    IMPORT = "import",
+    SHARE = "share",
+    DOWNLOAD = "download",
+    UPLOAD = "upload",
+    EXECUTE = "execute",
+    APPROVE = "approve",
+    REJECT = "reject",
+    CUSTOM = "custom"
+}
+declare enum ActivityStatus {
+    SUCCESS = "success",
+    FAILURE = "failure",
+    PENDING = "pending",
+    WARNING = "warning"
+}
+declare enum ActivitySeverity {
+    LOW = "low",
+    MEDIUM = "medium",
+    HIGH = "high",
+    CRITICAL = "critical"
+}
+interface LogActivityOptions {
+    userId: string;
+    activityType: ActivityType;
+    resourceType: string;
+    resourceId?: string;
+    action: string;
+    status: ActivityStatus;
+    workspaceId?: string;
+    organizationId?: string;
+    projectId?: string;
+    ipAddress?: string;
+    userAgent?: string;
+    metadata?: Record<string, unknown>;
+    severity?: ActivitySeverity;
+    errorMessage?: string;
+    duration?: number;
+}
+interface Activity {
+    id: string;
+    userId: string;
+    activityType: ActivityType;
+    resourceType: string;
+    resourceId?: string;
+    action: string;
+    status: ActivityStatus;
+    workspaceId?: string;
+    organizationId?: string;
+    projectId?: string;
+    ipAddress?: string;
+    userAgent?: string;
+    metadata?: Record<string, unknown>;
+    severity: ActivitySeverity;
+    errorMessage?: string;
+    duration?: number;
+    createdAt: string;
+}
+interface GetActivitiesOptions {
+    userId?: string;
+    workspaceId?: string;
+    organizationId?: string;
+    projectId?: string;
+    activityType?: ActivityType;
+    resourceType?: string;
+    resourceId?: string;
+    status?: ActivityStatus;
+    severity?: ActivitySeverity;
+    startDate?: string;
+    endDate?: string;
+    search?: string;
+    limit?: number;
+    offset?: number;
+    sortBy?: 'createdAt' | 'duration' | 'severity';
+    sortOrder?: 'asc' | 'desc';
+}
+interface ActivityStats {
+    totalActivities: number;
+    successCount: number;
+    failureCount: number;
+    pendingCount: number;
+    warningCount: number;
+    averageDuration?: number;
+    activitiesByType: Record<string, number>;
+    activitiesBySeverity: Record<string, number>;
+    topUsers: Array<{
+        userId: string;
+        count: number;
+    }>;
+    topResources: Array<{
+        resourceType: string;
+        count: number;
+    }>;
+}
+declare class ActivityModule {
+    private client;
+    private context;
+    constructor(client: BurdenoffGraphQLClient, context: SDKContext);
+    log(options: LogActivityOptions): Promise<Activity>;
+    logSuccess(userId: string, action: string, resourceType: string, resourceId?: string, metadata?: Record<string, unknown>): Promise<Activity>;
+    logFailure(userId: string, action: string, resourceType: string, errorMessage: string, resourceId?: string, metadata?: Record<string, unknown>): Promise<Activity>;
+    getActivities(options: GetActivitiesOptions): Promise<{
+        activities: Activity[];
+        total: number;
+    }>;
+    getActivity(activityId: string): Promise<Activity>;
+    getStats(options: Omit<GetActivitiesOptions, 'limit' | 'offset'>): Promise<ActivityStats>;
+    cleanup(olderThanDays: number, workspaceId?: string): Promise<number>;
+    private inferActivityType;
+    exportToCSV(options: GetActivitiesOptions): Promise<string>;
+}
+
+declare enum UsageMetricType {
+    API_CALLS = "api_calls",
+    STORAGE = "storage",
+    BANDWIDTH = "bandwidth",
+    USERS = "users",
+    PROJECTS = "projects",
+    WORKSPACES = "workspaces",
+    RECORDS = "records",
+    COMPUTE_TIME = "compute_time",
+    TRANSACTIONS = "transactions",
+    CUSTOM = "custom"
+}
+declare enum QuotaPeriod {
+    DAILY = "daily",
+    WEEKLY = "weekly",
+    MONTHLY = "monthly",
+    YEARLY = "yearly",
+    LIFETIME = "lifetime"
+}
+type UsageEntityType = 'user' | 'workspace' | 'organization';
+interface TrackUsageOptions {
+    entityId: string;
+    entityType: UsageEntityType;
+    metricType: UsageMetricType;
+    amount: number;
+    resourceId?: string;
+    metadata?: Record<string, unknown>;
+    workspaceId?: string;
+    organizationId?: string;
+}
+interface CheckQuotaOptions {
+    entityId: string;
+    entityType: UsageEntityType;
+    metricType: UsageMetricType;
+    requestedAmount: number;
+    workspaceId?: string;
+    organizationId?: string;
+}
+interface QuotaCheckResult {
+    allowed: boolean;
+    currentUsage: number;
+    quotaLimit: number;
+    remainingQuota: number;
+    resetAt?: string;
+    period: QuotaPeriod;
+    reason?: string;
+}
+interface UsageRecord {
+    id: string;
+    entityId: string;
+    entityType: UsageEntityType;
+    metricType: UsageMetricType;
+    amount: number;
+    resourceId?: string;
+    metadata?: Record<string, unknown>;
+    workspaceId?: string;
+    organizationId?: string;
+    recordedAt: string;
+}
+interface UsageSummary {
+    entityId: string;
+    entityType: string;
+    metricType: UsageMetricType;
+    totalUsage: number;
+    period: QuotaPeriod;
+    periodStart: string;
+    periodEnd: string;
+    quotaLimit?: number;
+    utilizationPercentage?: number;
+}
+interface SetQuotaOptions {
+    entityId: string;
+    entityType: UsageEntityType;
+    metricType: UsageMetricType;
+    limit: number;
+    period: QuotaPeriod;
+    workspaceId?: string;
+    organizationId?: string;
+}
+interface Quota {
+    id: string;
+    entityId: string;
+    entityType: string;
+    metricType: UsageMetricType;
+    limit: number;
+    period: QuotaPeriod;
+    currentUsage: number;
+    resetAt: string;
+    createdAt: string;
+    updatedAt: string;
+}
+interface GetUsageOptions {
+    entityId: string;
+    entityType: UsageEntityType;
+    metricType?: UsageMetricType;
+    startDate?: string;
+    endDate?: string;
+    workspaceId?: string;
+    organizationId?: string;
+    limit?: number;
+    offset?: number;
+}
+declare class UsageModule {
+    private client;
+    private context;
+    constructor(client: BurdenoffGraphQLClient, context: SDKContext);
+    track(options: TrackUsageOptions): Promise<UsageRecord>;
+    checkQuota(options: CheckQuotaOptions): Promise<QuotaCheckResult>;
+    requireQuota(options: CheckQuotaOptions): Promise<void>;
+    trackAndCheck(options: TrackUsageOptions): Promise<{
+        usage: UsageRecord;
+        quotaCheck: QuotaCheckResult;
+    }>;
+    getUsage(options: GetUsageOptions): Promise<{
+        records: UsageRecord[];
+        total: number;
+    }>;
+    getSummary(entityId: string, entityType: UsageEntityType, metricType: UsageMetricType, period: QuotaPeriod): Promise<UsageSummary>;
+    setQuota(options: SetQuotaOptions): Promise<Quota>;
+    getQuota(entityId: string, entityType: UsageEntityType, metricType: UsageMetricType): Promise<Quota | null>;
+    getQuotas(entityId: string, entityType: UsageEntityType): Promise<Quota[]>;
+    resetQuota(entityId: string, entityType: UsageEntityType, metricType: UsageMetricType): Promise<boolean>;
+    deleteQuota(entityId: string, entityType: UsageEntityType, metricType: UsageMetricType): Promise<boolean>;
+    trackBulk(records: TrackUsageOptions[]): Promise<UsageRecord[]>;
+}
+
+interface TrackingEvent {
+    eventType: string;
+    entityType: string;
+    entityId: string;
+    userId?: string;
+    workspaceId?: string;
+    metadata?: Record<string, unknown>;
+    timestamp?: Date;
+}
+interface RbacCheckOptions {
+    action?: string;
+    resourceType?: string;
+    resourceId?: string;
+    workspaceId?: string;
+    skipRbacCheck?: boolean;
+    options?: {
+        allowOwnerAccess?: boolean;
+        allowWorkspaceAdmin?: boolean;
+        scope?: string;
+    };
+}
+interface UsageTrackingOptions {
+    billingAccountId?: string;
+    addUsage?: boolean;
+    description?: string;
+    tags?: Record<string, unknown>;
+    quotaName?: string;
+    value?: number;
+}
+interface ActivityTrackingOptions {
+    activityType?: string;
+    description?: string;
+    metadata?: Record<string, unknown>;
+    workspaceId?: string;
+    teamId?: string;
+    groupId?: string;
+    projectId?: string;
+    targetUserId?: string;
+    resourceType?: string;
+    resourceId?: string;
+    enabled?: boolean;
+}
+interface UnifiedTrackingOptions {
+    operationName?: string;
+    userId?: string;
+    context?: unknown;
+    rbacCheck?: RbacCheckOptions;
+    activityOptions?: ActivityTrackingOptions;
+    usageOptions?: UsageTrackingOptions & {
+        enabled?: boolean;
+    };
+    success?: boolean;
+    errorMessage?: string;
+    productId?: string;
+    action?: string;
+    resourceType?: string;
+    resourceId?: string;
+    workspaceId?: string;
+    tenantId?: string;
+}
+declare class UnifiedTrackerStub {
+    private static instance;
+    static getInstance(): UnifiedTrackerStub;
+    track(event: TrackingEvent): Promise<void>;
+    trackBatch(events: TrackingEvent[]): Promise<void>;
+}
+declare const trackerStub: UnifiedTrackerStub;
+declare function trackOperation(options: UnifiedTrackingOptions): Promise<boolean>;
+type ProductTracker = {
+    track: (operationName: string, additionalOptions?: Partial<UnifiedTrackingOptions>) => Promise<boolean>;
+    freeUp: (operationName: string, additionalOptions?: Partial<UnifiedTrackingOptions>) => Promise<boolean>;
+    trackActivityOnly: (operationName: string, additionalOptions?: Partial<UnifiedTrackingOptions>) => Promise<boolean>;
+    trackUsageOnly: (operationName: string, additionalOptions?: Partial<UnifiedTrackingOptions>) => Promise<boolean>;
+    trackCustom: (operationName: string, additionalOptions: Partial<UnifiedTrackingOptions>) => Promise<boolean>;
+    productId: string;
+    userId: string;
+    billingAccountId: string | undefined;
+    defaultContext: Partial<UnifiedTrackingOptions> | undefined;
+};
+declare function createProductTracker(productId: string, userId: string, billingAccountId?: string, defaultContext?: Partial<UnifiedTrackingOptions>): ProductTracker;
+declare const UNIFIED_TRACKER_CONSTANTS: {
+    readonly DEFAULT_PRODUCT_ID: "module";
+    readonly OPERATIONS: {};
+    readonly PRODUCTS: {};
+};
+
+interface TrackOptions {
+    userId: string;
+    action: string;
+    resourceType: string;
+    resourceId?: string;
+    workspaceId?: string;
+    organizationId?: string;
+    projectId?: string;
+    rbac?: {
+        enabled?: boolean;
+        permissionAction?: string;
+    };
+    activity?: {
+        enabled?: boolean;
+        activityType?: ActivityType;
+        metadata?: Record<string, unknown>;
+        ipAddress?: string;
+        userAgent?: string;
+        severity?: ActivitySeverity;
+    };
+    usage?: {
+        enabled?: boolean;
+        metricType: UsageMetricType;
+        amount?: number;
+        checkQuota?: boolean;
+        entityType?: 'user' | 'workspace' | 'organization';
+    };
+    notification?: {
+        onSuccess?: {
+            title: string;
+            message: string;
+            type?: NotificationType;
+            additionalUserIds?: string[];
+        };
+        onFailure?: {
+            title: string;
+            message: string;
+            type?: NotificationType;
+            additionalUserIds?: string[];
+        };
+    };
+}
+interface TrackResult {
+    success: boolean;
+    permissionGranted: boolean;
+    quotaAvailable?: boolean;
+    quotaRemaining?: number;
+    activityId?: string;
+    usageRecordId?: string;
+    notificationIds?: string[];
+    error?: {
+        type: 'permission' | 'quota' | 'validation' | 'unknown';
+        message: string;
+        details?: Record<string, unknown>;
+    };
+    duration: number;
+}
+declare class TrackerModule {
+    private context;
+    private rbac;
+    private activity;
+    private usage;
+    private notifications;
+    constructor(client: BurdenoffGraphQLClient, context?: SDKContext);
+    track(options: TrackOptions): Promise<TrackResult>;
+    trackOrThrow(options: TrackOptions): Promise<TrackResult>;
+    trackSimple(userId: string, action: string, resourceType: string, resourceId?: string, metricType?: UsageMetricType): Promise<boolean>;
+    private validateOptions;
+    private checkPermission;
+    private checkQuota;
+    private trackUsage;
+    private logSuccessActivity;
+    private logFailedActivity;
+    private sendSuccessNotification;
+    private sendFailureNotification;
+    private inferActivityType;
+    trackBatch(operations: TrackOptions[]): Promise<TrackResult[]>;
+}
+
+export { ActivityModule as A, type ProductTracker as P, type RbacCheckOptions as R, TrackerModule as T, UsageModule as U, type ActivityTrackingOptions as a, type TrackOptions as b, type TrackResult as c, type TrackingEvent as d, UNIFIED_TRACKER_CONSTANTS as e, UnifiedTrackerStub as f, type UnifiedTrackingOptions as g, UsageMetricType as h, type UsageTrackingOptions as i, createProductTracker as j, trackerStub as k, trackOperation as t };

package/dist/index-PaojfSdd.d.ts

@@ -0,0 +1,71 @@
+declare function isValidEmail(email: string): boolean;
+declare function isValidUrl(url: string): boolean;
+declare function isValidRegexPattern(pattern: string): boolean;
+declare function compileValidatedPattern(pattern: string): RegExp | null;
+declare function isValidPhone(phone: string): boolean;
+declare function isValidUUID(uuid: string): boolean;
+declare function isValidIPv4(ip: string): boolean;
+declare function isValidSlug(slug: string): boolean;
+declare function isValidHexColor(color: string): boolean;
+declare function isValidBase64(str: string): boolean;
+declare function isValidJSON(str: string): boolean;
+declare function isNumberInRange(value: number, min: number | null, max: number | null): boolean;
+declare function isStringLengthValid(value: string, min: number | null, max: number | null): boolean;
+
+declare function retry<T>(fn: () => Promise<T>, options: {
+    maxAttempts: number;
+    initialDelay: number;
+    maxDelay: number;
+    backoffMultiplier: number;
+}): Promise<T>;
+declare function sleep(ms: number): Promise<void>;
+declare function deepMerge<T extends Record<string, unknown>>(target: T, source: Partial<T>): T;
+declare function generateUUID(): string;
+declare function sanitizeForLog(data: Record<string, unknown>): Record<string, unknown>;
+declare function debounce<T extends (...args: unknown[]) => unknown>(fn: T, delay: number): (...args: Parameters<T>) => void;
+declare function throttle<T extends (...args: unknown[]) => unknown>(fn: T, delay: number): (...args: Parameters<T>) => void;
+declare function parseJWT(token: string): Record<string, unknown> | null;
+declare function isTokenExpired(token: string): boolean;
+declare function formatBytes(bytes: number, decimals?: number): string;
+
+declare function truncate(str: string, maxLength: number): string;
+declare function chunk<T>(array: T[], size: number): T[][];
+declare function unique<T>(array: T[]): T[];
+declare function groupBy<T>(array: T[], key: keyof T): Record<string, T[]>;
+declare function pick<T extends Record<string, unknown>, K extends keyof T>(obj: T, keys: K[]): Pick<T, K>;
+declare function omit<T extends Record<string, unknown>, K extends keyof T>(obj: T, keys: K[]): Omit<T, K>;
+
+declare const index_chunk: typeof chunk;
+declare const index_compileValidatedPattern: typeof compileValidatedPattern;
+declare const index_debounce: typeof debounce;
+declare const index_deepMerge: typeof deepMerge;
+declare const index_formatBytes: typeof formatBytes;
+declare const index_generateUUID: typeof generateUUID;
+declare const index_groupBy: typeof groupBy;
+declare const index_isNumberInRange: typeof isNumberInRange;
+declare const index_isStringLengthValid: typeof isStringLengthValid;
+declare const index_isTokenExpired: typeof isTokenExpired;
+declare const index_isValidBase64: typeof isValidBase64;
+declare const index_isValidEmail: typeof isValidEmail;
+declare const index_isValidHexColor: typeof isValidHexColor;
+declare const index_isValidIPv4: typeof isValidIPv4;
+declare const index_isValidJSON: typeof isValidJSON;
+declare const index_isValidPhone: typeof isValidPhone;
+declare const index_isValidRegexPattern: typeof isValidRegexPattern;
+declare const index_isValidSlug: typeof isValidSlug;
+declare const index_isValidUUID: typeof isValidUUID;
+declare const index_isValidUrl: typeof isValidUrl;
+declare const index_omit: typeof omit;
+declare const index_parseJWT: typeof parseJWT;
+declare const index_pick: typeof pick;
+declare const index_retry: typeof retry;
+declare const index_sanitizeForLog: typeof sanitizeForLog;
+declare const index_sleep: typeof sleep;
+declare const index_throttle: typeof throttle;
+declare const index_truncate: typeof truncate;
+declare const index_unique: typeof unique;
+declare namespace index {
+  export { index_chunk as chunk, index_compileValidatedPattern as compileValidatedPattern, index_debounce as debounce, index_deepMerge as deepMerge, index_formatBytes as formatBytes, index_generateUUID as generateUUID, index_groupBy as groupBy, index_isNumberInRange as isNumberInRange, index_isStringLengthValid as isStringLengthValid, index_isTokenExpired as isTokenExpired, index_isValidBase64 as isValidBase64, index_isValidEmail as isValidEmail, index_isValidHexColor as isValidHexColor, index_isValidIPv4 as isValidIPv4, index_isValidJSON as isValidJSON, index_isValidPhone as isValidPhone, index_isValidRegexPattern as isValidRegexPattern, index_isValidSlug as isValidSlug, index_isValidUUID as isValidUUID, index_isValidUrl as isValidUrl, index_omit as omit, index_parseJWT as parseJWT, index_pick as pick, index_retry as retry, index_sanitizeForLog as sanitizeForLog, index_sleep as sleep, index_throttle as throttle, index_truncate as truncate, index_unique as unique };
+}
+
+export { sleep as A, throttle as B, truncate as C, unique as D, compileValidatedPattern as a, deepMerge as b, chunk as c, debounce as d, groupBy as e, formatBytes as f, generateUUID as g, isNumberInRange as h, index as i, isStringLengthValid as j, isTokenExpired as k, isValidBase64 as l, isValidEmail as m, isValidHexColor as n, isValidIPv4 as o, isValidJSON as p, isValidPhone as q, isValidRegexPattern as r, isValidSlug as s, isValidUUID as t, isValidUrl as u, omit as v, parseJWT as w, pick as x, retry as y, sanitizeForLog as z };